gcc/c/c-typeck.c

   1 /* Build expressions with type checking for C compiler.
   2    Copyright (C) 1987-2017 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20
  21 /* This file is part of the C front end.
  22    It contains routines to build C expressions given their operands,
  23    including computing the types of the result, C-specific error checks,
  24    and some optimization.  */
  25
  26 #include "config.h"
  27 #include "system.h"
  28 #include "coretypes.h"
  29 #include "memmodel.h"
  30 #include "target.h"
  31 #include "function.h"
  32 #include "bitmap.h"
  33 #include "c-tree.h"
  34 #include "gimple-expr.h"
  35 #include "predict.h"
  36 #include "stor-layout.h"
  37 #include "trans-mem.h"
  38 #include "varasm.h"
  39 #include "stmt.h"
  40 #include "langhooks.h"
  41 #include "c-lang.h"
  42 #include "intl.h"
  43 #include "tree-iterator.h"
  44 #include "gimplify.h"
  45 #include "tree-inline.h"
  46 #include "omp-general.h"
  47 #include "c-family/c-objc.h"
  48 #include "c-family/c-ubsan.h"
  49 #include "gomp-constants.h"
  50 #include "spellcheck-tree.h"
  51 #include "gcc-rich-location.h"
  52 #include "stringpool.h"
  53 #include "attribs.h"
  54 #include "asan.h"
  55
  56 /* Possible cases of implicit bad conversions.  Used to select
  57    diagnostic messages in convert_for_assignment.  */
  58 enum impl_conv {
  59   ic_argpass,
  60   ic_assign,
  61   ic_init,
  62   ic_return
  63 };
  64
  65 /* The level of nesting inside "__alignof__".  */
  66 int in_alignof;
  67
  68 /* The level of nesting inside "sizeof".  */
  69 int in_sizeof;
  70
  71 /* The level of nesting inside "typeof".  */
  72 int in_typeof;
  73
  74 /* The argument of last parsed sizeof expression, only to be tested
  75    if expr.original_code == SIZEOF_EXPR.  */
  76 tree c_last_sizeof_arg;
  77 location_t c_last_sizeof_loc;
  78
  79 /* Nonzero if we might need to print a "missing braces around
  80    initializer" message within this initializer.  */
  81 static int found_missing_braces;
  82
  83 static int require_constant_value;
  84 static int require_constant_elements;
  85
  86 static bool null_pointer_constant_p (const_tree);
  87 static tree qualify_type (tree, tree);
  88 static int tagged_types_tu_compatible_p (const_tree, const_tree, bool *,
  89                                          bool *);
  90 static int comp_target_types (location_t, tree, tree);
  91 static int function_types_compatible_p (const_tree, const_tree, bool *,
  92                                         bool *);
  93 static int type_lists_compatible_p (const_tree, const_tree, bool *, bool *);
  94 static tree lookup_field (tree, tree);
  95 static int convert_arguments (location_t, vec<location_t>, tree,
  96                               vec<tree, va_gc> *, vec<tree, va_gc> *, tree,
  97                               tree);
  98 static tree pointer_diff (location_t, tree, tree, tree *);
  99 static tree convert_for_assignment (location_t, location_t, tree, tree, tree,
 100                                     enum impl_conv, bool, tree, tree, int);
 101 static tree valid_compound_expr_initializer (tree, tree);
 102 static void push_string (const char *);
 103 static void push_member_name (tree);
 104 static int spelling_length (void);
 105 static char *print_spelling (char *);
 106 static void warning_init (location_t, int, const char *);
 107 static tree digest_init (location_t, tree, tree, tree, bool, bool, int);
 108 static void output_init_element (location_t, tree, tree, bool, tree, tree, bool,
 109                                  bool, struct obstack *);
 110 static void output_pending_init_elements (int, struct obstack *);
 111 static bool set_designator (location_t, bool, struct obstack *);
 112 static void push_range_stack (tree, struct obstack *);
 113 static void add_pending_init (location_t, tree, tree, tree, bool,
 114                               struct obstack *);
 115 static void set_nonincremental_init (struct obstack *);
 116 static void set_nonincremental_init_from_string (tree, struct obstack *);
 117 static tree find_init_member (tree, struct obstack *);
 118 static void readonly_warning (tree, enum lvalue_use);
 119 static int lvalue_or_else (location_t, const_tree, enum lvalue_use);
 120 static void record_maybe_used_decl (tree);
 121 static int comptypes_internal (const_tree, const_tree, bool *, bool *);
 122 \f
 123 /* Return true if EXP is a null pointer constant, false otherwise.  */
 124
 125 static bool
 126 null_pointer_constant_p (const_tree expr)
 127 {
 128   /* This should really operate on c_expr structures, but they aren't
 129      yet available everywhere required.  */
 130   tree type = TREE_TYPE (expr);
 131   return (TREE_CODE (expr) == INTEGER_CST
 132           && !TREE_OVERFLOW (expr)
 133           && integer_zerop (expr)
 134           && (INTEGRAL_TYPE_P (type)
 135               || (TREE_CODE (type) == POINTER_TYPE
 136                   && VOID_TYPE_P (TREE_TYPE (type))
 137                   && TYPE_QUALS (TREE_TYPE (type)) == TYPE_UNQUALIFIED)));
 138 }
 139
 140 /* EXPR may appear in an unevaluated part of an integer constant
 141    expression, but not in an evaluated part.  Wrap it in a
 142    C_MAYBE_CONST_EXPR, or mark it with TREE_OVERFLOW if it is just an
 143    INTEGER_CST and we cannot create a C_MAYBE_CONST_EXPR.  */
 144
 145 static tree
 146 note_integer_operands (tree expr)
 147 {
 148   tree ret;
 149   if (TREE_CODE (expr) == INTEGER_CST && in_late_binary_op)
 150     {
 151       ret = copy_node (expr);
 152       TREE_OVERFLOW (ret) = 1;
 153     }
 154   else
 155     {
 156       ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL_TREE, expr);
 157       C_MAYBE_CONST_EXPR_INT_OPERANDS (ret) = 1;
 158     }
 159   return ret;
 160 }
 161
 162 /* Having checked whether EXPR may appear in an unevaluated part of an
 163    integer constant expression and found that it may, remove any
 164    C_MAYBE_CONST_EXPR noting this fact and return the resulting
 165    expression.  */
 166
 167 static inline tree
 168 remove_c_maybe_const_expr (tree expr)
 169 {
 170   if (TREE_CODE (expr) == C_MAYBE_CONST_EXPR)
 171     return C_MAYBE_CONST_EXPR_EXPR (expr);
 172   else
 173     return expr;
 174 }
 175
 176 \f/* This is a cache to hold if two types are compatible or not.  */
 177
 178 struct tagged_tu_seen_cache {
 179   const struct tagged_tu_seen_cache * next;
 180   const_tree t1;
 181   const_tree t2;
 182   /* The return value of tagged_types_tu_compatible_p if we had seen
 183      these two types already.  */
 184   int val;
 185 };
 186
 187 static const struct tagged_tu_seen_cache * tagged_tu_seen_base;
 188 static void free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *);
 189
 190 /* Do `exp = require_complete_type (loc, exp);' to make sure exp
 191    does not have an incomplete type.  (That includes void types.)
 192    LOC is the location of the use.  */
 193
 194 tree
 195 require_complete_type (location_t loc, tree value)
 196 {
 197   tree type = TREE_TYPE (value);
 198
 199   if (error_operand_p (value))
 200     return error_mark_node;
 201
 202   /* First, detect a valid value with a complete type.  */
 203   if (COMPLETE_TYPE_P (type))
 204     return value;
 205
 206   c_incomplete_type_error (loc, value, type);
 207   return error_mark_node;
 208 }
 209
 210 /* Print an error message for invalid use of an incomplete type.
 211    VALUE is the expression that was used (or 0 if that isn't known)
 212    and TYPE is the type that was invalid.  LOC is the location for
 213    the error.  */
 214
 215 void
 216 c_incomplete_type_error (location_t loc, const_tree value, const_tree type)
 217 {
 218   /* Avoid duplicate error message.  */
 219   if (TREE_CODE (type) == ERROR_MARK)
 220     return;
 221
 222   if (value != NULL_TREE && (VAR_P (value) || TREE_CODE (value) == PARM_DECL))
 223     error_at (loc, "%qD has an incomplete type %qT", value, type);
 224   else
 225     {
 226     retry:
 227       /* We must print an error message.  Be clever about what it says.  */
 228
 229       switch (TREE_CODE (type))
 230         {
 231         case RECORD_TYPE:
 232         case UNION_TYPE:
 233         case ENUMERAL_TYPE:
 234           break;
 235
 236         case VOID_TYPE:
 237           error_at (loc, "invalid use of void expression");
 238           return;
 239
 240         case ARRAY_TYPE:
 241           if (TYPE_DOMAIN (type))
 242             {
 243               if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL)
 244                 {
 245                   error_at (loc, "invalid use of flexible array member");
 246                   return;
 247                 }
 248               type = TREE_TYPE (type);
 249               goto retry;
 250             }
 251           error_at (loc, "invalid use of array with unspecified bounds");
 252           return;
 253
 254         default:
 255           gcc_unreachable ();
 256         }
 257
 258       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
 259         error_at (loc, "invalid use of undefined type %qT", type);
 260       else
 261         /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL.  */
 262         error_at (loc, "invalid use of incomplete typedef %qT", type);
 263     }
 264 }
 265
 266 /* Given a type, apply default promotions wrt unnamed function
 267    arguments and return the new type.  */
 268
 269 tree
 270 c_type_promotes_to (tree type)
 271 {
 272   tree ret = NULL_TREE;
 273
 274   if (TYPE_MAIN_VARIANT (type) == float_type_node)
 275     ret = double_type_node;
 276   else if (c_promoting_integer_type_p (type))
 277     {
 278       /* Preserve unsignedness if not really getting any wider.  */
 279       if (TYPE_UNSIGNED (type)
 280           && (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
 281         ret = unsigned_type_node;
 282       else
 283         ret = integer_type_node;
 284     }
 285
 286   if (ret != NULL_TREE)
 287     return (TYPE_ATOMIC (type)
 288             ? c_build_qualified_type (ret, TYPE_QUAL_ATOMIC)
 289             : ret);
 290
 291   return type;
 292 }
 293
 294 /* Return true if between two named address spaces, whether there is a superset
 295    named address space that encompasses both address spaces.  If there is a
 296    superset, return which address space is the superset.  */
 297
 298 static bool
 299 addr_space_superset (addr_space_t as1, addr_space_t as2, addr_space_t *common)
 300 {
 301   if (as1 == as2)
 302     {
 303       *common = as1;
 304       return true;
 305     }
 306   else if (targetm.addr_space.subset_p (as1, as2))
 307     {
 308       *common = as2;
 309       return true;
 310     }
 311   else if (targetm.addr_space.subset_p (as2, as1))
 312     {
 313       *common = as1;
 314       return true;
 315     }
 316   else
 317     return false;
 318 }
 319
 320 /* Return a variant of TYPE which has all the type qualifiers of LIKE
 321    as well as those of TYPE.  */
 322
 323 static tree
 324 qualify_type (tree type, tree like)
 325 {
 326   addr_space_t as_type = TYPE_ADDR_SPACE (type);
 327   addr_space_t as_like = TYPE_ADDR_SPACE (like);
 328   addr_space_t as_common;
 329
 330   /* If the two named address spaces are different, determine the common
 331      superset address space.  If there isn't one, raise an error.  */
 332   if (!addr_space_superset (as_type, as_like, &as_common))
 333     {
 334       as_common = as_type;
 335       error ("%qT and %qT are in disjoint named address spaces",
 336              type, like);
 337     }
 338
 339   return c_build_qualified_type (type,
 340                                  TYPE_QUALS_NO_ADDR_SPACE (type)
 341                                  | TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (like)
 342                                  | ENCODE_QUAL_ADDR_SPACE (as_common));
 343 }
 344
 345 /* Return true iff the given tree T is a variable length array.  */
 346
 347 bool
 348 c_vla_type_p (const_tree t)
 349 {
 350   if (TREE_CODE (t) == ARRAY_TYPE
 351       && C_TYPE_VARIABLE_SIZE (t))
 352     return true;
 353   return false;
 354 }
 355 \f
 356 /* Return the composite type of two compatible types.
 357
 358    We assume that comptypes has already been done and returned
 359    nonzero; if that isn't so, this may crash.  In particular, we
 360    assume that qualifiers match.  */
 361
 362 tree
 363 composite_type (tree t1, tree t2)
 364 {
 365   enum tree_code code1;
 366   enum tree_code code2;
 367   tree attributes;
 368
 369   /* Save time if the two types are the same.  */
 370
 371   if (t1 == t2) return t1;
 372
 373   /* If one type is nonsense, use the other.  */
 374   if (t1 == error_mark_node)
 375     return t2;
 376   if (t2 == error_mark_node)
 377     return t1;
 378
 379   code1 = TREE_CODE (t1);
 380   code2 = TREE_CODE (t2);
 381
 382   /* Merge the attributes.  */
 383   attributes = targetm.merge_type_attributes (t1, t2);
 384
 385   /* If one is an enumerated type and the other is the compatible
 386      integer type, the composite type might be either of the two
 387      (DR#013 question 3).  For consistency, use the enumerated type as
 388      the composite type.  */
 389
 390   if (code1 == ENUMERAL_TYPE && code2 == INTEGER_TYPE)
 391     return t1;
 392   if (code2 == ENUMERAL_TYPE && code1 == INTEGER_TYPE)
 393     return t2;
 394
 395   gcc_assert (code1 == code2);
 396
 397   switch (code1)
 398     {
 399     case POINTER_TYPE:
 400       /* For two pointers, do this recursively on the target type.  */
 401       {
 402         tree pointed_to_1 = TREE_TYPE (t1);
 403         tree pointed_to_2 = TREE_TYPE (t2);
 404         tree target = composite_type (pointed_to_1, pointed_to_2);
 405         t1 = build_pointer_type_for_mode (target, TYPE_MODE (t1), false);
 406         t1 = build_type_attribute_variant (t1, attributes);
 407         return qualify_type (t1, t2);
 408       }
 409
 410     case ARRAY_TYPE:
 411       {
 412         tree elt = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
 413         int quals;
 414         tree unqual_elt;
 415         tree d1 = TYPE_DOMAIN (t1);
 416         tree d2 = TYPE_DOMAIN (t2);
 417         bool d1_variable, d2_variable;
 418         bool d1_zero, d2_zero;
 419         bool t1_complete, t2_complete;
 420
 421         /* We should not have any type quals on arrays at all.  */
 422         gcc_assert (!TYPE_QUALS_NO_ADDR_SPACE (t1)
 423                     && !TYPE_QUALS_NO_ADDR_SPACE (t2));
 424
 425         t1_complete = COMPLETE_TYPE_P (t1);
 426         t2_complete = COMPLETE_TYPE_P (t2);
 427
 428         d1_zero = d1 == NULL_TREE || !TYPE_MAX_VALUE (d1);
 429         d2_zero = d2 == NULL_TREE || !TYPE_MAX_VALUE (d2);
 430
 431         d1_variable = (!d1_zero
 432                        && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
 433                            || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
 434         d2_variable = (!d2_zero
 435                        && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
 436                            || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
 437         d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1));
 438         d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2));
 439
 440         /* Save space: see if the result is identical to one of the args.  */
 441         if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1)
 442             && (d2_variable || d2_zero || !d1_variable))
 443           return build_type_attribute_variant (t1, attributes);
 444         if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2)
 445             && (d1_variable || d1_zero || !d2_variable))
 446           return build_type_attribute_variant (t2, attributes);
 447
 448         if (elt == TREE_TYPE (t1) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
 449           return build_type_attribute_variant (t1, attributes);
 450         if (elt == TREE_TYPE (t2) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
 451           return build_type_attribute_variant (t2, attributes);
 452
 453         /* Merge the element types, and have a size if either arg has
 454            one.  We may have qualifiers on the element types.  To set
 455            up TYPE_MAIN_VARIANT correctly, we need to form the
 456            composite of the unqualified types and add the qualifiers
 457            back at the end.  */
 458         quals = TYPE_QUALS (strip_array_types (elt));
 459         unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
 460         t1 = build_array_type (unqual_elt,
 461                                TYPE_DOMAIN ((TYPE_DOMAIN (t1)
 462                                              && (d2_variable
 463                                                  || d2_zero
 464                                                  || !d1_variable))
 465                                             ? t1
 466                                             : t2));
 467         /* Ensure a composite type involving a zero-length array type
 468            is a zero-length type not an incomplete type.  */
 469         if (d1_zero && d2_zero
 470             && (t1_complete || t2_complete)
 471             && !COMPLETE_TYPE_P (t1))
 472           {
 473             TYPE_SIZE (t1) = bitsize_zero_node;
 474             TYPE_SIZE_UNIT (t1) = size_zero_node;
 475           }
 476         t1 = c_build_qualified_type (t1, quals);
 477         return build_type_attribute_variant (t1, attributes);
 478       }
 479
 480     case ENUMERAL_TYPE:
 481     case RECORD_TYPE:
 482     case UNION_TYPE:
 483       if (attributes != NULL)
 484         {
 485           /* Try harder not to create a new aggregate type.  */
 486           if (attribute_list_equal (TYPE_ATTRIBUTES (t1), attributes))
 487             return t1;
 488           if (attribute_list_equal (TYPE_ATTRIBUTES (t2), attributes))
 489             return t2;
 490         }
 491       return build_type_attribute_variant (t1, attributes);
 492
 493     case FUNCTION_TYPE:
 494       /* Function types: prefer the one that specified arg types.
 495          If both do, merge the arg types.  Also merge the return types.  */
 496       {
 497         tree valtype = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
 498         tree p1 = TYPE_ARG_TYPES (t1);
 499         tree p2 = TYPE_ARG_TYPES (t2);
 500         int len;
 501         tree newargs, n;
 502         int i;
 503
 504         /* Save space: see if the result is identical to one of the args.  */
 505         if (valtype == TREE_TYPE (t1) && !TYPE_ARG_TYPES (t2))
 506           return build_type_attribute_variant (t1, attributes);
 507         if (valtype == TREE_TYPE (t2) && !TYPE_ARG_TYPES (t1))
 508           return build_type_attribute_variant (t2, attributes);
 509
 510         /* Simple way if one arg fails to specify argument types.  */
 511         if (TYPE_ARG_TYPES (t1) == NULL_TREE)
 512          {
 513             t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
 514             t1 = build_type_attribute_variant (t1, attributes);
 515             return qualify_type (t1, t2);
 516          }
 517         if (TYPE_ARG_TYPES (t2) == NULL_TREE)
 518          {
 519            t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
 520            t1 = build_type_attribute_variant (t1, attributes);
 521            return qualify_type (t1, t2);
 522          }
 523
 524         /* If both args specify argument types, we must merge the two
 525            lists, argument by argument.  */
 526
 527         for (len = 0, newargs = p1;
 528              newargs && newargs != void_list_node;
 529              len++, newargs = TREE_CHAIN (newargs))
 530           ;
 531
 532         for (i = 0; i < len; i++)
 533           newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
 534
 535         n = newargs;
 536
 537         for (; p1 && p1 != void_list_node;
 538              p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
 539           {
 540             /* A null type means arg type is not specified.
 541                Take whatever the other function type has.  */
 542             if (TREE_VALUE (p1) == NULL_TREE)
 543               {
 544                 TREE_VALUE (n) = TREE_VALUE (p2);
 545                 goto parm_done;
 546               }
 547             if (TREE_VALUE (p2) == NULL_TREE)
 548               {
 549                 TREE_VALUE (n) = TREE_VALUE (p1);
 550                 goto parm_done;
 551               }
 552
 553             /* Given  wait (union {union wait *u; int *i} *)
 554                and  wait (union wait *),
 555                prefer  union wait *  as type of parm.  */
 556             if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
 557                 && TREE_VALUE (p1) != TREE_VALUE (p2))
 558               {
 559                 tree memb;
 560                 tree mv2 = TREE_VALUE (p2);
 561                 if (mv2 && mv2 != error_mark_node
 562                     && TREE_CODE (mv2) != ARRAY_TYPE)
 563                   mv2 = TYPE_MAIN_VARIANT (mv2);
 564                 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
 565                      memb; memb = DECL_CHAIN (memb))
 566                   {
 567                     tree mv3 = TREE_TYPE (memb);
 568                     if (mv3 && mv3 != error_mark_node
 569                         && TREE_CODE (mv3) != ARRAY_TYPE)
 570                       mv3 = TYPE_MAIN_VARIANT (mv3);
 571                     if (comptypes (mv3, mv2))
 572                       {
 573                         TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
 574                                                          TREE_VALUE (p2));
 575                         pedwarn (input_location, OPT_Wpedantic,
 576                                  "function types not truly compatible in ISO C");
 577                         goto parm_done;
 578                       }
 579                   }
 580               }
 581             if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
 582                 && TREE_VALUE (p2) != TREE_VALUE (p1))
 583               {
 584                 tree memb;
 585                 tree mv1 = TREE_VALUE (p1);
 586                 if (mv1 && mv1 != error_mark_node
 587                     && TREE_CODE (mv1) != ARRAY_TYPE)
 588                   mv1 = TYPE_MAIN_VARIANT (mv1);
 589                 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
 590                      memb; memb = DECL_CHAIN (memb))
 591                   {
 592                     tree mv3 = TREE_TYPE (memb);
 593                     if (mv3 && mv3 != error_mark_node
 594                         && TREE_CODE (mv3) != ARRAY_TYPE)
 595                       mv3 = TYPE_MAIN_VARIANT (mv3);
 596                     if (comptypes (mv3, mv1))
 597                       {
 598                         TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
 599                                                          TREE_VALUE (p1));
 600                         pedwarn (input_location, OPT_Wpedantic,
 601                                  "function types not truly compatible in ISO C");
 602                         goto parm_done;
 603                       }
 604                   }
 605               }
 606             TREE_VALUE (n) = composite_type (TREE_VALUE (p1), TREE_VALUE (p2));
 607           parm_done: ;
 608           }
 609
 610         t1 = build_function_type (valtype, newargs);
 611         t1 = qualify_type (t1, t2);
 612       }
 613       /* FALLTHRU */
 614
 615     default:
 616       return build_type_attribute_variant (t1, attributes);
 617     }
 618
 619 }
 620
 621 /* Return the type of a conditional expression between pointers to
 622    possibly differently qualified versions of compatible types.
 623
 624    We assume that comp_target_types has already been done and returned
 625    nonzero; if that isn't so, this may crash.  */
 626
 627 static tree
 628 common_pointer_type (tree t1, tree t2)
 629 {
 630   tree attributes;
 631   tree pointed_to_1, mv1;
 632   tree pointed_to_2, mv2;
 633   tree target;
 634   unsigned target_quals;
 635   addr_space_t as1, as2, as_common;
 636   int quals1, quals2;
 637
 638   /* Save time if the two types are the same.  */
 639
 640   if (t1 == t2) return t1;
 641
 642   /* If one type is nonsense, use the other.  */
 643   if (t1 == error_mark_node)
 644     return t2;
 645   if (t2 == error_mark_node)
 646     return t1;
 647
 648   gcc_assert (TREE_CODE (t1) == POINTER_TYPE
 649               && TREE_CODE (t2) == POINTER_TYPE);
 650
 651   /* Merge the attributes.  */
 652   attributes = targetm.merge_type_attributes (t1, t2);
 653
 654   /* Find the composite type of the target types, and combine the
 655      qualifiers of the two types' targets.  Do not lose qualifiers on
 656      array element types by taking the TYPE_MAIN_VARIANT.  */
 657   mv1 = pointed_to_1 = TREE_TYPE (t1);
 658   mv2 = pointed_to_2 = TREE_TYPE (t2);
 659   if (TREE_CODE (mv1) != ARRAY_TYPE)
 660     mv1 = TYPE_MAIN_VARIANT (pointed_to_1);
 661   if (TREE_CODE (mv2) != ARRAY_TYPE)
 662     mv2 = TYPE_MAIN_VARIANT (pointed_to_2);
 663   target = composite_type (mv1, mv2);
 664
 665   /* Strip array types to get correct qualifier for pointers to arrays */
 666   quals1 = TYPE_QUALS_NO_ADDR_SPACE (strip_array_types (pointed_to_1));
 667   quals2 = TYPE_QUALS_NO_ADDR_SPACE (strip_array_types (pointed_to_2));
 668
 669   /* For function types do not merge const qualifiers, but drop them
 670      if used inconsistently.  The middle-end uses these to mark const
 671      and noreturn functions.  */
 672   if (TREE_CODE (pointed_to_1) == FUNCTION_TYPE)
 673     target_quals = (quals1 & quals2);
 674   else
 675     target_quals = (quals1 | quals2);
 676
 677   /* If the two named address spaces are different, determine the common
 678      superset address space.  This is guaranteed to exist due to the
 679      assumption that comp_target_type returned non-zero.  */
 680   as1 = TYPE_ADDR_SPACE (pointed_to_1);
 681   as2 = TYPE_ADDR_SPACE (pointed_to_2);
 682   if (!addr_space_superset (as1, as2, &as_common))
 683     gcc_unreachable ();
 684
 685   target_quals |= ENCODE_QUAL_ADDR_SPACE (as_common);
 686
 687   t1 = build_pointer_type (c_build_qualified_type (target, target_quals));
 688   return build_type_attribute_variant (t1, attributes);
 689 }
 690
 691 /* Return the common type for two arithmetic types under the usual
 692    arithmetic conversions.  The default conversions have already been
 693    applied, and enumerated types converted to their compatible integer
 694    types.  The resulting type is unqualified and has no attributes.
 695
 696    This is the type for the result of most arithmetic operations
 697    if the operands have the given two types.  */
 698
 699 static tree
 700 c_common_type (tree t1, tree t2)
 701 {
 702   enum tree_code code1;
 703   enum tree_code code2;
 704
 705   /* If one type is nonsense, use the other.  */
 706   if (t1 == error_mark_node)
 707     return t2;
 708   if (t2 == error_mark_node)
 709     return t1;
 710
 711   if (TYPE_QUALS (t1) != TYPE_UNQUALIFIED)
 712     t1 = TYPE_MAIN_VARIANT (t1);
 713
 714   if (TYPE_QUALS (t2) != TYPE_UNQUALIFIED)
 715     t2 = TYPE_MAIN_VARIANT (t2);
 716
 717   if (TYPE_ATTRIBUTES (t1) != NULL_TREE)
 718     t1 = build_type_attribute_variant (t1, NULL_TREE);
 719
 720   if (TYPE_ATTRIBUTES (t2) != NULL_TREE)
 721     t2 = build_type_attribute_variant (t2, NULL_TREE);
 722
 723   /* Save time if the two types are the same.  */
 724
 725   if (t1 == t2) return t1;
 726
 727   code1 = TREE_CODE (t1);
 728   code2 = TREE_CODE (t2);
 729
 730   gcc_assert (code1 == VECTOR_TYPE || code1 == COMPLEX_TYPE
 731               || code1 == FIXED_POINT_TYPE || code1 == REAL_TYPE
 732               || code1 == INTEGER_TYPE);
 733   gcc_assert (code2 == VECTOR_TYPE || code2 == COMPLEX_TYPE
 734               || code2 == FIXED_POINT_TYPE || code2 == REAL_TYPE
 735               || code2 == INTEGER_TYPE);
 736
 737   /* When one operand is a decimal float type, the other operand cannot be
 738      a generic float type or a complex type.  We also disallow vector types
 739      here.  */
 740   if ((DECIMAL_FLOAT_TYPE_P (t1) || DECIMAL_FLOAT_TYPE_P (t2))
 741       && !(DECIMAL_FLOAT_TYPE_P (t1) && DECIMAL_FLOAT_TYPE_P (t2)))
 742     {
 743       if (code1 == VECTOR_TYPE || code2 == VECTOR_TYPE)
 744         {
 745           error ("can%'t mix operands of decimal float and vector types");
 746           return error_mark_node;
 747         }
 748       if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
 749         {
 750           error ("can%'t mix operands of decimal float and complex types");
 751           return error_mark_node;
 752         }
 753       if (code1 == REAL_TYPE && code2 == REAL_TYPE)
 754         {
 755           error ("can%'t mix operands of decimal float and other float types");
 756           return error_mark_node;
 757         }
 758     }
 759
 760   /* If one type is a vector type, return that type.  (How the usual
 761      arithmetic conversions apply to the vector types extension is not
 762      precisely specified.)  */
 763   if (code1 == VECTOR_TYPE)
 764     return t1;
 765
 766   if (code2 == VECTOR_TYPE)
 767     return t2;
 768
 769   /* If one type is complex, form the common type of the non-complex
 770      components, then make that complex.  Use T1 or T2 if it is the
 771      required type.  */
 772   if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
 773     {
 774       tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
 775       tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
 776       tree subtype = c_common_type (subtype1, subtype2);
 777
 778       if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
 779         return t1;
 780       else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
 781         return t2;
 782       else
 783         return build_complex_type (subtype);
 784     }
 785
 786   /* If only one is real, use it as the result.  */
 787
 788   if (code1 == REAL_TYPE && code2 != REAL_TYPE)
 789     return t1;
 790
 791   if (code2 == REAL_TYPE && code1 != REAL_TYPE)
 792     return t2;
 793
 794   /* If both are real and either are decimal floating point types, use
 795      the decimal floating point type with the greater precision. */
 796
 797   if (code1 == REAL_TYPE && code2 == REAL_TYPE)
 798     {
 799       if (TYPE_MAIN_VARIANT (t1) == dfloat128_type_node
 800           || TYPE_MAIN_VARIANT (t2) == dfloat128_type_node)
 801         return dfloat128_type_node;
 802       else if (TYPE_MAIN_VARIANT (t1) == dfloat64_type_node
 803                || TYPE_MAIN_VARIANT (t2) == dfloat64_type_node)
 804         return dfloat64_type_node;
 805       else if (TYPE_MAIN_VARIANT (t1) == dfloat32_type_node
 806                || TYPE_MAIN_VARIANT (t2) == dfloat32_type_node)
 807         return dfloat32_type_node;
 808     }
 809
 810   /* Deal with fixed-point types.  */
 811   if (code1 == FIXED_POINT_TYPE || code2 == FIXED_POINT_TYPE)
 812     {
 813       unsigned int unsignedp = 0, satp = 0;
 814       scalar_mode m1, m2;
 815       unsigned int fbit1, ibit1, fbit2, ibit2, max_fbit, max_ibit;
 816
 817       m1 = SCALAR_TYPE_MODE (t1);
 818       m2 = SCALAR_TYPE_MODE (t2);
 819
 820       /* If one input type is saturating, the result type is saturating.  */
 821       if (TYPE_SATURATING (t1) || TYPE_SATURATING (t2))
 822         satp = 1;
 823
 824       /* If both fixed-point types are unsigned, the result type is unsigned.
 825          When mixing fixed-point and integer types, follow the sign of the
 826          fixed-point type.
 827          Otherwise, the result type is signed.  */
 828       if ((TYPE_UNSIGNED (t1) && TYPE_UNSIGNED (t2)
 829            && code1 == FIXED_POINT_TYPE && code2 == FIXED_POINT_TYPE)
 830           || (code1 == FIXED_POINT_TYPE && code2 != FIXED_POINT_TYPE
 831               && TYPE_UNSIGNED (t1))
 832           || (code1 != FIXED_POINT_TYPE && code2 == FIXED_POINT_TYPE
 833               && TYPE_UNSIGNED (t2)))
 834         unsignedp = 1;
 835
 836       /* The result type is signed.  */
 837       if (unsignedp == 0)
 838         {
 839           /* If the input type is unsigned, we need to convert to the
 840              signed type.  */
 841           if (code1 == FIXED_POINT_TYPE && TYPE_UNSIGNED (t1))
 842             {
 843               enum mode_class mclass = (enum mode_class) 0;
 844               if (GET_MODE_CLASS (m1) == MODE_UFRACT)
 845                 mclass = MODE_FRACT;
 846               else if (GET_MODE_CLASS (m1) == MODE_UACCUM)
 847                 mclass = MODE_ACCUM;
 848               else
 849                 gcc_unreachable ();
 850               m1 = as_a <scalar_mode>
 851                 (mode_for_size (GET_MODE_PRECISION (m1), mclass, 0));
 852             }
 853           if (code2 == FIXED_POINT_TYPE && TYPE_UNSIGNED (t2))
 854             {
 855               enum mode_class mclass = (enum mode_class) 0;
 856               if (GET_MODE_CLASS (m2) == MODE_UFRACT)
 857                 mclass = MODE_FRACT;
 858               else if (GET_MODE_CLASS (m2) == MODE_UACCUM)
 859                 mclass = MODE_ACCUM;
 860               else
 861                 gcc_unreachable ();
 862               m2 = as_a <scalar_mode>
 863                 (mode_for_size (GET_MODE_PRECISION (m2), mclass, 0));
 864             }
 865         }
 866
 867       if (code1 == FIXED_POINT_TYPE)
 868         {
 869           fbit1 = GET_MODE_FBIT (m1);
 870           ibit1 = GET_MODE_IBIT (m1);
 871         }
 872       else
 873         {
 874           fbit1 = 0;
 875           /* Signed integers need to subtract one sign bit.  */
 876           ibit1 = TYPE_PRECISION (t1) - (!TYPE_UNSIGNED (t1));
 877         }
 878
 879       if (code2 == FIXED_POINT_TYPE)
 880         {
 881           fbit2 = GET_MODE_FBIT (m2);
 882           ibit2 = GET_MODE_IBIT (m2);
 883         }
 884       else
 885         {
 886           fbit2 = 0;
 887           /* Signed integers need to subtract one sign bit.  */
 888           ibit2 = TYPE_PRECISION (t2) - (!TYPE_UNSIGNED (t2));
 889         }
 890
 891       max_ibit = ibit1 >= ibit2 ?  ibit1 : ibit2;
 892       max_fbit = fbit1 >= fbit2 ?  fbit1 : fbit2;
 893       return c_common_fixed_point_type_for_size (max_ibit, max_fbit, unsignedp,
 894                                                  satp);
 895     }
 896
 897   /* Both real or both integers; use the one with greater precision.  */
 898
 899   if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
 900     return t1;
 901   else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
 902     return t2;
 903
 904   /* Same precision.  Prefer long longs to longs to ints when the
 905      same precision, following the C99 rules on integer type rank
 906      (which are equivalent to the C90 rules for C90 types).  */
 907
 908   if (TYPE_MAIN_VARIANT (t1) == long_long_unsigned_type_node
 909       || TYPE_MAIN_VARIANT (t2) == long_long_unsigned_type_node)
 910     return long_long_unsigned_type_node;
 911
 912   if (TYPE_MAIN_VARIANT (t1) == long_long_integer_type_node
 913       || TYPE_MAIN_VARIANT (t2) == long_long_integer_type_node)
 914     {
 915       if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
 916         return long_long_unsigned_type_node;
 917       else
 918         return long_long_integer_type_node;
 919     }
 920
 921   if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
 922       || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
 923     return long_unsigned_type_node;
 924
 925   if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
 926       || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
 927     {
 928       /* But preserve unsignedness from the other type,
 929          since long cannot hold all the values of an unsigned int.  */
 930       if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
 931         return long_unsigned_type_node;
 932       else
 933         return long_integer_type_node;
 934     }
 935
 936   /* For floating types of the same TYPE_PRECISION (which we here
 937      assume means either the same set of values, or sets of values
 938      neither a subset of the other, with behavior being undefined in
 939      the latter case), follow the rules from TS 18661-3: prefer
 940      interchange types _FloatN, then standard types long double,
 941      double, float, then extended types _FloatNx.  For extended types,
 942      check them starting with _Float128x as that seems most consistent
 943      in spirit with preferring long double to double; for interchange
 944      types, also check in that order for consistency although it's not
 945      possible for more than one of them to have the same
 946      precision.  */
 947   tree mv1 = TYPE_MAIN_VARIANT (t1);
 948   tree mv2 = TYPE_MAIN_VARIANT (t2);
 949
 950   for (int i = NUM_FLOATN_TYPES - 1; i >= 0; i--)
 951     if (mv1 == FLOATN_TYPE_NODE (i) || mv2 == FLOATN_TYPE_NODE (i))
 952       return FLOATN_TYPE_NODE (i);
 953
 954   /* Likewise, prefer long double to double even if same size.  */
 955   if (mv1 == long_double_type_node || mv2 == long_double_type_node)
 956     return long_double_type_node;
 957
 958   /* Likewise, prefer double to float even if same size.
 959      We got a couple of embedded targets with 32 bit doubles, and the
 960      pdp11 might have 64 bit floats.  */
 961   if (mv1 == double_type_node || mv2 == double_type_node)
 962     return double_type_node;
 963
 964   if (mv1 == float_type_node || mv2 == float_type_node)
 965     return float_type_node;
 966
 967   for (int i = NUM_FLOATNX_TYPES - 1; i >= 0; i--)
 968     if (mv1 == FLOATNX_TYPE_NODE (i) || mv2 == FLOATNX_TYPE_NODE (i))
 969       return FLOATNX_TYPE_NODE (i);
 970
 971   /* Otherwise prefer the unsigned one.  */
 972
 973   if (TYPE_UNSIGNED (t1))
 974     return t1;
 975   else
 976     return t2;
 977 }
 978 \f
 979 /* Wrapper around c_common_type that is used by c-common.c and other
 980    front end optimizations that remove promotions.  ENUMERAL_TYPEs
 981    are allowed here and are converted to their compatible integer types.
 982    BOOLEAN_TYPEs are allowed here and return either boolean_type_node or
 983    preferably a non-Boolean type as the common type.  */
 984 tree
 985 common_type (tree t1, tree t2)
 986 {
 987   if (TREE_CODE (t1) == ENUMERAL_TYPE)
 988     t1 = c_common_type_for_size (TYPE_PRECISION (t1), 1);
 989   if (TREE_CODE (t2) == ENUMERAL_TYPE)
 990     t2 = c_common_type_for_size (TYPE_PRECISION (t2), 1);
 991
 992   /* If both types are BOOLEAN_TYPE, then return boolean_type_node.  */
 993   if (TREE_CODE (t1) == BOOLEAN_TYPE
 994       && TREE_CODE (t2) == BOOLEAN_TYPE)
 995     return boolean_type_node;
 996
 997   /* If either type is BOOLEAN_TYPE, then return the other.  */
 998   if (TREE_CODE (t1) == BOOLEAN_TYPE)
 999     return t2;
1000   if (TREE_CODE (t2) == BOOLEAN_TYPE)
1001     return t1;
1002
1003   return c_common_type (t1, t2);
1004 }
1005
1006 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
1007    or various other operations.  Return 2 if they are compatible
1008    but a warning may be needed if you use them together.  */
1009
1010 int
1011 comptypes (tree type1, tree type2)
1012 {
1013   const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base;
1014   int val;
1015
1016   val = comptypes_internal (type1, type2, NULL, NULL);
1017   free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1);
1018
1019   return val;
1020 }
1021
1022 /* Like comptypes, but if it returns non-zero because enum and int are
1023    compatible, it sets *ENUM_AND_INT_P to true.  */
1024
1025 static int
1026 comptypes_check_enum_int (tree type1, tree type2, bool *enum_and_int_p)
1027 {
1028   const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base;
1029   int val;
1030
1031   val = comptypes_internal (type1, type2, enum_and_int_p, NULL);
1032   free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1);
1033
1034   return val;
1035 }
1036
1037 /* Like comptypes, but if it returns nonzero for different types, it
1038    sets *DIFFERENT_TYPES_P to true.  */
1039
1040 int
1041 comptypes_check_different_types (tree type1, tree type2,
1042                                  bool *different_types_p)
1043 {
1044   const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base;
1045   int val;
1046
1047   val = comptypes_internal (type1, type2, NULL, different_types_p);
1048   free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1);
1049
1050   return val;
1051 }
1052 \f
1053 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
1054    or various other operations.  Return 2 if they are compatible
1055    but a warning may be needed if you use them together.  If
1056    ENUM_AND_INT_P is not NULL, and one type is an enum and the other a
1057    compatible integer type, then this sets *ENUM_AND_INT_P to true;
1058    *ENUM_AND_INT_P is never set to false.  If DIFFERENT_TYPES_P is not
1059    NULL, and the types are compatible but different enough not to be
1060    permitted in C11 typedef redeclarations, then this sets
1061    *DIFFERENT_TYPES_P to true; *DIFFERENT_TYPES_P is never set to
1062    false, but may or may not be set if the types are incompatible.
1063    This differs from comptypes, in that we don't free the seen
1064    types.  */
1065
1066 static int
1067 comptypes_internal (const_tree type1, const_tree type2, bool *enum_and_int_p,
1068                     bool *different_types_p)
1069 {
1070   const_tree t1 = type1;
1071   const_tree t2 = type2;
1072   int attrval, val;
1073
1074   /* Suppress errors caused by previously reported errors.  */
1075
1076   if (t1 == t2 || !t1 || !t2
1077       || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
1078     return 1;
1079
1080   /* Enumerated types are compatible with integer types, but this is
1081      not transitive: two enumerated types in the same translation unit
1082      are compatible with each other only if they are the same type.  */
1083
1084   if (TREE_CODE (t1) == ENUMERAL_TYPE && TREE_CODE (t2) != ENUMERAL_TYPE)
1085     {
1086       t1 = c_common_type_for_size (TYPE_PRECISION (t1), TYPE_UNSIGNED (t1));
1087       if (TREE_CODE (t2) != VOID_TYPE)
1088         {
1089           if (enum_and_int_p != NULL)
1090             *enum_and_int_p = true;
1091           if (different_types_p != NULL)
1092             *different_types_p = true;
1093         }
1094     }
1095   else if (TREE_CODE (t2) == ENUMERAL_TYPE && TREE_CODE (t1) != ENUMERAL_TYPE)
1096     {
1097       t2 = c_common_type_for_size (TYPE_PRECISION (t2), TYPE_UNSIGNED (t2));
1098       if (TREE_CODE (t1) != VOID_TYPE)
1099         {
1100           if (enum_and_int_p != NULL)
1101             *enum_and_int_p = true;
1102           if (different_types_p != NULL)
1103             *different_types_p = true;
1104         }
1105     }
1106
1107   if (t1 == t2)
1108     return 1;
1109
1110   /* Different classes of types can't be compatible.  */
1111
1112   if (TREE_CODE (t1) != TREE_CODE (t2))
1113     return 0;
1114
1115   /* Qualifiers must match. C99 6.7.3p9 */
1116
1117   if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
1118     return 0;
1119
1120   /* Allow for two different type nodes which have essentially the same
1121      definition.  Note that we already checked for equality of the type
1122      qualifiers (just above).  */
1123
1124   if (TREE_CODE (t1) != ARRAY_TYPE
1125       && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
1126     return 1;
1127
1128   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
1129   if (!(attrval = comp_type_attributes (t1, t2)))
1130      return 0;
1131
1132   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
1133   val = 0;
1134
1135   switch (TREE_CODE (t1))
1136     {
1137     case INTEGER_TYPE:
1138     case FIXED_POINT_TYPE:
1139     case REAL_TYPE:
1140       /* With these nodes, we can't determine type equivalence by
1141          looking at what is stored in the nodes themselves, because
1142          two nodes might have different TYPE_MAIN_VARIANTs but still
1143          represent the same type.  For example, wchar_t and int could
1144          have the same properties (TYPE_PRECISION, TYPE_MIN_VALUE,
1145          TYPE_MAX_VALUE, etc.), but have different TYPE_MAIN_VARIANTs
1146          and are distinct types.  On the other hand, int and the
1147          following typedef
1148
1149            typedef int INT __attribute((may_alias));
1150
1151          have identical properties, different TYPE_MAIN_VARIANTs, but
1152          represent the same type.  The canonical type system keeps
1153          track of equivalence in this case, so we fall back on it.  */
1154       return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
1155
1156     case POINTER_TYPE:
1157       /* Do not remove mode information.  */
1158       if (TYPE_MODE (t1) != TYPE_MODE (t2))
1159         break;
1160       val = (TREE_TYPE (t1) == TREE_TYPE (t2)
1161              ? 1 : comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
1162                                        enum_and_int_p, different_types_p));
1163       break;
1164
1165     case FUNCTION_TYPE:
1166       val = function_types_compatible_p (t1, t2, enum_and_int_p,
1167                                          different_types_p);
1168       break;
1169
1170     case ARRAY_TYPE:
1171       {
1172         tree d1 = TYPE_DOMAIN (t1);
1173         tree d2 = TYPE_DOMAIN (t2);
1174         bool d1_variable, d2_variable;
1175         bool d1_zero, d2_zero;
1176         val = 1;
1177
1178         /* Target types must match incl. qualifiers.  */
1179         if (TREE_TYPE (t1) != TREE_TYPE (t2)
1180             && (val = comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
1181                                           enum_and_int_p,
1182                                           different_types_p)) == 0)
1183           return 0;
1184
1185         if (different_types_p != NULL
1186             && (d1 == NULL_TREE) != (d2 == NULL_TREE))
1187           *different_types_p = true;
1188         /* Sizes must match unless one is missing or variable.  */
1189         if (d1 == NULL_TREE || d2 == NULL_TREE || d1 == d2)
1190           break;
1191
1192         d1_zero = !TYPE_MAX_VALUE (d1);
1193         d2_zero = !TYPE_MAX_VALUE (d2);
1194
1195         d1_variable = (!d1_zero
1196                        && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
1197                            || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
1198         d2_variable = (!d2_zero
1199                        && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
1200                            || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
1201         d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1));
1202         d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2));
1203
1204         if (different_types_p != NULL
1205             && d1_variable != d2_variable)
1206           *different_types_p = true;
1207         if (d1_variable || d2_variable)
1208           break;
1209         if (d1_zero && d2_zero)
1210           break;
1211         if (d1_zero || d2_zero
1212             || !tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
1213             || !tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
1214           val = 0;
1215
1216         break;
1217       }
1218
1219     case ENUMERAL_TYPE:
1220     case RECORD_TYPE:
1221     case UNION_TYPE:
1222       if (val != 1 && !same_translation_unit_p (t1, t2))
1223         {
1224           tree a1 = TYPE_ATTRIBUTES (t1);
1225           tree a2 = TYPE_ATTRIBUTES (t2);
1226
1227           if (! attribute_list_contained (a1, a2)
1228               && ! attribute_list_contained (a2, a1))
1229             break;
1230
1231           if (attrval != 2)
1232             return tagged_types_tu_compatible_p (t1, t2, enum_and_int_p,
1233                                                  different_types_p);
1234           val = tagged_types_tu_compatible_p (t1, t2, enum_and_int_p,
1235                                               different_types_p);
1236         }
1237       break;
1238
1239     case VECTOR_TYPE:
1240       val = (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1241              && comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
1242                                     enum_and_int_p, different_types_p));
1243       break;
1244
1245     default:
1246       break;
1247     }
1248   return attrval == 2 && val == 1 ? 2 : val;
1249 }
1250
1251 /* Return 1 if TTL and TTR are pointers to types that are equivalent, ignoring
1252    their qualifiers, except for named address spaces.  If the pointers point to
1253    different named addresses, then we must determine if one address space is a
1254    subset of the other.  */
1255
1256 static int
1257 comp_target_types (location_t location, tree ttl, tree ttr)
1258 {
1259   int val;
1260   int val_ped;
1261   tree mvl = TREE_TYPE (ttl);
1262   tree mvr = TREE_TYPE (ttr);
1263   addr_space_t asl = TYPE_ADDR_SPACE (mvl);
1264   addr_space_t asr = TYPE_ADDR_SPACE (mvr);
1265   addr_space_t as_common;
1266   bool enum_and_int_p;
1267
1268   /* Fail if pointers point to incompatible address spaces.  */
1269   if (!addr_space_superset (asl, asr, &as_common))
1270     return 0;
1271
1272   /* For pedantic record result of comptypes on arrays before losing
1273      qualifiers on the element type below. */
1274   val_ped = 1;
1275
1276   if (TREE_CODE (mvl) == ARRAY_TYPE
1277       && TREE_CODE (mvr) == ARRAY_TYPE)
1278     val_ped = comptypes (mvl, mvr);
1279
1280   /* Qualifiers on element types of array types that are
1281      pointer targets are lost by taking their TYPE_MAIN_VARIANT.  */
1282
1283   mvl = (TYPE_ATOMIC (strip_array_types (mvl))
1284          ? c_build_qualified_type (TYPE_MAIN_VARIANT (mvl), TYPE_QUAL_ATOMIC)
1285          : TYPE_MAIN_VARIANT (mvl));
1286
1287   mvr = (TYPE_ATOMIC (strip_array_types (mvr))
1288          ? c_build_qualified_type (TYPE_MAIN_VARIANT (mvr), TYPE_QUAL_ATOMIC)
1289          : TYPE_MAIN_VARIANT (mvr));
1290
1291   enum_and_int_p = false;
1292   val = comptypes_check_enum_int (mvl, mvr, &enum_and_int_p);
1293
1294   if (val == 1 && val_ped != 1)
1295     pedwarn (location, OPT_Wpedantic, "pointers to arrays with different qualifiers "
1296                                       "are incompatible in ISO C");
1297
1298   if (val == 2)
1299     pedwarn (location, OPT_Wpedantic, "types are not quite compatible");
1300
1301   if (val == 1 && enum_and_int_p && warn_cxx_compat)
1302     warning_at (location, OPT_Wc___compat,
1303                 "pointer target types incompatible in C++");
1304
1305   return val;
1306 }
1307 \f
1308 /* Subroutines of `comptypes'.  */
1309
1310 /* Determine whether two trees derive from the same translation unit.
1311    If the CONTEXT chain ends in a null, that tree's context is still
1312    being parsed, so if two trees have context chains ending in null,
1313    they're in the same translation unit.  */
1314
1315 bool
1316 same_translation_unit_p (const_tree t1, const_tree t2)
1317 {
1318   while (t1 && TREE_CODE (t1) != TRANSLATION_UNIT_DECL)
1319     switch (TREE_CODE_CLASS (TREE_CODE (t1)))
1320       {
1321       case tcc_declaration:
1322         t1 = DECL_CONTEXT (t1); break;
1323       case tcc_type:
1324         t1 = TYPE_CONTEXT (t1); break;
1325       case tcc_exceptional:
1326         t1 = BLOCK_SUPERCONTEXT (t1); break;  /* assume block */
1327       default: gcc_unreachable ();
1328       }
1329
1330   while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL)
1331     switch (TREE_CODE_CLASS (TREE_CODE (t2)))
1332       {
1333       case tcc_declaration:
1334         t2 = DECL_CONTEXT (t2); break;
1335       case tcc_type:
1336         t2 = TYPE_CONTEXT (t2); break;
1337       case tcc_exceptional:
1338         t2 = BLOCK_SUPERCONTEXT (t2); break;  /* assume block */
1339       default: gcc_unreachable ();
1340       }
1341
1342   return t1 == t2;
1343 }
1344
1345 /* Allocate the seen two types, assuming that they are compatible. */
1346
1347 static struct tagged_tu_seen_cache *
1348 alloc_tagged_tu_seen_cache (const_tree t1, const_tree t2)
1349 {
1350   struct tagged_tu_seen_cache *tu = XNEW (struct tagged_tu_seen_cache);
1351   tu->next = tagged_tu_seen_base;
1352   tu->t1 = t1;
1353   tu->t2 = t2;
1354
1355   tagged_tu_seen_base = tu;
1356
1357   /* The C standard says that two structures in different translation
1358      units are compatible with each other only if the types of their
1359      fields are compatible (among other things).  We assume that they
1360      are compatible until proven otherwise when building the cache.
1361      An example where this can occur is:
1362      struct a
1363      {
1364        struct a *next;
1365      };
1366      If we are comparing this against a similar struct in another TU,
1367      and did not assume they were compatible, we end up with an infinite
1368      loop.  */
1369   tu->val = 1;
1370   return tu;
1371 }
1372
1373 /* Free the seen types until we get to TU_TIL. */
1374
1375 static void
1376 free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *tu_til)
1377 {
1378   const struct tagged_tu_seen_cache *tu = tagged_tu_seen_base;
1379   while (tu != tu_til)
1380     {
1381       const struct tagged_tu_seen_cache *const tu1
1382         = (const struct tagged_tu_seen_cache *) tu;
1383       tu = tu1->next;
1384       free (CONST_CAST (struct tagged_tu_seen_cache *, tu1));
1385     }
1386   tagged_tu_seen_base = tu_til;
1387 }
1388
1389 /* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are
1390    compatible.  If the two types are not the same (which has been
1391    checked earlier), this can only happen when multiple translation
1392    units are being compiled.  See C99 6.2.7 paragraph 1 for the exact
1393    rules.  ENUM_AND_INT_P and DIFFERENT_TYPES_P are as in
1394    comptypes_internal.  */
1395
1396 static int
1397 tagged_types_tu_compatible_p (const_tree t1, const_tree t2,
1398                               bool *enum_and_int_p, bool *different_types_p)
1399 {
1400   tree s1, s2;
1401   bool needs_warning = false;
1402
1403   /* We have to verify that the tags of the types are the same.  This
1404      is harder than it looks because this may be a typedef, so we have
1405      to go look at the original type.  It may even be a typedef of a
1406      typedef...
1407      In the case of compiler-created builtin structs the TYPE_DECL
1408      may be a dummy, with no DECL_ORIGINAL_TYPE.  Don't fault.  */
1409   while (TYPE_NAME (t1)
1410          && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL
1411          && DECL_ORIGINAL_TYPE (TYPE_NAME (t1)))
1412     t1 = DECL_ORIGINAL_TYPE (TYPE_NAME (t1));
1413
1414   while (TYPE_NAME (t2)
1415          && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL
1416          && DECL_ORIGINAL_TYPE (TYPE_NAME (t2)))
1417     t2 = DECL_ORIGINAL_TYPE (TYPE_NAME (t2));
1418
1419   /* C90 didn't have the requirement that the two tags be the same.  */
1420   if (flag_isoc99 && TYPE_NAME (t1) != TYPE_NAME (t2))
1421     return 0;
1422
1423   /* C90 didn't say what happened if one or both of the types were
1424      incomplete; we choose to follow C99 rules here, which is that they
1425      are compatible.  */
1426   if (TYPE_SIZE (t1) == NULL
1427       || TYPE_SIZE (t2) == NULL)
1428     return 1;
1429
1430   {
1431     const struct tagged_tu_seen_cache * tts_i;
1432     for (tts_i = tagged_tu_seen_base; tts_i != NULL; tts_i = tts_i->next)
1433       if (tts_i->t1 == t1 && tts_i->t2 == t2)
1434         return tts_i->val;
1435   }
1436
1437   switch (TREE_CODE (t1))
1438     {
1439     case ENUMERAL_TYPE:
1440       {
1441         struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
1442         /* Speed up the case where the type values are in the same order.  */
1443         tree tv1 = TYPE_VALUES (t1);
1444         tree tv2 = TYPE_VALUES (t2);
1445
1446         if (tv1 == tv2)
1447           {
1448             return 1;
1449           }
1450
1451         for (;tv1 && tv2; tv1 = TREE_CHAIN (tv1), tv2 = TREE_CHAIN (tv2))
1452           {
1453             if (TREE_PURPOSE (tv1) != TREE_PURPOSE (tv2))
1454               break;
1455             if (simple_cst_equal (TREE_VALUE (tv1), TREE_VALUE (tv2)) != 1)
1456               {
1457                 tu->val = 0;
1458                 return 0;
1459               }
1460           }
1461
1462         if (tv1 == NULL_TREE && tv2 == NULL_TREE)
1463           {
1464             return 1;
1465           }
1466         if (tv1 == NULL_TREE || tv2 == NULL_TREE)
1467           {
1468             tu->val = 0;
1469             return 0;
1470           }
1471
1472         if (list_length (TYPE_VALUES (t1)) != list_length (TYPE_VALUES (t2)))
1473           {
1474             tu->val = 0;
1475             return 0;
1476           }
1477
1478         for (s1 = TYPE_VALUES (t1); s1; s1 = TREE_CHAIN (s1))
1479           {
1480             s2 = purpose_member (TREE_PURPOSE (s1), TYPE_VALUES (t2));
1481             if (s2 == NULL
1482                 || simple_cst_equal (TREE_VALUE (s1), TREE_VALUE (s2)) != 1)
1483               {
1484                 tu->val = 0;
1485                 return 0;
1486               }
1487           }
1488         return 1;
1489       }
1490
1491     case UNION_TYPE:
1492       {
1493         struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
1494         if (list_length (TYPE_FIELDS (t1)) != list_length (TYPE_FIELDS (t2)))
1495           {
1496             tu->val = 0;
1497             return 0;
1498           }
1499
1500         /*  Speed up the common case where the fields are in the same order. */
1501         for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2); s1 && s2;
1502              s1 = DECL_CHAIN (s1), s2 = DECL_CHAIN (s2))
1503           {
1504             int result;
1505
1506             if (DECL_NAME (s1) != DECL_NAME (s2))
1507               break;
1508             result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2),
1509                                          enum_and_int_p, different_types_p);
1510
1511             if (result != 1 && !DECL_NAME (s1))
1512               break;
1513             if (result == 0)
1514               {
1515                 tu->val = 0;
1516                 return 0;
1517               }
1518             if (result == 2)
1519               needs_warning = true;
1520
1521             if (TREE_CODE (s1) == FIELD_DECL
1522                 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
1523                                      DECL_FIELD_BIT_OFFSET (s2)) != 1)
1524               {
1525                 tu->val = 0;
1526                 return 0;
1527               }
1528           }
1529         if (!s1 && !s2)
1530           {
1531             tu->val = needs_warning ? 2 : 1;
1532             return tu->val;
1533           }
1534
1535         for (s1 = TYPE_FIELDS (t1); s1; s1 = DECL_CHAIN (s1))
1536           {
1537             bool ok = false;
1538
1539             for (s2 = TYPE_FIELDS (t2); s2; s2 = DECL_CHAIN (s2))
1540               if (DECL_NAME (s1) == DECL_NAME (s2))
1541                 {
1542                   int result;
1543
1544                   result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2),
1545                                                enum_and_int_p,
1546                                                different_types_p);
1547
1548                   if (result != 1 && !DECL_NAME (s1))
1549                     continue;
1550                   if (result == 0)
1551                     {
1552                       tu->val = 0;
1553                       return 0;
1554                     }
1555                   if (result == 2)
1556                     needs_warning = true;
1557
1558                   if (TREE_CODE (s1) == FIELD_DECL
1559                       && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
1560                                            DECL_FIELD_BIT_OFFSET (s2)) != 1)
1561                     break;
1562
1563                   ok = true;
1564                   break;
1565                 }
1566             if (!ok)
1567               {
1568                 tu->val = 0;
1569                 return 0;
1570               }
1571           }
1572         tu->val = needs_warning ? 2 : 10;
1573         return tu->val;
1574       }
1575
1576     case RECORD_TYPE:
1577       {
1578         struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
1579
1580         for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2);
1581              s1 && s2;
1582              s1 = DECL_CHAIN (s1), s2 = DECL_CHAIN (s2))
1583           {
1584             int result;
1585             if (TREE_CODE (s1) != TREE_CODE (s2)
1586                 || DECL_NAME (s1) != DECL_NAME (s2))
1587               break;
1588             result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2),
1589                                          enum_and_int_p, different_types_p);
1590             if (result == 0)
1591               break;
1592             if (result == 2)
1593               needs_warning = true;
1594
1595             if (TREE_CODE (s1) == FIELD_DECL
1596                 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
1597                                      DECL_FIELD_BIT_OFFSET (s2)) != 1)
1598               break;
1599           }
1600         if (s1 && s2)
1601           tu->val = 0;
1602         else
1603           tu->val = needs_warning ? 2 : 1;
1604         return tu->val;
1605       }
1606
1607     default:
1608       gcc_unreachable ();
1609     }
1610 }
1611
1612 /* Return 1 if two function types F1 and F2 are compatible.
1613    If either type specifies no argument types,
1614    the other must specify a fixed number of self-promoting arg types.
1615    Otherwise, if one type specifies only the number of arguments,
1616    the other must specify that number of self-promoting arg types.
1617    Otherwise, the argument types must match.
1618    ENUM_AND_INT_P and DIFFERENT_TYPES_P are as in comptypes_internal.  */
1619
1620 static int
1621 function_types_compatible_p (const_tree f1, const_tree f2,
1622                              bool *enum_and_int_p, bool *different_types_p)
1623 {
1624   tree args1, args2;
1625   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
1626   int val = 1;
1627   int val1;
1628   tree ret1, ret2;
1629
1630   ret1 = TREE_TYPE (f1);
1631   ret2 = TREE_TYPE (f2);
1632
1633   /* 'volatile' qualifiers on a function's return type used to mean
1634      the function is noreturn.  */
1635   if (TYPE_VOLATILE (ret1) != TYPE_VOLATILE (ret2))
1636     pedwarn (input_location, 0, "function return types not compatible due to %<volatile%>");
1637   if (TYPE_VOLATILE (ret1))
1638     ret1 = build_qualified_type (TYPE_MAIN_VARIANT (ret1),
1639                                  TYPE_QUALS (ret1) & ~TYPE_QUAL_VOLATILE);
1640   if (TYPE_VOLATILE (ret2))
1641     ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2),
1642                                  TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE);
1643   val = comptypes_internal (ret1, ret2, enum_and_int_p, different_types_p);
1644   if (val == 0)
1645     return 0;
1646
1647   args1 = TYPE_ARG_TYPES (f1);
1648   args2 = TYPE_ARG_TYPES (f2);
1649
1650   if (different_types_p != NULL
1651       && (args1 == NULL_TREE) != (args2 == NULL_TREE))
1652     *different_types_p = true;
1653
1654   /* An unspecified parmlist matches any specified parmlist
1655      whose argument types don't need default promotions.  */
1656
1657   if (args1 == NULL_TREE)
1658     {
1659       if (!self_promoting_args_p (args2))
1660         return 0;
1661       /* If one of these types comes from a non-prototype fn definition,
1662          compare that with the other type's arglist.
1663          If they don't match, ask for a warning (but no error).  */
1664       if (TYPE_ACTUAL_ARG_TYPES (f1)
1665           && type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1),
1666                                       enum_and_int_p, different_types_p) != 1)
1667         val = 2;
1668       return val;
1669     }
1670   if (args2 == NULL_TREE)
1671     {
1672       if (!self_promoting_args_p (args1))
1673         return 0;
1674       if (TYPE_ACTUAL_ARG_TYPES (f2)
1675           && type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2),
1676                                       enum_and_int_p, different_types_p) != 1)
1677         val = 2;
1678       return val;
1679     }
1680
1681   /* Both types have argument lists: compare them and propagate results.  */
1682   val1 = type_lists_compatible_p (args1, args2, enum_and_int_p,
1683                                   different_types_p);
1684   return val1 != 1 ? val1 : val;
1685 }
1686
1687 /* Check two lists of types for compatibility, returning 0 for
1688    incompatible, 1 for compatible, or 2 for compatible with
1689    warning.  ENUM_AND_INT_P and DIFFERENT_TYPES_P are as in
1690    comptypes_internal.  */
1691
1692 static int
1693 type_lists_compatible_p (const_tree args1, const_tree args2,
1694                          bool *enum_and_int_p, bool *different_types_p)
1695 {
1696   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
1697   int val = 1;
1698   int newval = 0;
1699
1700   while (1)
1701     {
1702       tree a1, mv1, a2, mv2;
1703       if (args1 == NULL_TREE && args2 == NULL_TREE)
1704         return val;
1705       /* If one list is shorter than the other,
1706          they fail to match.  */
1707       if (args1 == NULL_TREE || args2 == NULL_TREE)
1708         return 0;
1709       mv1 = a1 = TREE_VALUE (args1);
1710       mv2 = a2 = TREE_VALUE (args2);
1711       if (mv1 && mv1 != error_mark_node && TREE_CODE (mv1) != ARRAY_TYPE)
1712         mv1 = (TYPE_ATOMIC (mv1)
1713                ? c_build_qualified_type (TYPE_MAIN_VARIANT (mv1),
1714                                          TYPE_QUAL_ATOMIC)
1715                : TYPE_MAIN_VARIANT (mv1));
1716       if (mv2 && mv2 != error_mark_node && TREE_CODE (mv2) != ARRAY_TYPE)
1717         mv2 = (TYPE_ATOMIC (mv2)
1718                ? c_build_qualified_type (TYPE_MAIN_VARIANT (mv2),
1719                                          TYPE_QUAL_ATOMIC)
1720                : TYPE_MAIN_VARIANT (mv2));
1721       /* A null pointer instead of a type
1722          means there is supposed to be an argument
1723          but nothing is specified about what type it has.
1724          So match anything that self-promotes.  */
1725       if (different_types_p != NULL
1726           && (a1 == NULL_TREE) != (a2 == NULL_TREE))
1727         *different_types_p = true;
1728       if (a1 == NULL_TREE)
1729         {
1730           if (c_type_promotes_to (a2) != a2)
1731             return 0;
1732         }
1733       else if (a2 == NULL_TREE)
1734         {
1735           if (c_type_promotes_to (a1) != a1)
1736             return 0;
1737         }
1738       /* If one of the lists has an error marker, ignore this arg.  */
1739       else if (TREE_CODE (a1) == ERROR_MARK
1740                || TREE_CODE (a2) == ERROR_MARK)
1741         ;
1742       else if (!(newval = comptypes_internal (mv1, mv2, enum_and_int_p,
1743                                               different_types_p)))
1744         {
1745           if (different_types_p != NULL)
1746             *different_types_p = true;
1747           /* Allow  wait (union {union wait *u; int *i} *)
1748              and  wait (union wait *)  to be compatible.  */
1749           if (TREE_CODE (a1) == UNION_TYPE
1750               && (TYPE_NAME (a1) == NULL_TREE
1751                   || TYPE_TRANSPARENT_AGGR (a1))
1752               && TREE_CODE (TYPE_SIZE (a1)) == INTEGER_CST
1753               && tree_int_cst_equal (TYPE_SIZE (a1),
1754                                      TYPE_SIZE (a2)))
1755             {
1756               tree memb;
1757               for (memb = TYPE_FIELDS (a1);
1758                    memb; memb = DECL_CHAIN (memb))
1759                 {
1760                   tree mv3 = TREE_TYPE (memb);
1761                   if (mv3 && mv3 != error_mark_node
1762                       && TREE_CODE (mv3) != ARRAY_TYPE)
1763                     mv3 = (TYPE_ATOMIC (mv3)
1764                            ? c_build_qualified_type (TYPE_MAIN_VARIANT (mv3),
1765                                                      TYPE_QUAL_ATOMIC)
1766                            : TYPE_MAIN_VARIANT (mv3));
1767                   if (comptypes_internal (mv3, mv2, enum_and_int_p,
1768                                           different_types_p))
1769                     break;
1770                 }
1771               if (memb == NULL_TREE)
1772                 return 0;
1773             }
1774           else if (TREE_CODE (a2) == UNION_TYPE
1775                    && (TYPE_NAME (a2) == NULL_TREE
1776                        || TYPE_TRANSPARENT_AGGR (a2))
1777                    && TREE_CODE (TYPE_SIZE (a2)) == INTEGER_CST
1778                    && tree_int_cst_equal (TYPE_SIZE (a2),
1779                                           TYPE_SIZE (a1)))
1780             {
1781               tree memb;
1782               for (memb = TYPE_FIELDS (a2);
1783                    memb; memb = DECL_CHAIN (memb))
1784                 {
1785                   tree mv3 = TREE_TYPE (memb);
1786                   if (mv3 && mv3 != error_mark_node
1787                       && TREE_CODE (mv3) != ARRAY_TYPE)
1788                     mv3 = (TYPE_ATOMIC (mv3)
1789                            ? c_build_qualified_type (TYPE_MAIN_VARIANT (mv3),
1790                                                      TYPE_QUAL_ATOMIC)
1791                            : TYPE_MAIN_VARIANT (mv3));
1792                   if (comptypes_internal (mv3, mv1, enum_and_int_p,
1793                                           different_types_p))
1794                     break;
1795                 }
1796               if (memb == NULL_TREE)
1797                 return 0;
1798             }
1799           else
1800             return 0;
1801         }
1802
1803       /* comptypes said ok, but record if it said to warn.  */
1804       if (newval > val)
1805         val = newval;
1806
1807       args1 = TREE_CHAIN (args1);
1808       args2 = TREE_CHAIN (args2);
1809     }
1810 }
1811 \f
1812 /* Compute the size to increment a pointer by.  When a function type or void
1813    type or incomplete type is passed, size_one_node is returned.
1814    This function does not emit any diagnostics; the caller is responsible
1815    for that.  */
1816
1817 static tree
1818 c_size_in_bytes (const_tree type)
1819 {
1820   enum tree_code code = TREE_CODE (type);
1821
1822   if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK
1823       || !COMPLETE_TYPE_P (type))
1824     return size_one_node;
1825
1826   /* Convert in case a char is more than one unit.  */
1827   return size_binop_loc (input_location, CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
1828                          size_int (TYPE_PRECISION (char_type_node)
1829                                    / BITS_PER_UNIT));
1830 }
1831 \f
1832 /* Return either DECL or its known constant value (if it has one).  */
1833
1834 tree
1835 decl_constant_value_1 (tree decl)
1836 {
1837   if (/* Note that DECL_INITIAL isn't valid for a PARM_DECL.  */
1838       TREE_CODE (decl) != PARM_DECL
1839       && !TREE_THIS_VOLATILE (decl)
1840       && TREE_READONLY (decl)
1841       && DECL_INITIAL (decl) != NULL_TREE
1842       && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
1843       /* This is invalid if initial value is not constant.
1844          If it has either a function call, a memory reference,
1845          or a variable, then re-evaluating it could give different results.  */
1846       && TREE_CONSTANT (DECL_INITIAL (decl))
1847       /* Check for cases where this is sub-optimal, even though valid.  */
1848       && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
1849     return DECL_INITIAL (decl);
1850   return decl;
1851 }
1852
1853 /* Return either DECL or its known constant value (if it has one).
1854    Like the above, but always return decl outside of functions.  */
1855
1856 tree
1857 decl_constant_value (tree decl)
1858 {
1859   /* Don't change a variable array bound or initial value to a constant
1860      in a place where a variable is invalid.  */
1861   return current_function_decl ? decl_constant_value_1 (decl) : decl;
1862 }
1863
1864 /* Convert the array expression EXP to a pointer.  */
1865 static tree
1866 array_to_pointer_conversion (location_t loc, tree exp)
1867 {
1868   tree orig_exp = exp;
1869   tree type = TREE_TYPE (exp);
1870   tree adr;
1871   tree restype = TREE_TYPE (type);
1872   tree ptrtype;
1873
1874   gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
1875
1876   STRIP_TYPE_NOPS (exp);
1877
1878   if (TREE_NO_WARNING (orig_exp))
1879     TREE_NO_WARNING (exp) = 1;
1880
1881   ptrtype = build_pointer_type (restype);
1882
1883   if (INDIRECT_REF_P (exp))
1884     return convert (ptrtype, TREE_OPERAND (exp, 0));
1885
1886   /* In C++ array compound literals are temporary objects unless they are
1887      const or appear in namespace scope, so they are destroyed too soon
1888      to use them for much of anything  (c++/53220).  */
1889   if (warn_cxx_compat && TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
1890     {
1891       tree decl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
1892       if (!TREE_READONLY (decl) && !TREE_STATIC (decl))
1893         warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
1894                     "converting an array compound literal to a pointer "
1895                     "is ill-formed in C++");
1896     }
1897
1898   adr = build_unary_op (loc, ADDR_EXPR, exp, true);
1899   return convert (ptrtype, adr);
1900 }
1901
1902 /* Convert the function expression EXP to a pointer.  */
1903 static tree
1904 function_to_pointer_conversion (location_t loc, tree exp)
1905 {
1906   tree orig_exp = exp;
1907
1908   gcc_assert (TREE_CODE (TREE_TYPE (exp)) == FUNCTION_TYPE);
1909
1910   STRIP_TYPE_NOPS (exp);
1911
1912   if (TREE_NO_WARNING (orig_exp))
1913     TREE_NO_WARNING (exp) = 1;
1914
1915   return build_unary_op (loc, ADDR_EXPR, exp, false);
1916 }
1917
1918 /* Mark EXP as read, not just set, for set but not used -Wunused
1919    warning purposes.  */
1920
1921 void
1922 mark_exp_read (tree exp)
1923 {
1924   switch (TREE_CODE (exp))
1925     {
1926     case VAR_DECL:
1927     case PARM_DECL:
1928       DECL_READ_P (exp) = 1;
1929       break;
1930     case ARRAY_REF:
1931     case COMPONENT_REF:
1932     case MODIFY_EXPR:
1933     case REALPART_EXPR:
1934     case IMAGPART_EXPR:
1935     CASE_CONVERT:
1936     case ADDR_EXPR:
1937     case VIEW_CONVERT_EXPR:
1938       mark_exp_read (TREE_OPERAND (exp, 0));
1939       break;
1940     case COMPOUND_EXPR:
1941     case C_MAYBE_CONST_EXPR:
1942       mark_exp_read (TREE_OPERAND (exp, 1));
1943       break;
1944     default:
1945       break;
1946     }
1947 }
1948
1949 /* Perform the default conversion of arrays and functions to pointers.
1950    Return the result of converting EXP.  For any other expression, just
1951    return EXP.
1952
1953    LOC is the location of the expression.  */
1954
1955 struct c_expr
1956 default_function_array_conversion (location_t loc, struct c_expr exp)
1957 {
1958   tree orig_exp = exp.value;
1959   tree type = TREE_TYPE (exp.value);
1960   enum tree_code code = TREE_CODE (type);
1961
1962   switch (code)
1963     {
1964     case ARRAY_TYPE:
1965       {
1966         bool not_lvalue = false;
1967         bool lvalue_array_p;
1968
1969         while ((TREE_CODE (exp.value) == NON_LVALUE_EXPR
1970                 || CONVERT_EXPR_P (exp.value))
1971                && TREE_TYPE (TREE_OPERAND (exp.value, 0)) == type)
1972           {
1973             if (TREE_CODE (exp.value) == NON_LVALUE_EXPR)
1974               not_lvalue = true;
1975             exp.value = TREE_OPERAND (exp.value, 0);
1976           }
1977
1978         if (TREE_NO_WARNING (orig_exp))
1979           TREE_NO_WARNING (exp.value) = 1;
1980
1981         lvalue_array_p = !not_lvalue && lvalue_p (exp.value);
1982         if (!flag_isoc99 && !lvalue_array_p)
1983           {
1984             /* Before C99, non-lvalue arrays do not decay to pointers.
1985                Normally, using such an array would be invalid; but it can
1986                be used correctly inside sizeof or as a statement expression.
1987                Thus, do not give an error here; an error will result later.  */
1988             return exp;
1989           }
1990
1991         exp.value = array_to_pointer_conversion (loc, exp.value);
1992       }
1993       break;
1994     case FUNCTION_TYPE:
1995       exp.value = function_to_pointer_conversion (loc, exp.value);
1996       break;
1997     default:
1998       break;
1999     }
2000
2001   return exp;
2002 }
2003
2004 struct c_expr
2005 default_function_array_read_conversion (location_t loc, struct c_expr exp)
2006 {
2007   mark_exp_read (exp.value);
2008   return default_function_array_conversion (loc, exp);
2009 }
2010
2011 /* Return whether EXPR should be treated as an atomic lvalue for the
2012    purposes of load and store handling.  */
2013
2014 static bool
2015 really_atomic_lvalue (tree expr)
2016 {
2017   if (error_operand_p (expr))
2018     return false;
2019   if (!TYPE_ATOMIC (TREE_TYPE (expr)))
2020     return false;
2021   if (!lvalue_p (expr))
2022     return false;
2023
2024   /* Ignore _Atomic on register variables, since their addresses can't
2025      be taken so (a) atomicity is irrelevant and (b) the normal atomic
2026      sequences wouldn't work.  Ignore _Atomic on structures containing
2027      bit-fields, since accessing elements of atomic structures or
2028      unions is undefined behavior (C11 6.5.2.3#5), but it's unclear if
2029      it's undefined at translation time or execution time, and the
2030      normal atomic sequences again wouldn't work.  */
2031   while (handled_component_p (expr))
2032     {
2033       if (TREE_CODE (expr) == COMPONENT_REF
2034           && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2035         return false;
2036       expr = TREE_OPERAND (expr, 0);
2037     }
2038   if (DECL_P (expr) && C_DECL_REGISTER (expr))
2039     return false;
2040   return true;
2041 }
2042
2043 /* Convert expression EXP (location LOC) from lvalue to rvalue,
2044    including converting functions and arrays to pointers if CONVERT_P.
2045    If READ_P, also mark the expression as having been read.  */
2046
2047 struct c_expr
2048 convert_lvalue_to_rvalue (location_t loc, struct c_expr exp,
2049                           bool convert_p, bool read_p)
2050 {
2051   if (read_p)
2052     mark_exp_read (exp.value);
2053   if (convert_p)
2054     exp = default_function_array_conversion (loc, exp);
2055   if (really_atomic_lvalue (exp.value))
2056     {
2057       vec<tree, va_gc> *params;
2058       tree nonatomic_type, tmp, tmp_addr, fndecl, func_call;
2059       tree expr_type = TREE_TYPE (exp.value);
2060       tree expr_addr = build_unary_op (loc, ADDR_EXPR, exp.value, false);
2061       tree seq_cst = build_int_cst (integer_type_node, MEMMODEL_SEQ_CST);
2062
2063       gcc_assert (TYPE_ATOMIC (expr_type));
2064
2065       /* Expansion of a generic atomic load may require an addition
2066          element, so allocate enough to prevent a resize.  */
2067       vec_alloc (params, 4);
2068
2069       /* Remove the qualifiers for the rest of the expressions and
2070          create the VAL temp variable to hold the RHS.  */
2071       nonatomic_type = build_qualified_type (expr_type, TYPE_UNQUALIFIED);
2072       tmp = create_tmp_var_raw (nonatomic_type);
2073       tmp_addr = build_unary_op (loc, ADDR_EXPR, tmp, false);
2074       TREE_ADDRESSABLE (tmp) = 1;
2075       TREE_NO_WARNING (tmp) = 1;
2076
2077       /* Issue __atomic_load (&expr, &tmp, SEQ_CST);  */
2078       fndecl = builtin_decl_explicit (BUILT_IN_ATOMIC_LOAD);
2079       params->quick_push (expr_addr);
2080       params->quick_push (tmp_addr);
2081       params->quick_push (seq_cst);
2082       func_call = c_build_function_call_vec (loc, vNULL, fndecl, params, NULL);
2083
2084       /* EXPR is always read.  */
2085       mark_exp_read (exp.value);
2086
2087       /* Return tmp which contains the value loaded.  */
2088       exp.value = build4 (TARGET_EXPR, nonatomic_type, tmp, func_call,
2089                           NULL_TREE, NULL_TREE);
2090     }
2091   return exp;
2092 }
2093
2094 /* EXP is an expression of integer type.  Apply the integer promotions
2095    to it and return the promoted value.  */
2096
2097 tree
2098 perform_integral_promotions (tree exp)
2099 {
2100   tree type = TREE_TYPE (exp);
2101   enum tree_code code = TREE_CODE (type);
2102
2103   gcc_assert (INTEGRAL_TYPE_P (type));
2104
2105   /* Normally convert enums to int,
2106      but convert wide enums to something wider.  */
2107   if (code == ENUMERAL_TYPE)
2108     {
2109       type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
2110                                           TYPE_PRECISION (integer_type_node)),
2111                                      ((TYPE_PRECISION (type)
2112                                        >= TYPE_PRECISION (integer_type_node))
2113                                       && TYPE_UNSIGNED (type)));
2114
2115       return convert (type, exp);
2116     }
2117
2118   /* ??? This should no longer be needed now bit-fields have their
2119      proper types.  */
2120   if (TREE_CODE (exp) == COMPONENT_REF
2121       && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
2122       /* If it's thinner than an int, promote it like a
2123          c_promoting_integer_type_p, otherwise leave it alone.  */
2124       && compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
2125                            TYPE_PRECISION (integer_type_node)) < 0)
2126     return convert (integer_type_node, exp);
2127
2128   if (c_promoting_integer_type_p (type))
2129     {
2130       /* Preserve unsignedness if not really getting any wider.  */
2131       if (TYPE_UNSIGNED (type)
2132           && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2133         return convert (unsigned_type_node, exp);
2134
2135       return convert (integer_type_node, exp);
2136     }
2137
2138   return exp;
2139 }
2140
2141
2142 /* Perform default promotions for C data used in expressions.
2143    Enumeral types or short or char are converted to int.
2144    In addition, manifest constants symbols are replaced by their values.  */
2145
2146 tree
2147 default_conversion (tree exp)
2148 {
2149   tree orig_exp;
2150   tree type = TREE_TYPE (exp);
2151   enum tree_code code = TREE_CODE (type);
2152   tree promoted_type;
2153
2154   mark_exp_read (exp);
2155
2156   /* Functions and arrays have been converted during parsing.  */
2157   gcc_assert (code != FUNCTION_TYPE);
2158   if (code == ARRAY_TYPE)
2159     return exp;
2160
2161   /* Constants can be used directly unless they're not loadable.  */
2162   if (TREE_CODE (exp) == CONST_DECL)
2163     exp = DECL_INITIAL (exp);
2164
2165   /* Strip no-op conversions.  */
2166   orig_exp = exp;
2167   STRIP_TYPE_NOPS (exp);
2168
2169   if (TREE_NO_WARNING (orig_exp))
2170     TREE_NO_WARNING (exp) = 1;
2171
2172   if (code == VOID_TYPE)
2173     {
2174       error_at (EXPR_LOC_OR_LOC (exp, input_location),
2175                 "void value not ignored as it ought to be");
2176       return error_mark_node;
2177     }
2178
2179   exp = require_complete_type (EXPR_LOC_OR_LOC (exp, input_location), exp);
2180   if (exp == error_mark_node)
2181     return error_mark_node;
2182
2183   promoted_type = targetm.promoted_type (type);
2184   if (promoted_type)
2185     return convert (promoted_type, exp);
2186
2187   if (INTEGRAL_TYPE_P (type))
2188     return perform_integral_promotions (exp);
2189
2190   return exp;
2191 }
2192 \f
2193 /* Look up COMPONENT in a structure or union TYPE.
2194
2195    If the component name is not found, returns NULL_TREE.  Otherwise,
2196    the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
2197    stepping down the chain to the component, which is in the last
2198    TREE_VALUE of the list.  Normally the list is of length one, but if
2199    the component is embedded within (nested) anonymous structures or
2200    unions, the list steps down the chain to the component.  */
2201
2202 static tree
2203 lookup_field (tree type, tree component)
2204 {
2205   tree field;
2206
2207   /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
2208      to the field elements.  Use a binary search on this array to quickly
2209      find the element.  Otherwise, do a linear search.  TYPE_LANG_SPECIFIC
2210      will always be set for structures which have many elements.  */
2211
2212   if (TYPE_LANG_SPECIFIC (type) && TYPE_LANG_SPECIFIC (type)->s)
2213     {
2214       int bot, top, half;
2215       tree *field_array = &TYPE_LANG_SPECIFIC (type)->s->elts[0];
2216
2217       field = TYPE_FIELDS (type);
2218       bot = 0;
2219       top = TYPE_LANG_SPECIFIC (type)->s->len;
2220       while (top - bot > 1)
2221         {
2222           half = (top - bot + 1) >> 1;
2223           field = field_array[bot+half];
2224
2225           if (DECL_NAME (field) == NULL_TREE)
2226             {
2227               /* Step through all anon unions in linear fashion.  */
2228               while (DECL_NAME (field_array[bot]) == NULL_TREE)
2229                 {
2230                   field = field_array[bot++];
2231                   if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (field)))
2232                     {
2233                       tree anon = lookup_field (TREE_TYPE (field), component);
2234
2235                       if (anon)
2236                         return tree_cons (NULL_TREE, field, anon);
2237
2238                       /* The Plan 9 compiler permits referring
2239                          directly to an anonymous struct/union field
2240                          using a typedef name.  */
2241                       if (flag_plan9_extensions
2242                           && TYPE_NAME (TREE_TYPE (field)) != NULL_TREE
2243                           && (TREE_CODE (TYPE_NAME (TREE_TYPE (field)))
2244                               == TYPE_DECL)
2245                           && (DECL_NAME (TYPE_NAME (TREE_TYPE (field)))
2246                               == component))
2247                         break;
2248                     }
2249                 }
2250
2251               /* Entire record is only anon unions.  */
2252               if (bot > top)
2253                 return NULL_TREE;
2254
2255               /* Restart the binary search, with new lower bound.  */
2256               continue;
2257             }
2258
2259           if (DECL_NAME (field) == component)
2260             break;
2261           if (DECL_NAME (field) < component)
2262             bot += half;
2263           else
2264             top = bot + half;
2265         }
2266
2267       if (DECL_NAME (field_array[bot]) == component)
2268         field = field_array[bot];
2269       else if (DECL_NAME (field) != component)
2270         return NULL_TREE;
2271     }
2272   else
2273     {
2274       for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
2275         {
2276           if (DECL_NAME (field) == NULL_TREE
2277               && RECORD_OR_UNION_TYPE_P (TREE_TYPE (field)))
2278             {
2279               tree anon = lookup_field (TREE_TYPE (field), component);
2280
2281               if (anon)
2282                 return tree_cons (NULL_TREE, field, anon);
2283
2284               /* The Plan 9 compiler permits referring directly to an
2285                  anonymous struct/union field using a typedef
2286                  name.  */
2287               if (flag_plan9_extensions
2288                   && TYPE_NAME (TREE_TYPE (field)) != NULL_TREE
2289                   && TREE_CODE (TYPE_NAME (TREE_TYPE (field))) == TYPE_DECL
2290                   && (DECL_NAME (TYPE_NAME (TREE_TYPE (field)))
2291                       == component))
2292                 break;
2293             }
2294
2295           if (DECL_NAME (field) == component)
2296             break;
2297         }
2298
2299       if (field == NULL_TREE)
2300         return NULL_TREE;
2301     }
2302
2303   return tree_cons (NULL_TREE, field, NULL_TREE);
2304 }
2305
2306 /* Recursively append candidate IDENTIFIER_NODEs to CANDIDATES.  */
2307
2308 static void
2309 lookup_field_fuzzy_find_candidates (tree type, tree component,
2310                                     vec<tree> *candidates)
2311 {
2312   tree field;
2313   for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
2314     {
2315       if (DECL_NAME (field) == NULL_TREE
2316           && RECORD_OR_UNION_TYPE_P (TREE_TYPE (field)))
2317         lookup_field_fuzzy_find_candidates (TREE_TYPE (field), component,
2318                                             candidates);
2319
2320       if (DECL_NAME (field))
2321         candidates->safe_push (DECL_NAME (field));
2322     }
2323 }
2324
2325 /* Like "lookup_field", but find the closest matching IDENTIFIER_NODE,
2326    rather than returning a TREE_LIST for an exact match.  */
2327
2328 static tree
2329 lookup_field_fuzzy (tree type, tree component)
2330 {
2331   gcc_assert (TREE_CODE (component) == IDENTIFIER_NODE);
2332
2333   /* First, gather a list of candidates.  */
2334   auto_vec <tree> candidates;
2335
2336   lookup_field_fuzzy_find_candidates (type, component,
2337                                       &candidates);
2338
2339   return find_closest_identifier (component, &candidates);
2340 }
2341
2342 /* Support function for build_component_ref's error-handling.
2343
2344    Given DATUM_TYPE, and "DATUM.COMPONENT", where DATUM is *not* a
2345    struct or union, should we suggest "DATUM->COMPONENT" as a hint?  */
2346
2347 static bool
2348 should_suggest_deref_p (tree datum_type)
2349 {
2350   /* We don't do it for Objective-C, since Objective-C 2.0 dot-syntax
2351      allows "." for ptrs; we could be handling a failed attempt
2352      to access a property.  */
2353   if (c_dialect_objc ())
2354     return false;
2355
2356   /* Only suggest it for pointers...  */
2357   if (TREE_CODE (datum_type) != POINTER_TYPE)
2358     return false;
2359
2360   /* ...to structs/unions.  */
2361   tree underlying_type = TREE_TYPE (datum_type);
2362   enum tree_code code = TREE_CODE (underlying_type);
2363   if (code == RECORD_TYPE || code == UNION_TYPE)
2364     return true;
2365   else
2366     return false;
2367 }
2368
2369 /* Make an expression to refer to the COMPONENT field of structure or
2370    union value DATUM.  COMPONENT is an IDENTIFIER_NODE.  LOC is the
2371    location of the COMPONENT_REF.  COMPONENT_LOC is the location
2372    of COMPONENT.  */
2373
2374 tree
2375 build_component_ref (location_t loc, tree datum, tree component,
2376                      location_t component_loc)
2377 {
2378   tree type = TREE_TYPE (datum);
2379   enum tree_code code = TREE_CODE (type);
2380   tree field = NULL;
2381   tree ref;
2382   bool datum_lvalue = lvalue_p (datum);
2383
2384   if (!objc_is_public (datum, component))
2385     return error_mark_node;
2386
2387   /* Detect Objective-C property syntax object.property.  */
2388   if (c_dialect_objc ()
2389       && (ref = objc_maybe_build_component_ref (datum, component)))
2390     return ref;
2391
2392   /* See if there is a field or component with name COMPONENT.  */
2393
2394   if (code == RECORD_TYPE || code == UNION_TYPE)
2395     {
2396       if (!COMPLETE_TYPE_P (type))
2397         {
2398           c_incomplete_type_error (loc, NULL_TREE, type);
2399           return error_mark_node;
2400         }
2401
2402       field = lookup_field (type, component);
2403
2404       if (!field)
2405         {
2406           tree guessed_id = lookup_field_fuzzy (type, component);
2407           if (guessed_id)
2408             {
2409               /* Attempt to provide a fixit replacement hint, if
2410                  we have a valid range for the component.  */
2411               location_t reported_loc
2412                 = (component_loc != UNKNOWN_LOCATION) ? component_loc : loc;
2413               gcc_rich_location rich_loc (reported_loc);
2414               if (component_loc != UNKNOWN_LOCATION)
2415                 rich_loc.add_fixit_misspelled_id (component_loc, guessed_id);
2416               error_at (&rich_loc,
2417                         "%qT has no member named %qE; did you mean %qE?",
2418                         type, component, guessed_id);
2419             }
2420           else
2421             error_at (loc, "%qT has no member named %qE", type, component);
2422           return error_mark_node;
2423         }
2424
2425       /* Accessing elements of atomic structures or unions is undefined
2426          behavior (C11 6.5.2.3#5).  */
2427       if (TYPE_ATOMIC (type) && c_inhibit_evaluation_warnings == 0)
2428         {
2429           if (code == RECORD_TYPE)
2430             warning_at (loc, 0, "accessing a member %qE of an atomic "
2431                         "structure %qE", component, datum);
2432           else
2433             warning_at (loc, 0, "accessing a member %qE of an atomic "
2434                         "union %qE", component, datum);
2435         }
2436
2437       /* Chain the COMPONENT_REFs if necessary down to the FIELD.
2438          This might be better solved in future the way the C++ front
2439          end does it - by giving the anonymous entities each a
2440          separate name and type, and then have build_component_ref
2441          recursively call itself.  We can't do that here.  */
2442       do
2443         {
2444           tree subdatum = TREE_VALUE (field);
2445           int quals;
2446           tree subtype;
2447           bool use_datum_quals;
2448
2449           if (TREE_TYPE (subdatum) == error_mark_node)
2450             return error_mark_node;
2451
2452           /* If this is an rvalue, it does not have qualifiers in C
2453              standard terms and we must avoid propagating such
2454              qualifiers down to a non-lvalue array that is then
2455              converted to a pointer.  */
2456           use_datum_quals = (datum_lvalue
2457                              || TREE_CODE (TREE_TYPE (subdatum)) != ARRAY_TYPE);
2458
2459           quals = TYPE_QUALS (strip_array_types (TREE_TYPE (subdatum)));
2460           if (use_datum_quals)
2461             quals |= TYPE_QUALS (TREE_TYPE (datum));
2462           subtype = c_build_qualified_type (TREE_TYPE (subdatum), quals);
2463
2464           ref = build3 (COMPONENT_REF, subtype, datum, subdatum,
2465                         NULL_TREE);
2466           SET_EXPR_LOCATION (ref, loc);
2467           if (TREE_READONLY (subdatum)
2468               || (use_datum_quals && TREE_READONLY (datum)))
2469             TREE_READONLY (ref) = 1;
2470           if (TREE_THIS_VOLATILE (subdatum)
2471               || (use_datum_quals && TREE_THIS_VOLATILE (datum)))
2472             TREE_THIS_VOLATILE (ref) = 1;
2473
2474           if (TREE_DEPRECATED (subdatum))
2475             warn_deprecated_use (subdatum, NULL_TREE);
2476
2477           datum = ref;
2478
2479           field = TREE_CHAIN (field);
2480         }
2481       while (field);
2482
2483       return ref;
2484     }
2485   else if (should_suggest_deref_p (type))
2486     {
2487       /* Special-case the error message for "ptr.field" for the case
2488          where the user has confused "." vs "->".  */
2489       rich_location richloc (line_table, loc);
2490       /* "loc" should be the "." token.  */
2491       richloc.add_fixit_replace ("->");
2492       error_at (&richloc,
2493                 "%qE is a pointer; did you mean to use %<->%>?",
2494                 datum);
2495       return error_mark_node;
2496     }
2497   else if (code != ERROR_MARK)
2498     error_at (loc,
2499               "request for member %qE in something not a structure or union",
2500               component);
2501
2502   return error_mark_node;
2503 }
2504 \f
2505 /* Given an expression PTR for a pointer, return an expression
2506    for the value pointed to.
2507    ERRORSTRING is the name of the operator to appear in error messages.
2508
2509    LOC is the location to use for the generated tree.  */
2510
2511 tree
2512 build_indirect_ref (location_t loc, tree ptr, ref_operator errstring)
2513 {
2514   tree pointer = default_conversion (ptr);
2515   tree type = TREE_TYPE (pointer);
2516   tree ref;
2517
2518   if (TREE_CODE (type) == POINTER_TYPE)
2519     {
2520       if (CONVERT_EXPR_P (pointer)
2521           || TREE_CODE (pointer) == VIEW_CONVERT_EXPR)
2522         {
2523           /* If a warning is issued, mark it to avoid duplicates from
2524              the backend.  This only needs to be done at
2525              warn_strict_aliasing > 2.  */
2526           if (warn_strict_aliasing > 2)
2527             if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (pointer, 0)),
2528                                          type, TREE_OPERAND (pointer, 0)))
2529               TREE_NO_WARNING (pointer) = 1;
2530         }
2531
2532       if (TREE_CODE (pointer) == ADDR_EXPR
2533           && (TREE_TYPE (TREE_OPERAND (pointer, 0))
2534               == TREE_TYPE (type)))
2535         {
2536           ref = TREE_OPERAND (pointer, 0);
2537           protected_set_expr_location (ref, loc);
2538           return ref;
2539         }
2540       else
2541         {
2542           tree t = TREE_TYPE (type);
2543
2544           ref = build1 (INDIRECT_REF, t, pointer);
2545
2546           if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
2547             {
2548               if (!C_TYPE_ERROR_REPORTED (TREE_TYPE (ptr)))
2549                 {
2550                   error_at (loc, "dereferencing pointer to incomplete type "
2551                             "%qT", t);
2552                   C_TYPE_ERROR_REPORTED (TREE_TYPE (ptr)) = 1;
2553                 }
2554               return error_mark_node;
2555             }
2556           if (VOID_TYPE_P (t) && c_inhibit_evaluation_warnings == 0)
2557             warning_at (loc, 0, "dereferencing %<void *%> pointer");
2558
2559           /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2560              so that we get the proper error message if the result is used
2561              to assign to.  Also, &* is supposed to be a no-op.
2562              And ANSI C seems to specify that the type of the result
2563              should be the const type.  */
2564           /* A de-reference of a pointer to const is not a const.  It is valid
2565              to change it via some other pointer.  */
2566           TREE_READONLY (ref) = TYPE_READONLY (t);
2567           TREE_SIDE_EFFECTS (ref)
2568             = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer);
2569           TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
2570           protected_set_expr_location (ref, loc);
2571           return ref;
2572         }
2573     }
2574   else if (TREE_CODE (pointer) != ERROR_MARK)
2575     invalid_indirection_error (loc, type, errstring);
2576
2577   return error_mark_node;
2578 }
2579
2580 /* This handles expressions of the form "a[i]", which denotes
2581    an array reference.
2582
2583    This is logically equivalent in C to *(a+i), but we may do it differently.
2584    If A is a variable or a member, we generate a primitive ARRAY_REF.
2585    This avoids forcing the array out of registers, and can work on
2586    arrays that are not lvalues (for example, members of structures returned
2587    by functions).
2588
2589    For vector types, allow vector[i] but not i[vector], and create
2590    *(((type*)&vectortype) + i) for the expression.
2591
2592    LOC is the location to use for the returned expression.  */
2593
2594 tree
2595 build_array_ref (location_t loc, tree array, tree index)
2596 {
2597   tree ret;
2598   bool swapped = false;
2599   if (TREE_TYPE (array) == error_mark_node
2600       || TREE_TYPE (index) == error_mark_node)
2601     return error_mark_node;
2602
2603   if (TREE_CODE (TREE_TYPE (array)) != ARRAY_TYPE
2604       && TREE_CODE (TREE_TYPE (array)) != POINTER_TYPE
2605       /* Allow vector[index] but not index[vector].  */
2606       && !VECTOR_TYPE_P (TREE_TYPE (array)))
2607     {
2608       if (TREE_CODE (TREE_TYPE (index)) != ARRAY_TYPE
2609           && TREE_CODE (TREE_TYPE (index)) != POINTER_TYPE)
2610         {
2611           error_at (loc,
2612             "subscripted value is neither array nor pointer nor vector");
2613
2614           return error_mark_node;
2615         }
2616       std::swap (array, index);
2617       swapped = true;
2618     }
2619
2620   if (!INTEGRAL_TYPE_P (TREE_TYPE (index)))
2621     {
2622       error_at (loc, "array subscript is not an integer");
2623       return error_mark_node;
2624     }
2625
2626   if (TREE_CODE (TREE_TYPE (TREE_TYPE (array))) == FUNCTION_TYPE)
2627     {
2628       error_at (loc, "subscripted value is pointer to function");
2629       return error_mark_node;
2630     }
2631
2632   /* ??? Existing practice has been to warn only when the char
2633      index is syntactically the index, not for char[array].  */
2634   if (!swapped)
2635      warn_array_subscript_with_type_char (loc, index);
2636
2637   /* Apply default promotions *after* noticing character types.  */
2638   index = default_conversion (index);
2639   if (index == error_mark_node)
2640     return error_mark_node;
2641
2642   gcc_assert (TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE);
2643
2644   bool was_vector = VECTOR_TYPE_P (TREE_TYPE (array));
2645   bool non_lvalue = convert_vector_to_array_for_subscript (loc, &array, index);
2646
2647   if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
2648     {
2649       tree rval, type;
2650
2651       /* An array that is indexed by a non-constant
2652          cannot be stored in a register; we must be able to do
2653          address arithmetic on its address.
2654          Likewise an array of elements of variable size.  */
2655       if (TREE_CODE (index) != INTEGER_CST
2656           || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
2657               && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
2658         {
2659           if (!c_mark_addressable (array, true))
2660             return error_mark_node;
2661         }
2662       /* An array that is indexed by a constant value which is not within
2663          the array bounds cannot be stored in a register either; because we
2664          would get a crash in store_bit_field/extract_bit_field when trying
2665          to access a non-existent part of the register.  */
2666       if (TREE_CODE (index) == INTEGER_CST
2667           && TYPE_DOMAIN (TREE_TYPE (array))
2668           && !int_fits_type_p (index, TYPE_DOMAIN (TREE_TYPE (array))))
2669         {
2670           if (!c_mark_addressable (array))
2671             return error_mark_node;
2672         }
2673
2674       if ((pedantic || warn_c90_c99_compat)
2675           && ! was_vector)
2676         {
2677           tree foo = array;
2678           while (TREE_CODE (foo) == COMPONENT_REF)
2679             foo = TREE_OPERAND (foo, 0);
2680           if (VAR_P (foo) && C_DECL_REGISTER (foo))
2681             pedwarn (loc, OPT_Wpedantic,
2682                      "ISO C forbids subscripting %<register%> array");
2683           else if (!lvalue_p (foo))
2684             pedwarn_c90 (loc, OPT_Wpedantic,
2685                          "ISO C90 forbids subscripting non-lvalue "
2686                          "array");
2687         }
2688
2689       type = TREE_TYPE (TREE_TYPE (array));
2690       rval = build4 (ARRAY_REF, type, array, index, NULL_TREE, NULL_TREE);
2691       /* Array ref is const/volatile if the array elements are
2692          or if the array is.  */
2693       TREE_READONLY (rval)
2694         |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
2695             | TREE_READONLY (array));
2696       TREE_SIDE_EFFECTS (rval)
2697         |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
2698             | TREE_SIDE_EFFECTS (array));
2699       TREE_THIS_VOLATILE (rval)
2700         |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
2701             /* This was added by rms on 16 Nov 91.
2702                It fixes  vol struct foo *a;  a->elts[1]
2703                in an inline function.
2704                Hope it doesn't break something else.  */
2705             | TREE_THIS_VOLATILE (array));
2706       ret = require_complete_type (loc, rval);
2707       protected_set_expr_location (ret, loc);
2708       if (non_lvalue)
2709         ret = non_lvalue_loc (loc, ret);
2710       return ret;
2711     }
2712   else
2713     {
2714       tree ar = default_conversion (array);
2715
2716       if (ar == error_mark_node)
2717         return ar;
2718
2719       gcc_assert (TREE_CODE (TREE_TYPE (ar)) == POINTER_TYPE);
2720       gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) != FUNCTION_TYPE);
2721
2722       ret = build_indirect_ref (loc, build_binary_op (loc, PLUS_EXPR, ar,
2723                                                       index, false),
2724                                 RO_ARRAY_INDEXING);
2725       if (non_lvalue)
2726         ret = non_lvalue_loc (loc, ret);
2727       return ret;
2728     }
2729 }
2730 \f
2731 /* Build an external reference to identifier ID.  FUN indicates
2732    whether this will be used for a function call.  LOC is the source
2733    location of the identifier.  This sets *TYPE to the type of the
2734    identifier, which is not the same as the type of the returned value
2735    for CONST_DECLs defined as enum constants.  If the type of the
2736    identifier is not available, *TYPE is set to NULL.  */
2737 tree
2738 build_external_ref (location_t loc, tree id, bool fun, tree *type)
2739 {
2740   tree ref;
2741   tree decl = lookup_name (id);
2742
2743   /* In Objective-C, an instance variable (ivar) may be preferred to
2744      whatever lookup_name() found.  */
2745   decl = objc_lookup_ivar (decl, id);
2746
2747   *type = NULL;
2748   if (decl && decl != error_mark_node)
2749     {
2750       ref = decl;
2751       *type = TREE_TYPE (ref);
2752     }
2753   else if (fun)
2754     /* Implicit function declaration.  */
2755     ref = implicitly_declare (loc, id);
2756   else if (decl == error_mark_node)
2757     /* Don't complain about something that's already been
2758        complained about.  */
2759     return error_mark_node;
2760   else
2761     {
2762       undeclared_variable (loc, id);
2763       return error_mark_node;
2764     }
2765
2766   if (TREE_TYPE (ref) == error_mark_node)
2767     return error_mark_node;
2768
2769   if (TREE_DEPRECATED (ref))
2770     warn_deprecated_use (ref, NULL_TREE);
2771
2772   /* Recursive call does not count as usage.  */
2773   if (ref != current_function_decl)
2774     {
2775       TREE_USED (ref) = 1;
2776     }
2777
2778   if (TREE_CODE (ref) == FUNCTION_DECL && !in_alignof)
2779     {
2780       if (!in_sizeof && !in_typeof)
2781         C_DECL_USED (ref) = 1;
2782       else if (DECL_INITIAL (ref) == NULL_TREE
2783                && DECL_EXTERNAL (ref)
2784                && !TREE_PUBLIC (ref))
2785         record_maybe_used_decl (ref);
2786     }
2787
2788   if (TREE_CODE (ref) == CONST_DECL)
2789     {
2790       used_types_insert (TREE_TYPE (ref));
2791
2792       if (warn_cxx_compat
2793           && TREE_CODE (TREE_TYPE (ref)) == ENUMERAL_TYPE
2794           && C_TYPE_DEFINED_IN_STRUCT (TREE_TYPE (ref)))
2795         {
2796           warning_at (loc, OPT_Wc___compat,
2797                       ("enum constant defined in struct or union "
2798                        "is not visible in C++"));
2799           inform (DECL_SOURCE_LOCATION (ref), "enum constant defined here");
2800         }
2801
2802       ref = DECL_INITIAL (ref);
2803       TREE_CONSTANT (ref) = 1;
2804     }
2805   else if (current_function_decl != NULL_TREE
2806            && !DECL_FILE_SCOPE_P (current_function_decl)
2807            && (VAR_OR_FUNCTION_DECL_P (ref)
2808                || TREE_CODE (ref) == PARM_DECL))
2809     {
2810       tree context = decl_function_context (ref);
2811
2812       if (context != NULL_TREE && context != current_function_decl)
2813         DECL_NONLOCAL (ref) = 1;
2814     }
2815   /* C99 6.7.4p3: An inline definition of a function with external
2816      linkage ... shall not contain a reference to an identifier with
2817      internal linkage.  */
2818   else if (current_function_decl != NULL_TREE
2819            && DECL_DECLARED_INLINE_P (current_function_decl)
2820            && DECL_EXTERNAL (current_function_decl)
2821            && VAR_OR_FUNCTION_DECL_P (ref)
2822            && (!VAR_P (ref) || TREE_STATIC (ref))
2823            && ! TREE_PUBLIC (ref)
2824            && DECL_CONTEXT (ref) != current_function_decl)
2825     record_inline_static (loc, current_function_decl, ref,
2826                           csi_internal);
2827
2828   return ref;
2829 }
2830
2831 /* Record details of decls possibly used inside sizeof or typeof.  */
2832 struct maybe_used_decl
2833 {
2834   /* The decl.  */
2835   tree decl;
2836   /* The level seen at (in_sizeof + in_typeof).  */
2837   int level;
2838   /* The next one at this level or above, or NULL.  */
2839   struct maybe_used_decl *next;
2840 };
2841
2842 static struct maybe_used_decl *maybe_used_decls;
2843
2844 /* Record that DECL, an undefined static function reference seen
2845    inside sizeof or typeof, might be used if the operand of sizeof is
2846    a VLA type or the operand of typeof is a variably modified
2847    type.  */
2848
2849 static void
2850 record_maybe_used_decl (tree decl)
2851 {
2852   struct maybe_used_decl *t = XOBNEW (&parser_obstack, struct maybe_used_decl);
2853   t->decl = decl;
2854   t->level = in_sizeof + in_typeof;
2855   t->next = maybe_used_decls;
2856   maybe_used_decls = t;
2857 }
2858
2859 /* Pop the stack of decls possibly used inside sizeof or typeof.  If
2860    USED is false, just discard them.  If it is true, mark them used
2861    (if no longer inside sizeof or typeof) or move them to the next
2862    level up (if still inside sizeof or typeof).  */
2863
2864 void
2865 pop_maybe_used (bool used)
2866 {
2867   struct maybe_used_decl *p = maybe_used_decls;
2868   int cur_level = in_sizeof + in_typeof;
2869   while (p && p->level > cur_level)
2870     {
2871       if (used)
2872         {
2873           if (cur_level == 0)
2874             C_DECL_USED (p->decl) = 1;
2875           else
2876             p->level = cur_level;
2877         }
2878       p = p->next;
2879     }
2880   if (!used || cur_level == 0)
2881     maybe_used_decls = p;
2882 }
2883
2884 /* Return the result of sizeof applied to EXPR.  */
2885
2886 struct c_expr
2887 c_expr_sizeof_expr (location_t loc, struct c_expr expr)
2888 {
2889   struct c_expr ret;
2890   if (expr.value == error_mark_node)
2891     {
2892       ret.value = error_mark_node;
2893       ret.original_code = ERROR_MARK;
2894       ret.original_type = NULL;
2895       pop_maybe_used (false);
2896     }
2897   else
2898     {
2899       bool expr_const_operands = true;
2900
2901       if (TREE_CODE (expr.value) == PARM_DECL
2902           && C_ARRAY_PARAMETER (expr.value))
2903         {
2904           if (warning_at (loc, OPT_Wsizeof_array_argument,
2905                           "%<sizeof%> on array function parameter %qE will "
2906                           "return size of %qT", expr.value,
2907                           TREE_TYPE (expr.value)))
2908             inform (DECL_SOURCE_LOCATION (expr.value), "declared here");
2909         }
2910       tree folded_expr = c_fully_fold (expr.value, require_constant_value,
2911                                        &expr_const_operands);
2912       ret.value = c_sizeof (loc, TREE_TYPE (folded_expr));
2913       c_last_sizeof_arg = expr.value;
2914       c_last_sizeof_loc = loc;
2915       ret.original_code = SIZEOF_EXPR;
2916       ret.original_type = NULL;
2917       if (c_vla_type_p (TREE_TYPE (folded_expr)))
2918         {
2919           /* sizeof is evaluated when given a vla (C99 6.5.3.4p2).  */
2920           ret.value = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret.value),
2921                               folded_expr, ret.value);
2922           C_MAYBE_CONST_EXPR_NON_CONST (ret.value) = !expr_const_operands;
2923           SET_EXPR_LOCATION (ret.value, loc);
2924         }
2925       pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (folded_expr)));
2926     }
2927   return ret;
2928 }
2929
2930 /* Return the result of sizeof applied to T, a structure for the type
2931    name passed to sizeof (rather than the type itself).  LOC is the
2932    location of the original expression.  */
2933
2934 struct c_expr
2935 c_expr_sizeof_type (location_t loc, struct c_type_name *t)
2936 {
2937   tree type;
2938   struct c_expr ret;
2939   tree type_expr = NULL_TREE;
2940   bool type_expr_const = true;
2941   type = groktypename (t, &type_expr, &type_expr_const);
2942   ret.value = c_sizeof (loc, type);
2943   c_last_sizeof_arg = type;
2944   c_last_sizeof_loc = loc;
2945   ret.original_code = SIZEOF_EXPR;
2946   ret.original_type = NULL;
2947   if ((type_expr || TREE_CODE (ret.value) == INTEGER_CST)
2948       && c_vla_type_p (type))
2949     {
2950       /* If the type is a [*] array, it is a VLA but is represented as
2951          having a size of zero.  In such a case we must ensure that
2952          the result of sizeof does not get folded to a constant by
2953          c_fully_fold, because if the size is evaluated the result is
2954          not constant and so constraints on zero or negative size
2955          arrays must not be applied when this sizeof call is inside
2956          another array declarator.  */
2957       if (!type_expr)
2958         type_expr = integer_zero_node;
2959       ret.value = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret.value),
2960                           type_expr, ret.value);
2961       C_MAYBE_CONST_EXPR_NON_CONST (ret.value) = !type_expr_const;
2962     }
2963   pop_maybe_used (type != error_mark_node
2964                   ? C_TYPE_VARIABLE_SIZE (type) : false);
2965   return ret;
2966 }
2967
2968 /* Build a function call to function FUNCTION with parameters PARAMS.
2969    The function call is at LOC.
2970    PARAMS is a list--a chain of TREE_LIST nodes--in which the
2971    TREE_VALUE of each node is a parameter-expression.
2972    FUNCTION's data type may be a function type or a pointer-to-function.  */
2973
2974 tree
2975 build_function_call (location_t loc, tree function, tree params)
2976 {
2977   vec<tree, va_gc> *v;
2978   tree ret;
2979
2980   vec_alloc (v, list_length (params));
2981   for (; params; params = TREE_CHAIN (params))
2982     v->quick_push (TREE_VALUE (params));
2983   ret = c_build_function_call_vec (loc, vNULL, function, v, NULL);
2984   vec_free (v);
2985   return ret;
2986 }
2987
2988 /* Give a note about the location of the declaration of DECL.  */
2989
2990 static void
2991 inform_declaration (tree decl)
2992 {
2993   if (decl && (TREE_CODE (decl) != FUNCTION_DECL || !DECL_IS_BUILTIN (decl)))
2994     inform (DECL_SOURCE_LOCATION (decl), "declared here");
2995 }
2996
2997 /* Build a function call to function FUNCTION with parameters PARAMS.
2998    ORIGTYPES, if not NULL, is a vector of types; each element is
2999    either NULL or the original type of the corresponding element in
3000    PARAMS.  The original type may differ from TREE_TYPE of the
3001    parameter for enums.  FUNCTION's data type may be a function type
3002    or pointer-to-function.  This function changes the elements of
3003    PARAMS.  */
3004
3005 tree
3006 build_function_call_vec (location_t loc, vec<location_t> arg_loc,
3007                          tree function, vec<tree, va_gc> *params,
3008                          vec<tree, va_gc> *origtypes)
3009 {
3010   tree fntype, fundecl = NULL_TREE;
3011   tree name = NULL_TREE, result;
3012   tree tem;
3013   int nargs;
3014   tree *argarray;
3015
3016
3017   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
3018   STRIP_TYPE_NOPS (function);
3019
3020   /* Convert anything with function type to a pointer-to-function.  */
3021   if (TREE_CODE (function) == FUNCTION_DECL)
3022     {
3023       name = DECL_NAME (function);
3024
3025       if (flag_tm)
3026         tm_malloc_replacement (function);
3027       fundecl = function;
3028       /* Atomic functions have type checking/casting already done.  They are
3029          often rewritten and don't match the original parameter list.  */
3030       if (name && !strncmp (IDENTIFIER_POINTER (name), "__atomic_", 9))
3031         origtypes = NULL;
3032     }
3033   if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE)
3034     function = function_to_pointer_conversion (loc, function);
3035
3036   /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
3037      expressions, like those used for ObjC messenger dispatches.  */
3038   if (params && !params->is_empty ())
3039     function = objc_rewrite_function_call (function, (*params)[0]);
3040
3041   function = c_fully_fold (function, false, NULL);
3042
3043   fntype = TREE_TYPE (function);
3044
3045   if (TREE_CODE (fntype) == ERROR_MARK)
3046     return error_mark_node;
3047
3048   if (!(TREE_CODE (fntype) == POINTER_TYPE
3049         && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
3050     {
3051       if (!flag_diagnostics_show_caret)
3052         error_at (loc,
3053                   "called object %qE is not a function or function pointer",
3054                   function);
3055       else if (DECL_P (function))
3056         {
3057           error_at (loc,
3058                     "called object %qD is not a function or function pointer",
3059                     function);
3060           inform_declaration (function);
3061         }
3062       else
3063         error_at (loc,
3064                   "called object is not a function or function pointer");
3065       return error_mark_node;
3066     }
3067
3068   if (fundecl && TREE_THIS_VOLATILE (fundecl))
3069     current_function_returns_abnormally = 1;
3070
3071   /* fntype now gets the type of function pointed to.  */
3072   fntype = TREE_TYPE (fntype);
3073
3074   /* Convert the parameters to the types declared in the
3075      function prototype, or apply default promotions.  */
3076
3077   nargs = convert_arguments (loc, arg_loc, TYPE_ARG_TYPES (fntype), params,
3078                              origtypes, function, fundecl);
3079   if (nargs < 0)
3080     return error_mark_node;
3081
3082   /* Check that the function is called through a compatible prototype.
3083      If it is not, warn.  */
3084   if (CONVERT_EXPR_P (function)
3085       && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR
3086       && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL
3087       && !comptypes (fntype, TREE_TYPE (tem)))
3088     {
3089       tree return_type = TREE_TYPE (fntype);
3090
3091       /* This situation leads to run-time undefined behavior.  We can't,
3092          therefore, simply error unless we can prove that all possible
3093          executions of the program must execute the code.  */
3094       warning_at (loc, 0, "function called through a non-compatible type");
3095
3096       if (VOID_TYPE_P (return_type)
3097           && TYPE_QUALS (return_type) != TYPE_UNQUALIFIED)
3098         pedwarn (loc, 0,
3099                  "function with qualified void return type called");
3100      }
3101
3102   argarray = vec_safe_address (params);
3103
3104   /* Check that arguments to builtin functions match the expectations.  */
3105   if (fundecl
3106       && DECL_BUILT_IN (fundecl)
3107       && DECL_BUILT_IN_CLASS (fundecl) == BUILT_IN_NORMAL
3108       && !check_builtin_function_arguments (loc, arg_loc, fundecl, nargs,
3109                                             argarray))
3110     return error_mark_node;
3111
3112   /* Check that the arguments to the function are valid.  */
3113   bool warned_p = check_function_arguments (loc, fundecl, fntype,
3114                                             nargs, argarray, &arg_loc);
3115
3116   if (name != NULL_TREE
3117       && !strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10))
3118     {
3119       if (require_constant_value)
3120         result
3121           = fold_build_call_array_initializer_loc (loc, TREE_TYPE (fntype),
3122                                                    function, nargs, argarray);
3123       else
3124         result = fold_build_call_array_loc (loc, TREE_TYPE (fntype),
3125                                             function, nargs, argarray);
3126       if (TREE_CODE (result) == NOP_EXPR
3127           && TREE_CODE (TREE_OPERAND (result, 0)) == INTEGER_CST)
3128         STRIP_TYPE_NOPS (result);
3129     }
3130   else
3131     result = build_call_array_loc (loc, TREE_TYPE (fntype),
3132                                    function, nargs, argarray);
3133   /* If -Wnonnull warning has been diagnosed, avoid diagnosing it again
3134      later.  */
3135   if (warned_p && TREE_CODE (result) == CALL_EXPR)
3136     TREE_NO_WARNING (result) = 1;
3137
3138   /* In this improbable scenario, a nested function returns a VM type.
3139      Create a TARGET_EXPR so that the call always has a LHS, much as
3140      what the C++ FE does for functions returning non-PODs.  */
3141   if (variably_modified_type_p (TREE_TYPE (fntype), NULL_TREE))
3142     {
3143       tree tmp = create_tmp_var_raw (TREE_TYPE (fntype));
3144       result = build4 (TARGET_EXPR, TREE_TYPE (fntype), tmp, result,
3145                        NULL_TREE, NULL_TREE);
3146     }
3147
3148   if (VOID_TYPE_P (TREE_TYPE (result)))
3149     {
3150       if (TYPE_QUALS (TREE_TYPE (result)) != TYPE_UNQUALIFIED)
3151         pedwarn (loc, 0,
3152                  "function with qualified void return type called");
3153       return result;
3154     }
3155   return require_complete_type (loc, result);
3156 }
3157
3158 /* Like build_function_call_vec, but call also resolve_overloaded_builtin.  */
3159
3160 tree
3161 c_build_function_call_vec (location_t loc, vec<location_t> arg_loc,
3162                            tree function, vec<tree, va_gc> *params,
3163                            vec<tree, va_gc> *origtypes)
3164 {
3165   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
3166   STRIP_TYPE_NOPS (function);
3167
3168   /* Convert anything with function type to a pointer-to-function.  */
3169   if (TREE_CODE (function) == FUNCTION_DECL)
3170     {
3171       /* Implement type-directed function overloading for builtins.
3172          resolve_overloaded_builtin and targetm.resolve_overloaded_builtin
3173          handle all the type checking.  The result is a complete expression
3174          that implements this function call.  */
3175       tree tem = resolve_overloaded_builtin (loc, function, params);
3176       if (tem)
3177         return tem;
3178     }
3179   return build_function_call_vec (loc, arg_loc, function, params, origtypes);
3180 }
3181 \f
3182 /* Convert the argument expressions in the vector VALUES
3183    to the types in the list TYPELIST.
3184
3185    If TYPELIST is exhausted, or when an element has NULL as its type,
3186    perform the default conversions.
3187
3188    ORIGTYPES is the original types of the expressions in VALUES.  This
3189    holds the type of enum values which have been converted to integral
3190    types.  It may be NULL.
3191
3192    FUNCTION is a tree for the called function.  It is used only for
3193    error messages, where it is formatted with %qE.
3194
3195    This is also where warnings about wrong number of args are generated.
3196
3197    ARG_LOC are locations of function arguments (if any).
3198
3199    Returns the actual number of arguments processed (which may be less
3200    than the length of VALUES in some error situations), or -1 on
3201    failure.  */
3202
3203 static int
3204 convert_arguments (location_t loc, vec<location_t> arg_loc, tree typelist,
3205                    vec<tree, va_gc> *values, vec<tree, va_gc> *origtypes,
3206                    tree function, tree fundecl)
3207 {
3208   tree typetail, val;
3209   unsigned int parmnum;
3210   bool error_args = false;
3211   const bool type_generic = fundecl
3212     && lookup_attribute ("type generic", TYPE_ATTRIBUTES (TREE_TYPE (fundecl)));
3213   bool type_generic_remove_excess_precision = false;
3214   bool type_generic_overflow_p = false;
3215   tree selector;
3216
3217   /* Change pointer to function to the function itself for
3218      diagnostics.  */
3219   if (TREE_CODE (function) == ADDR_EXPR
3220       && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
3221     function = TREE_OPERAND (function, 0);
3222
3223   /* Handle an ObjC selector specially for diagnostics.  */
3224   selector = objc_message_selector ();
3225
3226   /* For type-generic built-in functions, determine whether excess
3227      precision should be removed (classification) or not
3228      (comparison).  */
3229   if (type_generic
3230       && DECL_BUILT_IN (fundecl)
3231       && DECL_BUILT_IN_CLASS (fundecl) == BUILT_IN_NORMAL)
3232     {
3233       switch (DECL_FUNCTION_CODE (fundecl))
3234         {
3235         case BUILT_IN_ISFINITE:
3236         case BUILT_IN_ISINF:
3237         case BUILT_IN_ISINF_SIGN:
3238         case BUILT_IN_ISNAN:
3239         case BUILT_IN_ISNORMAL:
3240         case BUILT_IN_FPCLASSIFY:
3241           type_generic_remove_excess_precision = true;
3242           break;
3243
3244         case BUILT_IN_ADD_OVERFLOW_P:
3245         case BUILT_IN_SUB_OVERFLOW_P:
3246         case BUILT_IN_MUL_OVERFLOW_P:
3247           /* The last argument of these type-generic builtins
3248              should not be promoted.  */
3249           type_generic_overflow_p = true;
3250           break;
3251
3252         default:
3253           break;
3254         }
3255     }
3256
3257   /* Scan the given expressions and types, producing individual
3258      converted arguments.  */
3259
3260   for (typetail = typelist, parmnum = 0;
3261        values && values->iterate (parmnum, &val);
3262        ++parmnum)
3263     {
3264       tree type = typetail ? TREE_VALUE (typetail) : 0;
3265       tree valtype = TREE_TYPE (val);
3266       tree rname = function;
3267       int argnum = parmnum + 1;
3268       const char *invalid_func_diag;
3269       bool excess_precision = false;
3270       bool npc;
3271       tree parmval;
3272       /* Some __atomic_* builtins have additional hidden argument at
3273          position 0.  */
3274       location_t ploc
3275         = !arg_loc.is_empty () && values->length () == arg_loc.length ()
3276           ? expansion_point_location_if_in_system_header (arg_loc[parmnum])
3277           : input_location;
3278
3279       if (type == void_type_node)
3280         {
3281           if (selector)
3282             error_at (loc, "too many arguments to method %qE", selector);
3283           else
3284             error_at (loc, "too many arguments to function %qE", function);
3285           inform_declaration (fundecl);
3286           return error_args ? -1 : (int) parmnum;
3287         }
3288
3289       if (selector && argnum > 2)
3290         {
3291           rname = selector;
3292           argnum -= 2;
3293         }
3294
3295       npc = null_pointer_constant_p (val);
3296
3297       /* If there is excess precision and a prototype, convert once to
3298          the required type rather than converting via the semantic
3299          type.  Likewise without a prototype a float value represented
3300          as long double should be converted once to double.  But for
3301          type-generic classification functions excess precision must
3302          be removed here.  */
3303       if (TREE_CODE (val) == EXCESS_PRECISION_EXPR
3304           && (type || !type_generic || !type_generic_remove_excess_precision))
3305         {
3306           val = TREE_OPERAND (val, 0);
3307           excess_precision = true;
3308         }
3309       val = c_fully_fold (val, false, NULL);
3310       STRIP_TYPE_NOPS (val);
3311
3312       val = require_complete_type (ploc, val);
3313
3314       /* Some floating-point arguments must be promoted to double when
3315          no type is specified by a prototype.  This applies to
3316          arguments of type float, and to architecture-specific types
3317          (ARM __fp16), but not to _FloatN or _FloatNx types.  */
3318       bool promote_float_arg = false;
3319       if (type == NULL_TREE
3320           && TREE_CODE (valtype) == REAL_TYPE
3321           && (TYPE_PRECISION (valtype)
3322               <= TYPE_PRECISION (double_type_node))
3323           && TYPE_MAIN_VARIANT (valtype) != double_type_node
3324           && TYPE_MAIN_VARIANT (valtype) != long_double_type_node
3325           && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (valtype)))
3326         {
3327           /* Promote this argument, unless it has a _FloatN or
3328              _FloatNx type.  */
3329           promote_float_arg = true;
3330           for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
3331             if (TYPE_MAIN_VARIANT (valtype) == FLOATN_NX_TYPE_NODE (i))
3332               {
3333                 promote_float_arg = false;
3334                 break;
3335               }
3336         }
3337
3338       if (type != NULL_TREE)
3339         {
3340           /* Formal parm type is specified by a function prototype.  */
3341
3342           if (type == error_mark_node || !COMPLETE_TYPE_P (type))
3343             {
3344               error_at (ploc, "type of formal parameter %d is incomplete",
3345                         parmnum + 1);
3346               parmval = val;
3347             }
3348           else
3349             {
3350               tree origtype;
3351
3352               /* Optionally warn about conversions that
3353                  differ from the default conversions.  */
3354               if (warn_traditional_conversion || warn_traditional)
3355                 {
3356                   unsigned int formal_prec = TYPE_PRECISION (type);
3357
3358                   if (INTEGRAL_TYPE_P (type)
3359                       && TREE_CODE (valtype) == REAL_TYPE)
3360                     warning_at (ploc, OPT_Wtraditional_conversion,
3361                                 "passing argument %d of %qE as integer rather "
3362                                 "than floating due to prototype",
3363                                 argnum, rname);
3364                   if (INTEGRAL_TYPE_P (type)
3365                       && TREE_CODE (valtype) == COMPLEX_TYPE)
3366                     warning_at (ploc, OPT_Wtraditional_conversion,
3367                                 "passing argument %d of %qE as integer rather "
3368                                 "than complex due to prototype",
3369                                 argnum, rname);
3370                   else if (TREE_CODE (type) == COMPLEX_TYPE
3371                            && TREE_CODE (valtype) == REAL_TYPE)
3372                     warning_at (ploc, OPT_Wtraditional_conversion,
3373                                 "passing argument %d of %qE as complex rather "
3374                                 "than floating due to prototype",
3375                                 argnum, rname);
3376                   else if (TREE_CODE (type) == REAL_TYPE
3377                            && INTEGRAL_TYPE_P (valtype))
3378                     warning_at (ploc, OPT_Wtraditional_conversion,
3379                                 "passing argument %d of %qE as floating rather "
3380                                 "than integer due to prototype",
3381                                 argnum, rname);
3382                   else if (TREE_CODE (type) == COMPLEX_TYPE
3383                            && INTEGRAL_TYPE_P (valtype))
3384                     warning_at (ploc, OPT_Wtraditional_conversion,
3385                                 "passing argument %d of %qE as complex rather "
3386                                 "than integer due to prototype",
3387                                 argnum, rname);
3388                   else if (TREE_CODE (type) == REAL_TYPE
3389                            && TREE_CODE (valtype) == COMPLEX_TYPE)
3390                     warning_at (ploc, OPT_Wtraditional_conversion,
3391                                 "passing argument %d of %qE as floating rather "
3392                                 "than complex due to prototype",
3393                                 argnum, rname);
3394                   /* ??? At some point, messages should be written about
3395                      conversions between complex types, but that's too messy
3396                      to do now.  */
3397                   else if (TREE_CODE (type) == REAL_TYPE
3398                            && TREE_CODE (valtype) == REAL_TYPE)
3399                     {
3400                       /* Warn if any argument is passed as `float',
3401                          since without a prototype it would be `double'.  */
3402                       if (formal_prec == TYPE_PRECISION (float_type_node)
3403                           && type != dfloat32_type_node)
3404                         warning_at (ploc, 0,
3405                                     "passing argument %d of %qE as %<float%> "
3406                                     "rather than %<double%> due to prototype",
3407                                     argnum, rname);
3408
3409                       /* Warn if mismatch between argument and prototype
3410                          for decimal float types.  Warn of conversions with
3411                          binary float types and of precision narrowing due to
3412                          prototype. */
3413                       else if (type != valtype
3414                                && (type == dfloat32_type_node
3415                                    || type == dfloat64_type_node
3416                                    || type == dfloat128_type_node
3417                                    || valtype == dfloat32_type_node
3418                                    || valtype == dfloat64_type_node
3419                                    || valtype == dfloat128_type_node)
3420                                && (formal_prec
3421                                    <= TYPE_PRECISION (valtype)
3422                                    || (type == dfloat128_type_node
3423                                        && (valtype
3424                                            != dfloat64_type_node
3425                                            && (valtype
3426                                                != dfloat32_type_node)))
3427                                    || (type == dfloat64_type_node
3428                                        && (valtype
3429                                            != dfloat32_type_node))))
3430                         warning_at (ploc, 0,
3431                                     "passing argument %d of %qE as %qT "
3432                                     "rather than %qT due to prototype",
3433                                     argnum, rname, type, valtype);
3434
3435                     }
3436                   /* Detect integer changing in width or signedness.
3437                      These warnings are only activated with
3438                      -Wtraditional-conversion, not with -Wtraditional.  */
3439                   else if (warn_traditional_conversion
3440                            && INTEGRAL_TYPE_P (type)
3441                            && INTEGRAL_TYPE_P (valtype))
3442                     {
3443                       tree would_have_been = default_conversion (val);
3444                       tree type1 = TREE_TYPE (would_have_been);
3445
3446                       if (val == error_mark_node)
3447                         /* VAL could have been of incomplete type.  */;
3448                       else if (TREE_CODE (type) == ENUMERAL_TYPE
3449                                && (TYPE_MAIN_VARIANT (type)
3450                                    == TYPE_MAIN_VARIANT (valtype)))
3451                         /* No warning if function asks for enum
3452                            and the actual arg is that enum type.  */
3453                         ;
3454                       else if (formal_prec != TYPE_PRECISION (type1))
3455                         warning_at (ploc, OPT_Wtraditional_conversion,
3456                                     "passing argument %d of %qE "
3457                                     "with different width due to prototype",
3458                                     argnum, rname);
3459                       else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1))
3460                         ;
3461                       /* Don't complain if the formal parameter type
3462                          is an enum, because we can't tell now whether
3463                          the value was an enum--even the same enum.  */
3464                       else if (TREE_CODE (type) == ENUMERAL_TYPE)
3465                         ;
3466                       else if (TREE_CODE (val) == INTEGER_CST
3467                                && int_fits_type_p (val, type))
3468                         /* Change in signedness doesn't matter
3469                            if a constant value is unaffected.  */
3470                         ;
3471                       /* If the value is extended from a narrower
3472                          unsigned type, it doesn't matter whether we
3473                          pass it as signed or unsigned; the value
3474                          certainly is the same either way.  */
3475                       else if (TYPE_PRECISION (valtype) < TYPE_PRECISION (type)
3476                                && TYPE_UNSIGNED (valtype))
3477                         ;
3478                       else if (TYPE_UNSIGNED (type))
3479                         warning_at (ploc, OPT_Wtraditional_conversion,
3480                                     "passing argument %d of %qE "
3481                                     "as unsigned due to prototype",
3482                                     argnum, rname);
3483                       else
3484                         warning_at (ploc, OPT_Wtraditional_conversion,
3485                                     "passing argument %d of %qE "
3486                                     "as signed due to prototype",
3487                                     argnum, rname);
3488                     }
3489                 }
3490
3491               /* Possibly restore an EXCESS_PRECISION_EXPR for the
3492                  sake of better warnings from convert_and_check.  */
3493               if (excess_precision)
3494                 val = build1 (EXCESS_PRECISION_EXPR, valtype, val);
3495               origtype = (!origtypes) ? NULL_TREE : (*origtypes)[parmnum];
3496               parmval = convert_for_assignment (loc, ploc, type,
3497                                                 val, origtype, ic_argpass,
3498                                                 npc, fundecl, function,
3499                                                 parmnum + 1);
3500
3501               if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0)
3502                   && INTEGRAL_TYPE_P (type)
3503                   && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
3504                 parmval = default_conversion (parmval);
3505             }
3506         }
3507       else if (promote_float_arg)
3508         {
3509           if (type_generic)
3510             parmval = val;
3511           else
3512             {
3513               /* Convert `float' to `double'.  */
3514               if (warn_double_promotion && !c_inhibit_evaluation_warnings)
3515                 warning_at (ploc, OPT_Wdouble_promotion,
3516                             "implicit conversion from %qT to %qT when passing "
3517                             "argument to function",
3518                             valtype, double_type_node);
3519               parmval = convert (double_type_node, val);
3520             }
3521         }
3522       else if ((excess_precision && !type_generic)
3523                || (type_generic_overflow_p && parmnum == 2))
3524         /* A "double" argument with excess precision being passed
3525            without a prototype or in variable arguments.
3526            The last argument of __builtin_*_overflow_p should not be
3527            promoted.  */
3528         parmval = convert (valtype, val);
3529       else if ((invalid_func_diag =
3530                 targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val)))
3531         {
3532           error (invalid_func_diag);
3533           return -1;
3534         }
3535       else if (TREE_CODE (val) == ADDR_EXPR && reject_gcc_builtin (val))
3536         {
3537           return -1;
3538         }
3539       else
3540         /* Convert `short' and `char' to full-size `int'.  */
3541         parmval = default_conversion (val);
3542
3543       (*values)[parmnum] = parmval;
3544       if (parmval == error_mark_node)
3545         error_args = true;
3546
3547       if (typetail)
3548         typetail = TREE_CHAIN (typetail);
3549     }
3550
3551   gcc_assert (parmnum == vec_safe_length (values));
3552
3553   if (typetail != NULL_TREE && TREE_VALUE (typetail) != void_type_node)
3554     {
3555       error_at (loc, "too few arguments to function %qE", function);
3556       inform_declaration (fundecl);
3557       return -1;
3558     }
3559
3560   return error_args ? -1 : (int) parmnum;
3561 }
3562 \f
3563 /* This is the entry point used by the parser to build unary operators
3564    in the input.  CODE, a tree_code, specifies the unary operator, and
3565    ARG is the operand.  For unary plus, the C parser currently uses
3566    CONVERT_EXPR for code.
3567
3568    LOC is the location to use for the tree generated.
3569 */
3570
3571 struct c_expr
3572 parser_build_unary_op (location_t loc, enum tree_code code, struct c_expr arg)
3573 {
3574   struct c_expr result;
3575
3576   result.original_code = code;
3577   result.original_type = NULL;
3578
3579   if (reject_gcc_builtin (arg.value))
3580     {
3581       result.value = error_mark_node;
3582     }
3583   else
3584     {
3585       result.value = build_unary_op (loc, code, arg.value, false);
3586
3587       if (TREE_OVERFLOW_P (result.value) && !TREE_OVERFLOW_P (arg.value))
3588         overflow_warning (loc, result.value, arg.value);
3589     }
3590
3591   /* We are typically called when parsing a prefix token at LOC acting on
3592      ARG.  Reflect this by updating the source range of the result to
3593      start at LOC and end at the end of ARG.  */
3594   set_c_expr_source_range (&result,
3595                            loc, arg.get_finish ());
3596
3597   return result;
3598 }
3599
3600 /* Returns true if TYPE is a character type, *not* including wchar_t.  */
3601
3602 static bool
3603 char_type_p (tree type)
3604 {
3605   return (type == char_type_node
3606           || type == unsigned_char_type_node
3607           || type == signed_char_type_node
3608           || type == char16_type_node
3609           || type == char32_type_node);
3610 }
3611
3612 /* This is the entry point used by the parser to build binary operators
3613    in the input.  CODE, a tree_code, specifies the binary operator, and
3614    ARG1 and ARG2 are the operands.  In addition to constructing the
3615    expression, we check for operands that were written with other binary
3616    operators in a way that is likely to confuse the user.
3617
3618    LOCATION is the location of the binary operator.  */
3619
3620 struct c_expr
3621 parser_build_binary_op (location_t location, enum tree_code code,
3622                         struct c_expr arg1, struct c_expr arg2)
3623 {
3624   struct c_expr result;
3625
3626   enum tree_code code1 = arg1.original_code;
3627   enum tree_code code2 = arg2.original_code;
3628   tree type1 = (arg1.original_type
3629                 ? arg1.original_type
3630                 : TREE_TYPE (arg1.value));
3631   tree type2 = (arg2.original_type
3632                 ? arg2.original_type
3633                 : TREE_TYPE (arg2.value));
3634
3635   result.value = build_binary_op (location, code,
3636                                   arg1.value, arg2.value, true);
3637   result.original_code = code;
3638   result.original_type = NULL;
3639
3640   if (TREE_CODE (result.value) == ERROR_MARK)
3641     {
3642       set_c_expr_source_range (&result,
3643                                arg1.get_start (),
3644                                arg2.get_finish ());
3645       return result;
3646     }
3647
3648   if (location != UNKNOWN_LOCATION)
3649     protected_set_expr_location (result.value, location);
3650
3651   set_c_expr_source_range (&result,
3652                            arg1.get_start (),
3653                            arg2.get_finish ());
3654
3655   /* Check for cases such as x+y<<z which users are likely
3656      to misinterpret.  */
3657   if (warn_parentheses)
3658     warn_about_parentheses (location, code, code1, arg1.value, code2,
3659                             arg2.value);
3660
3661   if (warn_logical_op)
3662     warn_logical_operator (location, code, TREE_TYPE (result.value),
3663                            code1, arg1.value, code2, arg2.value);
3664
3665   if (warn_tautological_compare)
3666     {
3667       tree lhs = arg1.value;
3668       tree rhs = arg2.value;
3669       if (TREE_CODE (lhs) == C_MAYBE_CONST_EXPR)
3670         {
3671           if (C_MAYBE_CONST_EXPR_PRE (lhs) != NULL_TREE
3672               && TREE_SIDE_EFFECTS (C_MAYBE_CONST_EXPR_PRE (lhs)))
3673             lhs = NULL_TREE;
3674           else
3675             lhs = C_MAYBE_CONST_EXPR_EXPR (lhs);
3676         }
3677       if (TREE_CODE (rhs) == C_MAYBE_CONST_EXPR)
3678         {
3679           if (C_MAYBE_CONST_EXPR_PRE (rhs) != NULL_TREE
3680               && TREE_SIDE_EFFECTS (C_MAYBE_CONST_EXPR_PRE (rhs)))
3681             rhs = NULL_TREE;
3682           else
3683             rhs = C_MAYBE_CONST_EXPR_EXPR (rhs);
3684         }
3685       if (lhs != NULL_TREE && rhs != NULL_TREE)
3686         warn_tautological_cmp (location, code, lhs, rhs);
3687     }
3688
3689   if (warn_logical_not_paren
3690       && TREE_CODE_CLASS (code) == tcc_comparison
3691       && code1 == TRUTH_NOT_EXPR
3692       && code2 != TRUTH_NOT_EXPR
3693       /* Avoid warning for !!x == y.  */
3694       && (TREE_CODE (arg1.value) != NE_EXPR
3695           || !integer_zerop (TREE_OPERAND (arg1.value, 1))))
3696     {
3697       /* Avoid warning for !b == y where b has _Bool type.  */
3698       tree t = integer_zero_node;
3699       if (TREE_CODE (arg1.value) == EQ_EXPR
3700           && integer_zerop (TREE_OPERAND (arg1.value, 1))
3701           && TREE_TYPE (TREE_OPERAND (arg1.value, 0)) == integer_type_node)
3702         {
3703           t = TREE_OPERAND (arg1.value, 0);
3704           do
3705             {
3706               if (TREE_TYPE (t) != integer_type_node)
3707                 break;
3708               if (TREE_CODE (t) == C_MAYBE_CONST_EXPR)
3709                 t = C_MAYBE_CONST_EXPR_EXPR (t);
3710               else if (CONVERT_EXPR_P (t))
3711                 t = TREE_OPERAND (t, 0);
3712               else
3713                 break;
3714             }
3715           while (1);
3716         }
3717       if (TREE_CODE (TREE_TYPE (t)) != BOOLEAN_TYPE)
3718         warn_logical_not_parentheses (location, code, arg1.value, arg2.value);
3719     }
3720
3721   /* Warn about comparisons against string literals, with the exception
3722      of testing for equality or inequality of a string literal with NULL.  */
3723   if (code == EQ_EXPR || code == NE_EXPR)
3724     {
3725       if ((code1 == STRING_CST
3726            && !integer_zerop (tree_strip_nop_conversions (arg2.value)))
3727           || (code2 == STRING_CST
3728               && !integer_zerop (tree_strip_nop_conversions (arg1.value))))
3729         warning_at (location, OPT_Waddress,
3730                     "comparison with string literal results in unspecified behavior");
3731       /* Warn for ptr == '\0', it's likely that it should've been ptr[0].  */
3732       if (POINTER_TYPE_P (type1)
3733            && null_pointer_constant_p (arg2.value)
3734            && char_type_p (type2)
3735            && warning_at (location, OPT_Wpointer_compare,
3736                           "comparison between pointer and zero character "
3737                           "constant"))
3738         inform (arg1.get_start (), "did you mean to dereference the pointer?");
3739       else if (POINTER_TYPE_P (type2)
3740                && null_pointer_constant_p (arg1.value)
3741                && char_type_p (type1)
3742                && warning_at (location, OPT_Wpointer_compare,
3743                               "comparison between pointer and zero character "
3744                               "constant"))
3745         inform (arg2.get_start (), "did you mean to dereference the pointer?");
3746     }
3747   else if (TREE_CODE_CLASS (code) == tcc_comparison
3748            && (code1 == STRING_CST || code2 == STRING_CST))
3749     warning_at (location, OPT_Waddress,
3750                 "comparison with string literal results in unspecified behavior");
3751
3752   if (TREE_OVERFLOW_P (result.value)
3753       && !TREE_OVERFLOW_P (arg1.value)
3754       && !TREE_OVERFLOW_P (arg2.value))
3755     overflow_warning (location, result.value);
3756
3757   /* Warn about comparisons of different enum types.  */
3758   if (warn_enum_compare
3759       && TREE_CODE_CLASS (code) == tcc_comparison
3760       && TREE_CODE (type1) == ENUMERAL_TYPE
3761       && TREE_CODE (type2) == ENUMERAL_TYPE
3762       && TYPE_MAIN_VARIANT (type1) != TYPE_MAIN_VARIANT (type2))
3763     warning_at (location, OPT_Wenum_compare,
3764                 "comparison between %qT and %qT",
3765                 type1, type2);
3766
3767   return result;
3768 }
3769 \f
3770 /* Return a tree for the difference of pointers OP0 and OP1.
3771    The resulting tree has type ptrdiff_t.  If POINTER_SUBTRACT sanitization is
3772    enabled, assign to INSTRUMENT_EXPR call to libsanitizer.  */
3773
3774 static tree
3775 pointer_diff (location_t loc, tree op0, tree op1, tree *instrument_expr)
3776 {
3777   tree restype = ptrdiff_type_node;
3778   tree result, inttype;
3779
3780   addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op0)));
3781   addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op1)));
3782   tree target_type = TREE_TYPE (TREE_TYPE (op0));
3783   tree orig_op1 = op1;
3784
3785   /* If the operands point into different address spaces, we need to
3786      explicitly convert them to pointers into the common address space
3787      before we can subtract the numerical address values.  */
3788   if (as0 != as1)
3789     {
3790       addr_space_t as_common;
3791       tree common_type;
3792
3793       /* Determine the common superset address space.  This is guaranteed
3794          to exist because the caller verified that comp_target_types
3795          returned non-zero.  */
3796       if (!addr_space_superset (as0, as1, &as_common))
3797         gcc_unreachable ();
3798
3799       common_type = common_pointer_type (TREE_TYPE (op0), TREE_TYPE (op1));
3800       op0 = convert (common_type, op0);
3801       op1 = convert (common_type, op1);
3802     }
3803
3804   /* Determine integer type result of the subtraction.  This will usually
3805      be the same as the result type (ptrdiff_t), but may need to be a wider
3806      type if pointers for the address space are wider than ptrdiff_t.  */
3807   if (TYPE_PRECISION (restype) < TYPE_PRECISION (TREE_TYPE (op0)))
3808     inttype = c_common_type_for_size (TYPE_PRECISION (TREE_TYPE (op0)), 0);
3809   else
3810     inttype = restype;
3811
3812   if (TREE_CODE (target_type) == VOID_TYPE)
3813     pedwarn (loc, OPT_Wpointer_arith,
3814              "pointer of type %<void *%> used in subtraction");
3815   if (TREE_CODE (target_type) == FUNCTION_TYPE)
3816     pedwarn (loc, OPT_Wpointer_arith,
3817              "pointer to a function used in subtraction");
3818
3819   if (sanitize_flags_p (SANITIZE_POINTER_SUBTRACT))
3820     {
3821       gcc_assert (current_function_decl != NULL_TREE);
3822
3823       op0 = save_expr (op0);
3824       op1 = save_expr (op1);
3825
3826       tree tt = builtin_decl_explicit (BUILT_IN_ASAN_POINTER_SUBTRACT);
3827       *instrument_expr = build_call_expr_loc (loc, tt, 2, op0, op1);
3828     }
3829
3830   /* First do the subtraction, then build the divide operator
3831      and only convert at the very end.
3832      Do not do default conversions in case restype is a short type.  */
3833
3834   /* POINTER_DIFF_EXPR requires a signed integer type of the same size as
3835      pointers.  If some platform cannot provide that, or has a larger
3836      ptrdiff_type to support differences larger than half the address
3837      space, cast the pointers to some larger integer type and do the
3838      computations in that type.  */
3839   if (TYPE_PRECISION (inttype) > TYPE_PRECISION (TREE_TYPE (op0)))
3840     op0 = build_binary_op (loc, MINUS_EXPR, convert (inttype, op0),
3841                            convert (inttype, op1), false);
3842   else
3843     op0 = build2_loc (loc, POINTER_DIFF_EXPR, inttype, op0, op1);
3844
3845   /* This generates an error if op1 is pointer to incomplete type.  */
3846   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
3847     error_at (loc, "arithmetic on pointer to an incomplete type");
3848
3849   op1 = c_size_in_bytes (target_type);
3850
3851   if (pointer_to_zero_sized_aggr_p (TREE_TYPE (orig_op1)))
3852     error_at (loc, "arithmetic on pointer to an empty aggregate");
3853
3854   /* Divide by the size, in easiest possible way.  */
3855   result = fold_build2_loc (loc, EXACT_DIV_EXPR, inttype,
3856                             op0, convert (inttype, op1));
3857
3858   /* Convert to final result type if necessary.  */
3859   return convert (restype, result);
3860 }
3861 \f
3862 /* Expand atomic compound assignments into an appropriate sequence as
3863    specified by the C11 standard section 6.5.16.2.
3864
3865        _Atomic T1 E1
3866        T2 E2
3867        E1 op= E2
3868
3869   This sequence is used for all types for which these operations are
3870   supported.
3871
3872   In addition, built-in versions of the 'fe' prefixed routines may
3873   need to be invoked for floating point (real, complex or vector) when
3874   floating-point exceptions are supported.  See 6.5.16.2 footnote 113.
3875
3876   T1 newval;
3877   T1 old;
3878   T1 *addr
3879   T2 val
3880   fenv_t fenv
3881
3882   addr = &E1;
3883   val = (E2);
3884   __atomic_load (addr, &old, SEQ_CST);
3885   feholdexcept (&fenv);
3886 loop:
3887     newval = old op val;
3888     if (__atomic_compare_exchange_strong (addr, &old, &newval, SEQ_CST,
3889                                           SEQ_CST))
3890       goto done;
3891     feclearexcept (FE_ALL_EXCEPT);
3892     goto loop:
3893 done:
3894   feupdateenv (&fenv);
3895
3896   The compiler will issue the __atomic_fetch_* built-in when possible,
3897   otherwise it will generate the generic form of the atomic operations.
3898   This requires temp(s) and has their address taken.  The atomic processing
3899   is smart enough to figure out when the size of an object can utilize
3900   a lock-free version, and convert the built-in call to the appropriate
3901   lock-free routine.  The optimizers will then dispose of any temps that
3902   are no longer required, and lock-free implementations are utilized as
3903   long as there is target support for the required size.
3904
3905   If the operator is NOP_EXPR, then this is a simple assignment, and
3906   an __atomic_store is issued to perform the assignment rather than
3907   the above loop.  */
3908
3909 /* Build an atomic assignment at LOC, expanding into the proper
3910    sequence to store LHS MODIFYCODE= RHS.  Return a value representing
3911    the result of the operation, unless RETURN_OLD_P, in which case
3912    return the old value of LHS (this is only for postincrement and
3913    postdecrement).  */
3914
3915 static tree
3916 build_atomic_assign (location_t loc, tree lhs, enum tree_code modifycode,
3917                      tree rhs, bool return_old_p)
3918 {
3919   tree fndecl, func_call;
3920   vec<tree, va_gc> *params;
3921   tree val, nonatomic_lhs_type, nonatomic_rhs_type, newval, newval_addr;
3922   tree old, old_addr;
3923   tree compound_stmt;
3924   tree stmt, goto_stmt;
3925   tree loop_label, loop_decl, done_label, done_decl;
3926
3927   tree lhs_type = TREE_TYPE (lhs);
3928   tree lhs_addr = build_unary_op (loc, ADDR_EXPR, lhs, false);
3929   tree seq_cst = build_int_cst (integer_type_node, MEMMODEL_SEQ_CST);
3930   tree rhs_semantic_type = TREE_TYPE (rhs);
3931   tree nonatomic_rhs_semantic_type;
3932   tree rhs_type;
3933
3934   gcc_assert (TYPE_ATOMIC (lhs_type));
3935
3936   if (return_old_p)
3937     gcc_assert (modifycode == PLUS_EXPR || modifycode == MINUS_EXPR);
3938
3939   /* Allocate enough vector items for a compare_exchange.  */
3940   vec_alloc (params, 6);
3941
3942   /* Create a compound statement to hold the sequence of statements
3943      with a loop.  */
3944   compound_stmt = c_begin_compound_stmt (false);
3945
3946   /* Remove any excess precision (which is only present here in the
3947      case of compound assignments).  */
3948   if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
3949     {
3950       gcc_assert (modifycode != NOP_EXPR);
3951       rhs = TREE_OPERAND (rhs, 0);
3952     }
3953   rhs_type = TREE_TYPE (rhs);
3954
3955   /* Fold the RHS if it hasn't already been folded.  */
3956   if (modifycode != NOP_EXPR)
3957     rhs = c_fully_fold (rhs, false, NULL);
3958
3959   /* Remove the qualifiers for the rest of the expressions and create
3960      the VAL temp variable to hold the RHS.  */
3961   nonatomic_lhs_type = build_qualified_type (lhs_type, TYPE_UNQUALIFIED);
3962   nonatomic_rhs_type = build_qualified_type (rhs_type, TYPE_UNQUALIFIED);
3963   nonatomic_rhs_semantic_type = build_qualified_type (rhs_semantic_type,
3964                                                       TYPE_UNQUALIFIED);
3965   val = create_tmp_var_raw (nonatomic_rhs_type);
3966   TREE_ADDRESSABLE (val) = 1;
3967   TREE_NO_WARNING (val) = 1;
3968   rhs = build4 (TARGET_EXPR, nonatomic_rhs_type, val, rhs, NULL_TREE,
3969                 NULL_TREE);
3970   SET_EXPR_LOCATION (rhs, loc);
3971   add_stmt (rhs);
3972
3973   /* NOP_EXPR indicates it's a straight store of the RHS. Simply issue
3974      an atomic_store.  */
3975   if (modifycode == NOP_EXPR)
3976     {
3977       /* Build __atomic_store (&lhs, &val, SEQ_CST)  */
3978       rhs = build_unary_op (loc, ADDR_EXPR, val, false);
3979       fndecl = builtin_decl_explicit (BUILT_IN_ATOMIC_STORE);
3980       params->quick_push (lhs_addr);
3981       params->quick_push (rhs);
3982       params->quick_push (seq_cst);
3983       func_call = c_build_function_call_vec (loc, vNULL, fndecl, params, NULL);
3984       add_stmt (func_call);
3985
3986       /* Finish the compound statement.  */
3987       compound_stmt = c_end_compound_stmt (loc, compound_stmt, false);
3988
3989       /* VAL is the value which was stored, return a COMPOUND_STMT of
3990          the statement and that value.  */
3991       return build2 (COMPOUND_EXPR, nonatomic_lhs_type, compound_stmt, val);
3992     }
3993
3994   /* Attempt to implement the atomic operation as an __atomic_fetch_* or
3995      __atomic_*_fetch built-in rather than a CAS loop.  atomic_bool type
3996      isn't applicable for such builtins.  ??? Do we want to handle enums?  */
3997   if ((TREE_CODE (lhs_type) == INTEGER_TYPE || POINTER_TYPE_P (lhs_type))
3998       && TREE_CODE (rhs_type) == INTEGER_TYPE)
3999     {
4000       built_in_function fncode;
4001       switch (modifycode)
4002         {
4003         case PLUS_EXPR:
4004         case POINTER_PLUS_EXPR:
4005           fncode = (return_old_p
4006                     ? BUILT_IN_ATOMIC_FETCH_ADD_N
4007                     : BUILT_IN_ATOMIC_ADD_FETCH_N);
4008           break;
4009         case MINUS_EXPR:
4010           fncode = (return_old_p
4011                     ? BUILT_IN_ATOMIC_FETCH_SUB_N
4012                     : BUILT_IN_ATOMIC_SUB_FETCH_N);
4013           break;
4014         case BIT_AND_EXPR:
4015           fncode = (return_old_p
4016                     ? BUILT_IN_ATOMIC_FETCH_AND_N
4017                     : BUILT_IN_ATOMIC_AND_FETCH_N);
4018           break;
4019         case BIT_IOR_EXPR:
4020           fncode = (return_old_p
4021                     ? BUILT_IN_ATOMIC_FETCH_OR_N
4022                     : BUILT_IN_ATOMIC_OR_FETCH_N);
4023           break;
4024         case BIT_XOR_EXPR:
4025           fncode = (return_old_p
4026                     ? BUILT_IN_ATOMIC_FETCH_XOR_N
4027                     : BUILT_IN_ATOMIC_XOR_FETCH_N);
4028           break;
4029         default:
4030           goto cas_loop;
4031         }
4032
4033       /* We can only use "_1" through "_16" variants of the atomic fetch
4034          built-ins.  */
4035       unsigned HOST_WIDE_INT size = tree_to_uhwi (TYPE_SIZE_UNIT (lhs_type));
4036       if (size != 1 && size != 2 && size != 4 && size != 8 && size != 16)
4037         goto cas_loop;
4038
4039       /* If this is a pointer type, we need to multiply by the size of
4040          the pointer target type.  */
4041       if (POINTER_TYPE_P (lhs_type))
4042         {
4043           if (!COMPLETE_TYPE_P (TREE_TYPE (lhs_type))
4044               /* ??? This would introduce -Wdiscarded-qualifiers
4045                  warning: __atomic_fetch_* expect volatile void *
4046                  type as the first argument.  (Assignments between
4047                  atomic and non-atomic objects are OK.) */
4048               || TYPE_RESTRICT (lhs_type))
4049             goto cas_loop;
4050           tree sz = TYPE_SIZE_UNIT (TREE_TYPE (lhs_type));
4051           rhs = fold_build2_loc (loc, MULT_EXPR, ptrdiff_type_node,
4052                                  convert (ptrdiff_type_node, rhs),
4053                                  convert (ptrdiff_type_node, sz));
4054         }
4055
4056       /* Build __atomic_fetch_* (&lhs, &val, SEQ_CST), or
4057          __atomic_*_fetch (&lhs, &val, SEQ_CST).  */
4058       fndecl = builtin_decl_explicit (fncode);
4059       params->quick_push (lhs_addr);
4060       params->quick_push (rhs);
4061       params->quick_push (seq_cst);
4062       func_call = c_build_function_call_vec (loc, vNULL, fndecl, params, NULL);
4063
4064       newval = create_tmp_var_raw (nonatomic_lhs_type);
4065       TREE_ADDRESSABLE (newval) = 1;
4066       TREE_NO_WARNING (newval) = 1;
4067       rhs = build4 (TARGET_EXPR, nonatomic_lhs_type, newval, func_call,
4068                     NULL_TREE, NULL_TREE);
4069       SET_EXPR_LOCATION (rhs, loc);
4070       add_stmt (rhs);
4071
4072       /* Finish the compound statement.  */
4073       compound_stmt = c_end_compound_stmt (loc, compound_stmt, false);
4074
4075       /* NEWVAL is the value which was stored, return a COMPOUND_STMT of
4076          the statement and that value.  */
4077       return build2 (COMPOUND_EXPR, nonatomic_lhs_type, compound_stmt, newval);
4078     }
4079
4080 cas_loop:
4081   /* Create the variables and labels required for the op= form.  */
4082   old = create_tmp_var_raw (nonatomic_lhs_type);
4083   old_addr = build_unary_op (loc, ADDR_EXPR, old, false);
4084   TREE_ADDRESSABLE (old) = 1;
4085   TREE_NO_WARNING (old) = 1;
4086
4087   newval = create_tmp_var_raw (nonatomic_lhs_type);
4088   newval_addr = build_unary_op (loc, ADDR_EXPR, newval, false);
4089   TREE_ADDRESSABLE (newval) = 1;
4090   TREE_NO_WARNING (newval) = 1;
4091
4092   loop_decl = create_artificial_label (loc);
4093   loop_label = build1 (LABEL_EXPR, void_type_node, loop_decl);
4094
4095   done_decl = create_artificial_label (loc);
4096   done_label = build1 (LABEL_EXPR, void_type_node, done_decl);
4097
4098   /* __atomic_load (addr, &old, SEQ_CST).  */
4099   fndecl = builtin_decl_explicit (BUILT_IN_ATOMIC_LOAD);
4100   params->quick_push (lhs_addr);
4101   params->quick_push (old_addr);
4102   params->quick_push (seq_cst);
4103   func_call = c_build_function_call_vec (loc, vNULL, fndecl, params, NULL);
4104   old = build4 (TARGET_EXPR, nonatomic_lhs_type, old, func_call, NULL_TREE,
4105                 NULL_TREE);
4106   add_stmt (old);
4107   params->truncate (0);
4108
4109   /* Create the expressions for floating-point environment
4110      manipulation, if required.  */
4111   bool need_fenv = (flag_trapping_math
4112                     && (FLOAT_TYPE_P (lhs_type) || FLOAT_TYPE_P (rhs_type)));
4113   tree hold_call = NULL_TREE, clear_call = NULL_TREE, update_call = NULL_TREE;
4114   if (need_fenv)
4115     targetm.atomic_assign_expand_fenv (&hold_call, &clear_call, &update_call);
4116
4117   if (hold_call)
4118     add_stmt (hold_call);
4119
4120   /* loop:  */
4121   add_stmt (loop_label);
4122
4123   /* newval = old + val;  */
4124   if (rhs_type != rhs_semantic_type)
4125     val = build1 (EXCESS_PRECISION_EXPR, nonatomic_rhs_semantic_type, val);
4126   rhs = build_binary_op (loc, modifycode, old, val, true);
4127   if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
4128     {
4129       tree eptype = TREE_TYPE (rhs);
4130       rhs = c_fully_fold (TREE_OPERAND (rhs, 0), false, NULL);
4131       rhs = build1 (EXCESS_PRECISION_EXPR, eptype, rhs);
4132     }
4133   else
4134     rhs = c_fully_fold (rhs, false, NULL);
4135   rhs = convert_for_assignment (loc, UNKNOWN_LOCATION, nonatomic_lhs_type,
4136                                 rhs, NULL_TREE, ic_assign, false, NULL_TREE,
4137                                 NULL_TREE, 0);
4138   if (rhs != error_mark_node)
4139     {
4140       rhs = build4 (TARGET_EXPR, nonatomic_lhs_type, newval, rhs, NULL_TREE,
4141                     NULL_TREE);
4142       SET_EXPR_LOCATION (rhs, loc);
4143       add_stmt (rhs);
4144     }
4145
4146   /* if (__atomic_compare_exchange (addr, &old, &new, false, SEQ_CST, SEQ_CST))
4147        goto done;  */
4148   fndecl = builtin_decl_explicit (BUILT_IN_ATOMIC_COMPARE_EXCHANGE);
4149   params->quick_push (lhs_addr);
4150   params->quick_push (old_addr);
4151   params->quick_push (newval_addr);
4152   params->quick_push (integer_zero_node);
4153   params->quick_push (seq_cst);
4154   params->quick_push (seq_cst);
4155   func_call = c_build_function_call_vec (loc, vNULL, fndecl, params, NULL);
4156
4157   goto_stmt = build1 (GOTO_EXPR, void_type_node, done_decl);
4158   SET_EXPR_LOCATION (goto_stmt, loc);
4159
4160   stmt = build3 (COND_EXPR, void_type_node, func_call, goto_stmt, NULL_TREE);
4161   SET_EXPR_LOCATION (stmt, loc);
4162   add_stmt (stmt);
4163
4164   if (clear_call)
4165     add_stmt (clear_call);
4166
4167   /* goto loop;  */
4168   goto_stmt  = build1 (GOTO_EXPR, void_type_node, loop_decl);
4169   SET_EXPR_LOCATION (goto_stmt, loc);
4170   add_stmt (goto_stmt);
4171
4172   /* done:  */
4173   add_stmt (done_label);
4174
4175   if (update_call)
4176     add_stmt (update_call);
4177
4178   /* Finish the compound statement.  */
4179   compound_stmt = c_end_compound_stmt (loc, compound_stmt, false);
4180
4181   /* NEWVAL is the value that was successfully stored, return a
4182      COMPOUND_EXPR of the statement and the appropriate value.  */
4183   return build2 (COMPOUND_EXPR, nonatomic_lhs_type, compound_stmt,
4184                  return_old_p ? old : newval);
4185 }
4186
4187 /* Construct and perhaps optimize a tree representation
4188    for a unary operation.  CODE, a tree_code, specifies the operation
4189    and XARG is the operand.
4190    For any CODE other than ADDR_EXPR, NOCONVERT suppresses the default
4191    promotions (such as from short to int).
4192    For ADDR_EXPR, the default promotions are not applied; NOCONVERT allows
4193    non-lvalues; this is only used to handle conversion of non-lvalue arrays
4194    to pointers in C99.
4195
4196    LOCATION is the location of the operator.  */
4197
4198 tree
4199 build_unary_op (location_t location, enum tree_code code, tree xarg,
4200                 bool noconvert)
4201 {
4202   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
4203   tree arg = xarg;
4204   tree argtype = NULL_TREE;
4205   enum tree_code typecode;
4206   tree val;
4207   tree ret = error_mark_node;
4208   tree eptype = NULL_TREE;
4209   const char *invalid_op_diag;
4210   bool int_operands;
4211
4212   int_operands = EXPR_INT_CONST_OPERANDS (xarg);
4213   if (int_operands)
4214     arg = remove_c_maybe_const_expr (arg);
4215
4216   if (code != ADDR_EXPR)
4217     arg = require_complete_type (location, arg);
4218
4219   typecode = TREE_CODE (TREE_TYPE (arg));
4220   if (typecode == ERROR_MARK)
4221     return error_mark_node;
4222   if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
4223     typecode = INTEGER_TYPE;
4224
4225   if ((invalid_op_diag
4226        = targetm.invalid_unary_op (code, TREE_TYPE (xarg))))
4227     {
4228       error_at (location, invalid_op_diag);
4229       return error_mark_node;
4230     }
4231
4232   if (TREE_CODE (arg) == EXCESS_PRECISION_EXPR)
4233     {
4234       eptype = TREE_TYPE (arg);
4235       arg = TREE_OPERAND (arg, 0);
4236     }
4237
4238   switch (code)
4239     {
4240     case CONVERT_EXPR:
4241       /* This is used for unary plus, because a CONVERT_EXPR
4242          is enough to prevent anybody from looking inside for
4243          associativity, but won't generate any code.  */
4244       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
4245             || typecode == FIXED_POINT_TYPE || typecode == COMPLEX_TYPE
4246             || typecode == VECTOR_TYPE))
4247         {
4248           error_at (location, "wrong type argument to unary plus");
4249           return error_mark_node;
4250         }
4251       else if (!noconvert)
4252         arg = default_conversion (arg);
4253       arg = non_lvalue_loc (location, arg);
4254       break;
4255
4256     case NEGATE_EXPR:
4257       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
4258             || typecode == FIXED_POINT_TYPE || typecode == COMPLEX_TYPE
4259             || typecode == VECTOR_TYPE))
4260         {
4261           error_at (location, "wrong type argument to unary minus");
4262           return error_mark_node;
4263         }
4264       else if (!noconvert)
4265         arg = default_conversion (arg);
4266       break;
4267
4268     case BIT_NOT_EXPR:
4269       /* ~ works on integer types and non float vectors. */
4270       if (typecode == INTEGER_TYPE
4271           || (typecode == VECTOR_TYPE
4272               && !VECTOR_FLOAT_TYPE_P (TREE_TYPE (arg))))
4273         {
4274           tree e = arg;
4275
4276           /* Warn if the expression has boolean value.  */
4277           while (TREE_CODE (e) == COMPOUND_EXPR)
4278             e = TREE_OPERAND (e, 1);
4279
4280           if ((TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE
4281                || truth_value_p (TREE_CODE (e)))
4282               && warning_at (location, OPT_Wbool_operation,
4283                              "%<~%> on a boolean expression"))
4284             {
4285               gcc_rich_location richloc (location);
4286               richloc.add_fixit_insert_before (location, "!");
4287               inform (&richloc, "did you mean to use logical not?");
4288             }
4289           if (!noconvert)
4290             arg = default_conversion (arg);
4291         }
4292       else if (typecode == COMPLEX_TYPE)
4293         {
4294           code = CONJ_EXPR;
4295           pedwarn (location, OPT_Wpedantic,
4296                    "ISO C does not support %<~%> for complex conjugation");
4297           if (!noconvert)
4298             arg = default_conversion (arg);
4299         }
4300       else
4301         {
4302           error_at (location, "wrong type argument to bit-complement");
4303           return error_mark_node;
4304         }
4305       break;
4306
4307     case ABS_EXPR:
4308       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
4309         {
4310           error_at (location, "wrong type argument to abs");
4311           return error_mark_node;
4312         }
4313       else if (!noconvert)
4314         arg = default_conversion (arg);
4315       break;
4316
4317     case CONJ_EXPR:
4318       /* Conjugating a real value is a no-op, but allow it anyway.  */
4319       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
4320             || typecode == COMPLEX_TYPE))
4321         {
4322           error_at (location, "wrong type argument to conjugation");
4323           return error_mark_node;
4324         }
4325       else if (!noconvert)
4326         arg = default_conversion (arg);
4327       break;
4328
4329     case TRUTH_NOT_EXPR:
4330       if (typecode != INTEGER_TYPE && typecode != FIXED_POINT_TYPE
4331           && typecode != REAL_TYPE && typecode != POINTER_TYPE
4332           && typecode != COMPLEX_TYPE)
4333         {
4334           error_at (location,
4335                     "wrong type argument to unary exclamation mark");
4336           return error_mark_node;
4337         }
4338       if (int_operands)
4339         {
4340           arg = c_objc_common_truthvalue_conversion (location, xarg);
4341           arg = remove_c_maybe_const_expr (arg);
4342         }
4343       else
4344         arg = c_objc_common_truthvalue_conversion (location, arg);
4345       ret = invert_truthvalue_loc (location, arg);
4346       /* If the TRUTH_NOT_EXPR has been folded, reset the location.  */
4347       if (EXPR_P (ret) && EXPR_HAS_LOCATION (ret))
4348         location = EXPR_LOCATION (ret);
4349       goto return_build_unary_op;
4350
4351     case REALPART_EXPR:
4352     case IMAGPART_EXPR:
4353       ret = build_real_imag_expr (location, code, arg);
4354       if (ret == error_mark_node)
4355         return error_mark_node;
4356       if (eptype && TREE_CODE (eptype) == COMPLEX_TYPE)
4357         eptype = TREE_TYPE (eptype);
4358       goto return_build_unary_op;
4359
4360     case PREINCREMENT_EXPR:
4361     case POSTINCREMENT_EXPR:
4362     case PREDECREMENT_EXPR:
4363     case POSTDECREMENT_EXPR:
4364
4365       if (TREE_CODE (arg) == C_MAYBE_CONST_EXPR)
4366         {
4367           tree inner = build_unary_op (location, code,
4368                                        C_MAYBE_CONST_EXPR_EXPR (arg),
4369                                        noconvert);
4370           if (inner == error_mark_node)
4371             return error_mark_node;
4372           ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
4373                         C_MAYBE_CONST_EXPR_PRE (arg), inner);
4374           gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (arg));
4375           C_MAYBE_CONST_EXPR_NON_CONST (ret) = 1;
4376           goto return_build_unary_op;
4377         }
4378
4379       /* Complain about anything that is not a true lvalue.  In
4380          Objective-C, skip this check for property_refs.  */
4381       if (!objc_is_property_ref (arg)
4382           && !lvalue_or_else (location,
4383                               arg, ((code == PREINCREMENT_EXPR
4384                                      || code == POSTINCREMENT_EXPR)
4385                                     ? lv_increment
4386                                     : lv_decrement)))
4387         return error_mark_node;
4388
4389       if (warn_cxx_compat && TREE_CODE (TREE_TYPE (arg)) == ENUMERAL_TYPE)
4390         {
4391           if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
4392             warning_at (location, OPT_Wc___compat,
4393                         "increment of enumeration value is invalid in C++");
4394           else
4395             warning_at (location, OPT_Wc___compat,
4396                         "decrement of enumeration value is invalid in C++");
4397         }
4398
4399       if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
4400         {
4401           if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
4402             warning_at (location, OPT_Wbool_operation,
4403                         "increment of a boolean expression");
4404           else
4405             warning_at (location, OPT_Wbool_operation,
4406                         "decrement of a boolean expression");
4407         }
4408
4409       /* Ensure the argument is fully folded inside any SAVE_EXPR.  */
4410       arg = c_fully_fold (arg, false, NULL, true);
4411
4412       bool atomic_op;
4413       atomic_op = really_atomic_lvalue (arg);
4414
4415       /* Increment or decrement the real part of the value,
4416          and don't change the imaginary part.  */
4417       if (typecode == COMPLEX_TYPE)
4418         {
4419           tree real, imag;
4420
4421           pedwarn (location, OPT_Wpedantic,
4422                    "ISO C does not support %<++%> and %<--%> on complex types");
4423
4424           if (!atomic_op)
4425             {
4426               arg = stabilize_reference (arg);
4427               real = build_unary_op (EXPR_LOCATION (arg), REALPART_EXPR, arg,
4428                                      true);
4429               imag = build_unary_op (EXPR_LOCATION (arg), IMAGPART_EXPR, arg,
4430                                      true);
4431               real = build_unary_op (EXPR_LOCATION (arg), code, real, true);
4432               if (real == error_mark_node || imag == error_mark_node)
4433                 return error_mark_node;
4434               ret = build2 (COMPLEX_EXPR, TREE_TYPE (arg),
4435                             real, imag);
4436               goto return_build_unary_op;
4437             }
4438         }
4439
4440       /* Report invalid types.  */
4441
4442       if (typecode != POINTER_TYPE && typecode != FIXED_POINT_TYPE
4443           && typecode != INTEGER_TYPE && typecode != REAL_TYPE
4444           && typecode != COMPLEX_TYPE && typecode != VECTOR_TYPE)
4445         {
4446           if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
4447             error_at (location, "wrong type argument to increment");
4448           else
4449             error_at (location, "wrong type argument to decrement");
4450
4451           return error_mark_node;
4452         }
4453
4454       {
4455         tree inc;
4456
4457         argtype = TREE_TYPE (arg);
4458
4459         /* Compute the increment.  */
4460
4461         if (typecode == POINTER_TYPE)
4462           {
4463             /* If pointer target is an incomplete type,
4464                we just cannot know how to do the arithmetic.  */
4465             if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (argtype)))
4466               {
4467                 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
4468                   error_at (location,
4469                             "increment of pointer to an incomplete type %qT",
4470                             TREE_TYPE (argtype));
4471                 else
4472                   error_at (location,
4473                             "decrement of pointer to an incomplete type %qT",
4474                             TREE_TYPE (argtype));
4475               }
4476             else if (TREE_CODE (TREE_TYPE (argtype)) == FUNCTION_TYPE
4477                      || TREE_CODE (TREE_TYPE (argtype)) == VOID_TYPE)
4478               {
4479                 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
4480                   pedwarn (location, OPT_Wpointer_arith,
4481                            "wrong type argument to increment");
4482                 else
4483                   pedwarn (location, OPT_Wpointer_arith,
4484                            "wrong type argument to decrement");
4485               }
4486
4487             inc = c_size_in_bytes (TREE_TYPE (argtype));
4488             inc = convert_to_ptrofftype_loc (location, inc);
4489           }
4490         else if (FRACT_MODE_P (TYPE_MODE (argtype)))
4491           {
4492             /* For signed fract types, we invert ++ to -- or
4493                -- to ++, and change inc from 1 to -1, because
4494                it is not possible to represent 1 in signed fract constants.
4495                For unsigned fract types, the result always overflows and
4496                we get an undefined (original) or the maximum value.  */
4497             if (code == PREINCREMENT_EXPR)
4498               code = PREDECREMENT_EXPR;
4499             else if (code == PREDECREMENT_EXPR)
4500               code = PREINCREMENT_EXPR;
4501             else if (code == POSTINCREMENT_EXPR)
4502               code = POSTDECREMENT_EXPR;
4503             else /* code == POSTDECREMENT_EXPR  */
4504               code = POSTINCREMENT_EXPR;
4505
4506             inc = integer_minus_one_node;
4507             inc = convert (argtype, inc);
4508           }
4509         else
4510           {
4511             inc = VECTOR_TYPE_P (argtype)
4512               ? build_one_cst (argtype)
4513               : integer_one_node;
4514             inc = convert (argtype, inc);
4515           }
4516
4517         /* If 'arg' is an Objective-C PROPERTY_REF expression, then we
4518            need to ask Objective-C to build the increment or decrement
4519            expression for it.  */
4520         if (objc_is_property_ref (arg))
4521           return objc_build_incr_expr_for_property_ref (location, code,
4522                                                         arg, inc);
4523
4524         /* Report a read-only lvalue.  */
4525         if (TYPE_READONLY (argtype))
4526           {
4527             readonly_error (location, arg,
4528                             ((code == PREINCREMENT_EXPR
4529                               || code == POSTINCREMENT_EXPR)
4530                              ? lv_increment : lv_decrement));
4531             return error_mark_node;
4532           }
4533         else if (TREE_READONLY (arg))
4534           readonly_warning (arg,
4535                             ((code == PREINCREMENT_EXPR
4536                               || code == POSTINCREMENT_EXPR)
4537                              ? lv_increment : lv_decrement));
4538
4539         /* If the argument is atomic, use the special code sequences for
4540            atomic compound assignment.  */
4541         if (atomic_op)
4542           {
4543             arg = stabilize_reference (arg);
4544             ret = build_atomic_assign (location, arg,
4545                                        ((code == PREINCREMENT_EXPR
4546                                          || code == POSTINCREMENT_EXPR)
4547                                         ? PLUS_EXPR
4548                                         : MINUS_EXPR),
4549                                        (FRACT_MODE_P (TYPE_MODE (argtype))
4550                                         ? inc
4551                                         : integer_one_node),
4552                                        (code == POSTINCREMENT_EXPR
4553                                         || code == POSTDECREMENT_EXPR));
4554             goto return_build_unary_op;
4555           }
4556
4557         if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
4558           val = boolean_increment (code, arg);
4559         else
4560           val = build2 (code, TREE_TYPE (arg), arg, inc);
4561         TREE_SIDE_EFFECTS (val) = 1;
4562         if (TREE_CODE (val) != code)
4563           TREE_NO_WARNING (val) = 1;
4564         ret = val;
4565         goto return_build_unary_op;
4566       }
4567
4568     case ADDR_EXPR:
4569       /* Note that this operation never does default_conversion.  */
4570
4571       /* The operand of unary '&' must be an lvalue (which excludes
4572          expressions of type void), or, in C99, the result of a [] or
4573          unary '*' operator.  */
4574       if (VOID_TYPE_P (TREE_TYPE (arg))
4575           && TYPE_QUALS (TREE_TYPE (arg)) == TYPE_UNQUALIFIED
4576           && (!INDIRECT_REF_P (arg) || !flag_isoc99))
4577         pedwarn (location, 0, "taking address of expression of type %<void%>");
4578
4579       /* Let &* cancel out to simplify resulting code.  */
4580       if (INDIRECT_REF_P (arg))
4581         {
4582           /* Don't let this be an lvalue.  */
4583           if (lvalue_p (TREE_OPERAND (arg, 0)))
4584             return non_lvalue_loc (location, TREE_OPERAND (arg, 0));
4585           ret = TREE_OPERAND (arg, 0);
4586           goto return_build_unary_op;
4587         }
4588
4589       /* Anything not already handled and not a true memory reference
4590          or a non-lvalue array is an error.  */
4591       if (typecode != FUNCTION_TYPE && !noconvert
4592           && !lvalue_or_else (location, arg, lv_addressof))
4593         return error_mark_node;
4594
4595       /* Move address operations inside C_MAYBE_CONST_EXPR to simplify
4596          folding later.  */
4597       if (TREE_CODE (arg) == C_MAYBE_CONST_EXPR)
4598         {
4599           tree inner = build_unary_op (location, code,
4600                                        C_MAYBE_CONST_EXPR_EXPR (arg),
4601                                        noconvert);
4602           ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
4603                         C_MAYBE_CONST_EXPR_PRE (arg), inner);
4604           gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (arg));
4605           C_MAYBE_CONST_EXPR_NON_CONST (ret)
4606             = C_MAYBE_CONST_EXPR_NON_CONST (arg);
4607           goto return_build_unary_op;
4608         }
4609
4610       /* Ordinary case; arg is a COMPONENT_REF or a decl.  */
4611       argtype = TREE_TYPE (arg);
4612
4613       /* If the lvalue is const or volatile, merge that into the type
4614          to which the address will point.  This is only needed
4615          for function types.  */
4616       if ((DECL_P (arg) || REFERENCE_CLASS_P (arg))
4617           && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg))
4618           && TREE_CODE (argtype) == FUNCTION_TYPE)
4619         {
4620           int orig_quals = TYPE_QUALS (strip_array_types (argtype));
4621           int quals = orig_quals;
4622
4623           if (TREE_READONLY (arg))
4624             quals |= TYPE_QUAL_CONST;
4625           if (TREE_THIS_VOLATILE (arg))
4626             quals |= TYPE_QUAL_VOLATILE;
4627
4628           argtype = c_build_qualified_type (argtype, quals);
4629         }
4630
4631       switch (TREE_CODE (arg))
4632         {
4633         case COMPONENT_REF:
4634           if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
4635             {
4636               error_at (location, "cannot take address of bit-field %qD",
4637                         TREE_OPERAND (arg, 1));
4638               return error_mark_node;
4639             }
4640
4641           /* fall through */
4642
4643         case ARRAY_REF:
4644           if (TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (TREE_OPERAND (arg, 0))))
4645             {
4646               if (!AGGREGATE_TYPE_P (TREE_TYPE (arg))
4647                   && !VECTOR_TYPE_P (TREE_TYPE (arg)))
4648                 {
4649                   error_at (location, "cannot take address of scalar with "
4650                             "reverse storage order");
4651                   return error_mark_node;
4652                 }
4653
4654               if (TREE_CODE (TREE_TYPE (arg)) == ARRAY_TYPE
4655                   && TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (arg)))
4656                 warning_at (location, OPT_Wscalar_storage_order,
4657                             "address of array with reverse scalar storage "
4658                             "order requested");
4659             }
4660
4661         default:
4662           break;
4663         }
4664
4665       if (!c_mark_addressable (arg))
4666         return error_mark_node;
4667
4668       gcc_assert (TREE_CODE (arg) != COMPONENT_REF
4669                   || !DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)));
4670
4671       argtype = build_pointer_type (argtype);
4672
4673       /* ??? Cope with user tricks that amount to offsetof.  Delete this
4674          when we have proper support for integer constant expressions.  */
4675       val = get_base_address (arg);
4676       if (val && INDIRECT_REF_P (val)
4677           && TREE_CONSTANT (TREE_OPERAND (val, 0)))
4678         {
4679           ret = fold_convert_loc (location, argtype, fold_offsetof_1 (arg));
4680           goto return_build_unary_op;
4681         }
4682
4683       val = build1 (ADDR_EXPR, argtype, arg);
4684
4685       ret = val;
4686       goto return_build_unary_op;
4687
4688     default:
4689       gcc_unreachable ();
4690     }
4691
4692   if (argtype == NULL_TREE)
4693     argtype = TREE_TYPE (arg);
4694   if (TREE_CODE (arg) == INTEGER_CST)
4695     ret = (require_constant_value
4696            ? fold_build1_initializer_loc (location, code, argtype, arg)
4697            : fold_build1_loc (location, code, argtype, arg));
4698   else
4699     ret = build1 (code, argtype, arg);
4700  return_build_unary_op:
4701   gcc_assert (ret != error_mark_node);
4702   if (TREE_CODE (ret) == INTEGER_CST && !TREE_OVERFLOW (ret)
4703       && !(TREE_CODE (xarg) == INTEGER_CST && !TREE_OVERFLOW (xarg)))
4704     ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
4705   else if (TREE_CODE (ret) != INTEGER_CST && int_operands)
4706     ret = note_integer_operands (ret);
4707   if (eptype)
4708     ret = build1 (EXCESS_PRECISION_EXPR, eptype, ret);
4709   protected_set_expr_location (ret, location);
4710   return ret;
4711 }
4712
4713 /* Return nonzero if REF is an lvalue valid for this language.
4714    Lvalues can be assigned, unless their type has TYPE_READONLY.
4715    Lvalues can have their address taken, unless they have C_DECL_REGISTER.  */
4716
4717 bool
4718 lvalue_p (const_tree ref)
4719 {
4720   const enum tree_code code = TREE_CODE (ref);
4721
4722   switch (code)
4723     {
4724     case REALPART_EXPR:
4725     case IMAGPART_EXPR:
4726     case COMPONENT_REF:
4727       return lvalue_p (TREE_OPERAND (ref, 0));
4728
4729     case C_MAYBE_CONST_EXPR:
4730       return lvalue_p (TREE_OPERAND (ref, 1));
4731
4732     case COMPOUND_LITERAL_EXPR:
4733     case STRING_CST:
4734       return true;
4735
4736     case INDIRECT_REF:
4737     case ARRAY_REF:
4738     case VAR_DECL:
4739     case PARM_DECL:
4740     case RESULT_DECL:
4741     case ERROR_MARK:
4742       return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
4743               && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
4744
4745     case BIND_EXPR:
4746       return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
4747
4748     default:
4749       return false;
4750     }
4751 }
4752 \f
4753 /* Give a warning for storing in something that is read-only in GCC
4754    terms but not const in ISO C terms.  */
4755
4756 static void
4757 readonly_warning (tree arg, enum lvalue_use use)
4758 {
4759   switch (use)
4760     {
4761     case lv_assign:
4762       warning (0, "assignment of read-only location %qE", arg);
4763       break;
4764     case lv_increment:
4765       warning (0, "increment of read-only location %qE", arg);
4766       break;
4767     case lv_decrement:
4768       warning (0, "decrement of read-only location %qE", arg);
4769       break;
4770     default:
4771       gcc_unreachable ();
4772     }
4773   return;
4774 }
4775
4776
4777 /* Return nonzero if REF is an lvalue valid for this language;
4778    otherwise, print an error message and return zero.  USE says
4779    how the lvalue is being used and so selects the error message.
4780    LOCATION is the location at which any error should be reported.  */
4781
4782 static int
4783 lvalue_or_else (location_t loc, const_tree ref, enum lvalue_use use)
4784 {
4785   int win = lvalue_p (ref);
4786
4787   if (!win)
4788     lvalue_error (loc, use);
4789
4790   return win;
4791 }
4792 \f
4793 /* Mark EXP saying that we need to be able to take the
4794    address of it; it should not be allocated in a register.
4795    Returns true if successful.  ARRAY_REF_P is true if this
4796    is for ARRAY_REF construction - in that case we don't want
4797    to look through VIEW_CONVERT_EXPR from VECTOR_TYPE to ARRAY_TYPE,
4798    it is fine to use ARRAY_REFs for vector subscripts on vector
4799    register variables.  */
4800
4801 bool
4802 c_mark_addressable (tree exp, bool array_ref_p)
4803 {
4804   tree x = exp;
4805
4806   while (1)
4807     switch (TREE_CODE (x))
4808       {
4809       case VIEW_CONVERT_EXPR:
4810         if (array_ref_p
4811             && TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
4812             && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (x, 0))))
4813           return true;
4814         /* FALLTHRU */
4815       case COMPONENT_REF:
4816       case ADDR_EXPR:
4817       case ARRAY_REF:
4818       case REALPART_EXPR:
4819       case IMAGPART_EXPR:
4820         x = TREE_OPERAND (x, 0);
4821         break;
4822
4823       case COMPOUND_LITERAL_EXPR:
4824       case CONSTRUCTOR:
4825         TREE_ADDRESSABLE (x) = 1;
4826         return true;
4827
4828       case VAR_DECL:
4829       case CONST_DECL:
4830       case PARM_DECL:
4831       case RESULT_DECL:
4832         if (C_DECL_REGISTER (x)
4833             && DECL_NONLOCAL (x))
4834           {
4835             if (TREE_PUBLIC (x) || is_global_var (x))
4836               {
4837                 error
4838                   ("global register variable %qD used in nested function", x);
4839                 return false;
4840               }
4841             pedwarn (input_location, 0, "register variable %qD used in nested function", x);
4842           }
4843         else if (C_DECL_REGISTER (x))
4844           {
4845             if (TREE_PUBLIC (x) || is_global_var (x))
4846               error ("address of global register variable %qD requested", x);
4847             else
4848               error ("address of register variable %qD requested", x);
4849             return false;
4850           }
4851
4852         /* FALLTHRU */
4853       case FUNCTION_DECL:
4854         TREE_ADDRESSABLE (x) = 1;
4855         /* FALLTHRU */
4856       default:
4857         return true;
4858     }
4859 }
4860 \f
4861 /* Convert EXPR to TYPE, warning about conversion problems with
4862    constants.  SEMANTIC_TYPE is the type this conversion would use
4863    without excess precision. If SEMANTIC_TYPE is NULL, this function
4864    is equivalent to convert_and_check. This function is a wrapper that
4865    handles conversions that may be different than
4866    the usual ones because of excess precision.  */
4867
4868 static tree
4869 ep_convert_and_check (location_t loc, tree type, tree expr,
4870                       tree semantic_type)
4871 {
4872   if (TREE_TYPE (expr) == type)
4873     return expr;
4874
4875   /* For C11, integer conversions may have results with excess
4876      precision.  */
4877   if (flag_isoc11 || !semantic_type)
4878     return convert_and_check (loc, type, expr);
4879
4880   if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
4881       && TREE_TYPE (expr) != semantic_type)
4882     {
4883       /* For integers, we need to check the real conversion, not
4884          the conversion to the excess precision type.  */
4885       expr = convert_and_check (loc, semantic_type, expr);
4886     }
4887   /* Result type is the excess precision type, which should be
4888      large enough, so do not check.  */
4889   return convert (type, expr);
4890 }
4891
4892 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  If
4893    IFEXP_BCP then the condition is a call to __builtin_constant_p, and
4894    if folded to an integer constant then the unselected half may
4895    contain arbitrary operations not normally permitted in constant
4896    expressions.  Set the location of the expression to LOC.  */
4897
4898 tree
4899 build_conditional_expr (location_t colon_loc, tree ifexp, bool ifexp_bcp,
4900                         tree op1, tree op1_original_type, location_t op1_loc,
4901                         tree op2, tree op2_original_type, location_t op2_loc)
4902 {
4903   tree type1;
4904   tree type2;
4905   enum tree_code code1;
4906   enum tree_code code2;
4907   tree result_type = NULL;
4908   tree semantic_result_type = NULL;
4909   tree orig_op1 = op1, orig_op2 = op2;
4910   bool int_const, op1_int_operands, op2_int_operands, int_operands;
4911   bool ifexp_int_operands;
4912   tree ret;
4913
4914   op1_int_operands = EXPR_INT_CONST_OPERANDS (orig_op1);
4915   if (op1_int_operands)
4916     op1 = remove_c_maybe_const_expr (op1);
4917   op2_int_operands = EXPR_INT_CONST_OPERANDS (orig_op2);
4918   if (op2_int_operands)
4919     op2 = remove_c_maybe_const_expr (op2);
4920   ifexp_int_operands = EXPR_INT_CONST_OPERANDS (ifexp);
4921   if (ifexp_int_operands)
4922     ifexp = remove_c_maybe_const_expr (ifexp);
4923
4924   /* Promote both alternatives.  */
4925
4926   if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
4927     op1 = default_conversion (op1);
4928   if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
4929     op2 = default_conversion (op2);
4930
4931   if (TREE_CODE (ifexp) == ERROR_MARK
4932       || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
4933       || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
4934     return error_mark_node;
4935
4936   type1 = TREE_TYPE (op1);
4937   code1 = TREE_CODE (type1);
4938   type2 = TREE_TYPE (op2);
4939   code2 = TREE_CODE (type2);
4940
4941   if (code1 == POINTER_TYPE && reject_gcc_builtin (op1))
4942     return error_mark_node;
4943
4944   if (code2 == POINTER_TYPE && reject_gcc_builtin (op2))
4945     return error_mark_node;
4946
4947   /* C90 does not permit non-lvalue arrays in conditional expressions.
4948      In C99 they will be pointers by now.  */
4949   if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE)
4950     {
4951       error_at (colon_loc, "non-lvalue array in conditional expression");
4952       return error_mark_node;
4953     }
4954
4955   if ((TREE_CODE (op1) == EXCESS_PRECISION_EXPR
4956        || TREE_CODE (op2) == EXCESS_PRECISION_EXPR)
4957       && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
4958           || code1 == COMPLEX_TYPE)
4959       && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
4960           || code2 == COMPLEX_TYPE))
4961     {
4962       semantic_result_type = c_common_type (type1, type2);
4963       if (TREE_CODE (op1) == EXCESS_PRECISION_EXPR)
4964         {
4965           op1 = TREE_OPERAND (op1, 0);
4966           type1 = TREE_TYPE (op1);
4967           gcc_assert (TREE_CODE (type1) == code1);
4968         }
4969       if (TREE_CODE (op2) == EXCESS_PRECISION_EXPR)
4970         {
4971           op2 = TREE_OPERAND (op2, 0);
4972           type2 = TREE_TYPE (op2);
4973           gcc_assert (TREE_CODE (type2) == code2);
4974         }
4975     }
4976
4977   if (warn_cxx_compat)
4978     {
4979       tree t1 = op1_original_type ? op1_original_type : TREE_TYPE (orig_op1);
4980       tree t2 = op2_original_type ? op2_original_type : TREE_TYPE (orig_op2);
4981
4982       if (TREE_CODE (t1) == ENUMERAL_TYPE
4983           && TREE_CODE (t2) == ENUMERAL_TYPE
4984           && TYPE_MAIN_VARIANT (t1) != TYPE_MAIN_VARIANT (t2))
4985         warning_at (colon_loc, OPT_Wc___compat,
4986                     ("different enum types in conditional is "
4987                      "invalid in C++: %qT vs %qT"),
4988                     t1, t2);
4989     }
4990
4991   /* Quickly detect the usual case where op1 and op2 have the same type
4992      after promotion.  */
4993   if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
4994     {
4995       if (type1 == type2)
4996         result_type = type1;
4997       else
4998         result_type = TYPE_MAIN_VARIANT (type1);
4999     }
5000   else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
5001             || code1 == COMPLEX_TYPE)
5002            && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
5003                || code2 == COMPLEX_TYPE))
5004     {
5005       /* In C11, a conditional expression between a floating-point
5006          type and an integer type should convert the integer type to
5007          the evaluation format of the floating-point type, with
5008          possible excess precision.  */
5009       tree eptype1 = type1;
5010       tree eptype2 = type2;
5011       if (flag_isoc11)
5012         {
5013           tree eptype;
5014           if (ANY_INTEGRAL_TYPE_P (type1)
5015               && (eptype = excess_precision_type (type2)) != NULL_TREE)
5016             {
5017               eptype2 = eptype;
5018               if (!semantic_result_type)
5019                 semantic_result_type = c_common_type (type1, type2);
5020             }
5021           else if (ANY_INTEGRAL_TYPE_P (type2)
5022                    && (eptype = excess_precision_type (type1)) != NULL_TREE)
5023             {
5024               eptype1 = eptype;
5025               if (!semantic_result_type)
5026                 semantic_result_type = c_common_type (type1, type2);
5027             }
5028         }
5029       result_type = c_common_type (eptype1, eptype2);
5030       if (result_type == error_mark_node)
5031         return error_mark_node;
5032       do_warn_double_promotion (result_type, type1, type2,
5033                                 "implicit conversion from %qT to %qT to "
5034                                 "match other result of conditional",
5035                                 colon_loc);
5036
5037       /* If -Wsign-compare, warn here if type1 and type2 have
5038          different signedness.  We'll promote the signed to unsigned
5039          and later code won't know it used to be different.
5040          Do this check on the original types, so that explicit casts
5041          will be considered, but default promotions won't.  */
5042       if (c_inhibit_evaluation_warnings == 0)
5043         {
5044           int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1));
5045           int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2));
5046
5047           if (unsigned_op1 ^ unsigned_op2)
5048             {
5049               bool ovf;
5050
5051               /* Do not warn if the result type is signed, since the
5052                  signed type will only be chosen if it can represent
5053                  all the values of the unsigned type.  */
5054               if (!TYPE_UNSIGNED (result_type))
5055                 /* OK */;
5056               else
5057                 {
5058                   bool op1_maybe_const = true;
5059                   bool op2_maybe_const = true;
5060
5061                   /* Do not warn if the signed quantity is an
5062                      unsuffixed integer literal (or some static
5063                      constant expression involving such literals) and
5064                      it is non-negative.  This warning requires the
5065                      operands to be folded for best results, so do
5066                      that folding in this case even without
5067                      warn_sign_compare to avoid warning options
5068                      possibly affecting code generation.  */
5069                   c_inhibit_evaluation_warnings
5070                     += (ifexp == truthvalue_false_node);
5071                   op1 = c_fully_fold (op1, require_constant_value,
5072                                       &op1_maybe_const);
5073                   c_inhibit_evaluation_warnings
5074                     -= (ifexp == truthvalue_false_node);
5075
5076                   c_inhibit_evaluation_warnings
5077                     += (ifexp == truthvalue_true_node);
5078                   op2 = c_fully_fold (op2, require_constant_value,
5079                                       &op2_maybe_const);
5080                   c_inhibit_evaluation_warnings
5081                     -= (ifexp == truthvalue_true_node);
5082
5083                   if (warn_sign_compare)
5084                     {
5085                       if ((unsigned_op2
5086                            && tree_expr_nonnegative_warnv_p (op1, &ovf))
5087                           || (unsigned_op1
5088                               && tree_expr_nonnegative_warnv_p (op2, &ovf)))
5089                         /* OK */;
5090                       else if (unsigned_op2)
5091                         warning_at (op1_loc, OPT_Wsign_compare,
5092                                     "operand of ?: changes signedness from "
5093                                     "%qT to %qT due to unsignedness of other "
5094                                     "operand", TREE_TYPE (orig_op1),
5095                                     TREE_TYPE (orig_op2));
5096                       else
5097                         warning_at (op2_loc, OPT_Wsign_compare,
5098                                     "operand of ?: changes signedness from "
5099                                     "%qT to %qT due to unsignedness of other "
5100                                     "operand", TREE_TYPE (orig_op2),
5101                                     TREE_TYPE (orig_op1));
5102                     }
5103                   if (!op1_maybe_const || TREE_CODE (op1) != INTEGER_CST)
5104                     op1 = c_wrap_maybe_const (op1, !op1_maybe_const);
5105                   if (!op2_maybe_const || TREE_CODE (op2) != INTEGER_CST)
5106                     op2 = c_wrap_maybe_const (op2, !op2_maybe_const);
5107                 }
5108             }
5109         }
5110     }
5111   else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
5112     {
5113       if (code1 != VOID_TYPE || code2 != VOID_TYPE)
5114         pedwarn (colon_loc, OPT_Wpedantic,
5115                  "ISO C forbids conditional expr with only one void side");
5116       result_type = void_type_node;
5117     }
5118   else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
5119     {
5120       addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (type1));
5121       addr_space_t as2 = TYPE_ADDR_SPACE (TREE_TYPE (type2));
5122       addr_space_t as_common;
5123
5124       if (comp_target_types (colon_loc, type1, type2))
5125         result_type = common_pointer_type (type1, type2);
5126       else if (null_pointer_constant_p (orig_op1))
5127         result_type = type2;
5128       else if (null_pointer_constant_p (orig_op2))
5129         result_type = type1;
5130       else if (!addr_space_superset (as1, as2, &as_common))
5131         {
5132           error_at (colon_loc, "pointers to disjoint address spaces "
5133                     "used in conditional expression");
5134           return error_mark_node;
5135         }
5136       else if (VOID_TYPE_P (TREE_TYPE (type1))
5137                && !TYPE_ATOMIC (TREE_TYPE (type1)))
5138         {
5139           if ((TREE_CODE (TREE_TYPE (type2)) == ARRAY_TYPE)
5140               && (TYPE_QUALS (strip_array_types (TREE_TYPE (type2)))
5141                   & ~TYPE_QUALS (TREE_TYPE (type1))))
5142             warning_at (colon_loc, OPT_Wdiscarded_array_qualifiers,
5143                         "pointer to array loses qualifier "
5144                         "in conditional expression");
5145
5146           if (TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
5147             pedwarn (colon_loc, OPT_Wpedantic,
5148                      "ISO C forbids conditional expr between "
5149                      "%<void *%> and function pointer");
5150           result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
5151                                                           TREE_TYPE (type2)));
5152         }
5153       else if (VOID_TYPE_P (TREE_TYPE (type2))
5154                && !TYPE_ATOMIC (TREE_TYPE (type2)))
5155         {
5156           if ((TREE_CODE (TREE_TYPE (type1)) == ARRAY_TYPE)
5157               && (TYPE_QUALS (strip_array_types (TREE_TYPE (type1)))
5158                   & ~TYPE_QUALS (TREE_TYPE (type2))))
5159             warning_at (colon_loc, OPT_Wdiscarded_array_qualifiers,
5160                         "pointer to array loses qualifier "
5161                         "in conditional expression");
5162
5163           if (TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
5164             pedwarn (colon_loc, OPT_Wpedantic,
5165                      "ISO C forbids conditional expr between "
5166                      "%<void *%> and function pointer");
5167           result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
5168                                                           TREE_TYPE (type1)));
5169         }
5170       /* Objective-C pointer comparisons are a bit more lenient.  */
5171       else if (objc_have_common_type (type1, type2, -3, NULL_TREE))
5172         result_type = objc_common_type (type1, type2);
5173       else
5174         {
5175           int qual = ENCODE_QUAL_ADDR_SPACE (as_common);
5176
5177           pedwarn (colon_loc, 0,
5178                    "pointer type mismatch in conditional expression");
5179           result_type = build_pointer_type
5180                           (build_qualified_type (void_type_node, qual));
5181         }
5182     }
5183   else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
5184     {
5185       if (!null_pointer_constant_p (orig_op2))
5186         pedwarn (colon_loc, 0,
5187                  "pointer/integer type mismatch in conditional expression");
5188       else
5189         {
5190           op2 = null_pointer_node;
5191         }
5192       result_type = type1;
5193     }
5194   else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
5195     {
5196       if (!null_pointer_constant_p (orig_op1))
5197         pedwarn (colon_loc, 0,
5198                  "pointer/integer type mismatch in conditional expression");
5199       else
5200         {
5201           op1 = null_pointer_node;
5202         }
5203       result_type = type2;
5204     }
5205
5206   if (!result_type)
5207     {
5208       if (flag_cond_mismatch)
5209         result_type = void_type_node;
5210       else
5211         {
5212           error_at (colon_loc, "type mismatch in conditional expression");
5213           return error_mark_node;
5214         }
5215     }
5216
5217   /* Merge const and volatile flags of the incoming types.  */
5218   result_type
5219     = build_type_variant (result_type,
5220                           TYPE_READONLY (type1) || TYPE_READONLY (type2),
5221                           TYPE_VOLATILE (type1) || TYPE_VOLATILE (type2));
5222
5223   op1 = ep_convert_and_check (colon_loc, result_type, op1,
5224                               semantic_result_type);
5225   op2 = ep_convert_and_check (colon_loc, result_type, op2,
5226                               semantic_result_type);
5227
5228   if (ifexp_bcp && ifexp == truthvalue_true_node)
5229     {
5230       op2_int_operands = true;
5231       op1 = c_fully_fold (op1, require_constant_value, NULL);
5232     }
5233   if (ifexp_bcp && ifexp == truthvalue_false_node)
5234     {
5235       op1_int_operands = true;
5236       op2 = c_fully_fold (op2, require_constant_value, NULL);
5237     }
5238   int_const = int_operands = (ifexp_int_operands
5239                               && op1_int_operands
5240                               && op2_int_operands);
5241   if (int_operands)
5242     {
5243       int_const = ((ifexp == truthvalue_true_node
5244                     && TREE_CODE (orig_op1) == INTEGER_CST
5245                     && !TREE_OVERFLOW (orig_op1))
5246                    || (ifexp == truthvalue_false_node
5247                        && TREE_CODE (orig_op2) == INTEGER_CST
5248                        && !TREE_OVERFLOW (orig_op2)));
5249     }
5250
5251   /* Need to convert condition operand into a vector mask.  */
5252   if (VECTOR_TYPE_P (TREE_TYPE (ifexp)))
5253     {
5254       tree vectype = TREE_TYPE (ifexp);
5255       tree elem_type = TREE_TYPE (vectype);
5256       tree zero = build_int_cst (elem_type, 0);
5257       tree zero_vec = build_vector_from_val (vectype, zero);
5258       tree cmp_type = build_same_sized_truth_vector_type (vectype);
5259       ifexp = build2 (NE_EXPR, cmp_type, ifexp, zero_vec);
5260     }
5261
5262   if (int_const || (ifexp_bcp && TREE_CODE (ifexp) == INTEGER_CST))
5263     ret = fold_build3_loc (colon_loc, COND_EXPR, result_type, ifexp, op1, op2);
5264   else
5265     {
5266       if (int_operands)
5267         {
5268           /* Use c_fully_fold here, since C_MAYBE_CONST_EXPR might be
5269              nested inside of the expression.  */
5270           op1 = c_fully_fold (op1, false, NULL);
5271           op2 = c_fully_fold (op2, false, NULL);
5272         }
5273       ret = build3 (COND_EXPR, result_type, ifexp, op1, op2);
5274       if (int_operands)
5275         ret = note_integer_operands (ret);
5276     }
5277   if (semantic_result_type)
5278     ret = build1 (EXCESS_PRECISION_EXPR, semantic_result_type, ret);
5279
5280   protected_set_expr_location (ret, colon_loc);
5281
5282   /* If the OP1 and OP2 are the same and don't have side-effects,
5283      warn here, because the COND_EXPR will be turned into OP1.  */
5284   if (warn_duplicated_branches
5285       && TREE_CODE (ret) == COND_EXPR
5286       && (op1 == op2 || operand_equal_p (op1, op2, 0)))
5287     warning_at (EXPR_LOCATION (ret), OPT_Wduplicated_branches,
5288                 "this condition has identical branches");
5289
5290   return ret;
5291 }
5292 \f
5293 /* Return a compound expression that performs two expressions and
5294    returns the value of the second of them.
5295
5296    LOC is the location of the COMPOUND_EXPR.  */
5297
5298 tree
5299 build_compound_expr (location_t loc, tree expr1, tree expr2)
5300 {
5301   bool expr1_int_operands, expr2_int_operands;
5302   tree eptype = NULL_TREE;
5303   tree ret;
5304
5305   expr1_int_operands = EXPR_INT_CONST_OPERANDS (expr1);
5306   if (expr1_int_operands)
5307     expr1 = remove_c_maybe_const_expr (expr1);
5308   expr2_int_operands = EXPR_INT_CONST_OPERANDS (expr2);
5309   if (expr2_int_operands)
5310     expr2 = remove_c_maybe_const_expr (expr2);
5311
5312   if (TREE_CODE (expr1) == EXCESS_PRECISION_EXPR)
5313     expr1 = TREE_OPERAND (expr1, 0);
5314   if (TREE_CODE (expr2) == EXCESS_PRECISION_EXPR)
5315     {
5316       eptype = TREE_TYPE (expr2);
5317       expr2 = TREE_OPERAND (expr2, 0);
5318     }
5319
5320   if (!TREE_SIDE_EFFECTS (expr1))
5321     {
5322       /* The left-hand operand of a comma expression is like an expression
5323          statement: with -Wunused, we should warn if it doesn't have
5324          any side-effects, unless it was explicitly cast to (void).  */
5325       if (warn_unused_value)
5326         {
5327           if (VOID_TYPE_P (TREE_TYPE (expr1))
5328               && CONVERT_EXPR_P (expr1))
5329             ; /* (void) a, b */
5330           else if (VOID_TYPE_P (TREE_TYPE (expr1))
5331                    && TREE_CODE (expr1) == COMPOUND_EXPR
5332                    && CONVERT_EXPR_P (TREE_OPERAND (expr1, 1)))
5333             ; /* (void) a, (void) b, c */
5334           else
5335             warning_at (loc, OPT_Wunused_value,
5336                         "left-hand operand of comma expression has no effect");
5337         }
5338     }
5339   else if (TREE_CODE (expr1) == COMPOUND_EXPR
5340            && warn_unused_value)
5341     {
5342       tree r = expr1;
5343       location_t cloc = loc;
5344       while (TREE_CODE (r) == COMPOUND_EXPR)
5345         {
5346           if (EXPR_HAS_LOCATION (r))
5347             cloc = EXPR_LOCATION (r);
5348           r = TREE_OPERAND (r, 1);
5349         }
5350       if (!TREE_SIDE_EFFECTS (r)
5351           && !VOID_TYPE_P (TREE_TYPE (r))
5352           && !CONVERT_EXPR_P (r))
5353         warning_at (cloc, OPT_Wunused_value,
5354                     "right-hand operand of comma expression has no effect");
5355     }
5356
5357   /* With -Wunused, we should also warn if the left-hand operand does have
5358      side-effects, but computes a value which is not used.  For example, in
5359      `foo() + bar(), baz()' the result of the `+' operator is not used,
5360      so we should issue a warning.  */
5361   else if (warn_unused_value)
5362     warn_if_unused_value (expr1, loc);
5363
5364   if (expr2 == error_mark_node)
5365     return error_mark_node;
5366
5367   ret = build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2);
5368
5369   if (flag_isoc99
5370       && expr1_int_operands
5371       && expr2_int_operands)
5372     ret = note_integer_operands (ret);
5373
5374   if (eptype)
5375     ret = build1 (EXCESS_PRECISION_EXPR, eptype, ret);
5376
5377   protected_set_expr_location (ret, loc);
5378   return ret;
5379 }
5380
5381 /* Issue -Wcast-qual warnings when appropriate.  TYPE is the type to
5382    which we are casting.  OTYPE is the type of the expression being
5383    cast.  Both TYPE and OTYPE are pointer types.  LOC is the location
5384    of the cast.  -Wcast-qual appeared on the command line.  Named
5385    address space qualifiers are not handled here, because they result
5386    in different warnings.  */
5387
5388 static void
5389 handle_warn_cast_qual (location_t loc, tree type, tree otype)
5390 {
5391   tree in_type = type;
5392   tree in_otype = otype;
5393   int added = 0;
5394   int discarded = 0;
5395   bool is_const;
5396
5397   /* Check that the qualifiers on IN_TYPE are a superset of the
5398      qualifiers of IN_OTYPE.  The outermost level of POINTER_TYPE
5399      nodes is uninteresting and we stop as soon as we hit a
5400      non-POINTER_TYPE node on either type.  */
5401   do
5402     {
5403       in_otype = TREE_TYPE (in_otype);
5404       in_type = TREE_TYPE (in_type);
5405
5406       /* GNU C allows cv-qualified function types.  'const' means the
5407          function is very pure, 'volatile' means it can't return.  We
5408          need to warn when such qualifiers are added, not when they're
5409          taken away.  */
5410       if (TREE_CODE (in_otype) == FUNCTION_TYPE
5411           && TREE_CODE (in_type) == FUNCTION_TYPE)
5412         added |= (TYPE_QUALS_NO_ADDR_SPACE (in_type)
5413                   & ~TYPE_QUALS_NO_ADDR_SPACE (in_otype));
5414       else
5415         discarded |= (TYPE_QUALS_NO_ADDR_SPACE (in_otype)
5416                       & ~TYPE_QUALS_NO_ADDR_SPACE (in_type));
5417     }
5418   while (TREE_CODE (in_type) == POINTER_TYPE
5419          && TREE_CODE (in_otype) == POINTER_TYPE);
5420
5421   if (added)
5422     warning_at (loc, OPT_Wcast_qual,
5423                 "cast adds %q#v qualifier to function type", added);
5424
5425   if (discarded)
5426     /* There are qualifiers present in IN_OTYPE that are not present
5427        in IN_TYPE.  */
5428     warning_at (loc, OPT_Wcast_qual,
5429                 "cast discards %qv qualifier from pointer target type",
5430                 discarded);
5431
5432   if (added || discarded)
5433     return;
5434
5435   /* A cast from **T to const **T is unsafe, because it can cause a
5436      const value to be changed with no additional warning.  We only
5437      issue this warning if T is the same on both sides, and we only
5438      issue the warning if there are the same number of pointers on
5439      both sides, as otherwise the cast is clearly unsafe anyhow.  A
5440      cast is unsafe when a qualifier is added at one level and const
5441      is not present at all outer levels.
5442
5443      To issue this warning, we check at each level whether the cast
5444      adds new qualifiers not already seen.  We don't need to special
5445      case function types, as they won't have the same
5446      TYPE_MAIN_VARIANT.  */
5447
5448   if (TYPE_MAIN_VARIANT (in_type) != TYPE_MAIN_VARIANT (in_otype))
5449     return;
5450   if (TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE)
5451     return;
5452
5453   in_type = type;
5454   in_otype = otype;
5455   is_const = TYPE_READONLY (TREE_TYPE (in_type));
5456   do
5457     {
5458       in_type = TREE_TYPE (in_type);
5459       in_otype = TREE_TYPE (in_otype);
5460       if ((TYPE_QUALS (in_type) &~ TYPE_QUALS (in_otype)) != 0
5461           && !is_const)
5462         {
5463           warning_at (loc, OPT_Wcast_qual,
5464                       "to be safe all intermediate pointers in cast from "
5465                       "%qT to %qT must be %<const%> qualified",
5466                       otype, type);
5467           break;
5468         }
5469       if (is_const)
5470         is_const = TYPE_READONLY (in_type);
5471     }
5472   while (TREE_CODE (in_type) == POINTER_TYPE);
5473 }
5474
5475 /* Heuristic check if two parameter types can be considered ABI-equivalent.  */
5476
5477 static bool
5478 c_safe_arg_type_equiv_p (tree t1, tree t2)
5479 {
5480   t1 = TYPE_MAIN_VARIANT (t1);
5481   t2 = TYPE_MAIN_VARIANT (t2);
5482
5483   if (TREE_CODE (t1) == POINTER_TYPE
5484       && TREE_CODE (t2) == POINTER_TYPE)
5485     return true;
5486
5487   /* The signedness of the parameter matters only when an integral
5488      type smaller than int is promoted to int, otherwise only the
5489      precision of the parameter matters.
5490      This check should make sure that the callee does not see
5491      undefined values in argument registers.  */
5492   if (INTEGRAL_TYPE_P (t1)
5493       && INTEGRAL_TYPE_P (t2)
5494       && TYPE_PRECISION (t1) == TYPE_PRECISION (t2)
5495       && (TYPE_UNSIGNED (t1) == TYPE_UNSIGNED (t2)
5496           || !targetm.calls.promote_prototypes (NULL_TREE)
5497           || TYPE_PRECISION (t1) >= TYPE_PRECISION (integer_type_node)))
5498     return true;
5499
5500   return comptypes (t1, t2);
5501 }
5502
5503 /* Check if a type cast between two function types can be considered safe.  */
5504
5505 static bool
5506 c_safe_function_type_cast_p (tree t1, tree t2)
5507 {
5508   if (TREE_TYPE (t1) == void_type_node &&
5509       TYPE_ARG_TYPES (t1) == void_list_node)
5510     return true;
5511
5512   if (TREE_TYPE (t2) == void_type_node &&
5513       TYPE_ARG_TYPES (t2) == void_list_node)
5514     return true;
5515
5516   if (!c_safe_arg_type_equiv_p (TREE_TYPE (t1), TREE_TYPE (t2)))
5517     return false;
5518
5519   for (t1 = TYPE_ARG_TYPES (t1), t2 = TYPE_ARG_TYPES (t2);
5520        t1 && t2;
5521        t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
5522     if (!c_safe_arg_type_equiv_p (TREE_VALUE (t1), TREE_VALUE (t2)))
5523       return false;
5524
5525   return true;
5526 }
5527
5528 /* Build an expression representing a cast to type TYPE of expression EXPR.
5529    LOC is the location of the cast-- typically the open paren of the cast.  */
5530
5531 tree
5532 build_c_cast (location_t loc, tree type, tree expr)
5533 {
5534   tree value;
5535
5536   if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
5537     expr = TREE_OPERAND (expr, 0);
5538
5539   value = expr;
5540
5541   if (type == error_mark_node || expr == error_mark_node)
5542     return error_mark_node;
5543
5544   /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
5545      only in <protocol> qualifications.  But when constructing cast expressions,
5546      the protocols do matter and must be kept around.  */
5547   if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr)))
5548     return build1 (NOP_EXPR, type, expr);
5549
5550   type = TYPE_MAIN_VARIANT (type);
5551
5552   if (TREE_CODE (type) == ARRAY_TYPE)
5553     {
5554       error_at (loc, "cast specifies array type");
5555       return error_mark_node;
5556     }
5557
5558   if (TREE_CODE (type) == FUNCTION_TYPE)
5559     {
5560       error_at (loc, "cast specifies function type");
5561       return error_mark_node;
5562     }
5563
5564   if (!VOID_TYPE_P (type))
5565     {
5566       value = require_complete_type (loc, value);
5567       if (value == error_mark_node)
5568         return error_mark_node;
5569     }
5570
5571   if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
5572     {
5573       if (RECORD_OR_UNION_TYPE_P (type))
5574         pedwarn (loc, OPT_Wpedantic,
5575                  "ISO C forbids casting nonscalar to the same type");
5576
5577       /* Convert to remove any qualifiers from VALUE's type.  */
5578       value = convert (type, value);
5579     }
5580   else if (TREE_CODE (type) == UNION_TYPE)
5581     {
5582       tree field;
5583
5584       for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5585         if (TREE_TYPE (field) != error_mark_node
5586             && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
5587                           TYPE_MAIN_VARIANT (TREE_TYPE (value))))
5588           break;
5589
5590       if (field)
5591         {
5592           tree t;
5593           bool maybe_const = true;
5594
5595           pedwarn (loc, OPT_Wpedantic, "ISO C forbids casts to union type");
5596           t = c_fully_fold (value, false, &maybe_const);
5597           t = build_constructor_single (type, field, t);
5598           if (!maybe_const)
5599             t = c_wrap_maybe_const (t, true);
5600           t = digest_init (loc, type, t,
5601                            NULL_TREE, false, true, 0);
5602           TREE_CONSTANT (t) = TREE_CONSTANT (value);
5603           return t;
5604         }
5605       error_at (loc, "cast to union type from type not present in union");
5606       return error_mark_node;
5607     }
5608   else
5609     {
5610       tree otype, ovalue;
5611
5612       if (type == void_type_node)
5613         {
5614           tree t = build1 (CONVERT_EXPR, type, value);
5615           SET_EXPR_LOCATION (t, loc);
5616           return t;
5617         }
5618
5619       otype = TREE_TYPE (value);
5620
5621       /* Optionally warn about potentially worrisome casts.  */
5622       if (warn_cast_qual
5623           && TREE_CODE (type) == POINTER_TYPE
5624           && TREE_CODE (otype) == POINTER_TYPE)
5625         handle_warn_cast_qual (loc, type, otype);
5626
5627       /* Warn about conversions between pointers to disjoint
5628          address spaces.  */
5629       if (TREE_CODE (type) == POINTER_TYPE
5630           && TREE_CODE (otype) == POINTER_TYPE
5631           && !null_pointer_constant_p (value))
5632         {
5633           addr_space_t as_to = TYPE_ADDR_SPACE (TREE_TYPE (type));
5634           addr_space_t as_from = TYPE_ADDR_SPACE (TREE_TYPE (otype));
5635           addr_space_t as_common;
5636
5637           if (!addr_space_superset (as_to, as_from, &as_common))
5638             {
5639               if (ADDR_SPACE_GENERIC_P (as_from))
5640                 warning_at (loc, 0, "cast to %s address space pointer "
5641                             "from disjoint generic address space pointer",
5642                             c_addr_space_name (as_to));
5643
5644               else if (ADDR_SPACE_GENERIC_P (as_to))
5645                 warning_at (loc, 0, "cast to generic address space pointer "
5646                             "from disjoint %s address space pointer",
5647                             c_addr_space_name (as_from));
5648
5649               else
5650                 warning_at (loc, 0, "cast to %s address space pointer "
5651                             "from disjoint %s address space pointer",
5652                             c_addr_space_name (as_to),
5653                             c_addr_space_name (as_from));
5654             }
5655         }
5656
5657       /* Warn about possible alignment problems.  */
5658       if ((STRICT_ALIGNMENT || warn_cast_align == 2)
5659           && TREE_CODE (type) == POINTER_TYPE
5660           && TREE_CODE (otype) == POINTER_TYPE
5661           && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
5662           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
5663           /* Don't warn about opaque types, where the actual alignment
5664              restriction is unknown.  */
5665           && !(RECORD_OR_UNION_TYPE_P (TREE_TYPE (otype))
5666                && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
5667           && min_align_of_type (TREE_TYPE (type))
5668              > min_align_of_type (TREE_TYPE (otype)))
5669         warning_at (loc, OPT_Wcast_align,
5670                     "cast increases required alignment of target type");
5671
5672       if (TREE_CODE (type) == INTEGER_TYPE
5673           && TREE_CODE (otype) == POINTER_TYPE
5674           && TYPE_PRECISION (type) != TYPE_PRECISION (otype))
5675       /* Unlike conversion of integers to pointers, where the
5676          warning is disabled for converting constants because
5677          of cases such as SIG_*, warn about converting constant
5678          pointers to integers. In some cases it may cause unwanted
5679          sign extension, and a warning is appropriate.  */
5680         warning_at (loc, OPT_Wpointer_to_int_cast,
5681                     "cast from pointer to integer of different size");
5682
5683       if (TREE_CODE (value) == CALL_EXPR
5684           && TREE_CODE (type) != TREE_CODE (otype))
5685         warning_at (loc, OPT_Wbad_function_cast,
5686                     "cast from function call of type %qT "
5687                     "to non-matching type %qT", otype, type);
5688
5689       if (TREE_CODE (type) == POINTER_TYPE
5690           && TREE_CODE (otype) == INTEGER_TYPE
5691           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
5692           /* Don't warn about converting any constant.  */
5693           && !TREE_CONSTANT (value))
5694         warning_at (loc,
5695                     OPT_Wint_to_pointer_cast, "cast to pointer from integer "
5696                     "of different size");
5697
5698       if (warn_strict_aliasing <= 2)
5699         strict_aliasing_warning (otype, type, expr);
5700
5701       /* If pedantic, warn for conversions between function and object
5702          pointer types, except for converting a null pointer constant
5703          to function pointer type.  */
5704       if (pedantic
5705           && TREE_CODE (type) == POINTER_TYPE
5706           && TREE_CODE (otype) == POINTER_TYPE
5707           && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
5708           && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
5709         pedwarn (loc, OPT_Wpedantic, "ISO C forbids "
5710                  "conversion of function pointer to object pointer type");
5711
5712       if (pedantic
5713           && TREE_CODE (type) == POINTER_TYPE
5714           && TREE_CODE (otype) == POINTER_TYPE
5715           && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
5716           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
5717           && !null_pointer_constant_p (value))
5718         pedwarn (loc, OPT_Wpedantic, "ISO C forbids "
5719                  "conversion of object pointer to function pointer type");
5720
5721       if (TREE_CODE (type) == POINTER_TYPE
5722           && TREE_CODE (otype) == POINTER_TYPE
5723           && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
5724           && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
5725           && !c_safe_function_type_cast_p (TREE_TYPE (type),
5726                                            TREE_TYPE (otype)))
5727         warning_at (loc, OPT_Wcast_function_type,
5728                     "cast between incompatible function types"
5729                     " from %qT to %qT", otype, type);
5730
5731       ovalue = value;
5732       value = convert (type, value);
5733
5734       /* Ignore any integer overflow caused by the cast.  */
5735       if (TREE_CODE (value) == INTEGER_CST && !FLOAT_TYPE_P (otype))
5736         {
5737           if (CONSTANT_CLASS_P (ovalue) && TREE_OVERFLOW (ovalue))
5738             {
5739               if (!TREE_OVERFLOW (value))
5740                 {
5741                   /* Avoid clobbering a shared constant.  */
5742                   value = copy_node (value);
5743                   TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
5744                 }
5745             }
5746           else if (TREE_OVERFLOW (value))
5747             /* Reset VALUE's overflow flags, ensuring constant sharing.  */
5748             value = wide_int_to_tree (TREE_TYPE (value), wi::to_wide (value));
5749         }
5750     }
5751
5752   /* Don't let a cast be an lvalue.  */
5753   if (lvalue_p (value))
5754     value = non_lvalue_loc (loc, value);
5755
5756   /* Don't allow the results of casting to floating-point or complex
5757      types be confused with actual constants, or casts involving
5758      integer and pointer types other than direct integer-to-integer
5759      and integer-to-pointer be confused with integer constant
5760      expressions and null pointer constants.  */
5761   if (TREE_CODE (value) == REAL_CST
5762       || TREE_CODE (value) == COMPLEX_CST
5763       || (TREE_CODE (value) == INTEGER_CST
5764           && !((TREE_CODE (expr) == INTEGER_CST
5765                 && INTEGRAL_TYPE_P (TREE_TYPE (expr)))
5766                || TREE_CODE (expr) == REAL_CST
5767                || TREE_CODE (expr) == COMPLEX_CST)))
5768       value = build1 (NOP_EXPR, type, value);
5769
5770   protected_set_expr_location (value, loc);
5771   return value;
5772 }
5773
5774 /* Interpret a cast of expression EXPR to type TYPE.  LOC is the
5775    location of the open paren of the cast, or the position of the cast
5776    expr.  */
5777 tree
5778 c_cast_expr (location_t loc, struct c_type_name *type_name, tree expr)
5779 {
5780   tree type;
5781   tree type_expr = NULL_TREE;
5782   bool type_expr_const = true;
5783   tree ret;
5784   int saved_wsp = warn_strict_prototypes;
5785
5786   /* This avoids warnings about unprototyped casts on
5787      integers.  E.g. "#define SIG_DFL (void(*)())0".  */
5788   if (TREE_CODE (expr) == INTEGER_CST)
5789     warn_strict_prototypes = 0;
5790   type = groktypename (type_name, &type_expr, &type_expr_const);
5791   warn_strict_prototypes = saved_wsp;
5792
5793   if (TREE_CODE (expr) == ADDR_EXPR && !VOID_TYPE_P (type)
5794       && reject_gcc_builtin (expr))
5795     return error_mark_node;
5796
5797   ret = build_c_cast (loc, type, expr);
5798   if (type_expr)
5799     {
5800       bool inner_expr_const = true;
5801       ret = c_fully_fold (ret, require_constant_value, &inner_expr_const);
5802       ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret), type_expr, ret);
5803       C_MAYBE_CONST_EXPR_NON_CONST (ret) = !(type_expr_const
5804                                              && inner_expr_const);
5805       SET_EXPR_LOCATION (ret, loc);
5806     }
5807
5808   if (!EXPR_HAS_LOCATION (ret))
5809     protected_set_expr_location (ret, loc);
5810
5811   /* C++ does not permits types to be defined in a cast, but it
5812      allows references to incomplete types.  */
5813   if (warn_cxx_compat && type_name->specs->typespec_kind == ctsk_tagdef)
5814     warning_at (loc, OPT_Wc___compat,
5815                 "defining a type in a cast is invalid in C++");
5816
5817   return ret;
5818 }
5819 \f
5820 /* Build an assignment expression of lvalue LHS from value RHS.
5821    If LHS_ORIGTYPE is not NULL, it is the original type of LHS, which
5822    may differ from TREE_TYPE (LHS) for an enum bitfield.
5823    MODIFYCODE is the code for a binary operator that we use
5824    to combine the old value of LHS with RHS to get the new value.
5825    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5826    If RHS_ORIGTYPE is not NULL_TREE, it is the original type of RHS,
5827    which may differ from TREE_TYPE (RHS) for an enum value.
5828
5829    LOCATION is the location of the MODIFYCODE operator.
5830    RHS_LOC is the location of the RHS.  */
5831
5832 tree
5833 build_modify_expr (location_t location, tree lhs, tree lhs_origtype,
5834                    enum tree_code modifycode,
5835                    location_t rhs_loc, tree rhs, tree rhs_origtype)
5836 {
5837   tree result;
5838   tree newrhs;
5839   tree rhseval = NULL_TREE;
5840   tree lhstype = TREE_TYPE (lhs);
5841   tree olhstype = lhstype;
5842   bool npc;
5843   bool is_atomic_op;
5844
5845   /* Types that aren't fully specified cannot be used in assignments.  */
5846   lhs = require_complete_type (location, lhs);
5847
5848   /* Avoid duplicate error messages from operands that had errors.  */
5849   if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
5850     return error_mark_node;
5851
5852   /* Ensure an error for assigning a non-lvalue array to an array in
5853      C90.  */
5854   if (TREE_CODE (lhstype) == ARRAY_TYPE)
5855     {
5856       error_at (location, "assignment to expression with array type");
5857       return error_mark_node;
5858     }
5859
5860   /* For ObjC properties, defer this check.  */
5861   if (!objc_is_property_ref (lhs) && !lvalue_or_else (location, lhs, lv_assign))
5862     return error_mark_node;
5863
5864   is_atomic_op = really_atomic_lvalue (lhs);
5865
5866   newrhs = rhs;
5867
5868   if (TREE_CODE (lhs) == C_MAYBE_CONST_EXPR)
5869     {
5870       tree inner = build_modify_expr (location, C_MAYBE_CONST_EXPR_EXPR (lhs),
5871                                       lhs_origtype, modifycode, rhs_loc, rhs,
5872                                       rhs_origtype);
5873       if (inner == error_mark_node)
5874         return error_mark_node;
5875       result = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
5876                        C_MAYBE_CONST_EXPR_PRE (lhs), inner);
5877       gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (lhs));
5878       C_MAYBE_CONST_EXPR_NON_CONST (result) = 1;
5879       protected_set_expr_location (result, location);
5880       return result;
5881     }
5882
5883   /* If a binary op has been requested, combine the old LHS value with the RHS
5884      producing the value we should actually store into the LHS.  */
5885
5886   if (modifycode != NOP_EXPR)
5887     {
5888       lhs = c_fully_fold (lhs, false, NULL, true);
5889       lhs = stabilize_reference (lhs);
5890
5891       /* Construct the RHS for any non-atomic compound assignemnt. */
5892       if (!is_atomic_op)
5893         {
5894           /* If in LHS op= RHS the RHS has side-effects, ensure they
5895              are preevaluated before the rest of the assignment expression's
5896              side-effects, because RHS could contain e.g. function calls
5897              that modify LHS.  */
5898           if (TREE_SIDE_EFFECTS (rhs))
5899             {
5900               if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
5901                 newrhs = save_expr (TREE_OPERAND (rhs, 0));
5902               else
5903                 newrhs = save_expr (rhs);
5904               rhseval = newrhs;
5905               if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
5906                 newrhs = build1 (EXCESS_PRECISION_EXPR, TREE_TYPE (rhs),
5907                                  newrhs);
5908             }
5909           newrhs = build_binary_op (location,
5910                                     modifycode, lhs, newrhs, true);
5911
5912           /* The original type of the right hand side is no longer
5913              meaningful.  */
5914           rhs_origtype = NULL_TREE;
5915         }
5916     }
5917
5918   if (c_dialect_objc ())
5919     {
5920       /* Check if we are modifying an Objective-C property reference;
5921          if so, we need to generate setter calls.  */
5922       if (TREE_CODE (newrhs) == EXCESS_PRECISION_EXPR)
5923         result = objc_maybe_build_modify_expr (lhs, TREE_OPERAND (newrhs, 0));
5924       else
5925         result = objc_maybe_build_modify_expr (lhs, newrhs);
5926       if (result)
5927         goto return_result;
5928
5929       /* Else, do the check that we postponed for Objective-C.  */
5930       if (!lvalue_or_else (location, lhs, lv_assign))
5931         return error_mark_node;
5932     }
5933
5934   /* Give an error for storing in something that is 'const'.  */
5935
5936   if (TYPE_READONLY (lhstype)
5937       || (RECORD_OR_UNION_TYPE_P (lhstype)
5938           && C_TYPE_FIELDS_READONLY (lhstype)))
5939     {
5940       readonly_error (location, lhs, lv_assign);
5941       return error_mark_node;
5942     }
5943   else if (TREE_READONLY (lhs))
5944     readonly_warning (lhs, lv_assign);
5945
5946   /* If storing into a structure or union member,
5947      it has probably been given type `int'.
5948      Compute the type that would go with
5949      the actual amount of storage the member occupies.  */
5950
5951   if (TREE_CODE (lhs) == COMPONENT_REF
5952       && (TREE_CODE (lhstype) == INTEGER_TYPE
5953           || TREE_CODE (lhstype) == BOOLEAN_TYPE
5954           || TREE_CODE (lhstype) == REAL_TYPE
5955           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
5956     lhstype = TREE_TYPE (get_unwidened (lhs, 0));
5957
5958   /* If storing in a field that is in actuality a short or narrower than one,
5959      we must store in the field in its actual type.  */
5960
5961   if (lhstype != TREE_TYPE (lhs))
5962     {
5963       lhs = copy_node (lhs);
5964       TREE_TYPE (lhs) = lhstype;
5965     }
5966
5967   /* Issue -Wc++-compat warnings about an assignment to an enum type
5968      when LHS does not have its original type.  This happens for,
5969      e.g., an enum bitfield in a struct.  */
5970   if (warn_cxx_compat
5971       && lhs_origtype != NULL_TREE
5972       && lhs_origtype != lhstype
5973       && TREE_CODE (lhs_origtype) == ENUMERAL_TYPE)
5974     {
5975       tree checktype = (rhs_origtype != NULL_TREE
5976                         ? rhs_origtype
5977                         : TREE_TYPE (rhs));
5978       if (checktype != error_mark_node
5979           && (TYPE_MAIN_VARIANT (checktype) != TYPE_MAIN_VARIANT (lhs_origtype)
5980               || (is_atomic_op && modifycode != NOP_EXPR)))
5981         warning_at (location, OPT_Wc___compat,
5982                     "enum conversion in assignment is invalid in C++");
5983     }
5984
5985   /* If the lhs is atomic, remove that qualifier.  */
5986   if (is_atomic_op)
5987     {
5988       lhstype = build_qualified_type (lhstype,
5989                                       (TYPE_QUALS (lhstype)
5990                                        & ~TYPE_QUAL_ATOMIC));
5991       olhstype = build_qualified_type (olhstype,
5992                                        (TYPE_QUALS (lhstype)
5993                                         & ~TYPE_QUAL_ATOMIC));
5994     }
5995
5996   /* Convert new value to destination type.  Fold it first, then
5997      restore any excess precision information, for the sake of
5998      conversion warnings.  */
5999
6000   if (!(is_atomic_op && modifycode != NOP_EXPR))
6001     {
6002       tree rhs_semantic_type = NULL_TREE;
6003       if (TREE_CODE (newrhs) == EXCESS_PRECISION_EXPR)
6004         {
6005           rhs_semantic_type = TREE_TYPE (newrhs);
6006           newrhs = TREE_OPERAND (newrhs, 0);
6007         }
6008       npc = null_pointer_constant_p (newrhs);
6009       newrhs = c_fully_fold (newrhs, false, NULL);
6010       if (rhs_semantic_type)
6011         newrhs = build1 (EXCESS_PRECISION_EXPR, rhs_semantic_type, newrhs);
6012       newrhs = convert_for_assignment (location, rhs_loc, lhstype, newrhs,
6013                                        rhs_origtype, ic_assign, npc,
6014                                        NULL_TREE, NULL_TREE, 0);
6015       if (TREE_CODE (newrhs) == ERROR_MARK)
6016         return error_mark_node;
6017     }
6018
6019   /* Emit ObjC write barrier, if necessary.  */
6020   if (c_dialect_objc () && flag_objc_gc)
6021     {
6022       result = objc_generate_write_barrier (lhs, modifycode, newrhs);
6023       if (result)
6024         {
6025           protected_set_expr_location (result, location);
6026           goto return_result;
6027         }
6028     }
6029
6030   /* Scan operands.  */
6031
6032   if (is_atomic_op)
6033     result = build_atomic_assign (location, lhs, modifycode, newrhs, false);
6034   else
6035     {
6036       result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs);
6037       TREE_SIDE_EFFECTS (result) = 1;
6038       protected_set_expr_location (result, location);
6039     }
6040
6041   /* If we got the LHS in a different type for storing in,
6042      convert the result back to the nominal type of LHS
6043      so that the value we return always has the same type
6044      as the LHS argument.  */
6045
6046   if (olhstype == TREE_TYPE (result))
6047     goto return_result;
6048
6049   result = convert_for_assignment (location, rhs_loc, olhstype, result,
6050                                    rhs_origtype, ic_assign, false, NULL_TREE,
6051                                    NULL_TREE, 0);
6052   protected_set_expr_location (result, location);
6053
6054 return_result:
6055   if (rhseval)
6056     result = build2 (COMPOUND_EXPR, TREE_TYPE (result), rhseval, result);
6057   return result;
6058 }
6059 \f
6060 /* Return whether STRUCT_TYPE has an anonymous field with type TYPE.
6061    This is used to implement -fplan9-extensions.  */
6062
6063 static bool
6064 find_anonymous_field_with_type (tree struct_type, tree type)
6065 {
6066   tree field;
6067   bool found;
6068
6069   gcc_assert (RECORD_OR_UNION_TYPE_P (struct_type));
6070   found = false;
6071   for (field = TYPE_FIELDS (struct_type);
6072        field != NULL_TREE;
6073        field = TREE_CHAIN (field))
6074     {
6075       tree fieldtype = (TYPE_ATOMIC (TREE_TYPE (field))
6076                         ? c_build_qualified_type (TREE_TYPE (field),
6077                                                   TYPE_QUAL_ATOMIC)
6078                         : TYPE_MAIN_VARIANT (TREE_TYPE (field)));
6079       if (DECL_NAME (field) == NULL
6080           && comptypes (type, fieldtype))
6081         {
6082           if (found)
6083             return false;
6084           found = true;
6085         }
6086       else if (DECL_NAME (field) == NULL
6087                && RECORD_OR_UNION_TYPE_P (TREE_TYPE (field))
6088                && find_anonymous_field_with_type (TREE_TYPE (field), type))
6089         {
6090           if (found)
6091             return false;
6092           found = true;
6093         }
6094     }
6095   return found;
6096 }
6097
6098 /* RHS is an expression whose type is pointer to struct.  If there is
6099    an anonymous field in RHS with type TYPE, then return a pointer to
6100    that field in RHS.  This is used with -fplan9-extensions.  This
6101    returns NULL if no conversion could be found.  */
6102
6103 static tree
6104 convert_to_anonymous_field (location_t location, tree type, tree rhs)
6105 {
6106   tree rhs_struct_type, lhs_main_type;
6107   tree field, found_field;
6108   bool found_sub_field;
6109   tree ret;
6110
6111   gcc_assert (POINTER_TYPE_P (TREE_TYPE (rhs)));
6112   rhs_struct_type = TREE_TYPE (TREE_TYPE (rhs));
6113   gcc_assert (RECORD_OR_UNION_TYPE_P (rhs_struct_type));
6114
6115   gcc_assert (POINTER_TYPE_P (type));
6116   lhs_main_type = (TYPE_ATOMIC (TREE_TYPE (type))
6117                    ? c_build_qualified_type (TREE_TYPE (type),
6118                                              TYPE_QUAL_ATOMIC)
6119                    : TYPE_MAIN_VARIANT (TREE_TYPE (type)));
6120
6121   found_field = NULL_TREE;
6122   found_sub_field = false;
6123   for (field = TYPE_FIELDS (rhs_struct_type);
6124        field != NULL_TREE;
6125        field = TREE_CHAIN (field))
6126     {
6127       if (DECL_NAME (field) != NULL_TREE
6128           || !RECORD_OR_UNION_TYPE_P (TREE_TYPE (field)))
6129         continue;
6130       tree fieldtype = (TYPE_ATOMIC (TREE_TYPE (field))
6131                         ? c_build_qualified_type (TREE_TYPE (field),
6132                                                   TYPE_QUAL_ATOMIC)
6133                         : TYPE_MAIN_VARIANT (TREE_TYPE (field)));
6134       if (comptypes (lhs_main_type, fieldtype))
6135         {
6136           if (found_field != NULL_TREE)
6137             return NULL_TREE;
6138           found_field = field;
6139         }
6140       else if (find_anonymous_field_with_type (TREE_TYPE (field),
6141                                                lhs_main_type))
6142         {
6143           if (found_field != NULL_TREE)
6144             return NULL_TREE;
6145           found_field = field;
6146           found_sub_field = true;
6147         }
6148     }
6149
6150   if (found_field == NULL_TREE)
6151     return NULL_TREE;
6152
6153   ret = fold_build3_loc (location, COMPONENT_REF, TREE_TYPE (found_field),
6154                          build_fold_indirect_ref (rhs), found_field,
6155                          NULL_TREE);
6156   ret = build_fold_addr_expr_loc (location, ret);
6157
6158   if (found_sub_field)
6159     {
6160       ret = convert_to_anonymous_field (location, type, ret);
6161       gcc_assert (ret != NULL_TREE);
6162     }
6163
6164   return ret;
6165 }
6166
6167 /* Issue an error message for a bad initializer component.
6168    GMSGID identifies the message.
6169    The component name is taken from the spelling stack.  */
6170
6171 static void
6172 error_init (location_t loc, const char *gmsgid)
6173 {
6174   char *ofwhat;
6175
6176   /* The gmsgid may be a format string with %< and %>. */
6177   error_at (loc, gmsgid);
6178   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
6179   if (*ofwhat)
6180     inform (loc, "(near initialization for %qs)", ofwhat);
6181 }
6182
6183 /* Issue a pedantic warning for a bad initializer component.  OPT is
6184    the option OPT_* (from options.h) controlling this warning or 0 if
6185    it is unconditionally given.  GMSGID identifies the message.  The
6186    component name is taken from the spelling stack.  */
6187
6188 static void ATTRIBUTE_GCC_DIAG (3,0)
6189 pedwarn_init (location_t loc, int opt, const char *gmsgid, ...)
6190 {
6191   /* Use the location where a macro was expanded rather than where
6192      it was defined to make sure macros defined in system headers
6193      but used incorrectly elsewhere are diagnosed.  */
6194   source_location exploc = expansion_point_location_if_in_system_header (loc);
6195
6196   va_list ap;
6197   va_start (ap, gmsgid);
6198   bool warned = emit_diagnostic_valist (DK_PEDWARN, exploc, opt, gmsgid, &ap);
6199   va_end (ap);
6200   char *ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
6201   if (*ofwhat && warned)
6202     inform (exploc, "(near initialization for %qs)", ofwhat);
6203 }
6204
6205 /* Issue a warning for a bad initializer component.
6206
6207    OPT is the OPT_W* value corresponding to the warning option that
6208    controls this warning.  GMSGID identifies the message.  The
6209    component name is taken from the spelling stack.  */
6210
6211 static void
6212 warning_init (location_t loc, int opt, const char *gmsgid)
6213 {
6214   char *ofwhat;
6215   bool warned;
6216
6217   /* Use the location where a macro was expanded rather than where
6218      it was defined to make sure macros defined in system headers
6219      but used incorrectly elsewhere are diagnosed.  */
6220   source_location exploc = expansion_point_location_if_in_system_header (loc);
6221
6222   /* The gmsgid may be a format string with %< and %>. */
6223   warned = warning_at (exploc, opt, gmsgid);
6224   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
6225   if (*ofwhat && warned)
6226     inform (exploc, "(near initialization for %qs)", ofwhat);
6227 }
6228 \f
6229 /* If TYPE is an array type and EXPR is a parenthesized string
6230    constant, warn if pedantic that EXPR is being used to initialize an
6231    object of type TYPE.  */
6232
6233 void
6234 maybe_warn_string_init (location_t loc, tree type, struct c_expr expr)
6235 {
6236   if (pedantic
6237       && TREE_CODE (type) == ARRAY_TYPE
6238       && TREE_CODE (expr.value) == STRING_CST
6239       && expr.original_code != STRING_CST)
6240     pedwarn_init (loc, OPT_Wpedantic,
6241                   "array initialized from parenthesized string constant");
6242 }
6243
6244 /* Attempt to locate the parameter with the given index within FNDECL,
6245    returning DECL_SOURCE_LOCATION (FNDECL) if it can't be found.  */
6246
6247 static location_t
6248 get_fndecl_argument_location (tree fndecl, int argnum)
6249 {
6250   int i;
6251   tree param;
6252
6253   /* Locate param by index within DECL_ARGUMENTS (fndecl).  */
6254   for (i = 0, param = DECL_ARGUMENTS (fndecl);
6255        i < argnum && param;
6256        i++, param = TREE_CHAIN (param))
6257     ;
6258
6259   /* If something went wrong (e.g. if we have a builtin and thus no arguments),
6260      return DECL_SOURCE_LOCATION (FNDECL).  */
6261   if (param == NULL)
6262     return DECL_SOURCE_LOCATION (fndecl);
6263
6264   return DECL_SOURCE_LOCATION (param);
6265 }
6266
6267 /* Issue a note about a mismatching argument for parameter PARMNUM
6268    to FUNDECL, for types EXPECTED_TYPE and ACTUAL_TYPE.
6269    Attempt to issue the note at the pertinent parameter of the decl;
6270    failing that issue it at the location of FUNDECL; failing that
6271    issue it at PLOC.  */
6272
6273 static void
6274 inform_for_arg (tree fundecl, location_t ploc, int parmnum,
6275                 tree expected_type, tree actual_type)
6276 {
6277   location_t loc;
6278   if (fundecl && !DECL_IS_BUILTIN (fundecl))
6279     loc = get_fndecl_argument_location (fundecl, parmnum - 1);
6280   else
6281     loc = ploc;
6282
6283   inform (loc,
6284           "expected %qT but argument is of type %qT",
6285           expected_type, actual_type);
6286 }
6287
6288 /* Convert value RHS to type TYPE as preparation for an assignment to
6289    an lvalue of type TYPE.  If ORIGTYPE is not NULL_TREE, it is the
6290    original type of RHS; this differs from TREE_TYPE (RHS) for enum
6291    types.  NULL_POINTER_CONSTANT says whether RHS was a null pointer
6292    constant before any folding.
6293    The real work of conversion is done by `convert'.
6294    The purpose of this function is to generate error messages
6295    for assignments that are not allowed in C.
6296    ERRTYPE says whether it is argument passing, assignment,
6297    initialization or return.
6298
6299    In the following example, '~' denotes where EXPR_LOC and '^' where
6300    LOCATION point to:
6301
6302      f (var);      [ic_argpass]
6303      ^  ~~~
6304      x = var;      [ic_assign]
6305        ^ ~~~;
6306      int x = var;  [ic_init]
6307              ^^^
6308      return x;     [ic_return]
6309             ^
6310
6311    FUNCTION is a tree for the function being called.
6312    PARMNUM is the number of the argument, for printing in error messages.  */
6313
6314 static tree
6315 convert_for_assignment (location_t location, location_t expr_loc, tree type,
6316                         tree rhs, tree origtype, enum impl_conv errtype,
6317                         bool null_pointer_constant, tree fundecl,
6318                         tree function, int parmnum)
6319 {
6320   enum tree_code codel = TREE_CODE (type);
6321   tree orig_rhs = rhs;
6322   tree rhstype;
6323   enum tree_code coder;
6324   tree rname = NULL_TREE;
6325   bool objc_ok = false;
6326
6327   /* Use the expansion point location to handle cases such as user's
6328      function returning a wrong-type macro defined in a system header.  */
6329   location = expansion_point_location_if_in_system_header (location);
6330
6331   if (errtype == ic_argpass)
6332     {
6333       tree selector;
6334       /* Change pointer to function to the function itself for
6335          diagnostics.  */
6336       if (TREE_CODE (function) == ADDR_EXPR
6337           && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
6338         function = TREE_OPERAND (function, 0);
6339
6340       /* Handle an ObjC selector specially for diagnostics.  */
6341       selector = objc_message_selector ();
6342       rname = function;
6343       if (selector && parmnum > 2)
6344         {
6345           rname = selector;
6346           parmnum -= 2;
6347         }
6348     }
6349
6350   /* This macro is used to emit diagnostics to ensure that all format
6351      strings are complete sentences, visible to gettext and checked at
6352      compile time.  */
6353 #define PEDWARN_FOR_ASSIGNMENT(LOCATION, PLOC, OPT, AR, AS, IN, RE)      \
6354   do {                                                                   \
6355     switch (errtype)                                                     \
6356       {                                                                  \
6357       case ic_argpass:                                                   \
6358         if (pedwarn (PLOC, OPT, AR, parmnum, rname))                     \
6359           inform_for_arg (fundecl, (PLOC), parmnum, type, rhstype);     \
6360         break;                                                           \
6361       case ic_assign:                                                    \
6362         pedwarn (LOCATION, OPT, AS);                                     \
6363         break;                                                           \
6364       case ic_init:                                                      \
6365         pedwarn_init (LOCATION, OPT, IN);                                \
6366         break;                                                           \
6367       case ic_return:                                                    \
6368         pedwarn (LOCATION, OPT, RE);                                     \
6369         break;                                                           \
6370       default:                                                           \
6371         gcc_unreachable ();                                              \
6372       }                                                                  \
6373   } while (0)
6374
6375   /* This macro is used to emit diagnostics to ensure that all format
6376      strings are complete sentences, visible to gettext and checked at
6377      compile time.  It is the same as PEDWARN_FOR_ASSIGNMENT but with an
6378      extra parameter to enumerate qualifiers.  */
6379 #define PEDWARN_FOR_QUALIFIERS(LOCATION, PLOC, OPT, AR, AS, IN, RE, QUALS) \
6380   do {                                                                   \
6381     switch (errtype)                                                     \
6382       {                                                                  \
6383       case ic_argpass:                                                   \
6384         if (pedwarn (PLOC, OPT, AR, parmnum, rname, QUALS))              \
6385           inform_for_arg (fundecl, (PLOC), parmnum, type, rhstype);     \
6386         break;                                                           \
6387       case ic_assign:                                                    \
6388         pedwarn (LOCATION, OPT, AS, QUALS);                              \
6389         break;                                                           \
6390       case ic_init:                                                      \
6391         pedwarn (LOCATION, OPT, IN, QUALS);                              \
6392         break;                                                           \
6393       case ic_return:                                                    \
6394         pedwarn (LOCATION, OPT, RE, QUALS);                              \
6395         break;                                                           \
6396       default:                                                           \
6397         gcc_unreachable ();                                              \
6398       }                                                                  \
6399   } while (0)
6400
6401   /* This macro is used to emit diagnostics to ensure that all format
6402      strings are complete sentences, visible to gettext and checked at
6403      compile time.  It is the same as PEDWARN_FOR_QUALIFIERS but uses
6404      warning_at instead of pedwarn.  */
6405 #define WARNING_FOR_QUALIFIERS(LOCATION, PLOC, OPT, AR, AS, IN, RE, QUALS) \
6406   do {                                                                   \
6407     switch (errtype)                                                     \
6408       {                                                                  \
6409       case ic_argpass:                                                   \
6410         if (warning_at (PLOC, OPT, AR, parmnum, rname, QUALS))           \
6411           inform_for_arg (fundecl, (PLOC), parmnum, type, rhstype);      \
6412         break;                                                           \
6413       case ic_assign:                                                    \
6414         warning_at (LOCATION, OPT, AS, QUALS);                           \
6415         break;                                                           \
6416       case ic_init:                                                      \
6417         warning_at (LOCATION, OPT, IN, QUALS);                           \
6418         break;                                                           \
6419       case ic_return:                                                    \
6420         warning_at (LOCATION, OPT, RE, QUALS);                           \
6421         break;                                                           \
6422       default:                                                           \
6423         gcc_unreachable ();                                              \
6424       }                                                                  \
6425   } while (0)
6426
6427   if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
6428     rhs = TREE_OPERAND (rhs, 0);
6429
6430   rhstype = TREE_TYPE (rhs);
6431   coder = TREE_CODE (rhstype);
6432
6433   if (coder == ERROR_MARK)
6434     return error_mark_node;
6435
6436   if (c_dialect_objc ())
6437     {
6438       int parmno;
6439
6440       switch (errtype)
6441         {
6442         case ic_return:
6443           parmno = 0;
6444           break;
6445
6446         case ic_assign:
6447           parmno = -1;
6448           break;
6449
6450         case ic_init:
6451           parmno = -2;
6452           break;
6453
6454         default:
6455           parmno = parmnum;
6456           break;
6457         }
6458
6459       objc_ok = objc_compare_types (type, rhstype, parmno, rname);
6460     }
6461
6462   if (warn_cxx_compat)
6463     {
6464       tree checktype = origtype != NULL_TREE ? origtype : rhstype;
6465       if (checktype != error_mark_node
6466           && TREE_CODE (type) == ENUMERAL_TYPE
6467           && TYPE_MAIN_VARIANT (checktype) != TYPE_MAIN_VARIANT (type))
6468         switch (errtype)
6469           {
6470           case ic_argpass:
6471             if (pedwarn (expr_loc, OPT_Wc___compat, "enum conversion when "
6472                          "passing argument %d of %qE is invalid in C++",
6473                          parmnum, rname))
6474               inform ((fundecl && !DECL_IS_BUILTIN (fundecl))
6475                       ? DECL_SOURCE_LOCATION (fundecl) : expr_loc,
6476                       "expected %qT but argument is of type %qT",
6477                       type, rhstype);
6478             break;
6479           case ic_assign:
6480             pedwarn (location, OPT_Wc___compat, "enum conversion from %qT to "
6481                      "%qT in assignment is invalid in C++", rhstype, type);
6482             break;
6483           case ic_init:
6484             pedwarn_init (location, OPT_Wc___compat, "enum conversion from "
6485                           "%qT to %qT in initialization is invalid in C++",
6486                           rhstype, type);
6487             break;
6488           case ic_return:
6489             pedwarn (location, OPT_Wc___compat, "enum conversion from %qT to "
6490                      "%qT in return is invalid in C++", rhstype, type);
6491             break;
6492           default:
6493             gcc_unreachable ();
6494           }
6495     }
6496
6497   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
6498     return rhs;
6499
6500   if (coder == VOID_TYPE)
6501     {
6502       /* Except for passing an argument to an unprototyped function,
6503          this is a constraint violation.  When passing an argument to
6504          an unprototyped function, it is compile-time undefined;
6505          making it a constraint in that case was rejected in
6506          DR#252.  */
6507       error_at (location, "void value not ignored as it ought to be");
6508       return error_mark_node;
6509     }
6510   rhs = require_complete_type (location, rhs);
6511   if (rhs == error_mark_node)
6512     return error_mark_node;
6513
6514   if (coder == POINTER_TYPE && reject_gcc_builtin (rhs))
6515     return error_mark_node;
6516
6517   /* A non-reference type can convert to a reference.  This handles
6518      va_start, va_copy and possibly port built-ins.  */
6519   if (codel == REFERENCE_TYPE && coder != REFERENCE_TYPE)
6520     {
6521       if (!lvalue_p (rhs))
6522         {
6523           error_at (location, "cannot pass rvalue to reference parameter");
6524           return error_mark_node;
6525         }
6526       if (!c_mark_addressable (rhs))
6527         return error_mark_node;
6528       rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
6529       SET_EXPR_LOCATION (rhs, location);
6530
6531       rhs = convert_for_assignment (location, expr_loc,
6532                                     build_pointer_type (TREE_TYPE (type)),
6533                                     rhs, origtype, errtype,
6534                                     null_pointer_constant, fundecl, function,
6535                                     parmnum);
6536       if (rhs == error_mark_node)
6537         return error_mark_node;
6538
6539       rhs = build1 (NOP_EXPR, type, rhs);
6540       SET_EXPR_LOCATION (rhs, location);
6541       return rhs;
6542     }
6543   /* Some types can interconvert without explicit casts.  */
6544   else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE
6545            && vector_types_convertible_p (type, TREE_TYPE (rhs), true))
6546     return convert (type, rhs);
6547   /* Arithmetic types all interconvert, and enum is treated like int.  */
6548   else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
6549             || codel == FIXED_POINT_TYPE
6550             || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
6551             || codel == BOOLEAN_TYPE)
6552            && (coder == INTEGER_TYPE || coder == REAL_TYPE
6553                || coder == FIXED_POINT_TYPE
6554                || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
6555                || coder == BOOLEAN_TYPE))
6556     {
6557       tree ret;
6558       bool save = in_late_binary_op;
6559       if (codel == BOOLEAN_TYPE || codel == COMPLEX_TYPE
6560           || (coder == REAL_TYPE
6561               && (codel == INTEGER_TYPE || codel == ENUMERAL_TYPE)
6562               && sanitize_flags_p (SANITIZE_FLOAT_CAST)))
6563         in_late_binary_op = true;
6564       ret = convert_and_check (expr_loc != UNKNOWN_LOCATION
6565                                ? expr_loc : location, type, orig_rhs);
6566       in_late_binary_op = save;
6567       return ret;
6568     }
6569
6570   /* Aggregates in different TUs might need conversion.  */
6571   if ((codel == RECORD_TYPE || codel == UNION_TYPE)
6572       && codel == coder
6573       && comptypes (type, rhstype))
6574     return convert_and_check (expr_loc != UNKNOWN_LOCATION
6575                               ? expr_loc : location, type, rhs);
6576
6577   /* Conversion to a transparent union or record from its member types.
6578      This applies only to function arguments.  */
6579   if (((codel == UNION_TYPE || codel == RECORD_TYPE)
6580       && TYPE_TRANSPARENT_AGGR (type))
6581       && errtype == ic_argpass)
6582     {
6583       tree memb, marginal_memb = NULL_TREE;
6584
6585       for (memb = TYPE_FIELDS (type); memb ; memb = DECL_CHAIN (memb))
6586         {
6587           tree memb_type = TREE_TYPE (memb);
6588
6589           if (comptypes (TYPE_MAIN_VARIANT (memb_type),
6590                          TYPE_MAIN_VARIANT (rhstype)))
6591             break;
6592
6593           if (TREE_CODE (memb_type) != POINTER_TYPE)
6594             continue;
6595
6596           if (coder == POINTER_TYPE)
6597             {
6598               tree ttl = TREE_TYPE (memb_type);
6599               tree ttr = TREE_TYPE (rhstype);
6600
6601               /* Any non-function converts to a [const][volatile] void *
6602                  and vice versa; otherwise, targets must be the same.
6603                  Meanwhile, the lhs target must have all the qualifiers of
6604                  the rhs.  */
6605               if ((VOID_TYPE_P (ttl) && !TYPE_ATOMIC (ttl))
6606                   || (VOID_TYPE_P (ttr) && !TYPE_ATOMIC (ttr))
6607                   || comp_target_types (location, memb_type, rhstype))
6608                 {
6609                   int lquals = TYPE_QUALS (ttl) & ~TYPE_QUAL_ATOMIC;
6610                   int rquals = TYPE_QUALS (ttr) & ~TYPE_QUAL_ATOMIC;
6611                   /* If this type won't generate any warnings, use it.  */
6612                   if (lquals == rquals
6613                       || ((TREE_CODE (ttr) == FUNCTION_TYPE
6614                            && TREE_CODE (ttl) == FUNCTION_TYPE)
6615                           ? ((lquals | rquals) == rquals)
6616                           : ((lquals | rquals) == lquals)))
6617                     break;
6618
6619                   /* Keep looking for a better type, but remember this one.  */
6620                   if (!marginal_memb)
6621                     marginal_memb = memb;
6622                 }
6623             }
6624
6625           /* Can convert integer zero to any pointer type.  */
6626           if (null_pointer_constant)
6627             {
6628               rhs = null_pointer_node;
6629               break;
6630             }
6631         }
6632
6633       if (memb || marginal_memb)
6634         {
6635           if (!memb)
6636             {
6637               /* We have only a marginally acceptable member type;
6638                  it needs a warning.  */
6639               tree ttl = TREE_TYPE (TREE_TYPE (marginal_memb));
6640               tree ttr = TREE_TYPE (rhstype);
6641
6642               /* Const and volatile mean something different for function
6643                  types, so the usual warnings are not appropriate.  */
6644               if (TREE_CODE (ttr) == FUNCTION_TYPE
6645                   && TREE_CODE (ttl) == FUNCTION_TYPE)
6646                 {
6647                   /* Because const and volatile on functions are
6648                      restrictions that say the function will not do
6649                      certain things, it is okay to use a const or volatile
6650                      function where an ordinary one is wanted, but not
6651                      vice-versa.  */
6652                   if (TYPE_QUALS_NO_ADDR_SPACE (ttl)
6653                       & ~TYPE_QUALS_NO_ADDR_SPACE (ttr))
6654                     PEDWARN_FOR_QUALIFIERS (location, expr_loc,
6655                                             OPT_Wdiscarded_qualifiers,
6656                                             G_("passing argument %d of %qE "
6657                                                "makes %q#v qualified function "
6658                                                "pointer from unqualified"),
6659                                             G_("assignment makes %q#v qualified "
6660                                                "function pointer from "
6661                                                "unqualified"),
6662                                             G_("initialization makes %q#v qualified "
6663                                                "function pointer from "
6664                                                "unqualified"),
6665                                             G_("return makes %q#v qualified function "
6666                                                "pointer from unqualified"),
6667                                             TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr));
6668                 }
6669               else if (TYPE_QUALS_NO_ADDR_SPACE (ttr)
6670                        & ~TYPE_QUALS_NO_ADDR_SPACE (ttl))
6671                 PEDWARN_FOR_QUALIFIERS (location, expr_loc,
6672                                         OPT_Wdiscarded_qualifiers,
6673                                         G_("passing argument %d of %qE discards "
6674                                            "%qv qualifier from pointer target type"),
6675                                         G_("assignment discards %qv qualifier "
6676                                            "from pointer target type"),
6677                                         G_("initialization discards %qv qualifier "
6678                                            "from pointer target type"),
6679                                         G_("return discards %qv qualifier from "
6680                                            "pointer target type"),
6681                                         TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl));
6682
6683               memb = marginal_memb;
6684             }
6685
6686           if (!fundecl || !DECL_IN_SYSTEM_HEADER (fundecl))
6687             pedwarn (location, OPT_Wpedantic,
6688                      "ISO C prohibits argument conversion to union type");
6689
6690           rhs = fold_convert_loc (location, TREE_TYPE (memb), rhs);
6691           return build_constructor_single (type, memb, rhs);
6692         }
6693     }
6694
6695   /* Conversions among pointers */
6696   else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
6697            && (coder == codel))
6698     {
6699       tree ttl = TREE_TYPE (type);
6700       tree ttr = TREE_TYPE (rhstype);
6701       tree mvl = ttl;
6702       tree mvr = ttr;
6703       bool is_opaque_pointer;
6704       int target_cmp = 0;   /* Cache comp_target_types () result.  */
6705       addr_space_t asl;
6706       addr_space_t asr;
6707
6708       if (TREE_CODE (mvl) != ARRAY_TYPE)
6709         mvl = (TYPE_ATOMIC (mvl)
6710                ? c_build_qualified_type (TYPE_MAIN_VARIANT (mvl),
6711                                          TYPE_QUAL_ATOMIC)
6712                : TYPE_MAIN_VARIANT (mvl));
6713       if (TREE_CODE (mvr) != ARRAY_TYPE)
6714         mvr = (TYPE_ATOMIC (mvr)
6715                ? c_build_qualified_type (TYPE_MAIN_VARIANT (mvr),
6716                                          TYPE_QUAL_ATOMIC)
6717                : TYPE_MAIN_VARIANT (mvr));
6718       /* Opaque pointers are treated like void pointers.  */
6719       is_opaque_pointer = vector_targets_convertible_p (ttl, ttr);
6720
6721       /* The Plan 9 compiler permits a pointer to a struct to be
6722          automatically converted into a pointer to an anonymous field
6723          within the struct.  */
6724       if (flag_plan9_extensions
6725           && RECORD_OR_UNION_TYPE_P (mvl)
6726           && RECORD_OR_UNION_TYPE_P (mvr)
6727           && mvl != mvr)
6728         {
6729           tree new_rhs = convert_to_anonymous_field (location, type, rhs);
6730           if (new_rhs != NULL_TREE)
6731             {
6732               rhs = new_rhs;
6733               rhstype = TREE_TYPE (rhs);
6734               coder = TREE_CODE (rhstype);
6735               ttr = TREE_TYPE (rhstype);
6736               mvr = TYPE_MAIN_VARIANT (ttr);
6737             }
6738         }
6739
6740       /* C++ does not allow the implicit conversion void* -> T*.  However,
6741          for the purpose of reducing the number of false positives, we
6742          tolerate the special case of
6743
6744                 int *p = NULL;
6745
6746          where NULL is typically defined in C to be '(void *) 0'.  */
6747       if (VOID_TYPE_P (ttr) && rhs != null_pointer_node && !VOID_TYPE_P (ttl))
6748         warning_at (errtype == ic_argpass ? expr_loc : location,
6749                     OPT_Wc___compat,
6750                     "request for implicit conversion "
6751                     "from %qT to %qT not permitted in C++", rhstype, type);
6752
6753       /* See if the pointers point to incompatible address spaces.  */
6754       asl = TYPE_ADDR_SPACE (ttl);
6755       asr = TYPE_ADDR_SPACE (ttr);
6756       if (!null_pointer_constant_p (rhs)
6757           && asr != asl && !targetm.addr_space.subset_p (asr, asl))
6758         {
6759           switch (errtype)
6760             {
6761             case ic_argpass:
6762               error_at (expr_loc, "passing argument %d of %qE from pointer to "
6763                         "non-enclosed address space", parmnum, rname);
6764               break;
6765             case ic_assign:
6766               error_at (location, "assignment from pointer to "
6767                         "non-enclosed address space");
6768               break;
6769             case ic_init:
6770               error_at (location, "initialization from pointer to "
6771                         "non-enclosed address space");
6772               break;
6773             case ic_return:
6774               error_at (location, "return from pointer to "
6775                         "non-enclosed address space");
6776               break;
6777             default:
6778               gcc_unreachable ();
6779             }
6780           return error_mark_node;
6781         }
6782
6783       /* Check if the right-hand side has a format attribute but the
6784          left-hand side doesn't.  */
6785       if (warn_suggest_attribute_format
6786           && check_missing_format_attribute (type, rhstype))
6787         {
6788           switch (errtype)
6789           {
6790           case ic_argpass:
6791             warning_at (expr_loc, OPT_Wsuggest_attribute_format,
6792                         "argument %d of %qE might be "
6793                         "a candidate for a format attribute",
6794                         parmnum, rname);
6795             break;
6796           case ic_assign:
6797             warning_at (location, OPT_Wsuggest_attribute_format,
6798                         "assignment left-hand side might be "
6799                         "a candidate for a format attribute");
6800             break;
6801           case ic_init:
6802             warning_at (location, OPT_Wsuggest_attribute_format,
6803                         "initialization left-hand side might be "
6804                         "a candidate for a format attribute");
6805             break;
6806           case ic_return:
6807             warning_at (location, OPT_Wsuggest_attribute_format,
6808                         "return type might be "
6809                         "a candidate for a format attribute");
6810             break;
6811           default:
6812             gcc_unreachable ();
6813           }
6814         }
6815
6816       /* Any non-function converts to a [const][volatile] void *
6817          and vice versa; otherwise, targets must be the same.
6818          Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
6819       if ((VOID_TYPE_P (ttl) && !TYPE_ATOMIC (ttl))
6820           || (VOID_TYPE_P (ttr) && !TYPE_ATOMIC (ttr))
6821           || (target_cmp = comp_target_types (location, type, rhstype))
6822           || is_opaque_pointer
6823           || ((c_common_unsigned_type (mvl)
6824                == c_common_unsigned_type (mvr))
6825               && (c_common_signed_type (mvl)
6826                   == c_common_signed_type (mvr))
6827               && TYPE_ATOMIC (mvl) == TYPE_ATOMIC (mvr)))
6828         {
6829           /* Warn about loss of qualifers from pointers to arrays with
6830              qualifiers on the element type. */
6831           if (TREE_CODE (ttr) == ARRAY_TYPE)
6832             {
6833               ttr = strip_array_types (ttr);
6834               ttl = strip_array_types (ttl);
6835
6836               if (TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (ttr)
6837                   & ~TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (ttl))
6838                 WARNING_FOR_QUALIFIERS (location, expr_loc,
6839                                         OPT_Wdiscarded_array_qualifiers,
6840                                         G_("passing argument %d of %qE discards "
6841                                            "%qv qualifier from pointer target type"),
6842                                         G_("assignment discards %qv qualifier "
6843                                            "from pointer target type"),
6844                                         G_("initialization discards %qv qualifier "
6845                                            "from pointer target type"),
6846                                         G_("return discards %qv qualifier from "
6847                                            "pointer target type"),
6848                                         TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl));
6849             }
6850           else if (pedantic
6851               && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
6852                   ||
6853                   (VOID_TYPE_P (ttr)
6854                    && !null_pointer_constant
6855                    && TREE_CODE (ttl) == FUNCTION_TYPE)))
6856             PEDWARN_FOR_ASSIGNMENT (location, expr_loc, OPT_Wpedantic,
6857                                     G_("ISO C forbids passing argument %d of "
6858                                        "%qE between function pointer "
6859                                        "and %<void *%>"),
6860                                     G_("ISO C forbids assignment between "
6861                                        "function pointer and %<void *%>"),
6862                                     G_("ISO C forbids initialization between "
6863                                        "function pointer and %<void *%>"),
6864                                     G_("ISO C forbids return between function "
6865                                        "pointer and %<void *%>"));
6866           /* Const and volatile mean something different for function types,
6867              so the usual warnings are not appropriate.  */
6868           else if (TREE_CODE (ttr) != FUNCTION_TYPE
6869                    && TREE_CODE (ttl) != FUNCTION_TYPE)
6870             {
6871               /* Don't warn about loss of qualifier for conversions from
6872                  qualified void* to pointers to arrays with corresponding
6873                  qualifier on the element type. */
6874               if (!pedantic)
6875                 ttl = strip_array_types (ttl);
6876
6877               /* Assignments between atomic and non-atomic objects are OK.  */
6878               if (TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (ttr)
6879                   & ~TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (ttl))
6880                 {
6881                   PEDWARN_FOR_QUALIFIERS (location, expr_loc,
6882                                           OPT_Wdiscarded_qualifiers,
6883                                           G_("passing argument %d of %qE discards "
6884                                              "%qv qualifier from pointer target type"),
6885                                           G_("assignment discards %qv qualifier "
6886                                              "from pointer target type"),
6887                                           G_("initialization discards %qv qualifier "
6888                                              "from pointer target type"),
6889                                           G_("return discards %qv qualifier from "
6890                                              "pointer target type"),
6891                                           TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl));
6892                 }
6893               /* If this is not a case of ignoring a mismatch in signedness,
6894                  no warning.  */
6895               else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
6896                        || target_cmp)
6897                 ;
6898               /* If there is a mismatch, do warn.  */
6899               else if (warn_pointer_sign)
6900                 switch (errtype)
6901                   {
6902                   case ic_argpass:
6903                     if (pedwarn (expr_loc, OPT_Wpointer_sign,
6904                                  "pointer targets in passing argument %d of "
6905                                  "%qE differ in signedness", parmnum, rname))
6906                       inform ((fundecl && !DECL_IS_BUILTIN (fundecl))
6907                               ? DECL_SOURCE_LOCATION (fundecl) : expr_loc,
6908                               "expected %qT but argument is of type %qT",
6909                               type, rhstype);
6910                     break;
6911                   case ic_assign:
6912                     pedwarn (location, OPT_Wpointer_sign,
6913                              "pointer targets in assignment from %qT to %qT "
6914                              "differ in signedness", rhstype, type);
6915                     break;
6916                   case ic_init:
6917                     pedwarn_init (location, OPT_Wpointer_sign,
6918                                   "pointer targets in initialization of %qT "
6919                                   "from %qT differ in signedness", type,
6920                                   rhstype);
6921                     break;
6922                   case ic_return:
6923                     pedwarn (location, OPT_Wpointer_sign, "pointer targets in "
6924                              "returning %qT from a function with return type "
6925                              "%qT differ in signedness", rhstype, type);
6926                     break;
6927                   default:
6928                     gcc_unreachable ();
6929                   }
6930             }
6931           else if (TREE_CODE (ttl) == FUNCTION_TYPE
6932                    && TREE_CODE (ttr) == FUNCTION_TYPE)
6933             {
6934               /* Because const and volatile on functions are restrictions
6935                  that say the function will not do certain things,
6936                  it is okay to use a const or volatile function
6937                  where an ordinary one is wanted, but not vice-versa.  */
6938               if (TYPE_QUALS_NO_ADDR_SPACE (ttl)
6939                   & ~TYPE_QUALS_NO_ADDR_SPACE (ttr))
6940                 PEDWARN_FOR_QUALIFIERS (location, expr_loc,
6941                                         OPT_Wdiscarded_qualifiers,
6942                                         G_("passing argument %d of %qE makes "
6943                                            "%q#v qualified function pointer "
6944                                            "from unqualified"),
6945                                         G_("assignment makes %q#v qualified function "
6946                                            "pointer from unqualified"),
6947                                         G_("initialization makes %q#v qualified "
6948                                            "function pointer from unqualified"),
6949                                         G_("return makes %q#v qualified function "
6950                                            "pointer from unqualified"),
6951                                         TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr));
6952             }
6953         }
6954       /* Avoid warning about the volatile ObjC EH puts on decls.  */
6955       else if (!objc_ok)
6956         {
6957           switch (errtype)
6958             {
6959             case ic_argpass:
6960               if (pedwarn (expr_loc, OPT_Wincompatible_pointer_types,
6961                            "passing argument %d of %qE from incompatible "
6962                            "pointer type", parmnum, rname))
6963                 inform_for_arg (fundecl, expr_loc, parmnum, type, rhstype);
6964               break;
6965             case ic_assign:
6966               pedwarn (location, OPT_Wincompatible_pointer_types,
6967                        "assignment to %qT from incompatible pointer type %qT",
6968                        type, rhstype);
6969               break;
6970             case ic_init:
6971               pedwarn_init (location, OPT_Wincompatible_pointer_types,
6972                             "initialization of %qT from incompatible pointer "
6973                             "type %qT", type, rhstype);
6974               break;
6975             case ic_return:
6976               pedwarn (location, OPT_Wincompatible_pointer_types,
6977                        "returning %qT from a function with incompatible "
6978                        "return type %qT", rhstype, type);
6979               break;
6980             default:
6981               gcc_unreachable ();
6982             }
6983         }
6984
6985       return convert (type, rhs);
6986     }
6987   else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
6988     {
6989       /* ??? This should not be an error when inlining calls to
6990          unprototyped functions.  */
6991       error_at (location, "invalid use of non-lvalue array");
6992       return error_mark_node;
6993     }
6994   else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
6995     {
6996       /* An explicit constant 0 can convert to a pointer,
6997          or one that results from arithmetic, even including
6998          a cast to integer type.  */
6999       if (!null_pointer_constant)
7000         switch (errtype)
7001           {
7002           case ic_argpass:
7003             if (pedwarn (expr_loc, OPT_Wint_conversion,
7004                          "passing argument %d of %qE makes pointer from "
7005                          "integer without a cast", parmnum, rname))
7006               inform_for_arg (fundecl, expr_loc, parmnum, type, rhstype);
7007             break;
7008           case ic_assign:
7009             pedwarn (location, OPT_Wint_conversion,
7010                      "assignment to %qT from %qT makes pointer from integer "
7011                      "without a cast", type, rhstype);
7012             break;
7013           case ic_init:
7014             pedwarn_init (location, OPT_Wint_conversion,
7015                           "initialization of %qT from %qT makes pointer from "
7016                           "integer without a cast", type, rhstype);
7017             break;
7018           case ic_return:
7019             pedwarn (location, OPT_Wint_conversion, "returning %qT from a "
7020                      "function with return type %qT makes pointer from "
7021                      "integer without a cast", rhstype, type);
7022             break;
7023           default:
7024             gcc_unreachable ();
7025           }
7026
7027       return convert (type, rhs);
7028     }
7029   else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
7030     {
7031       switch (errtype)
7032         {
7033         case ic_argpass:
7034           if (pedwarn (expr_loc, OPT_Wint_conversion,
7035                        "passing argument %d of %qE makes integer from "
7036                        "pointer without a cast", parmnum, rname))
7037             inform_for_arg (fundecl, expr_loc, parmnum, type, rhstype);
7038           break;
7039         case ic_assign:
7040           pedwarn (location, OPT_Wint_conversion,
7041                    "assignment to %qT from %qT makes integer from pointer "
7042                    "without a cast", type, rhstype);
7043           break;
7044         case ic_init:
7045           pedwarn_init (location, OPT_Wint_conversion,
7046                         "initialization of %qT from %qT makes integer from "
7047                         "pointer without a cast", type, rhstype);
7048           break;
7049         case ic_return:
7050           pedwarn (location, OPT_Wint_conversion, "returning %qT from a "
7051                    "function with return type %qT makes integer from "
7052                    "pointer without a cast", rhstype, type);
7053           break;
7054         default:
7055           gcc_unreachable ();
7056         }
7057
7058       return convert (type, rhs);
7059     }
7060   else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
7061     {
7062       tree ret;
7063       bool save = in_late_binary_op;
7064       in_late_binary_op = true;
7065       ret = convert (type, rhs);
7066       in_late_binary_op = save;
7067       return ret;
7068     }
7069
7070   switch (errtype)
7071     {
7072     case ic_argpass:
7073       error_at (expr_loc, "incompatible type for argument %d of %qE", parmnum,
7074                 rname);
7075       inform_for_arg (fundecl, expr_loc, parmnum, type, rhstype);
7076       break;
7077     case ic_assign:
7078       error_at (location, "incompatible types when assigning to type %qT from "
7079                 "type %qT", type, rhstype);
7080       break;
7081     case ic_init:
7082       error_at (location,
7083                 "incompatible types when initializing type %qT using type %qT",
7084                 type, rhstype);
7085       break;
7086     case ic_return:
7087       error_at (location,
7088                 "incompatible types when returning type %qT but %qT was "
7089                 "expected", rhstype, type);
7090       break;
7091     default:
7092       gcc_unreachable ();
7093     }
7094
7095   return error_mark_node;
7096 }
7097 \f
7098 /* If VALUE is a compound expr all of whose expressions are constant, then
7099    return its value.  Otherwise, return error_mark_node.
7100
7101    This is for handling COMPOUND_EXPRs as initializer elements
7102    which is allowed with a warning when -pedantic is specified.  */
7103
7104 static tree
7105 valid_compound_expr_initializer (tree value, tree endtype)
7106 {
7107   if (TREE_CODE (value) == COMPOUND_EXPR)
7108     {
7109       if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
7110           == error_mark_node)
7111         return error_mark_node;
7112       return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
7113                                               endtype);
7114     }
7115   else if (!initializer_constant_valid_p (value, endtype))
7116     return error_mark_node;
7117   else
7118     return value;
7119 }
7120 \f
7121 /* Perform appropriate conversions on the initial value of a variable,
7122    store it in the declaration DECL,
7123    and print any error messages that are appropriate.
7124    If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
7125    If the init is invalid, store an ERROR_MARK.
7126
7127    INIT_LOC is the location of the initial value.  */
7128
7129 void
7130 store_init_value (location_t init_loc, tree decl, tree init, tree origtype)
7131 {
7132   tree value, type;
7133   bool npc = false;
7134
7135   /* If variable's type was invalidly declared, just ignore it.  */
7136
7137   type = TREE_TYPE (decl);
7138   if (TREE_CODE (type) == ERROR_MARK)
7139     return;
7140
7141   /* Digest the specified initializer into an expression.  */
7142
7143   if (init)
7144     npc = null_pointer_constant_p (init);
7145   value = digest_init (init_loc, type, init, origtype, npc,
7146                        true, TREE_STATIC (decl));
7147
7148   /* Store the expression if valid; else report error.  */
7149
7150   if (!in_system_header_at (input_location)
7151       && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl))
7152     warning (OPT_Wtraditional, "traditional C rejects automatic "
7153              "aggregate initialization");
7154
7155   if (value != error_mark_node || TREE_CODE (decl) != FUNCTION_DECL)
7156     DECL_INITIAL (decl) = value;
7157
7158   /* ANSI wants warnings about out-of-range constant initializers.  */
7159   STRIP_TYPE_NOPS (value);
7160   if (TREE_STATIC (decl))
7161     constant_expression_warning (value);
7162
7163   /* Check if we need to set array size from compound literal size.  */
7164   if (TREE_CODE (type) == ARRAY_TYPE
7165       && TYPE_DOMAIN (type) == NULL_TREE
7166       && value != error_mark_node)
7167     {
7168       tree inside_init = init;
7169
7170       STRIP_TYPE_NOPS (inside_init);
7171       inside_init = fold (inside_init);
7172
7173       if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
7174         {
7175           tree cldecl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
7176
7177           if (TYPE_DOMAIN (TREE_TYPE (cldecl)))
7178             {
7179               /* For int foo[] = (int [3]){1}; we need to set array size
7180                  now since later on array initializer will be just the
7181                  brace enclosed list of the compound literal.  */
7182               tree etype = strip_array_types (TREE_TYPE (decl));
7183               type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
7184               TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (cldecl));
7185               layout_type (type);
7186               layout_decl (cldecl, 0);
7187               TREE_TYPE (decl)
7188                 = c_build_qualified_type (type, TYPE_QUALS (etype));
7189             }
7190         }
7191     }
7192 }
7193 \f
7194 /* Methods for storing and printing names for error messages.  */
7195
7196 /* Implement a spelling stack that allows components of a name to be pushed
7197    and popped.  Each element on the stack is this structure.  */
7198
7199 struct spelling
7200 {
7201   int kind;
7202   union
7203     {
7204       unsigned HOST_WIDE_INT i;
7205       const char *s;
7206     } u;
7207 };
7208
7209 #define SPELLING_STRING 1
7210 #define SPELLING_MEMBER 2
7211 #define SPELLING_BOUNDS 3
7212
7213 static struct spelling *spelling;       /* Next stack element (unused).  */
7214 static struct spelling *spelling_base;  /* Spelling stack base.  */
7215 static int spelling_size;               /* Size of the spelling stack.  */
7216
7217 /* Macros to save and restore the spelling stack around push_... functions.
7218    Alternative to SAVE_SPELLING_STACK.  */
7219
7220 #define SPELLING_DEPTH() (spelling - spelling_base)
7221 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
7222
7223 /* Push an element on the spelling stack with type KIND and assign VALUE
7224    to MEMBER.  */
7225
7226 #define PUSH_SPELLING(KIND, VALUE, MEMBER)                              \
7227 {                                                                       \
7228   int depth = SPELLING_DEPTH ();                                        \
7229                                                                         \
7230   if (depth >= spelling_size)                                           \
7231     {                                                                   \
7232       spelling_size += 10;                                              \
7233       spelling_base = XRESIZEVEC (struct spelling, spelling_base,       \
7234                                   spelling_size);                       \
7235       RESTORE_SPELLING_DEPTH (depth);                                   \
7236     }                                                                   \
7237                                                                         \
7238   spelling->kind = (KIND);                                              \
7239   spelling->MEMBER = (VALUE);                                           \
7240   spelling++;                                                           \
7241 }
7242
7243 /* Push STRING on the stack.  Printed literally.  */
7244
7245 static void
7246 push_string (const char *string)
7247 {
7248   PUSH_SPELLING (SPELLING_STRING, string, u.s);
7249 }
7250
7251 /* Push a member name on the stack.  Printed as '.' STRING.  */
7252
7253 static void
7254 push_member_name (tree decl)
7255 {
7256   const char *const string
7257     = (DECL_NAME (decl)
7258        ? identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl)))
7259        : _("<anonymous>"));
7260   PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
7261 }
7262
7263 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
7264
7265 static void
7266 push_array_bounds (unsigned HOST_WIDE_INT bounds)
7267 {
7268   PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
7269 }
7270
7271 /* Compute the maximum size in bytes of the printed spelling.  */
7272
7273 static int
7274 spelling_length (void)
7275 {
7276   int size = 0;
7277   struct spelling *p;
7278
7279   for (p = spelling_base; p < spelling; p++)
7280     {
7281       if (p->kind == SPELLING_BOUNDS)
7282         size += 25;
7283       else
7284         size += strlen (p->u.s) + 1;
7285     }
7286
7287   return size;
7288 }
7289
7290 /* Print the spelling to BUFFER and return it.  */
7291
7292 static char *
7293 print_spelling (char *buffer)
7294 {
7295   char *d = buffer;
7296   struct spelling *p;
7297
7298   for (p = spelling_base; p < spelling; p++)
7299     if (p->kind == SPELLING_BOUNDS)
7300       {
7301         sprintf (d, "[" HOST_WIDE_INT_PRINT_UNSIGNED "]", p->u.i);
7302         d += strlen (d);
7303       }
7304     else
7305       {
7306         const char *s;
7307         if (p->kind == SPELLING_MEMBER)
7308           *d++ = '.';
7309         for (s = p->u.s; (*d = *s++); d++)
7310           ;
7311       }
7312   *d++ = '\0';
7313   return buffer;
7314 }
7315
7316 /* Digest the parser output INIT as an initializer for type TYPE.
7317    Return a C expression of type TYPE to represent the initial value.
7318
7319    If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
7320
7321    NULL_POINTER_CONSTANT is true if INIT is a null pointer constant.
7322
7323    If INIT is a string constant, STRICT_STRING is true if it is
7324    unparenthesized or we should not warn here for it being parenthesized.
7325    For other types of INIT, STRICT_STRING is not used.
7326
7327    INIT_LOC is the location of the INIT.
7328
7329    REQUIRE_CONSTANT requests an error if non-constant initializers or
7330    elements are seen.  */
7331
7332 static tree
7333 digest_init (location_t init_loc, tree type, tree init, tree origtype,
7334              bool null_pointer_constant, bool strict_string,
7335              int require_constant)
7336 {
7337   enum tree_code code = TREE_CODE (type);
7338   tree inside_init = init;
7339   tree semantic_type = NULL_TREE;
7340   bool maybe_const = true;
7341
7342   if (type == error_mark_node
7343       || !init
7344       || error_operand_p (init))
7345     return error_mark_node;
7346
7347   STRIP_TYPE_NOPS (inside_init);
7348
7349   if (TREE_CODE (inside_init) == EXCESS_PRECISION_EXPR)
7350     {
7351       semantic_type = TREE_TYPE (inside_init);
7352       inside_init = TREE_OPERAND (inside_init, 0);
7353     }
7354   inside_init = c_fully_fold (inside_init, require_constant, &maybe_const);
7355
7356   /* Initialization of an array of chars from a string constant
7357      optionally enclosed in braces.  */
7358
7359   if (code == ARRAY_TYPE && inside_init
7360       && TREE_CODE (inside_init) == STRING_CST)
7361     {
7362       tree typ1
7363         = (TYPE_ATOMIC (TREE_TYPE (type))
7364            ? c_build_qualified_type (TYPE_MAIN_VARIANT (TREE_TYPE (type)),
7365                                      TYPE_QUAL_ATOMIC)
7366            : TYPE_MAIN_VARIANT (TREE_TYPE (type)));
7367       /* Note that an array could be both an array of character type
7368          and an array of wchar_t if wchar_t is signed char or unsigned
7369          char.  */
7370       bool char_array = (typ1 == char_type_node
7371                          || typ1 == signed_char_type_node
7372                          || typ1 == unsigned_char_type_node);
7373       bool wchar_array = !!comptypes (typ1, wchar_type_node);
7374       bool char16_array = !!comptypes (typ1, char16_type_node);
7375       bool char32_array = !!comptypes (typ1, char32_type_node);
7376
7377       if (char_array || wchar_array || char16_array || char32_array)
7378         {
7379           struct c_expr expr;
7380           tree typ2 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)));
7381           expr.value = inside_init;
7382           expr.original_code = (strict_string ? STRING_CST : ERROR_MARK);
7383           expr.original_type = NULL;
7384           maybe_warn_string_init (init_loc, type, expr);
7385
7386           if (TYPE_DOMAIN (type) && !TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
7387             pedwarn_init (init_loc, OPT_Wpedantic,
7388                           "initialization of a flexible array member");
7389
7390           if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
7391                          TYPE_MAIN_VARIANT (type)))
7392             return inside_init;
7393
7394           if (char_array)
7395             {
7396               if (typ2 != char_type_node)
7397                 {
7398                   error_init (init_loc, "char-array initialized from wide "
7399                               "string");
7400                   return error_mark_node;
7401                 }
7402             }
7403           else
7404             {
7405               if (typ2 == char_type_node)
7406                 {
7407                   error_init (init_loc, "wide character array initialized "
7408                               "from non-wide string");
7409                   return error_mark_node;
7410                 }
7411               else if (!comptypes(typ1, typ2))
7412                 {
7413                   error_init (init_loc, "wide character array initialized "
7414                               "from incompatible wide string");
7415                   return error_mark_node;
7416                 }
7417             }
7418
7419           TREE_TYPE (inside_init) = type;
7420           if (TYPE_DOMAIN (type) != NULL_TREE
7421               && TYPE_SIZE (type) != NULL_TREE
7422               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
7423             {
7424               unsigned HOST_WIDE_INT len = TREE_STRING_LENGTH (inside_init);
7425
7426               /* Subtract the size of a single (possibly wide) character
7427                  because it's ok to ignore the terminating null char
7428                  that is counted in the length of the constant.  */
7429               if (compare_tree_int (TYPE_SIZE_UNIT (type),
7430                                     (len - (TYPE_PRECISION (typ1)
7431                                             / BITS_PER_UNIT))) < 0)
7432                 pedwarn_init (init_loc, 0,
7433                               ("initializer-string for array of chars "
7434                                "is too long"));
7435               else if (warn_cxx_compat
7436                        && compare_tree_int (TYPE_SIZE_UNIT (type), len) < 0)
7437                 warning_at (init_loc, OPT_Wc___compat,
7438                             ("initializer-string for array chars "
7439                              "is too long for C++"));
7440             }
7441
7442           return inside_init;
7443         }
7444       else if (INTEGRAL_TYPE_P (typ1))
7445         {
7446           error_init (init_loc, "array of inappropriate type initialized "
7447                       "from string constant");
7448           return error_mark_node;
7449         }
7450     }
7451
7452   /* Build a VECTOR_CST from a *constant* vector constructor.  If the
7453      vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
7454      below and handle as a constructor.  */
7455   if (code == VECTOR_TYPE
7456       && VECTOR_TYPE_P (TREE_TYPE (inside_init))
7457       && vector_types_convertible_p (TREE_TYPE (inside_init), type, true)
7458       && TREE_CONSTANT (inside_init))
7459     {
7460       if (TREE_CODE (inside_init) == VECTOR_CST
7461           && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
7462                         TYPE_MAIN_VARIANT (type)))
7463         return inside_init;
7464
7465       if (TREE_CODE (inside_init) == CONSTRUCTOR)
7466         {
7467           unsigned HOST_WIDE_INT ix;
7468           tree value;
7469           bool constant_p = true;
7470
7471           /* Iterate through elements and check if all constructor
7472              elements are *_CSTs.  */
7473           FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (inside_init), ix, value)
7474             if (!CONSTANT_CLASS_P (value))
7475               {
7476                 constant_p = false;
7477                 break;
7478               }
7479
7480           if (constant_p)
7481             return build_vector_from_ctor (type,
7482                                            CONSTRUCTOR_ELTS (inside_init));
7483         }
7484     }
7485
7486   if (warn_sequence_point)
7487     verify_sequence_points (inside_init);
7488
7489   /* Any type can be initialized
7490      from an expression of the same type, optionally with braces.  */
7491
7492   if (inside_init && TREE_TYPE (inside_init) != NULL_TREE
7493       && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
7494                      TYPE_MAIN_VARIANT (type))
7495           || (code == ARRAY_TYPE
7496               && comptypes (TREE_TYPE (inside_init), type))
7497           || (code == VECTOR_TYPE
7498               && comptypes (TREE_TYPE (inside_init), type))
7499           || (code == POINTER_TYPE
7500               && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
7501               && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
7502                             TREE_TYPE (type)))))
7503     {
7504       if (code == POINTER_TYPE)
7505         {
7506           if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE)
7507             {
7508               if (TREE_CODE (inside_init) == STRING_CST
7509                   || TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
7510                 inside_init = array_to_pointer_conversion
7511                   (init_loc, inside_init);
7512               else
7513                 {
7514                   error_init (init_loc, "invalid use of non-lvalue array");
7515                   return error_mark_node;
7516                 }
7517             }
7518         }
7519
7520       if (code == VECTOR_TYPE)
7521         /* Although the types are compatible, we may require a
7522            conversion.  */
7523         inside_init = convert (type, inside_init);
7524
7525       if (require_constant
7526           && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
7527         {
7528           /* As an extension, allow initializing objects with static storage
7529              duration with compound literals (which are then treated just as
7530              the brace enclosed list they contain).  Also allow this for
7531              vectors, as we can only assign them with compound literals.  */
7532           if (flag_isoc99 && code != VECTOR_TYPE)
7533             pedwarn_init (init_loc, OPT_Wpedantic, "initializer element "
7534                           "is not constant");
7535           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
7536           inside_init = DECL_INITIAL (decl);
7537         }
7538
7539       if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
7540           && TREE_CODE (inside_init) != CONSTRUCTOR)
7541         {
7542           error_init (init_loc, "array initialized from non-constant array "
7543                       "expression");
7544           return error_mark_node;
7545         }
7546
7547       /* Compound expressions can only occur here if -Wpedantic or
7548          -pedantic-errors is specified.  In the later case, we always want
7549          an error.  In the former case, we simply want a warning.  */
7550       if (require_constant && pedantic
7551           && TREE_CODE (inside_init) == COMPOUND_EXPR)
7552         {
7553           inside_init
7554             = valid_compound_expr_initializer (inside_init,
7555                                                TREE_TYPE (inside_init));
7556           if (inside_init == error_mark_node)
7557             error_init (init_loc, "initializer element is not constant");
7558           else
7559             pedwarn_init (init_loc, OPT_Wpedantic,
7560                           "initializer element is not constant");
7561           if (flag_pedantic_errors)
7562             inside_init = error_mark_node;
7563         }
7564       else if (require_constant
7565                && !initializer_constant_valid_p (inside_init,
7566                                                  TREE_TYPE (inside_init)))
7567         {
7568           error_init (init_loc, "initializer element is not constant");
7569           inside_init = error_mark_node;
7570         }
7571       else if (require_constant && !maybe_const)
7572         pedwarn_init (init_loc, OPT_Wpedantic,
7573                       "initializer element is not a constant expression");
7574
7575       /* Added to enable additional -Wsuggest-attribute=format warnings.  */
7576       if (TREE_CODE (TREE_TYPE (inside_init)) == POINTER_TYPE)
7577         inside_init = convert_for_assignment (init_loc, UNKNOWN_LOCATION,
7578                                               type, inside_init, origtype,
7579                                               ic_init, null_pointer_constant,
7580                                               NULL_TREE, NULL_TREE, 0);
7581       return inside_init;
7582     }
7583
7584   /* Handle scalar types, including conversions.  */
7585
7586   if (code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE
7587       || code == POINTER_TYPE || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE
7588       || code == COMPLEX_TYPE || code == VECTOR_TYPE)
7589     {
7590       if (TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE
7591           && (TREE_CODE (init) == STRING_CST
7592               || TREE_CODE (init) == COMPOUND_LITERAL_EXPR))
7593         inside_init = init = array_to_pointer_conversion (init_loc, init);
7594       if (semantic_type)
7595         inside_init = build1 (EXCESS_PRECISION_EXPR, semantic_type,
7596                               inside_init);
7597       inside_init
7598         = convert_for_assignment (init_loc, UNKNOWN_LOCATION, type,
7599                                   inside_init, origtype, ic_init,
7600                                   null_pointer_constant, NULL_TREE, NULL_TREE,
7601                                   0);
7602
7603       /* Check to see if we have already given an error message.  */
7604       if (inside_init == error_mark_node)
7605         ;
7606       else if (require_constant && !TREE_CONSTANT (inside_init))
7607         {
7608           error_init (init_loc, "initializer element is not constant");
7609           inside_init = error_mark_node;
7610         }
7611       else if (require_constant
7612                && !initializer_constant_valid_p (inside_init,
7613                                                  TREE_TYPE (inside_init)))
7614         {
7615           error_init (init_loc, "initializer element is not computable at "
7616                       "load time");
7617           inside_init = error_mark_node;
7618         }
7619       else if (require_constant && !maybe_const)
7620         pedwarn_init (init_loc, OPT_Wpedantic,
7621                       "initializer element is not a constant expression");
7622
7623       return inside_init;
7624     }
7625
7626   /* Come here only for records and arrays.  */
7627
7628   if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
7629     {
7630       error_init (init_loc, "variable-sized object may not be initialized");
7631       return error_mark_node;
7632     }
7633
7634   error_init (init_loc, "invalid initializer");
7635   return error_mark_node;
7636 }
7637 \f
7638 /* Handle initializers that use braces.  */
7639
7640 /* Type of object we are accumulating a constructor for.
7641    This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE.  */
7642 static tree constructor_type;
7643
7644 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
7645    left to fill.  */
7646 static tree constructor_fields;
7647
7648 /* For an ARRAY_TYPE, this is the specified index
7649    at which to store the next element we get.  */
7650 static tree constructor_index;
7651
7652 /* For an ARRAY_TYPE, this is the maximum index.  */
7653 static tree constructor_max_index;
7654
7655 /* For a RECORD_TYPE, this is the first field not yet written out.  */
7656 static tree constructor_unfilled_fields;
7657
7658 /* For an ARRAY_TYPE, this is the index of the first element
7659    not yet written out.  */
7660 static tree constructor_unfilled_index;
7661
7662 /* In a RECORD_TYPE, the byte index of the next consecutive field.
7663    This is so we can generate gaps between fields, when appropriate.  */
7664 static tree constructor_bit_index;
7665
7666 /* If we are saving up the elements rather than allocating them,
7667    this is the list of elements so far (in reverse order,
7668    most recent first).  */
7669 static vec<constructor_elt, va_gc> *constructor_elements;
7670
7671 /* 1 if constructor should be incrementally stored into a constructor chain,
7672    0 if all the elements should be kept in AVL tree.  */
7673 static int constructor_incremental;
7674
7675 /* 1 if so far this constructor's elements are all compile-time constants.  */
7676 static int constructor_constant;
7677
7678 /* 1 if so far this constructor's elements are all valid address constants.  */
7679 static int constructor_simple;
7680
7681 /* 1 if this constructor has an element that cannot be part of a
7682    constant expression.  */
7683 static int constructor_nonconst;
7684
7685 /* 1 if this constructor is erroneous so far.  */
7686 static int constructor_erroneous;
7687
7688 /* 1 if this constructor is the universal zero initializer { 0 }.  */
7689 static int constructor_zeroinit;
7690
7691 /* Structure for managing pending initializer elements, organized as an
7692    AVL tree.  */
7693
7694 struct init_node
7695 {
7696   struct init_node *left, *right;
7697   struct init_node *parent;
7698   int balance;
7699   tree purpose;
7700   tree value;
7701   tree origtype;
7702 };
7703
7704 /* Tree of pending elements at this constructor level.
7705    These are elements encountered out of order
7706    which belong at places we haven't reached yet in actually
7707    writing the output.
7708    Will never hold tree nodes across GC runs.  */
7709 static struct init_node *constructor_pending_elts;
7710
7711 /* The SPELLING_DEPTH of this constructor.  */
7712 static int constructor_depth;
7713
7714 /* DECL node for which an initializer is being read.
7715    0 means we are reading a constructor expression
7716    such as (struct foo) {...}.  */
7717 static tree constructor_decl;
7718
7719 /* Nonzero if this is an initializer for a top-level decl.  */
7720 static int constructor_top_level;
7721
7722 /* Nonzero if there were any member designators in this initializer.  */
7723 static int constructor_designated;
7724
7725 /* Nesting depth of designator list.  */
7726 static int designator_depth;
7727
7728 /* Nonzero if there were diagnosed errors in this designator list.  */
7729 static int designator_erroneous;
7730
7731 \f
7732 /* This stack has a level for each implicit or explicit level of
7733    structuring in the initializer, including the outermost one.  It
7734    saves the values of most of the variables above.  */
7735
7736 struct constructor_range_stack;
7737
7738 struct constructor_stack
7739 {
7740   struct constructor_stack *next;
7741   tree type;
7742   tree fields;
7743   tree index;
7744   tree max_index;
7745   tree unfilled_index;
7746   tree unfilled_fields;
7747   tree bit_index;
7748   vec<constructor_elt, va_gc> *elements;
7749   struct init_node *pending_elts;
7750   int offset;
7751   int depth;
7752   /* If value nonzero, this value should replace the entire
7753      constructor at this level.  */
7754   struct c_expr replacement_value;
7755   struct constructor_range_stack *range_stack;
7756   char constant;
7757   char simple;
7758   char nonconst;
7759   char implicit;
7760   char erroneous;
7761   char outer;
7762   char incremental;
7763   char designated;
7764   int designator_depth;
7765 };
7766
7767 static struct constructor_stack *constructor_stack;
7768
7769 /* This stack represents designators from some range designator up to
7770    the last designator in the list.  */
7771
7772 struct constructor_range_stack
7773 {
7774   struct constructor_range_stack *next, *prev;
7775   struct constructor_stack *stack;
7776   tree range_start;
7777   tree index;
7778   tree range_end;
7779   tree fields;
7780 };
7781
7782 static struct constructor_range_stack *constructor_range_stack;
7783
7784 /* This stack records separate initializers that are nested.
7785    Nested initializers can't happen in ANSI C, but GNU C allows them
7786    in cases like { ... (struct foo) { ... } ... }.  */
7787
7788 struct initializer_stack
7789 {
7790   struct initializer_stack *next;
7791   tree decl;
7792   struct constructor_stack *constructor_stack;
7793   struct constructor_range_stack *constructor_range_stack;
7794   vec<constructor_elt, va_gc> *elements;
7795   struct spelling *spelling;
7796   struct spelling *spelling_base;
7797   int spelling_size;
7798   char top_level;
7799   char require_constant_value;
7800   char require_constant_elements;
7801   rich_location *missing_brace_richloc;
7802 };
7803
7804 static struct initializer_stack *initializer_stack;
7805 \f
7806 /* Prepare to parse and output the initializer for variable DECL.  */
7807
7808 void
7809 start_init (tree decl, tree asmspec_tree ATTRIBUTE_UNUSED, int top_level,
7810             rich_location *richloc)
7811 {
7812   const char *locus;
7813   struct initializer_stack *p = XNEW (struct initializer_stack);
7814
7815   p->decl = constructor_decl;
7816   p->require_constant_value = require_constant_value;
7817   p->require_constant_elements = require_constant_elements;
7818   p->constructor_stack = constructor_stack;
7819   p->constructor_range_stack = constructor_range_stack;
7820   p->elements = constructor_elements;
7821   p->spelling = spelling;
7822   p->spelling_base = spelling_base;
7823   p->spelling_size = spelling_size;
7824   p->top_level = constructor_top_level;
7825   p->next = initializer_stack;
7826   p->missing_brace_richloc = richloc;
7827   initializer_stack = p;
7828
7829   constructor_decl = decl;
7830   constructor_designated = 0;
7831   constructor_top_level = top_level;
7832
7833   if (decl != NULL_TREE && decl != error_mark_node)
7834     {
7835       require_constant_value = TREE_STATIC (decl);
7836       require_constant_elements
7837         = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
7838            /* For a scalar, you can always use any value to initialize,
7839               even within braces.  */
7840            && AGGREGATE_TYPE_P (TREE_TYPE (decl)));
7841       locus = identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl)));
7842     }
7843   else
7844     {
7845       require_constant_value = 0;
7846       require_constant_elements = 0;
7847       locus = _("(anonymous)");
7848     }
7849
7850   constructor_stack = 0;
7851   constructor_range_stack = 0;
7852
7853   found_missing_braces = 0;
7854
7855   spelling_base = 0;
7856   spelling_size = 0;
7857   RESTORE_SPELLING_DEPTH (0);
7858
7859   if (locus)
7860     push_string (locus);
7861 }
7862
7863 void
7864 finish_init (void)
7865 {
7866   struct initializer_stack *p = initializer_stack;
7867
7868   /* Free the whole constructor stack of this initializer.  */
7869   while (constructor_stack)
7870     {
7871       struct constructor_stack *q = constructor_stack;
7872       constructor_stack = q->next;
7873       free (q);
7874     }
7875
7876   gcc_assert (!constructor_range_stack);
7877
7878   /* Pop back to the data of the outer initializer (if any).  */
7879   free (spelling_base);
7880
7881   constructor_decl = p->decl;
7882   require_constant_value = p->require_constant_value;
7883   require_constant_elements = p->require_constant_elements;
7884   constructor_stack = p->constructor_stack;
7885   constructor_range_stack = p->constructor_range_stack;
7886   constructor_elements = p->elements;
7887   spelling = p->spelling;
7888   spelling_base = p->spelling_base;
7889   spelling_size = p->spelling_size;
7890   constructor_top_level = p->top_level;
7891   initializer_stack = p->next;
7892   free (p);
7893 }
7894 \f
7895 /* Call here when we see the initializer is surrounded by braces.
7896    This is instead of a call to push_init_level;
7897    it is matched by a call to pop_init_level.
7898
7899    TYPE is the type to initialize, for a constructor expression.
7900    For an initializer for a decl, TYPE is zero.  */
7901
7902 void
7903 really_start_incremental_init (tree type)
7904 {
7905   struct constructor_stack *p = XNEW (struct constructor_stack);
7906
7907   if (type == NULL_TREE)
7908     type = TREE_TYPE (constructor_decl);
7909
7910   if (VECTOR_TYPE_P (type)
7911       && TYPE_VECTOR_OPAQUE (type))
7912     error ("opaque vector types cannot be initialized");
7913
7914   p->type = constructor_type;
7915   p->fields = constructor_fields;
7916   p->index = constructor_index;
7917   p->max_index = constructor_max_index;
7918   p->unfilled_index = constructor_unfilled_index;
7919   p->unfilled_fields = constructor_unfilled_fields;
7920   p->bit_index = constructor_bit_index;
7921   p->elements = constructor_elements;
7922   p->constant = constructor_constant;
7923   p->simple = constructor_simple;
7924   p->nonconst = constructor_nonconst;
7925   p->erroneous = constructor_erroneous;
7926   p->pending_elts = constructor_pending_elts;
7927   p->depth = constructor_depth;
7928   p->replacement_value.value = 0;
7929   p->replacement_value.original_code = ERROR_MARK;
7930   p->replacement_value.original_type = NULL;
7931   p->implicit = 0;
7932   p->range_stack = 0;
7933   p->outer = 0;
7934   p->incremental = constructor_incremental;
7935   p->designated = constructor_designated;
7936   p->designator_depth = designator_depth;
7937   p->next = 0;
7938   constructor_stack = p;
7939
7940   constructor_constant = 1;
7941   constructor_simple = 1;
7942   constructor_nonconst = 0;
7943   constructor_depth = SPELLING_DEPTH ();
7944   constructor_elements = NULL;
7945   constructor_pending_elts = 0;
7946   constructor_type = type;
7947   constructor_incremental = 1;
7948   constructor_designated = 0;
7949   constructor_zeroinit = 1;
7950   designator_depth = 0;
7951   designator_erroneous = 0;
7952
7953   if (RECORD_OR_UNION_TYPE_P (constructor_type))
7954     {
7955       constructor_fields = TYPE_FIELDS (constructor_type);
7956       /* Skip any nameless bit fields at the beginning.  */
7957       while (constructor_fields != NULL_TREE
7958              && DECL_C_BIT_FIELD (constructor_fields)
7959              && DECL_NAME (constructor_fields) == NULL_TREE)
7960         constructor_fields = DECL_CHAIN (constructor_fields);
7961
7962       constructor_unfilled_fields = constructor_fields;
7963       constructor_bit_index = bitsize_zero_node;
7964     }
7965   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7966     {
7967       if (TYPE_DOMAIN (constructor_type))
7968         {
7969           constructor_max_index
7970             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
7971
7972           /* Detect non-empty initializations of zero-length arrays.  */
7973           if (constructor_max_index == NULL_TREE
7974               && TYPE_SIZE (constructor_type))
7975             constructor_max_index = integer_minus_one_node;
7976
7977           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
7978              to initialize VLAs will cause a proper error; avoid tree
7979              checking errors as well by setting a safe value.  */
7980           if (constructor_max_index
7981               && TREE_CODE (constructor_max_index) != INTEGER_CST)
7982             constructor_max_index = integer_minus_one_node;
7983
7984           constructor_index
7985             = convert (bitsizetype,
7986                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
7987         }
7988       else
7989         {
7990           constructor_index = bitsize_zero_node;
7991           constructor_max_index = NULL_TREE;
7992         }
7993
7994       constructor_unfilled_index = constructor_index;
7995     }
7996   else if (VECTOR_TYPE_P (constructor_type))
7997     {
7998       /* Vectors are like simple fixed-size arrays.  */
7999       constructor_max_index =
8000         bitsize_int (TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
8001       constructor_index = bitsize_zero_node;
8002       constructor_unfilled_index = constructor_index;
8003     }
8004   else
8005     {
8006       /* Handle the case of int x = {5}; */
8007       constructor_fields = constructor_type;
8008       constructor_unfilled_fields = constructor_type;
8009     }
8010 }
8011 \f
8012 extern location_t last_init_list_comma;
8013
8014 /* Called when we see an open brace for a nested initializer.  Finish
8015    off any pending levels with implicit braces.  */
8016 void
8017 finish_implicit_inits (location_t loc, struct obstack *braced_init_obstack)
8018 {
8019   while (constructor_stack->implicit)
8020     {
8021       if (RECORD_OR_UNION_TYPE_P (constructor_type)
8022           && constructor_fields == NULL_TREE)
8023         process_init_element (input_location,
8024                               pop_init_level (loc, 1, braced_init_obstack,
8025                                               last_init_list_comma),
8026                               true, braced_init_obstack);
8027       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
8028                && constructor_max_index
8029                && tree_int_cst_lt (constructor_max_index,
8030                                    constructor_index))
8031         process_init_element (input_location,
8032                               pop_init_level (loc, 1, braced_init_obstack,
8033                                               last_init_list_comma),
8034                               true, braced_init_obstack);
8035       else
8036         break;
8037     }
8038 }
8039
8040 /* Push down into a subobject, for initialization.
8041    If this is for an explicit set of braces, IMPLICIT is 0.
8042    If it is because the next element belongs at a lower level,
8043    IMPLICIT is 1 (or 2 if the push is because of designator list).  */
8044
8045 void
8046 push_init_level (location_t loc, int implicit,
8047                  struct obstack *braced_init_obstack)
8048 {
8049   struct constructor_stack *p;
8050   tree value = NULL_TREE;
8051
8052   /* Unless this is an explicit brace, we need to preserve previous
8053      content if any.  */
8054   if (implicit)
8055     {
8056       if (RECORD_OR_UNION_TYPE_P (constructor_type) && constructor_fields)
8057         value = find_init_member (constructor_fields, braced_init_obstack);
8058       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
8059         value = find_init_member (constructor_index, braced_init_obstack);
8060     }
8061
8062   p = XNEW (struct constructor_stack);
8063   p->type = constructor_type;
8064   p->fields = constructor_fields;
8065   p->index = constructor_index;
8066   p->max_index = constructor_max_index;
8067   p->unfilled_index = constructor_unfilled_index;
8068   p->unfilled_fields = constructor_unfilled_fields;
8069   p->bit_index = constructor_bit_index;
8070   p->elements = constructor_elements;
8071   p->constant = constructor_constant;
8072   p->simple = constructor_simple;
8073   p->nonconst = constructor_nonconst;
8074   p->erroneous = constructor_erroneous;
8075   p->pending_elts = constructor_pending_elts;
8076   p->depth = constructor_depth;
8077   p->replacement_value.value = NULL_TREE;
8078   p->replacement_value.original_code = ERROR_MARK;
8079   p->replacement_value.original_type = NULL;
8080   p->implicit = implicit;
8081   p->outer = 0;
8082   p->incremental = constructor_incremental;
8083   p->designated = constructor_designated;
8084   p->designator_depth = designator_depth;
8085   p->next = constructor_stack;
8086   p->range_stack = 0;
8087   constructor_stack = p;
8088
8089   constructor_constant = 1;
8090   constructor_simple = 1;
8091   constructor_nonconst = 0;
8092   constructor_depth = SPELLING_DEPTH ();
8093   constructor_elements = NULL;
8094   constructor_incremental = 1;
8095   constructor_designated = 0;
8096   constructor_pending_elts = 0;
8097   if (!implicit)
8098     {
8099       p->range_stack = constructor_range_stack;
8100       constructor_range_stack = 0;
8101       designator_depth = 0;
8102       designator_erroneous = 0;
8103     }
8104
8105   /* Don't die if an entire brace-pair level is superfluous
8106      in the containing level.  */
8107   if (constructor_type == NULL_TREE)
8108     ;
8109   else if (RECORD_OR_UNION_TYPE_P (constructor_type))
8110     {
8111       /* Don't die if there are extra init elts at the end.  */
8112       if (constructor_fields == NULL_TREE)
8113         constructor_type = NULL_TREE;
8114       else
8115         {
8116           constructor_type = TREE_TYPE (constructor_fields);
8117           push_member_name (constructor_fields);
8118           constructor_depth++;
8119         }
8120       /* If upper initializer is designated, then mark this as
8121          designated too to prevent bogus warnings.  */
8122       constructor_designated = p->designated;
8123     }
8124   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
8125     {
8126       constructor_type = TREE_TYPE (constructor_type);
8127       push_array_bounds (tree_to_uhwi (constructor_index));
8128       constructor_depth++;
8129     }
8130
8131   if (constructor_type == NULL_TREE)
8132     {
8133       error_init (loc, "extra brace group at end of initializer");
8134       constructor_fields = NULL_TREE;
8135       constructor_unfilled_fields = NULL_TREE;
8136       return;
8137     }
8138
8139   if (value && TREE_CODE (value) == CONSTRUCTOR)
8140     {
8141       constructor_constant = TREE_CONSTANT (value);
8142       constructor_simple = TREE_STATIC (value);
8143       constructor_nonconst = CONSTRUCTOR_NON_CONST (value);
8144       constructor_elements = CONSTRUCTOR_ELTS (value);
8145       if (!vec_safe_is_empty (constructor_elements)
8146           && (TREE_CODE (constructor_type) == RECORD_TYPE
8147               || TREE_CODE (constructor_type) == ARRAY_TYPE))
8148         set_nonincremental_init (braced_init_obstack);
8149     }
8150
8151   if (implicit == 1)
8152     {
8153       found_missing_braces = 1;
8154       if (initializer_stack->missing_brace_richloc)
8155         initializer_stack->missing_brace_richloc->add_fixit_insert_before
8156           (loc, "{");
8157     }
8158
8159   if (RECORD_OR_UNION_TYPE_P (constructor_type))
8160     {
8161       constructor_fields = TYPE_FIELDS (constructor_type);
8162       /* Skip any nameless bit fields at the beginning.  */
8163       while (constructor_fields != NULL_TREE
8164              && DECL_C_BIT_FIELD (constructor_fields)
8165              && DECL_NAME (constructor_fields) == NULL_TREE)
8166         constructor_fields = DECL_CHAIN (constructor_fields);
8167
8168       constructor_unfilled_fields = constructor_fields;
8169       constructor_bit_index = bitsize_zero_node;
8170     }
8171   else if (VECTOR_TYPE_P (constructor_type))
8172     {
8173       /* Vectors are like simple fixed-size arrays.  */
8174       constructor_max_index =
8175         bitsize_int (TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
8176       constructor_index = bitsize_int (0);
8177       constructor_unfilled_index = constructor_index;
8178     }
8179   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
8180     {
8181       if (TYPE_DOMAIN (constructor_type))
8182         {
8183           constructor_max_index
8184             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
8185
8186           /* Detect non-empty initializations of zero-length arrays.  */
8187           if (constructor_max_index == NULL_TREE
8188               && TYPE_SIZE (constructor_type))
8189             constructor_max_index = integer_minus_one_node;
8190
8191           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
8192              to initialize VLAs will cause a proper error; avoid tree
8193              checking errors as well by setting a safe value.  */
8194           if (constructor_max_index
8195               && TREE_CODE (constructor_max_index) != INTEGER_CST)
8196             constructor_max_index = integer_minus_one_node;
8197
8198           constructor_index
8199             = convert (bitsizetype,
8200                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
8201         }
8202       else
8203         constructor_index = bitsize_zero_node;
8204
8205       constructor_unfilled_index = constructor_index;
8206       if (value && TREE_CODE (value) == STRING_CST)
8207         {
8208           /* We need to split the char/wchar array into individual
8209              characters, so that we don't have to special case it
8210              everywhere.  */
8211           set_nonincremental_init_from_string (value, braced_init_obstack);
8212         }
8213     }
8214   else
8215     {
8216       if (constructor_type != error_mark_node)
8217         warning_init (input_location, 0, "braces around scalar initializer");
8218       constructor_fields = constructor_type;
8219       constructor_unfilled_fields = constructor_type;
8220     }
8221 }
8222
8223 /* At the end of an implicit or explicit brace level,
8224    finish up that level of constructor.  If a single expression
8225    with redundant braces initialized that level, return the
8226    c_expr structure for that expression.  Otherwise, the original_code
8227    element is set to ERROR_MARK.
8228    If we were outputting the elements as they are read, return 0 as the value
8229    from inner levels (process_init_element ignores that),
8230    but return error_mark_node as the value from the outermost level
8231    (that's what we want to put in DECL_INITIAL).
8232    Otherwise, return a CONSTRUCTOR expression as the value.  */
8233
8234 struct c_expr
8235 pop_init_level (location_t loc, int implicit,
8236                 struct obstack *braced_init_obstack,
8237                 location_t insert_before)
8238 {
8239   struct constructor_stack *p;
8240   struct c_expr ret;
8241   ret.value = NULL_TREE;
8242   ret.original_code = ERROR_MARK;
8243   ret.original_type = NULL;
8244
8245   if (implicit == 0)
8246     {
8247       /* When we come to an explicit close brace,
8248          pop any inner levels that didn't have explicit braces.  */
8249       while (constructor_stack->implicit)
8250         process_init_element (input_location,
8251                               pop_init_level (loc, 1, braced_init_obstack,
8252                                               insert_before),
8253                               true, braced_init_obstack);
8254       gcc_assert (!constructor_range_stack);
8255     }
8256   else
8257     if (initializer_stack->missing_brace_richloc)
8258       initializer_stack->missing_brace_richloc->add_fixit_insert_before
8259         (insert_before, "}");
8260
8261   /* Now output all pending elements.  */
8262   constructor_incremental = 1;
8263   output_pending_init_elements (1, braced_init_obstack);
8264
8265   p = constructor_stack;
8266
8267   /* Error for initializing a flexible array member, or a zero-length
8268      array member in an inappropriate context.  */
8269   if (constructor_type && constructor_fields
8270       && TREE_CODE (constructor_type) == ARRAY_TYPE
8271       && TYPE_DOMAIN (constructor_type)
8272       && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
8273     {
8274       /* Silently discard empty initializations.  The parser will
8275          already have pedwarned for empty brackets.  */
8276       if (integer_zerop (constructor_unfilled_index))
8277         constructor_type = NULL_TREE;
8278       else
8279         {
8280           gcc_assert (!TYPE_SIZE (constructor_type));
8281
8282           if (constructor_depth > 2)
8283             error_init (loc, "initialization of flexible array member in a nested context");
8284           else
8285             pedwarn_init (loc, OPT_Wpedantic,
8286                           "initialization of a flexible array member");
8287
8288           /* We have already issued an error message for the existence
8289              of a flexible array member not at the end of the structure.
8290              Discard the initializer so that we do not die later.  */
8291           if (DECL_CHAIN (constructor_fields) != NULL_TREE)
8292             constructor_type = NULL_TREE;
8293         }
8294     }
8295
8296   switch (vec_safe_length (constructor_elements))
8297     {
8298     case 0:
8299       /* Initialization with { } counts as zeroinit.  */
8300       constructor_zeroinit = 1;
8301       break;
8302     case 1:
8303       /* This might be zeroinit as well.  */
8304       if (integer_zerop ((*constructor_elements)[0].value))
8305         constructor_zeroinit = 1;
8306       break;
8307     default:
8308       /* If the constructor has more than one element, it can't be { 0 }.  */
8309       constructor_zeroinit = 0;
8310       break;
8311     }
8312
8313   /* Warn when some structs are initialized with direct aggregation.  */
8314   if (!implicit && found_missing_braces && warn_missing_braces
8315       && !constructor_zeroinit)
8316     {
8317       gcc_assert (initializer_stack->missing_brace_richloc);
8318       warning_at (initializer_stack->missing_brace_richloc,
8319                   OPT_Wmissing_braces,
8320                   "missing braces around initializer");
8321     }
8322
8323   /* Warn when some struct elements are implicitly initialized to zero.  */
8324   if (warn_missing_field_initializers
8325       && constructor_type
8326       && TREE_CODE (constructor_type) == RECORD_TYPE
8327       && constructor_unfilled_fields)
8328     {
8329         /* Do not warn for flexible array members or zero-length arrays.  */
8330         while (constructor_unfilled_fields
8331                && (!DECL_SIZE (constructor_unfilled_fields)
8332                    || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
8333           constructor_unfilled_fields = DECL_CHAIN (constructor_unfilled_fields);
8334
8335         if (constructor_unfilled_fields
8336             /* Do not warn if this level of the initializer uses member
8337                designators; it is likely to be deliberate.  */
8338             && !constructor_designated
8339             /* Do not warn about initializing with { 0 } or with { }.  */
8340             && !constructor_zeroinit)
8341           {
8342             if (warning_at (input_location, OPT_Wmissing_field_initializers,
8343                             "missing initializer for field %qD of %qT",
8344                             constructor_unfilled_fields,
8345                             constructor_type))
8346               inform (DECL_SOURCE_LOCATION (constructor_unfilled_fields),
8347                       "%qD declared here", constructor_unfilled_fields);
8348           }
8349     }
8350
8351   /* Pad out the end of the structure.  */
8352   if (p->replacement_value.value)
8353     /* If this closes a superfluous brace pair,
8354        just pass out the element between them.  */
8355     ret = p->replacement_value;
8356   else if (constructor_type == NULL_TREE)
8357     ;
8358   else if (!RECORD_OR_UNION_TYPE_P (constructor_type)
8359            && TREE_CODE (constructor_type) != ARRAY_TYPE
8360            && !VECTOR_TYPE_P (constructor_type))
8361     {
8362       /* A nonincremental scalar initializer--just return
8363          the element, after verifying there is just one.  */
8364       if (vec_safe_is_empty (constructor_elements))
8365         {
8366           if (!constructor_erroneous)
8367             error_init (loc, "empty scalar initializer");
8368           ret.value = error_mark_node;
8369         }
8370       else if (vec_safe_length (constructor_elements) != 1)
8371         {
8372           error_init (loc, "extra elements in scalar initializer");
8373           ret.value = (*constructor_elements)[0].value;
8374         }
8375       else
8376         ret.value = (*constructor_elements)[0].value;
8377     }
8378   else
8379     {
8380       if (constructor_erroneous)
8381         ret.value = error_mark_node;
8382       else
8383         {
8384           ret.value = build_constructor (constructor_type,
8385                                          constructor_elements);
8386           if (constructor_constant)
8387             TREE_CONSTANT (ret.value) = 1;
8388           if (constructor_constant && constructor_simple)
8389             TREE_STATIC (ret.value) = 1;
8390           if (constructor_nonconst)
8391             CONSTRUCTOR_NON_CONST (ret.value) = 1;
8392         }
8393     }
8394
8395   if (ret.value && TREE_CODE (ret.value) != CONSTRUCTOR)
8396     {
8397       if (constructor_nonconst)
8398         ret.original_code = C_MAYBE_CONST_EXPR;
8399       else if (ret.original_code == C_MAYBE_CONST_EXPR)
8400         ret.original_code = ERROR_MARK;
8401     }
8402
8403   constructor_type = p->type;
8404   constructor_fields = p->fields;
8405   constructor_index = p->index;
8406   constructor_max_index = p->max_index;
8407   constructor_unfilled_index = p->unfilled_index;
8408   constructor_unfilled_fields = p->unfilled_fields;
8409   constructor_bit_index = p->bit_index;
8410   constructor_elements = p->elements;
8411   constructor_constant = p->constant;
8412   constructor_simple = p->simple;
8413   constructor_nonconst = p->nonconst;
8414   constructor_erroneous = p->erroneous;
8415   constructor_incremental = p->incremental;
8416   constructor_designated = p->designated;
8417   designator_depth = p->designator_depth;
8418   constructor_pending_elts = p->pending_elts;
8419   constructor_depth = p->depth;
8420   if (!p->implicit)
8421     constructor_range_stack = p->range_stack;
8422   RESTORE_SPELLING_DEPTH (constructor_depth);
8423
8424   constructor_stack = p->next;
8425   free (p);
8426
8427   if (ret.value == NULL_TREE && constructor_stack == 0)
8428     ret.value = error_mark_node;
8429   return ret;
8430 }
8431
8432 /* Common handling for both array range and field name designators.
8433    ARRAY argument is nonzero for array ranges.  Returns false for success.  */
8434
8435 static bool
8436 set_designator (location_t loc, bool array,
8437                 struct obstack *braced_init_obstack)
8438 {
8439   tree subtype;
8440   enum tree_code subcode;
8441
8442   /* Don't die if an entire brace-pair level is superfluous
8443      in the containing level.  */
8444   if (constructor_type == NULL_TREE)
8445     return true;
8446
8447   /* If there were errors in this designator list already, bail out
8448      silently.  */
8449   if (designator_erroneous)
8450     return true;
8451
8452   if (!designator_depth)
8453     {
8454       gcc_assert (!constructor_range_stack);
8455
8456       /* Designator list starts at the level of closest explicit
8457          braces.  */
8458       while (constructor_stack->implicit)
8459         process_init_element (input_location,
8460                               pop_init_level (loc, 1, braced_init_obstack,
8461                                               last_init_list_comma),
8462                               true, braced_init_obstack);
8463       constructor_designated = 1;
8464       return false;
8465     }
8466
8467   switch (TREE_CODE (constructor_type))
8468     {
8469     case  RECORD_TYPE:
8470     case  UNION_TYPE:
8471       subtype = TREE_TYPE (constructor_fields);
8472       if (subtype != error_mark_node)
8473         subtype = TYPE_MAIN_VARIANT (subtype);
8474       break;
8475     case ARRAY_TYPE:
8476       subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
8477       break;
8478     default:
8479       gcc_unreachable ();
8480     }
8481
8482   subcode = TREE_CODE (subtype);
8483   if (array && subcode != ARRAY_TYPE)
8484     {
8485       error_init (loc, "array index in non-array initializer");
8486       return true;
8487     }
8488   else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
8489     {
8490       error_init (loc, "field name not in record or union initializer");
8491       return true;
8492     }
8493
8494   constructor_designated = 1;
8495   finish_implicit_inits (loc, braced_init_obstack);
8496   push_init_level (loc, 2, braced_init_obstack);
8497   return false;
8498 }
8499
8500 /* If there are range designators in designator list, push a new designator
8501    to constructor_range_stack.  RANGE_END is end of such stack range or
8502    NULL_TREE if there is no range designator at this level.  */
8503
8504 static void
8505 push_range_stack (tree range_end, struct obstack * braced_init_obstack)
8506 {
8507   struct constructor_range_stack *p;
8508
8509   p = (struct constructor_range_stack *)
8510     obstack_alloc (braced_init_obstack,
8511                    sizeof (struct constructor_range_stack));
8512   p->prev = constructor_range_stack;
8513   p->next = 0;
8514   p->fields = constructor_fields;
8515   p->range_start = constructor_index;
8516   p->index = constructor_index;
8517   p->stack = constructor_stack;
8518   p->range_end = range_end;
8519   if (constructor_range_stack)
8520     constructor_range_stack->next = p;
8521   constructor_range_stack = p;
8522 }
8523
8524 /* Within an array initializer, specify the next index to be initialized.
8525    FIRST is that index.  If LAST is nonzero, then initialize a range
8526    of indices, running from FIRST through LAST.  */
8527
8528 void
8529 set_init_index (location_t loc, tree first, tree last,
8530                 struct obstack *braced_init_obstack)
8531 {
8532   if (set_designator (loc, true, braced_init_obstack))
8533     return;
8534
8535   designator_erroneous = 1;
8536
8537   if (!INTEGRAL_TYPE_P (TREE_TYPE (first))
8538       || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last))))
8539     {
8540       error_init (loc, "array index in initializer not of integer type");
8541       return;
8542     }
8543
8544   if (TREE_CODE (first) != INTEGER_CST)
8545     {
8546       first = c_fully_fold (first, false, NULL);
8547       if (TREE_CODE (first) == INTEGER_CST)
8548         pedwarn_init (loc, OPT_Wpedantic,
8549                       "array index in initializer is not "
8550                       "an integer constant expression");
8551     }
8552
8553   if (last && TREE_CODE (last) != INTEGER_CST)
8554     {
8555       last = c_fully_fold (last, false, NULL);
8556       if (TREE_CODE (last) == INTEGER_CST)
8557         pedwarn_init (loc, OPT_Wpedantic,
8558                       "array index in initializer is not "
8559                       "an integer constant expression");
8560     }
8561
8562   if (TREE_CODE (first) != INTEGER_CST)
8563     error_init (loc, "nonconstant array index in initializer");
8564   else if (last != NULL_TREE && TREE_CODE (last) != INTEGER_CST)
8565     error_init (loc, "nonconstant array index in initializer");
8566   else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
8567     error_init (loc, "array index in non-array initializer");
8568   else if (tree_int_cst_sgn (first) == -1)
8569     error_init (loc, "array index in initializer exceeds array bounds");
8570   else if (constructor_max_index
8571            && tree_int_cst_lt (constructor_max_index, first))
8572     error_init (loc, "array index in initializer exceeds array bounds");
8573   else
8574     {
8575       constant_expression_warning (first);
8576       if (last)
8577         constant_expression_warning (last);
8578       constructor_index = convert (bitsizetype, first);
8579       if (tree_int_cst_lt (constructor_index, first))
8580         {
8581           constructor_index = copy_node (constructor_index);
8582           TREE_OVERFLOW (constructor_index) = 1;
8583         }
8584
8585       if (last)
8586         {
8587           if (tree_int_cst_equal (first, last))
8588             last = NULL_TREE;
8589           else if (tree_int_cst_lt (last, first))
8590             {
8591               error_init (loc, "empty index range in initializer");
8592               last = NULL_TREE;
8593             }
8594           else
8595             {
8596               last = convert (bitsizetype, last);
8597               if (constructor_max_index != NULL_TREE
8598                   && tree_int_cst_lt (constructor_max_index, last))
8599                 {
8600                   error_init (loc, "array index range in initializer exceeds "
8601                               "array bounds");
8602                   last = NULL_TREE;
8603                 }
8604             }
8605         }
8606
8607       designator_depth++;
8608       designator_erroneous = 0;
8609       if (constructor_range_stack || last)
8610         push_range_stack (last, braced_init_obstack);
8611     }
8612 }
8613
8614 /* Within a struct initializer, specify the next field to be initialized.  */
8615
8616 void
8617 set_init_label (location_t loc, tree fieldname, location_t fieldname_loc,
8618                 struct obstack *braced_init_obstack)
8619 {
8620   tree field;
8621
8622   if (set_designator (loc, false, braced_init_obstack))
8623     return;
8624
8625   designator_erroneous = 1;
8626
8627   if (!RECORD_OR_UNION_TYPE_P (constructor_type))
8628     {
8629       error_init (loc, "field name not in record or union initializer");
8630       return;
8631     }
8632
8633   field = lookup_field (constructor_type, fieldname);
8634
8635   if (field == NULL_TREE)
8636     {
8637       tree guessed_id = lookup_field_fuzzy (constructor_type, fieldname);
8638       if (guessed_id)
8639         {
8640           gcc_rich_location rich_loc (fieldname_loc);
8641           rich_loc.add_fixit_misspelled_id (fieldname_loc, guessed_id);
8642           error_at (&rich_loc,
8643                     "%qT has no member named %qE; did you mean %qE?",
8644                     constructor_type, fieldname, guessed_id);
8645         }
8646       else
8647         error_at (fieldname_loc, "%qT has no member named %qE",
8648                   constructor_type, fieldname);
8649     }
8650   else
8651     do
8652       {
8653         constructor_fields = TREE_VALUE (field);
8654         designator_depth++;
8655         designator_erroneous = 0;
8656         if (constructor_range_stack)
8657           push_range_stack (NULL_TREE, braced_init_obstack);
8658         field = TREE_CHAIN (field);
8659         if (field)
8660           {
8661             if (set_designator (loc, false, braced_init_obstack))
8662               return;
8663           }
8664       }
8665     while (field != NULL_TREE);
8666 }
8667 \f
8668 /* Add a new initializer to the tree of pending initializers.  PURPOSE
8669    identifies the initializer, either array index or field in a structure.
8670    VALUE is the value of that index or field.  If ORIGTYPE is not
8671    NULL_TREE, it is the original type of VALUE.
8672
8673    IMPLICIT is true if value comes from pop_init_level (1),
8674    the new initializer has been merged with the existing one
8675    and thus no warnings should be emitted about overriding an
8676    existing initializer.  */
8677
8678 static void
8679 add_pending_init (location_t loc, tree purpose, tree value, tree origtype,
8680                   bool implicit, struct obstack *braced_init_obstack)
8681 {
8682   struct init_node *p, **q, *r;
8683
8684   q = &constructor_pending_elts;
8685   p = 0;
8686
8687   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
8688     {
8689       while (*q != 0)
8690         {
8691           p = *q;
8692           if (tree_int_cst_lt (purpose, p->purpose))
8693             q = &p->left;
8694           else if (tree_int_cst_lt (p->purpose, purpose))
8695             q = &p->right;
8696           else
8697             {
8698               if (!implicit)
8699                 {
8700                   if (TREE_SIDE_EFFECTS (p->value))
8701                     warning_init (loc, OPT_Woverride_init_side_effects,
8702                                   "initialized field with side-effects "
8703                                   "overwritten");
8704                   else if (warn_override_init)
8705                     warning_init (loc, OPT_Woverride_init,
8706                                   "initialized field overwritten");
8707                 }
8708               p->value = value;
8709               p->origtype = origtype;
8710               return;
8711             }
8712         }
8713     }
8714   else
8715     {
8716       tree bitpos;
8717
8718       bitpos = bit_position (purpose);
8719       while (*q != NULL)
8720         {
8721           p = *q;
8722           if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
8723             q = &p->left;
8724           else if (p->purpose != purpose)
8725             q = &p->right;
8726           else
8727             {
8728               if (!implicit)
8729                 {
8730                   if (TREE_SIDE_EFFECTS (p->value))
8731                     warning_init (loc, OPT_Woverride_init_side_effects,
8732                                   "initialized field with side-effects "
8733                                   "overwritten");
8734                   else if (warn_override_init)
8735                     warning_init (loc, OPT_Woverride_init,
8736                                   "initialized field overwritten");
8737                 }
8738               p->value = value;
8739               p->origtype = origtype;
8740               return;
8741             }
8742         }
8743     }
8744
8745   r = (struct init_node *) obstack_alloc (braced_init_obstack,
8746                                           sizeof (struct init_node));
8747   r->purpose = purpose;
8748   r->value = value;
8749   r->origtype = origtype;
8750
8751   *q = r;
8752   r->parent = p;
8753   r->left = 0;
8754   r->right = 0;
8755   r->balance = 0;
8756
8757   while (p)
8758     {
8759       struct init_node *s;
8760
8761       if (r == p->left)
8762         {
8763           if (p->balance == 0)
8764             p->balance = -1;
8765           else if (p->balance < 0)
8766             {
8767               if (r->balance < 0)
8768                 {
8769                   /* L rotation.  */
8770                   p->left = r->right;
8771                   if (p->left)
8772                     p->left->parent = p;
8773                   r->right = p;
8774
8775                   p->balance = 0;
8776                   r->balance = 0;
8777
8778                   s = p->parent;
8779                   p->parent = r;
8780                   r->parent = s;
8781                   if (s)
8782                     {
8783                       if (s->left == p)
8784                         s->left = r;
8785                       else
8786                         s->right = r;
8787                     }
8788                   else
8789                     constructor_pending_elts = r;
8790                 }
8791               else
8792                 {
8793                   /* LR rotation.  */
8794                   struct init_node *t = r->right;
8795
8796                   r->right = t->left;
8797                   if (r->right)
8798                     r->right->parent = r;
8799                   t->left = r;
8800
8801                   p->left = t->right;
8802                   if (p->left)
8803                     p->left->parent = p;
8804                   t->right = p;
8805
8806                   p->balance = t->balance < 0;
8807                   r->balance = -(t->balance > 0);
8808                   t->balance = 0;
8809
8810                   s = p->parent;
8811                   p->parent = t;
8812                   r->parent = t;
8813                   t->parent = s;
8814                   if (s)
8815                     {
8816                       if (s->left == p)
8817                         s->left = t;
8818                       else
8819                         s->right = t;
8820                     }
8821                   else
8822                     constructor_pending_elts = t;
8823                 }
8824               break;
8825             }
8826           else
8827             {
8828               /* p->balance == +1; growth of left side balances the node.  */
8829               p->balance = 0;
8830               break;
8831             }
8832         }
8833       else /* r == p->right */
8834         {
8835           if (p->balance == 0)
8836             /* Growth propagation from right side.  */
8837             p->balance++;
8838           else if (p->balance > 0)
8839             {
8840               if (r->balance > 0)
8841                 {
8842                   /* R rotation.  */
8843                   p->right = r->left;
8844                   if (p->right)
8845                     p->right->parent = p;
8846                   r->left = p;
8847
8848                   p->balance = 0;
8849                   r->balance = 0;
8850
8851                   s = p->parent;
8852                   p->parent = r;
8853                   r->parent = s;
8854                   if (s)
8855                     {
8856                       if (s->left == p)
8857                         s->left = r;
8858                       else
8859                         s->right = r;
8860                     }
8861                   else
8862                     constructor_pending_elts = r;
8863                 }
8864               else /* r->balance == -1 */
8865                 {
8866                   /* RL rotation */
8867                   struct init_node *t = r->left;
8868
8869                   r->left = t->right;
8870                   if (r->left)
8871                     r->left->parent = r;
8872                   t->right = r;
8873
8874                   p->right = t->left;
8875                   if (p->right)
8876                     p->right->parent = p;
8877                   t->left = p;
8878
8879                   r->balance = (t->balance < 0);
8880                   p->balance = -(t->balance > 0);
8881                   t->balance = 0;
8882
8883                   s = p->parent;
8884                   p->parent = t;
8885                   r->parent = t;
8886                   t->parent = s;
8887                   if (s)
8888                     {
8889                       if (s->left == p)
8890                         s->left = t;
8891                       else
8892                         s->right = t;
8893                     }
8894                   else
8895                     constructor_pending_elts = t;
8896                 }
8897               break;
8898             }
8899           else
8900             {
8901               /* p->balance == -1; growth of right side balances the node.  */
8902               p->balance = 0;
8903               break;
8904             }
8905         }
8906
8907       r = p;
8908       p = p->parent;
8909     }
8910 }
8911
8912 /* Build AVL tree from a sorted chain.  */
8913
8914 static void
8915 set_nonincremental_init (struct obstack * braced_init_obstack)
8916 {
8917   unsigned HOST_WIDE_INT ix;
8918   tree index, value;
8919
8920   if (TREE_CODE (constructor_type) != RECORD_TYPE
8921       && TREE_CODE (constructor_type) != ARRAY_TYPE)
8922     return;
8923
8924   FOR_EACH_CONSTRUCTOR_ELT (constructor_elements, ix, index, value)
8925     add_pending_init (input_location, index, value, NULL_TREE, true,
8926                       braced_init_obstack);
8927   constructor_elements = NULL;
8928   if (TREE_CODE (constructor_type) == RECORD_TYPE)
8929     {
8930       constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
8931       /* Skip any nameless bit fields at the beginning.  */
8932       while (constructor_unfilled_fields != NULL_TREE
8933              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
8934              && DECL_NAME (constructor_unfilled_fields) == NULL_TREE)
8935         constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
8936
8937     }
8938   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
8939     {
8940       if (TYPE_DOMAIN (constructor_type))
8941         constructor_unfilled_index
8942             = convert (bitsizetype,
8943                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
8944       else
8945         constructor_unfilled_index = bitsize_zero_node;
8946     }
8947   constructor_incremental = 0;
8948 }
8949
8950 /* Build AVL tree from a string constant.  */
8951
8952 static void
8953 set_nonincremental_init_from_string (tree str,
8954                                      struct obstack * braced_init_obstack)
8955 {
8956   tree value, purpose, type;
8957   HOST_WIDE_INT val[2];
8958   const char *p, *end;
8959   int byte, wchar_bytes, charwidth, bitpos;
8960
8961   gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE);
8962
8963   wchar_bytes = TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) / BITS_PER_UNIT;
8964   charwidth = TYPE_PRECISION (char_type_node);
8965   gcc_assert ((size_t) wchar_bytes * charwidth
8966               <= ARRAY_SIZE (val) * HOST_BITS_PER_WIDE_INT);
8967   type = TREE_TYPE (constructor_type);
8968   p = TREE_STRING_POINTER (str);
8969   end = p + TREE_STRING_LENGTH (str);
8970
8971   for (purpose = bitsize_zero_node;
8972        p < end
8973        && !(constructor_max_index
8974             && tree_int_cst_lt (constructor_max_index, purpose));
8975        purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
8976     {
8977       if (wchar_bytes == 1)
8978         {
8979           val[0] = (unsigned char) *p++;
8980           val[1] = 0;
8981         }
8982       else
8983         {
8984           val[1] = 0;
8985           val[0] = 0;
8986           for (byte = 0; byte < wchar_bytes; byte++)
8987             {
8988               if (BYTES_BIG_ENDIAN)
8989                 bitpos = (wchar_bytes - byte - 1) * charwidth;
8990               else
8991                 bitpos = byte * charwidth;
8992               val[bitpos / HOST_BITS_PER_WIDE_INT]
8993                 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
8994                    << (bitpos % HOST_BITS_PER_WIDE_INT);
8995             }
8996         }
8997
8998       if (!TYPE_UNSIGNED (type))
8999         {
9000           bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
9001           if (bitpos < HOST_BITS_PER_WIDE_INT)
9002             {
9003               if (val[0] & (HOST_WIDE_INT_1 << (bitpos - 1)))
9004                 {
9005                   val[0] |= HOST_WIDE_INT_M1U << bitpos;
9006                   val[1] = -1;
9007                 }
9008             }
9009           else if (bitpos == HOST_BITS_PER_WIDE_INT)
9010             {
9011               if (val[0] < 0)
9012                 val[1] = -1;
9013             }
9014           else if (val[1] & (HOST_WIDE_INT_1
9015                              << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
9016             val[1] |= HOST_WIDE_INT_M1U << (bitpos - HOST_BITS_PER_WIDE_INT);
9017         }
9018
9019       value = wide_int_to_tree (type,
9020                                 wide_int::from_array (val, 2,
9021                                                       HOST_BITS_PER_WIDE_INT * 2));
9022       add_pending_init (input_location, purpose, value, NULL_TREE, true,
9023                         braced_init_obstack);
9024     }
9025
9026   constructor_incremental = 0;
9027 }
9028
9029 /* Return value of FIELD in pending initializer or NULL_TREE if the field was
9030    not initialized yet.  */
9031
9032 static tree
9033 find_init_member (tree field, struct obstack * braced_init_obstack)
9034 {
9035   struct init_node *p;
9036
9037   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
9038     {
9039       if (constructor_incremental
9040           && tree_int_cst_lt (field, constructor_unfilled_index))
9041         set_nonincremental_init (braced_init_obstack);
9042
9043       p = constructor_pending_elts;
9044       while (p)
9045         {
9046           if (tree_int_cst_lt (field, p->purpose))
9047             p = p->left;
9048           else if (tree_int_cst_lt (p->purpose, field))
9049             p = p->right;
9050           else
9051             return p->value;
9052         }
9053     }
9054   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
9055     {
9056       tree bitpos = bit_position (field);
9057
9058       if (constructor_incremental
9059           && (!constructor_unfilled_fields
9060               || tree_int_cst_lt (bitpos,
9061                                   bit_position (constructor_unfilled_fields))))
9062         set_nonincremental_init (braced_init_obstack);
9063
9064       p = constructor_pending_elts;
9065       while (p)
9066         {
9067           if (field == p->purpose)
9068             return p->value;
9069           else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
9070             p = p->left;
9071           else
9072             p = p->right;
9073         }
9074     }
9075   else if (TREE_CODE (constructor_type) == UNION_TYPE)
9076     {
9077       if (!vec_safe_is_empty (constructor_elements)
9078           && (constructor_elements->last ().index == field))
9079         return constructor_elements->last ().value;
9080     }
9081   return NULL_TREE;
9082 }
9083
9084 /* "Output" the next constructor element.
9085    At top level, really output it to assembler code now.
9086    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
9087    If ORIGTYPE is not NULL_TREE, it is the original type of VALUE.
9088    TYPE is the data type that the containing data type wants here.
9089    FIELD is the field (a FIELD_DECL) or the index that this element fills.
9090    If VALUE is a string constant, STRICT_STRING is true if it is
9091    unparenthesized or we should not warn here for it being parenthesized.
9092    For other types of VALUE, STRICT_STRING is not used.
9093
9094    PENDING if true means output pending elements that belong
9095    right after this element.  (PENDING is normally true;
9096    it is false while outputting pending elements, to avoid recursion.)
9097
9098    IMPLICIT is true if value comes from pop_init_level (1),
9099    the new initializer has been merged with the existing one
9100    and thus no warnings should be emitted about overriding an
9101    existing initializer.  */
9102
9103 static void
9104 output_init_element (location_t loc, tree value, tree origtype,
9105                      bool strict_string, tree type, tree field, bool pending,
9106                      bool implicit, struct obstack * braced_init_obstack)
9107 {
9108   tree semantic_type = NULL_TREE;
9109   bool maybe_const = true;
9110   bool npc;
9111
9112   if (type == error_mark_node || value == error_mark_node)
9113     {
9114       constructor_erroneous = 1;
9115       return;
9116     }
9117   if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
9118       && (TREE_CODE (value) == STRING_CST
9119           || TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
9120       && !(TREE_CODE (value) == STRING_CST
9121            && TREE_CODE (type) == ARRAY_TYPE
9122            && INTEGRAL_TYPE_P (TREE_TYPE (type)))
9123       && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
9124                      TYPE_MAIN_VARIANT (type)))
9125     value = array_to_pointer_conversion (input_location, value);
9126
9127   if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
9128       && require_constant_value && pending)
9129     {
9130       /* As an extension, allow initializing objects with static storage
9131          duration with compound literals (which are then treated just as
9132          the brace enclosed list they contain).  */
9133       if (flag_isoc99)
9134         pedwarn_init (loc, OPT_Wpedantic, "initializer element is not "
9135                       "constant");
9136       tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
9137       value = DECL_INITIAL (decl);
9138     }
9139
9140   npc = null_pointer_constant_p (value);
9141   if (TREE_CODE (value) == EXCESS_PRECISION_EXPR)
9142     {
9143       semantic_type = TREE_TYPE (value);
9144       value = TREE_OPERAND (value, 0);
9145     }
9146   value = c_fully_fold (value, require_constant_value, &maybe_const);
9147
9148   if (value == error_mark_node)
9149     constructor_erroneous = 1;
9150   else if (!TREE_CONSTANT (value))
9151     constructor_constant = 0;
9152   else if (!initializer_constant_valid_p (value,
9153                                           TREE_TYPE (value),
9154                                           AGGREGATE_TYPE_P (constructor_type)
9155                                           && TYPE_REVERSE_STORAGE_ORDER
9156                                              (constructor_type))
9157            || (RECORD_OR_UNION_TYPE_P (constructor_type)
9158                && DECL_C_BIT_FIELD (field)
9159                && TREE_CODE (value) != INTEGER_CST))
9160     constructor_simple = 0;
9161   if (!maybe_const)
9162     constructor_nonconst = 1;
9163
9164   /* Digest the initializer and issue any errors about incompatible
9165      types before issuing errors about non-constant initializers.  */
9166   tree new_value = value;
9167   if (semantic_type)
9168     new_value = build1 (EXCESS_PRECISION_EXPR, semantic_type, value);
9169   new_value = digest_init (loc, type, new_value, origtype, npc, strict_string,
9170                            require_constant_value);
9171   if (new_value == error_mark_node)
9172     {
9173       constructor_erroneous = 1;
9174       return;
9175     }
9176   if (require_constant_value || require_constant_elements)
9177     constant_expression_warning (new_value);
9178
9179   /* Proceed to check the constness of the original initializer.  */
9180   if (!initializer_constant_valid_p (value, TREE_TYPE (value)))
9181     {
9182       if (require_constant_value)
9183         {
9184           error_init (loc, "initializer element is not constant");
9185           value = error_mark_node;
9186         }
9187       else if (require_constant_elements)
9188         pedwarn (loc, OPT_Wpedantic,
9189                  "initializer element is not computable at load time");
9190     }
9191   else if (!maybe_const
9192            && (require_constant_value || require_constant_elements))
9193     pedwarn_init (loc, OPT_Wpedantic,
9194                   "initializer element is not a constant expression");
9195
9196   /* Issue -Wc++-compat warnings about initializing a bitfield with
9197      enum type.  */
9198   if (warn_cxx_compat
9199       && field != NULL_TREE
9200       && TREE_CODE (field) == FIELD_DECL
9201       && DECL_BIT_FIELD_TYPE (field) != NULL_TREE
9202       && (TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field))
9203           != TYPE_MAIN_VARIANT (type))
9204       && TREE_CODE (DECL_BIT_FIELD_TYPE (field)) == ENUMERAL_TYPE)
9205     {
9206       tree checktype = origtype != NULL_TREE ? origtype : TREE_TYPE (value);
9207       if (checktype != error_mark_node
9208           && (TYPE_MAIN_VARIANT (checktype)
9209               != TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field))))
9210         warning_init (loc, OPT_Wc___compat,
9211                       "enum conversion in initialization is invalid in C++");
9212     }
9213
9214   /* If this field is empty (and not at the end of structure),
9215      don't do anything other than checking the initializer.  */
9216   if (field
9217       && (TREE_TYPE (field) == error_mark_node
9218           || (COMPLETE_TYPE_P (TREE_TYPE (field))
9219               && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
9220               && (TREE_CODE (constructor_type) == ARRAY_TYPE
9221                   || DECL_CHAIN (field)))))
9222     return;
9223
9224   /* Finally, set VALUE to the initializer value digested above.  */
9225   value = new_value;
9226
9227   /* If this element doesn't come next in sequence,
9228      put it on constructor_pending_elts.  */
9229   if (TREE_CODE (constructor_type) == ARRAY_TYPE
9230       && (!constructor_incremental
9231           || !tree_int_cst_equal (field, constructor_unfilled_index)))
9232     {
9233       if (constructor_incremental
9234           && tree_int_cst_lt (field, constructor_unfilled_index))
9235         set_nonincremental_init (braced_init_obstack);
9236
9237       add_pending_init (loc, field, value, origtype, implicit,
9238                         braced_init_obstack);
9239       return;
9240     }
9241   else if (TREE_CODE (constructor_type) == RECORD_TYPE
9242            && (!constructor_incremental
9243                || field != constructor_unfilled_fields))
9244     {
9245       /* We do this for records but not for unions.  In a union,
9246          no matter which field is specified, it can be initialized
9247          right away since it starts at the beginning of the union.  */
9248       if (constructor_incremental)
9249         {
9250           if (!constructor_unfilled_fields)
9251             set_nonincremental_init (braced_init_obstack);
9252           else
9253             {
9254               tree bitpos, unfillpos;
9255
9256               bitpos = bit_position (field);
9257               unfillpos = bit_position (constructor_unfilled_fields);
9258
9259               if (tree_int_cst_lt (bitpos, unfillpos))
9260                 set_nonincremental_init (braced_init_obstack);
9261             }
9262         }
9263
9264       add_pending_init (loc, field, value, origtype, implicit,
9265                         braced_init_obstack);
9266       return;
9267     }
9268   else if (TREE_CODE (constructor_type) == UNION_TYPE
9269            && !vec_safe_is_empty (constructor_elements))
9270     {
9271       if (!implicit)
9272         {
9273           if (TREE_SIDE_EFFECTS (constructor_elements->last ().value))
9274             warning_init (loc, OPT_Woverride_init_side_effects,
9275                           "initialized field with side-effects overwritten");
9276           else if (warn_override_init)
9277             warning_init (loc, OPT_Woverride_init,
9278                           "initialized field overwritten");
9279         }
9280
9281       /* We can have just one union field set.  */
9282       constructor_elements = NULL;
9283     }
9284
9285   /* Otherwise, output this element either to
9286      constructor_elements or to the assembler file.  */
9287
9288   constructor_elt celt = {field, value};
9289   vec_safe_push (constructor_elements, celt);
9290
9291   /* Advance the variable that indicates sequential elements output.  */
9292   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
9293     constructor_unfilled_index
9294       = size_binop_loc (input_location, PLUS_EXPR, constructor_unfilled_index,
9295                         bitsize_one_node);
9296   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
9297     {
9298       constructor_unfilled_fields
9299         = DECL_CHAIN (constructor_unfilled_fields);
9300
9301       /* Skip any nameless bit fields.  */
9302       while (constructor_unfilled_fields != NULL_TREE
9303              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
9304              && DECL_NAME (constructor_unfilled_fields) == NULL_TREE)
9305         constructor_unfilled_fields =
9306           DECL_CHAIN (constructor_unfilled_fields);
9307     }
9308   else if (TREE_CODE (constructor_type) == UNION_TYPE)
9309     constructor_unfilled_fields = NULL_TREE;
9310
9311   /* Now output any pending elements which have become next.  */
9312   if (pending)
9313     output_pending_init_elements (0, braced_init_obstack);
9314 }
9315
9316 /* Output any pending elements which have become next.
9317    As we output elements, constructor_unfilled_{fields,index}
9318    advances, which may cause other elements to become next;
9319    if so, they too are output.
9320
9321    If ALL is 0, we return when there are
9322    no more pending elements to output now.
9323
9324    If ALL is 1, we output space as necessary so that
9325    we can output all the pending elements.  */
9326 static void
9327 output_pending_init_elements (int all, struct obstack * braced_init_obstack)
9328 {
9329   struct init_node *elt = constructor_pending_elts;
9330   tree next;
9331
9332  retry:
9333
9334   /* Look through the whole pending tree.
9335      If we find an element that should be output now,
9336      output it.  Otherwise, set NEXT to the element
9337      that comes first among those still pending.  */
9338
9339   next = NULL_TREE;
9340   while (elt)
9341     {
9342       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
9343         {
9344           if (tree_int_cst_equal (elt->purpose,
9345                                   constructor_unfilled_index))
9346             output_init_element (input_location, elt->value, elt->origtype,
9347                                  true, TREE_TYPE (constructor_type),
9348                                  constructor_unfilled_index, false, false,
9349                                  braced_init_obstack);
9350           else if (tree_int_cst_lt (constructor_unfilled_index,
9351                                     elt->purpose))
9352             {
9353               /* Advance to the next smaller node.  */
9354               if (elt->left)
9355                 elt = elt->left;
9356               else
9357                 {
9358                   /* We have reached the smallest node bigger than the
9359                      current unfilled index.  Fill the space first.  */
9360                   next = elt->purpose;
9361                   break;
9362                 }
9363             }
9364           else
9365             {
9366               /* Advance to the next bigger node.  */
9367               if (elt->right)
9368                 elt = elt->right;
9369               else
9370                 {
9371                   /* We have reached the biggest node in a subtree.  Find
9372                      the parent of it, which is the next bigger node.  */
9373                   while (elt->parent && elt->parent->right == elt)
9374                     elt = elt->parent;
9375                   elt = elt->parent;
9376                   if (elt && tree_int_cst_lt (constructor_unfilled_index,
9377                                               elt->purpose))
9378                     {
9379                       next = elt->purpose;
9380                       break;
9381                     }
9382                 }
9383             }
9384         }
9385       else if (RECORD_OR_UNION_TYPE_P (constructor_type))
9386         {
9387           tree ctor_unfilled_bitpos, elt_bitpos;
9388
9389           /* If the current record is complete we are done.  */
9390           if (constructor_unfilled_fields == NULL_TREE)
9391             break;
9392
9393           ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
9394           elt_bitpos = bit_position (elt->purpose);
9395           /* We can't compare fields here because there might be empty
9396              fields in between.  */
9397           if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
9398             {
9399               constructor_unfilled_fields = elt->purpose;
9400               output_init_element (input_location, elt->value, elt->origtype,
9401                                    true, TREE_TYPE (elt->purpose),
9402                                    elt->purpose, false, false,
9403                                    braced_init_obstack);
9404             }
9405           else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
9406             {
9407               /* Advance to the next smaller node.  */
9408               if (elt->left)
9409                 elt = elt->left;
9410               else
9411                 {
9412                   /* We have reached the smallest node bigger than the
9413                      current unfilled field.  Fill the space first.  */
9414                   next = elt->purpose;
9415                   break;
9416                 }
9417             }
9418           else
9419             {
9420               /* Advance to the next bigger node.  */
9421               if (elt->right)
9422                 elt = elt->right;
9423               else
9424                 {
9425                   /* We have reached the biggest node in a subtree.  Find
9426                      the parent of it, which is the next bigger node.  */
9427                   while (elt->parent && elt->parent->right == elt)
9428                     elt = elt->parent;
9429                   elt = elt->parent;
9430                   if (elt
9431                       && (tree_int_cst_lt (ctor_unfilled_bitpos,
9432                                            bit_position (elt->purpose))))
9433                     {
9434                       next = elt->purpose;
9435                       break;
9436                     }
9437                 }
9438             }
9439         }
9440     }
9441
9442   /* Ordinarily return, but not if we want to output all
9443      and there are elements left.  */
9444   if (!(all && next != NULL_TREE))
9445     return;
9446
9447   /* If it's not incremental, just skip over the gap, so that after
9448      jumping to retry we will output the next successive element.  */
9449   if (RECORD_OR_UNION_TYPE_P (constructor_type))
9450     constructor_unfilled_fields = next;
9451   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
9452     constructor_unfilled_index = next;
9453
9454   /* ELT now points to the node in the pending tree with the next
9455      initializer to output.  */
9456   goto retry;
9457 }
9458 \f
9459 /* Add one non-braced element to the current constructor level.
9460    This adjusts the current position within the constructor's type.
9461    This may also start or terminate implicit levels
9462    to handle a partly-braced initializer.
9463
9464    Once this has found the correct level for the new element,
9465    it calls output_init_element.
9466
9467    IMPLICIT is true if value comes from pop_init_level (1),
9468    the new initializer has been merged with the existing one
9469    and thus no warnings should be emitted about overriding an
9470    existing initializer.  */
9471
9472 void
9473 process_init_element (location_t loc, struct c_expr value, bool implicit,
9474                       struct obstack * braced_init_obstack)
9475 {
9476   tree orig_value = value.value;
9477   int string_flag
9478     = (orig_value != NULL_TREE && TREE_CODE (orig_value) == STRING_CST);
9479   bool strict_string = value.original_code == STRING_CST;
9480   bool was_designated = designator_depth != 0;
9481
9482   designator_depth = 0;
9483   designator_erroneous = 0;
9484
9485   if (!implicit && value.value && !integer_zerop (value.value))
9486     constructor_zeroinit = 0;
9487
9488   /* Handle superfluous braces around string cst as in
9489      char x[] = {"foo"}; */
9490   if (string_flag
9491       && constructor_type
9492       && !was_designated
9493       && TREE_CODE (constructor_type) == ARRAY_TYPE
9494       && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type))
9495       && integer_zerop (constructor_unfilled_index))
9496     {
9497       if (constructor_stack->replacement_value.value)
9498         error_init (loc, "excess elements in char array initializer");
9499       constructor_stack->replacement_value = value;
9500       return;
9501     }
9502
9503   if (constructor_stack->replacement_value.value != NULL_TREE)
9504     {
9505       error_init (loc, "excess elements in struct initializer");
9506       return;
9507     }
9508
9509   /* Ignore elements of a brace group if it is entirely superfluous
9510      and has already been diagnosed.  */
9511   if (constructor_type == NULL_TREE)
9512     return;
9513
9514   if (!implicit && warn_designated_init && !was_designated
9515       && TREE_CODE (constructor_type) == RECORD_TYPE
9516       && lookup_attribute ("designated_init",
9517                            TYPE_ATTRIBUTES (constructor_type)))
9518     warning_init (loc,
9519                   OPT_Wdesignated_init,
9520                   "positional initialization of field "
9521                   "in %<struct%> declared with %<designated_init%> attribute");
9522
9523   /* If we've exhausted any levels that didn't have braces,
9524      pop them now.  */
9525   while (constructor_stack->implicit)
9526     {
9527       if (RECORD_OR_UNION_TYPE_P (constructor_type)
9528           && constructor_fields == NULL_TREE)
9529         process_init_element (loc,
9530                               pop_init_level (loc, 1, braced_init_obstack,
9531                                               last_init_list_comma),
9532                               true, braced_init_obstack);
9533       else if ((TREE_CODE (constructor_type) == ARRAY_TYPE
9534                 || VECTOR_TYPE_P (constructor_type))
9535                && constructor_max_index
9536                && tree_int_cst_lt (constructor_max_index,
9537                                    constructor_index))
9538         process_init_element (loc,
9539                               pop_init_level (loc, 1, braced_init_obstack,
9540                                               last_init_list_comma),
9541                               true, braced_init_obstack);
9542       else
9543         break;
9544     }
9545
9546   /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once.  */
9547   if (constructor_range_stack)
9548     {
9549       /* If value is a compound literal and we'll be just using its
9550          content, don't put it into a SAVE_EXPR.  */
9551       if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR
9552           || !require_constant_value)
9553         {
9554           tree semantic_type = NULL_TREE;
9555           if (TREE_CODE (value.value) == EXCESS_PRECISION_EXPR)
9556             {
9557               semantic_type = TREE_TYPE (value.value);
9558               value.value = TREE_OPERAND (value.value, 0);
9559             }
9560           value.value = save_expr (value.value);
9561           if (semantic_type)
9562             value.value = build1 (EXCESS_PRECISION_EXPR, semantic_type,
9563                                   value.value);
9564         }
9565     }
9566
9567   while (1)
9568     {
9569       if (TREE_CODE (constructor_type) == RECORD_TYPE)
9570         {
9571           tree fieldtype;
9572           enum tree_code fieldcode;
9573
9574           if (constructor_fields == NULL_TREE)
9575             {
9576               pedwarn_init (loc, 0, "excess elements in struct initializer");
9577               break;
9578             }
9579
9580           fieldtype = TREE_TYPE (constructor_fields);
9581           if (fieldtype != error_mark_node)
9582             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
9583           fieldcode = TREE_CODE (fieldtype);
9584
9585           /* Error for non-static initialization of a flexible array member.  */
9586           if (fieldcode == ARRAY_TYPE
9587               && !require_constant_value
9588               && TYPE_SIZE (fieldtype) == NULL_TREE
9589               && DECL_CHAIN (constructor_fields) == NULL_TREE)
9590             {
9591               error_init (loc, "non-static initialization of a flexible "
9592                           "array member");
9593               break;
9594             }
9595
9596           /* Error for initialization of a flexible array member with
9597              a string constant if the structure is in an array.  E.g.:
9598              struct S { int x; char y[]; };
9599              struct S s[] = { { 1, "foo" } };
9600              is invalid.  */
9601           if (string_flag
9602               && fieldcode == ARRAY_TYPE
9603               && constructor_depth > 1
9604               && TYPE_SIZE (fieldtype) == NULL_TREE
9605               && DECL_CHAIN (constructor_fields) == NULL_TREE)
9606             {
9607               bool in_array_p = false;
9608               for (struct constructor_stack *p = constructor_stack;
9609                    p && p->type; p = p->next)
9610                 if (TREE_CODE (p->type) == ARRAY_TYPE)
9611                   {
9612                     in_array_p = true;
9613                     break;
9614                   }
9615               if (in_array_p)
9616                 {
9617                   error_init (loc, "initialization of flexible array "
9618                               "member in a nested context");
9619                   break;
9620                 }
9621             }
9622
9623           /* Accept a string constant to initialize a subarray.  */
9624           if (value.value != NULL_TREE
9625               && fieldcode == ARRAY_TYPE
9626               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
9627               && string_flag)
9628             value.value = orig_value;
9629           /* Otherwise, if we have come to a subaggregate,
9630              and we don't have an element of its type, push into it.  */
9631           else if (value.value != NULL_TREE
9632                    && value.value != error_mark_node
9633                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
9634                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
9635                        || fieldcode == UNION_TYPE || fieldcode == VECTOR_TYPE))
9636             {
9637               push_init_level (loc, 1, braced_init_obstack);
9638               continue;
9639             }
9640
9641           if (value.value)
9642             {
9643               push_member_name (constructor_fields);
9644               output_init_element (loc, value.value, value.original_type,
9645                                    strict_string, fieldtype,
9646                                    constructor_fields, true, implicit,
9647                                    braced_init_obstack);
9648               RESTORE_SPELLING_DEPTH (constructor_depth);
9649             }
9650           else
9651             /* Do the bookkeeping for an element that was
9652                directly output as a constructor.  */
9653             {
9654               /* For a record, keep track of end position of last field.  */
9655               if (DECL_SIZE (constructor_fields))
9656                 constructor_bit_index
9657                   = size_binop_loc (input_location, PLUS_EXPR,
9658                                     bit_position (constructor_fields),
9659                                     DECL_SIZE (constructor_fields));
9660
9661               /* If the current field was the first one not yet written out,
9662                  it isn't now, so update.  */
9663               if (constructor_unfilled_fields == constructor_fields)
9664                 {
9665                   constructor_unfilled_fields = DECL_CHAIN (constructor_fields);
9666                   /* Skip any nameless bit fields.  */
9667                   while (constructor_unfilled_fields != 0
9668                          && DECL_C_BIT_FIELD (constructor_unfilled_fields)
9669                          && DECL_NAME (constructor_unfilled_fields) == 0)
9670                     constructor_unfilled_fields =
9671                       DECL_CHAIN (constructor_unfilled_fields);
9672                 }
9673             }
9674
9675           constructor_fields = DECL_CHAIN (constructor_fields);
9676           /* Skip any nameless bit fields at the beginning.  */
9677           while (constructor_fields != NULL_TREE
9678                  && DECL_C_BIT_FIELD (constructor_fields)
9679                  && DECL_NAME (constructor_fields) == NULL_TREE)
9680             constructor_fields = DECL_CHAIN (constructor_fields);
9681         }
9682       else if (TREE_CODE (constructor_type) == UNION_TYPE)
9683         {
9684           tree fieldtype;
9685           enum tree_code fieldcode;
9686
9687           if (constructor_fields == NULL_TREE)
9688             {
9689               pedwarn_init (loc, 0,
9690                             "excess elements in union initializer");
9691               break;
9692             }
9693
9694           fieldtype = TREE_TYPE (constructor_fields);
9695           if (fieldtype != error_mark_node)
9696             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
9697           fieldcode = TREE_CODE (fieldtype);
9698
9699           /* Warn that traditional C rejects initialization of unions.
9700              We skip the warning if the value is zero.  This is done
9701              under the assumption that the zero initializer in user
9702              code appears conditioned on e.g. __STDC__ to avoid
9703              "missing initializer" warnings and relies on default
9704              initialization to zero in the traditional C case.
9705              We also skip the warning if the initializer is designated,
9706              again on the assumption that this must be conditional on
9707              __STDC__ anyway (and we've already complained about the
9708              member-designator already).  */
9709           if (!in_system_header_at (input_location) && !constructor_designated
9710               && !(value.value && (integer_zerop (value.value)
9711                                    || real_zerop (value.value))))
9712             warning (OPT_Wtraditional, "traditional C rejects initialization "
9713                      "of unions");
9714
9715           /* Accept a string constant to initialize a subarray.  */
9716           if (value.value != NULL_TREE
9717               && fieldcode == ARRAY_TYPE
9718               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
9719               && string_flag)
9720             value.value = orig_value;
9721           /* Otherwise, if we have come to a subaggregate,
9722              and we don't have an element of its type, push into it.  */
9723           else if (value.value != NULL_TREE
9724                    && value.value != error_mark_node
9725                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
9726                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
9727                        || fieldcode == UNION_TYPE || fieldcode == VECTOR_TYPE))
9728             {
9729               push_init_level (loc, 1, braced_init_obstack);
9730               continue;
9731             }
9732
9733           if (value.value)
9734             {
9735               push_member_name (constructor_fields);
9736               output_init_element (loc, value.value, value.original_type,
9737                                    strict_string, fieldtype,
9738                                    constructor_fields, true, implicit,
9739                                    braced_init_obstack);
9740               RESTORE_SPELLING_DEPTH (constructor_depth);
9741             }
9742           else
9743             /* Do the bookkeeping for an element that was
9744                directly output as a constructor.  */
9745             {
9746               constructor_bit_index = DECL_SIZE (constructor_fields);
9747               constructor_unfilled_fields = DECL_CHAIN (constructor_fields);
9748             }
9749
9750           constructor_fields = NULL_TREE;
9751         }
9752       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
9753         {
9754           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
9755           enum tree_code eltcode = TREE_CODE (elttype);
9756
9757           /* Accept a string constant to initialize a subarray.  */
9758           if (value.value != NULL_TREE
9759               && eltcode == ARRAY_TYPE
9760               && INTEGRAL_TYPE_P (TREE_TYPE (elttype))
9761               && string_flag)
9762             value.value = orig_value;
9763           /* Otherwise, if we have come to a subaggregate,
9764              and we don't have an element of its type, push into it.  */
9765           else if (value.value != NULL_TREE
9766                    && value.value != error_mark_node
9767                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype
9768                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
9769                        || eltcode == UNION_TYPE || eltcode == VECTOR_TYPE))
9770             {
9771               push_init_level (loc, 1, braced_init_obstack);
9772               continue;
9773             }
9774
9775           if (constructor_max_index != NULL_TREE
9776               && (tree_int_cst_lt (constructor_max_index, constructor_index)
9777                   || integer_all_onesp (constructor_max_index)))
9778             {
9779               pedwarn_init (loc, 0,
9780                             "excess elements in array initializer");
9781               break;
9782             }
9783
9784           /* Now output the actual element.  */
9785           if (value.value)
9786             {
9787               push_array_bounds (tree_to_uhwi (constructor_index));
9788               output_init_element (loc, value.value, value.original_type,
9789                                    strict_string, elttype,
9790                                    constructor_index, true, implicit,
9791                                    braced_init_obstack);
9792               RESTORE_SPELLING_DEPTH (constructor_depth);
9793             }
9794
9795           constructor_index
9796             = size_binop_loc (input_location, PLUS_EXPR,
9797                               constructor_index, bitsize_one_node);
9798
9799           if (!value.value)
9800             /* If we are doing the bookkeeping for an element that was
9801                directly output as a constructor, we must update
9802                constructor_unfilled_index.  */
9803             constructor_unfilled_index = constructor_index;
9804         }
9805       else if (VECTOR_TYPE_P (constructor_type))
9806         {
9807           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
9808
9809          /* Do a basic check of initializer size.  Note that vectors
9810             always have a fixed size derived from their type.  */
9811           if (tree_int_cst_lt (constructor_max_index, constructor_index))
9812             {
9813               pedwarn_init (loc, 0,
9814                             "excess elements in vector initializer");
9815               break;
9816             }
9817
9818           /* Now output the actual element.  */
9819           if (value.value)
9820             {
9821               if (TREE_CODE (value.value) == VECTOR_CST)
9822                 elttype = TYPE_MAIN_VARIANT (constructor_type);
9823               output_init_element (loc, value.value, value.original_type,
9824                                    strict_string, elttype,
9825                                    constructor_index, true, implicit,
9826                                    braced_init_obstack);
9827             }
9828
9829           constructor_index
9830             = size_binop_loc (input_location,
9831                               PLUS_EXPR, constructor_index, bitsize_one_node);
9832
9833           if (!value.value)
9834             /* If we are doing the bookkeeping for an element that was
9835                directly output as a constructor, we must update
9836                constructor_unfilled_index.  */
9837             constructor_unfilled_index = constructor_index;
9838         }
9839
9840       /* Handle the sole element allowed in a braced initializer
9841          for a scalar variable.  */
9842       else if (constructor_type != error_mark_node
9843                && constructor_fields == NULL_TREE)
9844         {
9845           pedwarn_init (loc, 0,
9846                         "excess elements in scalar initializer");
9847           break;
9848         }
9849       else
9850         {
9851           if (value.value)
9852             output_init_element (loc, value.value, value.original_type,
9853                                  strict_string, constructor_type,
9854                                  NULL_TREE, true, implicit,
9855                                  braced_init_obstack);
9856           constructor_fields = NULL_TREE;
9857         }
9858
9859       /* Handle range initializers either at this level or anywhere higher
9860          in the designator stack.  */
9861       if (constructor_range_stack)
9862         {
9863           struct constructor_range_stack *p, *range_stack;
9864           int finish = 0;
9865
9866           range_stack = constructor_range_stack;
9867           constructor_range_stack = 0;
9868           while (constructor_stack != range_stack->stack)
9869             {
9870               gcc_assert (constructor_stack->implicit);
9871               process_init_element (loc,
9872                                     pop_init_level (loc, 1,
9873                                                     braced_init_obstack,
9874                                                     last_init_list_comma),
9875                                     true, braced_init_obstack);
9876             }
9877           for (p = range_stack;
9878                !p->range_end || tree_int_cst_equal (p->index, p->range_end);
9879                p = p->prev)
9880             {
9881               gcc_assert (constructor_stack->implicit);
9882               process_init_element (loc,
9883                                     pop_init_level (loc, 1,
9884                                                     braced_init_obstack,
9885                                                     last_init_list_comma),
9886                                     true, braced_init_obstack);
9887             }
9888
9889           p->index = size_binop_loc (input_location,
9890                                      PLUS_EXPR, p->index, bitsize_one_node);
9891           if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
9892             finish = 1;
9893
9894           while (1)
9895             {
9896               constructor_index = p->index;
9897               constructor_fields = p->fields;
9898               if (finish && p->range_end && p->index == p->range_start)
9899                 {
9900                   finish = 0;
9901                   p->prev = 0;
9902                 }
9903               p = p->next;
9904               if (!p)
9905                 break;
9906               finish_implicit_inits (loc, braced_init_obstack);
9907               push_init_level (loc, 2, braced_init_obstack);
9908               p->stack = constructor_stack;
9909               if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
9910                 p->index = p->range_start;
9911             }
9912
9913           if (!finish)
9914             constructor_range_stack = range_stack;
9915           continue;
9916         }
9917
9918       break;
9919     }
9920
9921   constructor_range_stack = 0;
9922 }
9923 \f
9924 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
9925    (guaranteed to be 'volatile' or null) and ARGS (represented using
9926    an ASM_EXPR node).  */
9927 tree
9928 build_asm_stmt (tree cv_qualifier, tree args)
9929 {
9930   if (!ASM_VOLATILE_P (args) && cv_qualifier)
9931     ASM_VOLATILE_P (args) = 1;
9932   return add_stmt (args);
9933 }
9934
9935 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
9936    some INPUTS, and some CLOBBERS.  The latter three may be NULL.
9937    SIMPLE indicates whether there was anything at all after the
9938    string in the asm expression -- asm("blah") and asm("blah" : )
9939    are subtly different.  We use a ASM_EXPR node to represent this.  */
9940 tree
9941 build_asm_expr (location_t loc, tree string, tree outputs, tree inputs,
9942                 tree clobbers, tree labels, bool simple)
9943 {
9944   tree tail;
9945   tree args;
9946   int i;
9947   const char *constraint;
9948   const char **oconstraints;
9949   bool allows_mem, allows_reg, is_inout;
9950   int ninputs, noutputs;
9951
9952   ninputs = list_length (inputs);
9953   noutputs = list_length (outputs);
9954   oconstraints = (const char **) alloca (noutputs * sizeof (const char *));
9955
9956   string = resolve_asm_operand_names (string, outputs, inputs, labels);
9957
9958   /* Remove output conversions that change the type but not the mode.  */
9959   for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail))
9960     {
9961       tree output = TREE_VALUE (tail);
9962
9963       output = c_fully_fold (output, false, NULL, true);
9964
9965       /* ??? Really, this should not be here.  Users should be using a
9966          proper lvalue, dammit.  But there's a long history of using casts
9967          in the output operands.  In cases like longlong.h, this becomes a
9968          primitive form of typechecking -- if the cast can be removed, then
9969          the output operand had a type of the proper width; otherwise we'll
9970          get an error.  Gross, but ...  */
9971       STRIP_NOPS (output);
9972
9973       if (!lvalue_or_else (loc, output, lv_asm))
9974         output = error_mark_node;
9975
9976       if (output != error_mark_node
9977           && (TREE_READONLY (output)
9978               || TYPE_READONLY (TREE_TYPE (output))
9979               || (RECORD_OR_UNION_TYPE_P (TREE_TYPE (output))
9980                   && C_TYPE_FIELDS_READONLY (TREE_TYPE (output)))))
9981         readonly_error (loc, output, lv_asm);
9982
9983       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
9984       oconstraints[i] = constraint;
9985
9986       if (parse_output_constraint (&constraint, i, ninputs, noutputs,
9987                                    &allows_mem, &allows_reg, &is_inout))
9988         {
9989           /* If the operand is going to end up in memory,
9990              mark it addressable.  */
9991           if (!allows_reg && !c_mark_addressable (output))
9992             output = error_mark_node;
9993           if (!(!allows_reg && allows_mem)
9994               && output != error_mark_node
9995               && VOID_TYPE_P (TREE_TYPE (output)))
9996             {
9997               error_at (loc, "invalid use of void expression");
9998               output = error_mark_node;
9999             }
10000         }
10001       else
10002         output = error_mark_node;
10003
10004       TREE_VALUE (tail) = output;
10005     }
10006
10007   for (i = 0, tail = inputs; tail; ++i, tail = TREE_CHAIN (tail))
10008     {
10009       tree input;
10010
10011       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
10012       input = TREE_VALUE (tail);
10013
10014       if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
10015                                   oconstraints, &allows_mem, &allows_reg))
10016         {
10017           /* If the operand is going to end up in memory,
10018              mark it addressable.  */
10019           if (!allows_reg && allows_mem)
10020             {
10021               input = c_fully_fold (input, false, NULL, true);
10022
10023               /* Strip the nops as we allow this case.  FIXME, this really
10024                  should be rejected or made deprecated.  */
10025               STRIP_NOPS (input);
10026               if (!c_mark_addressable (input))
10027                 input = error_mark_node;
10028             }
10029           else
10030             {
10031               struct c_expr expr;
10032               memset (&expr, 0, sizeof (expr));
10033               expr.value = input;
10034               expr = convert_lvalue_to_rvalue (loc, expr, true, false);
10035               input = c_fully_fold (expr.value, false, NULL);
10036
10037               if (input != error_mark_node && VOID_TYPE_P (TREE_TYPE (input)))
10038                 {
10039                   error_at (loc, "invalid use of void expression");
10040                   input = error_mark_node;
10041                 }
10042             }
10043         }
10044       else
10045         input = error_mark_node;
10046
10047       TREE_VALUE (tail) = input;
10048     }
10049
10050   /* ASMs with labels cannot have outputs.  This should have been
10051      enforced by the parser.  */
10052   gcc_assert (outputs == NULL || labels == NULL);
10053
10054   args = build_stmt (loc, ASM_EXPR, string, outputs, inputs, clobbers, labels);
10055
10056   /* asm statements without outputs, including simple ones, are treated
10057      as volatile.  */
10058   ASM_INPUT_P (args) = simple;
10059   ASM_VOLATILE_P (args) = (noutputs == 0);
10060
10061   return args;
10062 }
10063 \f
10064 /* Generate a goto statement to LABEL.  LOC is the location of the
10065    GOTO.  */
10066
10067 tree
10068 c_finish_goto_label (location_t loc, tree label)
10069 {
10070   tree decl = lookup_label_for_goto (loc, label);
10071   if (!decl)
10072     return NULL_TREE;
10073   TREE_USED (decl) = 1;
10074   {
10075     add_stmt (build_predict_expr (PRED_GOTO, NOT_TAKEN));
10076     tree t = build1 (GOTO_EXPR, void_type_node, decl);
10077     SET_EXPR_LOCATION (t, loc);
10078     return add_stmt (t);
10079   }
10080 }
10081
10082 /* Generate a computed goto statement to EXPR.  LOC is the location of
10083    the GOTO.  */
10084
10085 tree
10086 c_finish_goto_ptr (location_t loc, tree expr)
10087 {
10088   tree t;
10089   pedwarn (loc, OPT_Wpedantic, "ISO C forbids %<goto *expr;%>");
10090   expr = c_fully_fold (expr, false, NULL);
10091   expr = convert (ptr_type_node, expr);
10092   t = build1 (GOTO_EXPR, void_type_node, expr);
10093   SET_EXPR_LOCATION (t, loc);
10094   return add_stmt (t);
10095 }
10096
10097 /* Generate a C `return' statement.  RETVAL is the expression for what
10098    to return, or a null pointer for `return;' with no value.  LOC is
10099    the location of the return statement, or the location of the expression,
10100    if the statement has any.  If ORIGTYPE is not NULL_TREE, it
10101    is the original type of RETVAL.  */
10102
10103 tree
10104 c_finish_return (location_t loc, tree retval, tree origtype)
10105 {
10106   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)), ret_stmt;
10107   bool no_warning = false;
10108   bool npc = false;
10109
10110   /* Use the expansion point to handle cases such as returning NULL
10111      in a function returning void.  */
10112   source_location xloc = expansion_point_location_if_in_system_header (loc);
10113
10114   if (TREE_THIS_VOLATILE (current_function_decl))
10115     warning_at (xloc, 0,
10116                 "function declared %<noreturn%> has a %<return%> statement");
10117
10118   if (retval)
10119     {
10120       tree semantic_type = NULL_TREE;
10121       npc = null_pointer_constant_p (retval);
10122       if (TREE_CODE (retval) == EXCESS_PRECISION_EXPR)
10123         {
10124           semantic_type = TREE_TYPE (retval);
10125           retval = TREE_OPERAND (retval, 0);
10126         }
10127       retval = c_fully_fold (retval, false, NULL);
10128       if (semantic_type)
10129         retval = build1 (EXCESS_PRECISION_EXPR, semantic_type, retval);
10130     }
10131
10132   if (!retval)
10133     {
10134       current_function_returns_null = 1;
10135       if ((warn_return_type || flag_isoc99)
10136           && valtype != NULL_TREE && TREE_CODE (valtype) != VOID_TYPE)
10137         {
10138           bool warned_here;
10139           if (flag_isoc99)
10140             warned_here = pedwarn
10141               (loc, 0,
10142                "%<return%> with no value, in function returning non-void");
10143           else
10144             warned_here = warning_at
10145               (loc, OPT_Wreturn_type,
10146                "%<return%> with no value, in function returning non-void");
10147           no_warning = true;
10148           if (warned_here)
10149             inform (DECL_SOURCE_LOCATION (current_function_decl),
10150                     "declared here");
10151         }
10152     }
10153   else if (valtype == NULL_TREE || TREE_CODE (valtype) == VOID_TYPE)
10154     {
10155       current_function_returns_null = 1;
10156       bool warned_here;
10157       if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
10158         warned_here = pedwarn
10159           (xloc, 0,
10160            "%<return%> with a value, in function returning void");
10161       else
10162         warned_here = pedwarn
10163           (xloc, OPT_Wpedantic, "ISO C forbids "
10164            "%<return%> with expression, in function returning void");
10165       if (warned_here)
10166         inform (DECL_SOURCE_LOCATION (current_function_decl),
10167                 "declared here");
10168     }
10169   else
10170     {
10171       tree t = convert_for_assignment (loc, UNKNOWN_LOCATION, valtype,
10172                                        retval, origtype, ic_return,
10173                                        npc, NULL_TREE, NULL_TREE, 0);
10174       tree res = DECL_RESULT (current_function_decl);
10175       tree inner;
10176       bool save;
10177
10178       current_function_returns_value = 1;
10179       if (t == error_mark_node)
10180         return NULL_TREE;
10181
10182       save = in_late_binary_op;
10183       if (TREE_CODE (TREE_TYPE (res)) == BOOLEAN_TYPE
10184           || TREE_CODE (TREE_TYPE (res)) == COMPLEX_TYPE
10185           || (TREE_CODE (TREE_TYPE (t)) == REAL_TYPE
10186               && (TREE_CODE (TREE_TYPE (res)) == INTEGER_TYPE
10187                   || TREE_CODE (TREE_TYPE (res)) == ENUMERAL_TYPE)
10188               && sanitize_flags_p (SANITIZE_FLOAT_CAST)))
10189         in_late_binary_op = true;
10190       inner = t = convert (TREE_TYPE (res), t);
10191       in_late_binary_op = save;
10192
10193       /* Strip any conversions, additions, and subtractions, and see if
10194          we are returning the address of a local variable.  Warn if so.  */
10195       while (1)
10196         {
10197           switch (TREE_CODE (inner))
10198             {
10199             CASE_CONVERT:
10200             case NON_LVALUE_EXPR:
10201             case PLUS_EXPR:
10202             case POINTER_PLUS_EXPR:
10203               inner = TREE_OPERAND (inner, 0);
10204               continue;
10205
10206             case MINUS_EXPR:
10207               /* If the second operand of the MINUS_EXPR has a pointer
10208                  type (or is converted from it), this may be valid, so
10209                  don't give a warning.  */
10210               {
10211                 tree op1 = TREE_OPERAND (inner, 1);
10212
10213                 while (!POINTER_TYPE_P (TREE_TYPE (op1))
10214                        && (CONVERT_EXPR_P (op1)
10215                            || TREE_CODE (op1) == NON_LVALUE_EXPR))
10216                   op1 = TREE_OPERAND (op1, 0);
10217
10218                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
10219                   break;
10220
10221                 inner = TREE_OPERAND (inner, 0);
10222                 continue;
10223               }
10224
10225             case ADDR_EXPR:
10226               inner = TREE_OPERAND (inner, 0);
10227
10228               while (REFERENCE_CLASS_P (inner)
10229                      && !INDIRECT_REF_P (inner))
10230                 inner = TREE_OPERAND (inner, 0);
10231
10232               if (DECL_P (inner)
10233                   && !DECL_EXTERNAL (inner)
10234                   && !TREE_STATIC (inner)
10235                   && DECL_CONTEXT (inner) == current_function_decl)
10236                 {
10237                   if (TREE_CODE (inner) == LABEL_DECL)
10238                     warning_at (loc, OPT_Wreturn_local_addr,
10239                                 "function returns address of label");
10240                   else
10241                     {
10242                       warning_at (loc, OPT_Wreturn_local_addr,
10243                                   "function returns address of local variable");
10244                       tree zero = build_zero_cst (TREE_TYPE (res));
10245                       t = build2 (COMPOUND_EXPR, TREE_TYPE (res), t, zero);
10246                     }
10247                 }
10248               break;
10249
10250             default:
10251               break;
10252             }
10253
10254           break;
10255         }
10256
10257       retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t);
10258       SET_EXPR_LOCATION (retval, loc);
10259
10260       if (warn_sequence_point)
10261         verify_sequence_points (retval);
10262     }
10263
10264   ret_stmt = build_stmt (loc, RETURN_EXPR, retval);
10265   TREE_NO_WARNING (ret_stmt) |= no_warning;
10266   return add_stmt (ret_stmt);
10267 }
10268 \f
10269 struct c_switch {
10270   /* The SWITCH_EXPR being built.  */
10271   tree switch_expr;
10272
10273   /* The original type of the testing expression, i.e. before the
10274      default conversion is applied.  */
10275   tree orig_type;
10276
10277   /* A splay-tree mapping the low element of a case range to the high
10278      element, or NULL_TREE if there is no high element.  Used to
10279      determine whether or not a new case label duplicates an old case
10280      label.  We need a tree, rather than simply a hash table, because
10281      of the GNU case range extension.  */
10282   splay_tree cases;
10283
10284   /* The bindings at the point of the switch.  This is used for
10285      warnings crossing decls when branching to a case label.  */
10286   struct c_spot_bindings *bindings;
10287
10288   /* The next node on the stack.  */
10289   struct c_switch *next;
10290
10291   /* Remember whether the controlling expression had boolean type
10292      before integer promotions for the sake of -Wswitch-bool.  */
10293   bool bool_cond_p;
10294
10295   /* Remember whether there was a case value that is outside the
10296      range of the ORIG_TYPE.  */
10297   bool outside_range_p;
10298 };
10299
10300 /* A stack of the currently active switch statements.  The innermost
10301    switch statement is on the top of the stack.  There is no need to
10302    mark the stack for garbage collection because it is only active
10303    during the processing of the body of a function, and we never
10304    collect at that point.  */
10305
10306 struct c_switch *c_switch_stack;
10307
10308 /* Start a C switch statement, testing expression EXP.  Return the new
10309    SWITCH_EXPR.  SWITCH_LOC is the location of the `switch'.
10310    SWITCH_COND_LOC is the location of the switch's condition.
10311    EXPLICIT_CAST_P is true if the expression EXP has an explicit cast.  */
10312
10313 tree
10314 c_start_case (location_t switch_loc,
10315               location_t switch_cond_loc,
10316               tree exp, bool explicit_cast_p)
10317 {
10318   tree orig_type = error_mark_node;
10319   bool bool_cond_p = false;
10320   struct c_switch *cs;
10321
10322   if (exp != error_mark_node)
10323     {
10324       orig_type = TREE_TYPE (exp);
10325
10326       if (!INTEGRAL_TYPE_P (orig_type))
10327         {
10328           if (orig_type != error_mark_node)
10329             {
10330               error_at (switch_cond_loc, "switch quantity not an integer");
10331               orig_type = error_mark_node;
10332             }
10333           exp = integer_zero_node;
10334         }
10335       else
10336         {
10337           tree type = TYPE_MAIN_VARIANT (orig_type);
10338           tree e = exp;
10339
10340           /* Warn if the condition has boolean value.  */
10341           while (TREE_CODE (e) == COMPOUND_EXPR)
10342             e = TREE_OPERAND (e, 1);
10343
10344           if ((TREE_CODE (type) == BOOLEAN_TYPE
10345                || truth_value_p (TREE_CODE (e)))
10346               /* Explicit cast to int suppresses this warning.  */
10347               && !(TREE_CODE (type) == INTEGER_TYPE
10348                    && explicit_cast_p))
10349             bool_cond_p = true;
10350
10351           if (!in_system_header_at (input_location)
10352               && (type == long_integer_type_node
10353                   || type == long_unsigned_type_node))
10354             warning_at (switch_cond_loc,
10355                         OPT_Wtraditional, "%<long%> switch expression not "
10356                         "converted to %<int%> in ISO C");
10357
10358           exp = c_fully_fold (exp, false, NULL);
10359           exp = default_conversion (exp);
10360
10361           if (warn_sequence_point)
10362             verify_sequence_points (exp);
10363         }
10364     }
10365
10366   /* Add this new SWITCH_EXPR to the stack.  */
10367   cs = XNEW (struct c_switch);
10368   cs->switch_expr = build2 (SWITCH_EXPR, orig_type, exp, NULL_TREE);
10369   SET_EXPR_LOCATION (cs->switch_expr, switch_loc);
10370   cs->orig_type = orig_type;
10371   cs->cases = splay_tree_new (case_compare, NULL, NULL);
10372   cs->bindings = c_get_switch_bindings ();
10373   cs->bool_cond_p = bool_cond_p;
10374   cs->outside_range_p = false;
10375   cs->next = c_switch_stack;
10376   c_switch_stack = cs;
10377
10378   return add_stmt (cs->switch_expr);
10379 }
10380
10381 /* Process a case label at location LOC.  */
10382
10383 tree
10384 do_case (location_t loc, tree low_value, tree high_value)
10385 {
10386   tree label = NULL_TREE;
10387
10388   if (low_value && TREE_CODE (low_value) != INTEGER_CST)
10389     {
10390       low_value = c_fully_fold (low_value, false, NULL);
10391       if (TREE_CODE (low_value) == INTEGER_CST)
10392         pedwarn (loc, OPT_Wpedantic,
10393                  "case label is not an integer constant expression");
10394     }
10395
10396   if (high_value && TREE_CODE (high_value) != INTEGER_CST)
10397     {
10398       high_value = c_fully_fold (high_value, false, NULL);
10399       if (TREE_CODE (high_value) == INTEGER_CST)
10400         pedwarn (input_location, OPT_Wpedantic,
10401                  "case label is not an integer constant expression");
10402     }
10403
10404   if (c_switch_stack == NULL)
10405     {
10406       if (low_value)
10407         error_at (loc, "case label not within a switch statement");
10408       else
10409         error_at (loc, "%<default%> label not within a switch statement");
10410       return NULL_TREE;
10411     }
10412
10413   if (c_check_switch_jump_warnings (c_switch_stack->bindings,
10414                                     EXPR_LOCATION (c_switch_stack->switch_expr),
10415                                     loc))
10416     return NULL_TREE;
10417
10418   label = c_add_case_label (loc, c_switch_stack->cases,
10419                             SWITCH_COND (c_switch_stack->switch_expr),
10420                             c_switch_stack->orig_type,
10421                             low_value, high_value,
10422                             &c_switch_stack->outside_range_p);
10423   if (label == error_mark_node)
10424     label = NULL_TREE;
10425   return label;
10426 }
10427
10428 /* Finish the switch statement.  TYPE is the original type of the
10429    controlling expression of the switch, or NULL_TREE.  */
10430
10431 void
10432 c_finish_case (tree body, tree type)
10433 {
10434   struct c_switch *cs = c_switch_stack;
10435   location_t switch_location;
10436
10437   SWITCH_BODY (cs->switch_expr) = body;
10438
10439   /* Emit warnings as needed.  */
10440   switch_location = EXPR_LOCATION (cs->switch_expr);
10441   c_do_switch_warnings (cs->cases, switch_location,
10442                         type ? type : TREE_TYPE (cs->switch_expr),
10443                         SWITCH_COND (cs->switch_expr),
10444                         cs->bool_cond_p, cs->outside_range_p);
10445   if (c_switch_covers_all_cases_p (cs->cases, TREE_TYPE (cs->switch_expr)))
10446     SWITCH_ALL_CASES_P (cs->switch_expr) = 1;
10447
10448   /* Pop the stack.  */
10449   c_switch_stack = cs->next;
10450   splay_tree_delete (cs->cases);
10451   c_release_switch_bindings (cs->bindings);
10452   XDELETE (cs);
10453 }
10454 \f
10455 /* Emit an if statement.  IF_LOCUS is the location of the 'if'.  COND,
10456    THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
10457    may be null.  */
10458
10459 void
10460 c_finish_if_stmt (location_t if_locus, tree cond, tree then_block,
10461                   tree else_block)
10462 {
10463   tree stmt;
10464
10465   stmt = build3 (COND_EXPR, void_type_node, cond, then_block, else_block);
10466   SET_EXPR_LOCATION (stmt, if_locus);
10467   add_stmt (stmt);
10468 }
10469
10470 /* Emit a general-purpose loop construct.  START_LOCUS is the location of
10471    the beginning of the loop.  COND is the loop condition.  COND_IS_FIRST
10472    is false for DO loops.  INCR is the FOR increment expression.  BODY is
10473    the statement controlled by the loop.  BLAB is the break label.  CLAB is
10474    the continue label.  Everything is allowed to be NULL.  */
10475
10476 void
10477 c_finish_loop (location_t start_locus, tree cond, tree incr, tree body,
10478                tree blab, tree clab, bool cond_is_first)
10479 {
10480   tree entry = NULL, exit = NULL, t;
10481
10482   /* If the condition is zero don't generate a loop construct.  */
10483   if (cond && integer_zerop (cond))
10484     {
10485       if (cond_is_first)
10486         {
10487           t = build_and_jump (&blab);
10488           SET_EXPR_LOCATION (t, start_locus);
10489           add_stmt (t);
10490         }
10491     }
10492   else
10493     {
10494       tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
10495
10496       /* If we have an exit condition, then we build an IF with gotos either
10497          out of the loop, or to the top of it.  If there's no exit condition,
10498          then we just build a jump back to the top.  */
10499       exit = build_and_jump (&LABEL_EXPR_LABEL (top));
10500
10501       if (cond && !integer_nonzerop (cond))
10502         {
10503           /* Canonicalize the loop condition to the end.  This means
10504              generating a branch to the loop condition.  Reuse the
10505              continue label, if possible.  */
10506           if (cond_is_first)
10507             {
10508               if (incr || !clab)
10509                 {
10510                   entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
10511                   t = build_and_jump (&LABEL_EXPR_LABEL (entry));
10512                 }
10513               else
10514                 t = build1 (GOTO_EXPR, void_type_node, clab);
10515               SET_EXPR_LOCATION (t, start_locus);
10516               add_stmt (t);
10517             }
10518
10519           t = build_and_jump (&blab);
10520           if (cond_is_first)
10521             exit = fold_build3_loc (start_locus,
10522                                 COND_EXPR, void_type_node, cond, exit, t);
10523           else
10524             exit = fold_build3_loc (input_location,
10525                                 COND_EXPR, void_type_node, cond, exit, t);
10526         }
10527       else
10528         {
10529           /* For the backward-goto's location of an unconditional loop
10530              use the beginning of the body, or, if there is none, the
10531              top of the loop.  */
10532           location_t loc = EXPR_LOCATION (expr_first (body));
10533           if (loc == UNKNOWN_LOCATION)
10534             loc = start_locus;
10535           SET_EXPR_LOCATION (exit, loc);
10536         }
10537
10538       add_stmt (top);
10539     }
10540
10541   if (body)
10542     add_stmt (body);
10543   if (clab)
10544     add_stmt (build1 (LABEL_EXPR, void_type_node, clab));
10545   if (incr)
10546     add_stmt (incr);
10547   if (entry)
10548     add_stmt (entry);
10549   if (exit)
10550     add_stmt (exit);
10551   if (blab)
10552     add_stmt (build1 (LABEL_EXPR, void_type_node, blab));
10553 }
10554
10555 tree
10556 c_finish_bc_stmt (location_t loc, tree *label_p, bool is_break)
10557 {
10558   bool skip;
10559   tree label = *label_p;
10560
10561   /* In switch statements break is sometimes stylistically used after
10562      a return statement.  This can lead to spurious warnings about
10563      control reaching the end of a non-void function when it is
10564      inlined.  Note that we are calling block_may_fallthru with
10565      language specific tree nodes; this works because
10566      block_may_fallthru returns true when given something it does not
10567      understand.  */
10568   skip = !block_may_fallthru (cur_stmt_list);
10569
10570   if (!label)
10571     {
10572       if (!skip)
10573         *label_p = label = create_artificial_label (loc);
10574     }
10575   else if (TREE_CODE (label) == LABEL_DECL)
10576     ;
10577   else switch (TREE_INT_CST_LOW (label))
10578     {
10579     case 0:
10580       if (is_break)
10581         error_at (loc, "break statement not within loop or switch");
10582       else
10583         error_at (loc, "continue statement not within a loop");
10584       return NULL_TREE;
10585
10586     case 1:
10587       gcc_assert (is_break);
10588       error_at (loc, "break statement used with OpenMP for loop");
10589       return NULL_TREE;
10590
10591     case 2:
10592       if (is_break)
10593         error ("break statement within %<#pragma simd%> loop body");
10594       else
10595         error ("continue statement within %<#pragma simd%> loop body");
10596       return NULL_TREE;
10597
10598     default:
10599       gcc_unreachable ();
10600     }
10601
10602   if (skip)
10603     return NULL_TREE;
10604
10605   if (!is_break)
10606     add_stmt (build_predict_expr (PRED_CONTINUE, NOT_TAKEN));
10607
10608   return add_stmt (build1 (GOTO_EXPR, void_type_node, label));
10609 }
10610
10611 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr.  */
10612
10613 static void
10614 emit_side_effect_warnings (location_t loc, tree expr)
10615 {
10616   if (expr == error_mark_node)
10617     ;
10618   else if (!TREE_SIDE_EFFECTS (expr))
10619     {
10620       if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr))
10621         warning_at (loc, OPT_Wunused_value, "statement with no effect");
10622     }
10623   else if (TREE_CODE (expr) == COMPOUND_EXPR)
10624     {
10625       tree r = expr;
10626       location_t cloc = loc;
10627       while (TREE_CODE (r) == COMPOUND_EXPR)
10628         {
10629           if (EXPR_HAS_LOCATION (r))
10630             cloc = EXPR_LOCATION (r);
10631           r = TREE_OPERAND (r, 1);
10632         }
10633       if (!TREE_SIDE_EFFECTS (r)
10634           && !VOID_TYPE_P (TREE_TYPE (r))
10635           && !CONVERT_EXPR_P (r)
10636           && !TREE_NO_WARNING (r)
10637           && !TREE_NO_WARNING (expr))
10638         warning_at (cloc, OPT_Wunused_value,
10639                     "right-hand operand of comma expression has no effect");
10640     }
10641   else
10642     warn_if_unused_value (expr, loc);
10643 }
10644
10645 /* Process an expression as if it were a complete statement.  Emit
10646    diagnostics, but do not call ADD_STMT.  LOC is the location of the
10647    statement.  */
10648
10649 tree
10650 c_process_expr_stmt (location_t loc, tree expr)
10651 {
10652   tree exprv;
10653
10654   if (!expr)
10655     return NULL_TREE;
10656
10657   expr = c_fully_fold (expr, false, NULL);
10658
10659   if (warn_sequence_point)
10660     verify_sequence_points (expr);
10661
10662   if (TREE_TYPE (expr) != error_mark_node
10663       && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
10664       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
10665     error_at (loc, "expression statement has incomplete type");
10666
10667   /* If we're not processing a statement expression, warn about unused values.
10668      Warnings for statement expressions will be emitted later, once we figure
10669      out which is the result.  */
10670   if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
10671       && warn_unused_value)
10672     emit_side_effect_warnings (EXPR_LOC_OR_LOC (expr, loc), expr);
10673
10674   exprv = expr;
10675   while (TREE_CODE (exprv) == COMPOUND_EXPR)
10676     exprv = TREE_OPERAND (exprv, 1);
10677   while (CONVERT_EXPR_P (exprv))
10678     exprv = TREE_OPERAND (exprv, 0);
10679   if (DECL_P (exprv)
10680       || handled_component_p (exprv)
10681       || TREE_CODE (exprv) == ADDR_EXPR)
10682     mark_exp_read (exprv);
10683
10684   /* If the expression is not of a type to which we cannot assign a line
10685      number, wrap the thing in a no-op NOP_EXPR.  */
10686   if (DECL_P (expr) || CONSTANT_CLASS_P (expr))
10687     {
10688       expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr);
10689       SET_EXPR_LOCATION (expr, loc);
10690     }
10691
10692   return expr;
10693 }
10694
10695 /* Emit an expression as a statement.  LOC is the location of the
10696    expression.  */
10697
10698 tree
10699 c_finish_expr_stmt (location_t loc, tree expr)
10700 {
10701   if (expr)
10702     return add_stmt (c_process_expr_stmt (loc, expr));
10703   else
10704     return NULL;
10705 }
10706
10707 /* Do the opposite and emit a statement as an expression.  To begin,
10708    create a new binding level and return it.  */
10709
10710 tree
10711 c_begin_stmt_expr (void)
10712 {
10713   tree ret;
10714
10715   /* We must force a BLOCK for this level so that, if it is not expanded
10716      later, there is a way to turn off the entire subtree of blocks that
10717      are contained in it.  */
10718   keep_next_level ();
10719   ret = c_begin_compound_stmt (true);
10720
10721   c_bindings_start_stmt_expr (c_switch_stack == NULL
10722                               ? NULL
10723                               : c_switch_stack->bindings);
10724
10725   /* Mark the current statement list as belonging to a statement list.  */
10726   STATEMENT_LIST_STMT_EXPR (ret) = 1;
10727
10728   return ret;
10729 }
10730
10731 /* LOC is the location of the compound statement to which this body
10732    belongs.  */
10733
10734 tree
10735 c_finish_stmt_expr (location_t loc, tree body)
10736 {
10737   tree last, type, tmp, val;
10738   tree *last_p;
10739
10740   body = c_end_compound_stmt (loc, body, true);
10741
10742   c_bindings_end_stmt_expr (c_switch_stack == NULL
10743                             ? NULL
10744                             : c_switch_stack->bindings);
10745
10746   /* Locate the last statement in BODY.  See c_end_compound_stmt
10747      about always returning a BIND_EXPR.  */
10748   last_p = &BIND_EXPR_BODY (body);
10749   last = BIND_EXPR_BODY (body);
10750
10751  continue_searching:
10752   if (TREE_CODE (last) == STATEMENT_LIST)
10753     {
10754       tree_stmt_iterator l = tsi_last (last);
10755
10756       while (!tsi_end_p (l) && TREE_CODE (tsi_stmt (l)) == DEBUG_BEGIN_STMT)
10757         tsi_prev (&l);
10758
10759       /* This can happen with degenerate cases like ({ }).  No value.  */
10760       if (tsi_end_p (l))
10761         return body;
10762
10763       /* If we're supposed to generate side effects warnings, process
10764          all of the statements except the last.  */
10765       if (warn_unused_value)
10766         {
10767           for (tree_stmt_iterator i = tsi_start (last);
10768                tsi_stmt (i) != tsi_stmt (l); tsi_next (&i))
10769             {
10770               location_t tloc;
10771               tree t = tsi_stmt (i);
10772
10773               tloc = EXPR_HAS_LOCATION (t) ? EXPR_LOCATION (t) : loc;
10774               emit_side_effect_warnings (tloc, t);
10775             }
10776         }
10777       last_p = tsi_stmt_ptr (l);
10778       last = *last_p;
10779     }
10780
10781   /* If the end of the list is exception related, then the list was split
10782      by a call to push_cleanup.  Continue searching.  */
10783   if (TREE_CODE (last) == TRY_FINALLY_EXPR
10784       || TREE_CODE (last) == TRY_CATCH_EXPR)
10785     {
10786       last_p = &TREE_OPERAND (last, 0);
10787       last = *last_p;
10788       goto continue_searching;
10789     }
10790
10791   if (last == error_mark_node)
10792     return last;
10793
10794   /* In the case that the BIND_EXPR is not necessary, return the
10795      expression out from inside it.  */
10796   if ((last == BIND_EXPR_BODY (body)
10797        /* Skip nested debug stmts.  */
10798        || last == expr_first (BIND_EXPR_BODY (body)))
10799       && BIND_EXPR_VARS (body) == NULL)
10800     {
10801       /* Even if this looks constant, do not allow it in a constant
10802          expression.  */
10803       last = c_wrap_maybe_const (last, true);
10804       /* Do not warn if the return value of a statement expression is
10805          unused.  */
10806       TREE_NO_WARNING (last) = 1;
10807       return last;
10808     }
10809
10810   /* Extract the type of said expression.  */
10811   type = TREE_TYPE (last);
10812
10813   /* If we're not returning a value at all, then the BIND_EXPR that
10814      we already have is a fine expression to return.  */
10815   if (!type || VOID_TYPE_P (type))
10816     return body;
10817
10818   /* Now that we've located the expression containing the value, it seems
10819      silly to make voidify_wrapper_expr repeat the process.  Create a
10820      temporary of the appropriate type and stick it in a TARGET_EXPR.  */
10821   tmp = create_tmp_var_raw (type);
10822
10823   /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt.  This avoids
10824      tree_expr_nonnegative_p giving up immediately.  */
10825   val = last;
10826   if (TREE_CODE (val) == NOP_EXPR
10827       && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
10828     val = TREE_OPERAND (val, 0);
10829
10830   *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val);
10831   SET_EXPR_LOCATION (*last_p, EXPR_LOCATION (last));
10832
10833   {
10834     tree t = build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE);
10835     SET_EXPR_LOCATION (t, loc);
10836     return t;
10837   }
10838 }
10839 \f
10840 /* Begin and end compound statements.  This is as simple as pushing
10841    and popping new statement lists from the tree.  */
10842
10843 tree
10844 c_begin_compound_stmt (bool do_scope)
10845 {
10846   tree stmt = push_stmt_list ();
10847   if (do_scope)
10848     push_scope ();
10849   return stmt;
10850 }
10851
10852 /* End a compound statement.  STMT is the statement.  LOC is the
10853    location of the compound statement-- this is usually the location
10854    of the opening brace.  */
10855
10856 tree
10857 c_end_compound_stmt (location_t loc, tree stmt, bool do_scope)
10858 {
10859   tree block = NULL;
10860
10861   if (do_scope)
10862     {
10863       if (c_dialect_objc ())
10864         objc_clear_super_receiver ();
10865       block = pop_scope ();
10866     }
10867
10868   stmt = pop_stmt_list (stmt);
10869   stmt = c_build_bind_expr (loc, block, stmt);
10870
10871   /* If this compound statement is nested immediately inside a statement
10872      expression, then force a BIND_EXPR to be created.  Otherwise we'll
10873      do the wrong thing for ({ { 1; } }) or ({ 1; { } }).  In particular,
10874      STATEMENT_LISTs merge, and thus we can lose track of what statement
10875      was really last.  */
10876   if (building_stmt_list_p ()
10877       && STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
10878       && TREE_CODE (stmt) != BIND_EXPR)
10879     {
10880       stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL);
10881       TREE_SIDE_EFFECTS (stmt) = 1;
10882       SET_EXPR_LOCATION (stmt, loc);
10883     }
10884
10885   return stmt;
10886 }
10887
10888 /* Queue a cleanup.  CLEANUP is an expression/statement to be executed
10889    when the current scope is exited.  EH_ONLY is true when this is not
10890    meant to apply to normal control flow transfer.  */
10891
10892 void
10893 push_cleanup (tree decl, tree cleanup, bool eh_only)
10894 {
10895   enum tree_code code;
10896   tree stmt, list;
10897   bool stmt_expr;
10898
10899   code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR;
10900   stmt = build_stmt (DECL_SOURCE_LOCATION (decl), code, NULL, cleanup);
10901   add_stmt (stmt);
10902   stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list);
10903   list = push_stmt_list ();
10904   TREE_OPERAND (stmt, 0) = list;
10905   STATEMENT_LIST_STMT_EXPR (list) = stmt_expr;
10906 }
10907 \f
10908 /* Build a vector comparison of ARG0 and ARG1 using CODE opcode
10909    into a value of TYPE type.  Comparison is done via VEC_COND_EXPR.  */
10910
10911 static tree
10912 build_vec_cmp (tree_code code, tree type,
10913                tree arg0, tree arg1)
10914 {
10915   tree zero_vec = build_zero_cst (type);
10916   tree minus_one_vec = build_minus_one_cst (type);
10917   tree cmp_type = build_same_sized_truth_vector_type (type);
10918   tree cmp = build2 (code, cmp_type, arg0, arg1);
10919   return build3 (VEC_COND_EXPR, type, cmp, minus_one_vec, zero_vec);
10920 }
10921
10922 /* Build a binary-operation expression without default conversions.
10923    CODE is the kind of expression to build.
10924    LOCATION is the operator's location.
10925    This function differs from `build' in several ways:
10926    the data type of the result is computed and recorded in it,
10927    warnings are generated if arg data types are invalid,
10928    special handling for addition and subtraction of pointers is known,
10929    and some optimization is done (operations on narrow ints
10930    are done in the narrower type when that gives the same result).
10931    Constant folding is also done before the result is returned.
10932
10933    Note that the operands will never have enumeral types, or function
10934    or array types, because either they will have the default conversions
10935    performed or they have both just been converted to some other type in which
10936    the arithmetic is to be done.  */
10937
10938 tree
10939 build_binary_op (location_t location, enum tree_code code,
10940                  tree orig_op0, tree orig_op1, bool convert_p)
10941 {
10942   tree type0, type1, orig_type0, orig_type1;
10943   tree eptype;
10944   enum tree_code code0, code1;
10945   tree op0, op1;
10946   tree ret = error_mark_node;
10947   const char *invalid_op_diag;
10948   bool op0_int_operands, op1_int_operands;
10949   bool int_const, int_const_or_overflow, int_operands;
10950
10951   /* Expression code to give to the expression when it is built.
10952      Normally this is CODE, which is what the caller asked for,
10953      but in some special cases we change it.  */
10954   enum tree_code resultcode = code;
10955
10956   /* Data type in which the computation is to be performed.
10957      In the simplest cases this is the common type of the arguments.  */
10958   tree result_type = NULL;
10959
10960   /* When the computation is in excess precision, the type of the
10961      final EXCESS_PRECISION_EXPR.  */
10962   tree semantic_result_type = NULL;
10963
10964   /* Nonzero means operands have already been type-converted
10965      in whatever way is necessary.
10966      Zero means they need to be converted to RESULT_TYPE.  */
10967   int converted = 0;
10968
10969   /* Nonzero means create the expression with this type, rather than
10970      RESULT_TYPE.  */
10971   tree build_type = NULL_TREE;
10972
10973   /* Nonzero means after finally constructing the expression
10974      convert it to this type.  */
10975   tree final_type = NULL_TREE;
10976
10977   /* Nonzero if this is an operation like MIN or MAX which can
10978      safely be computed in short if both args are promoted shorts.
10979      Also implies COMMON.
10980      -1 indicates a bitwise operation; this makes a difference
10981      in the exact conditions for when it is safe to do the operation
10982      in a narrower mode.  */
10983   int shorten = 0;
10984
10985   /* Nonzero if this is a comparison operation;
10986      if both args are promoted shorts, compare the original shorts.
10987      Also implies COMMON.  */
10988   int short_compare = 0;
10989
10990   /* Nonzero if this is a right-shift operation, which can be computed on the
10991      original short and then promoted if the operand is a promoted short.  */
10992   int short_shift = 0;
10993
10994   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
10995   int common = 0;
10996
10997   /* True means types are compatible as far as ObjC is concerned.  */
10998   bool objc_ok;
10999
11000   /* True means this is an arithmetic operation that may need excess
11001      precision.  */
11002   bool may_need_excess_precision;
11003
11004   /* True means this is a boolean operation that converts both its
11005      operands to truth-values.  */
11006   bool boolean_op = false;
11007
11008   /* Remember whether we're doing / or %.  */
11009   bool doing_div_or_mod = false;
11010
11011   /* Remember whether we're doing << or >>.  */
11012   bool doing_shift = false;
11013
11014   /* Tree holding instrumentation expression.  */
11015   tree instrument_expr = NULL;
11016
11017   if (location == UNKNOWN_LOCATION)
11018     location = input_location;
11019
11020   op0 = orig_op0;
11021   op1 = orig_op1;
11022
11023   op0_int_operands = EXPR_INT_CONST_OPERANDS (orig_op0);
11024   if (op0_int_operands)
11025     op0 = remove_c_maybe_const_expr (op0);
11026   op1_int_operands = EXPR_INT_CONST_OPERANDS (orig_op1);
11027   if (op1_int_operands)
11028     op1 = remove_c_maybe_const_expr (op1);
11029   int_operands = (op0_int_operands && op1_int_operands);
11030   if (int_operands)
11031     {
11032       int_const_or_overflow = (TREE_CODE (orig_op0) == INTEGER_CST
11033                                && TREE_CODE (orig_op1) == INTEGER_CST);
11034       int_const = (int_const_or_overflow
11035                    && !TREE_OVERFLOW (orig_op0)
11036                    && !TREE_OVERFLOW (orig_op1));
11037     }
11038   else
11039     int_const = int_const_or_overflow = false;
11040
11041   /* Do not apply default conversion in mixed vector/scalar expression.  */
11042   if (convert_p
11043       && VECTOR_TYPE_P (TREE_TYPE (op0)) == VECTOR_TYPE_P (TREE_TYPE (op1)))
11044     {
11045       op0 = default_conversion (op0);
11046       op1 = default_conversion (op1);
11047     }
11048
11049   orig_type0 = type0 = TREE_TYPE (op0);
11050
11051   orig_type1 = type1 = TREE_TYPE (op1);
11052
11053   /* The expression codes of the data types of the arguments tell us
11054      whether the arguments are integers, floating, pointers, etc.  */
11055   code0 = TREE_CODE (type0);
11056   code1 = TREE_CODE (type1);
11057
11058   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
11059   STRIP_TYPE_NOPS (op0);
11060   STRIP_TYPE_NOPS (op1);
11061
11062   /* If an error was already reported for one of the arguments,
11063      avoid reporting another error.  */
11064
11065   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
11066     return error_mark_node;
11067
11068   if (code0 == POINTER_TYPE
11069       && reject_gcc_builtin (op0, EXPR_LOCATION (orig_op0)))
11070     return error_mark_node;
11071
11072   if (code1 == POINTER_TYPE
11073       && reject_gcc_builtin (op1, EXPR_LOCATION (orig_op1)))
11074     return error_mark_node;
11075
11076   if ((invalid_op_diag
11077        = targetm.invalid_binary_op (code, type0, type1)))
11078     {
11079       error_at (location, invalid_op_diag);
11080       return error_mark_node;
11081     }
11082
11083   switch (code)
11084     {
11085     case PLUS_EXPR:
11086     case MINUS_EXPR:
11087     case MULT_EXPR:
11088     case TRUNC_DIV_EXPR:
11089     case CEIL_DIV_EXPR:
11090     case FLOOR_DIV_EXPR:
11091     case ROUND_DIV_EXPR:
11092     case EXACT_DIV_EXPR:
11093       may_need_excess_precision = true;
11094       break;
11095     default:
11096       may_need_excess_precision = false;
11097       break;
11098     }
11099   if (TREE_CODE (op0) == EXCESS_PRECISION_EXPR)
11100     {
11101       op0 = TREE_OPERAND (op0, 0);
11102       type0 = TREE_TYPE (op0);
11103     }
11104   else if (may_need_excess_precision
11105            && (eptype = excess_precision_type (type0)) != NULL_TREE)
11106     {
11107       type0 = eptype;
11108       op0 = convert (eptype, op0);
11109     }
11110   if (TREE_CODE (op1) == EXCESS_PRECISION_EXPR)
11111     {
11112       op1 = TREE_OPERAND (op1, 0);
11113       type1 = TREE_TYPE (op1);
11114     }
11115   else if (may_need_excess_precision
11116            && (eptype = excess_precision_type (type1)) != NULL_TREE)
11117     {
11118       type1 = eptype;
11119       op1 = convert (eptype, op1);
11120     }
11121
11122   objc_ok = objc_compare_types (type0, type1, -3, NULL_TREE);
11123
11124   /* In case when one of the operands of the binary operation is
11125      a vector and another is a scalar -- convert scalar to vector.  */
11126   if ((code0 == VECTOR_TYPE) != (code1 == VECTOR_TYPE))
11127     {
11128       enum stv_conv convert_flag = scalar_to_vector (location, code, op0, op1,
11129                                                      true);
11130
11131       switch (convert_flag)
11132         {
11133           case stv_error:
11134             return error_mark_node;
11135           case stv_firstarg:
11136             {
11137               bool maybe_const = true;
11138               tree sc;
11139               sc = c_fully_fold (op0, false, &maybe_const);
11140               sc = save_expr (sc);
11141               sc = convert (TREE_TYPE (type1), sc);
11142               op0 = build_vector_from_val (type1, sc);
11143               if (!maybe_const)
11144                 op0 = c_wrap_maybe_const (op0, true);
11145               orig_type0 = type0 = TREE_TYPE (op0);
11146               code0 = TREE_CODE (type0);
11147               converted = 1;
11148               break;
11149             }
11150           case stv_secondarg:
11151             {
11152               bool maybe_const = true;
11153               tree sc;
11154               sc = c_fully_fold (op1, false, &maybe_const);
11155               sc = save_expr (sc);
11156               sc = convert (TREE_TYPE (type0), sc);
11157               op1 = build_vector_from_val (type0, sc);
11158               if (!maybe_const)
11159                 op1 = c_wrap_maybe_const (op1, true);
11160               orig_type1 = type1 = TREE_TYPE (op1);
11161               code1 = TREE_CODE (type1);
11162               converted = 1;
11163               break;
11164             }
11165           default:
11166             break;
11167         }
11168     }
11169
11170   switch (code)
11171     {
11172     case PLUS_EXPR:
11173       /* Handle the pointer + int case.  */
11174       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
11175         {
11176           ret = pointer_int_sum (location, PLUS_EXPR, op0, op1);
11177           goto return_build_binary_op;
11178         }
11179       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
11180         {
11181           ret = pointer_int_sum (location, PLUS_EXPR, op1, op0);
11182           goto return_build_binary_op;
11183         }
11184       else
11185         common = 1;
11186       break;
11187
11188     case MINUS_EXPR:
11189       /* Subtraction of two similar pointers.
11190          We must subtract them as integers, then divide by object size.  */
11191       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
11192           && comp_target_types (location, type0, type1))
11193         {
11194           ret = pointer_diff (location, op0, op1, &instrument_expr);
11195           goto return_build_binary_op;
11196         }
11197       /* Handle pointer minus int.  Just like pointer plus int.  */
11198       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
11199         {
11200           ret = pointer_int_sum (location, MINUS_EXPR, op0, op1);
11201           goto return_build_binary_op;
11202         }
11203       else
11204         common = 1;
11205       break;
11206
11207     case MULT_EXPR:
11208       common = 1;
11209       break;
11210
11211     case TRUNC_DIV_EXPR:
11212     case CEIL_DIV_EXPR:
11213     case FLOOR_DIV_EXPR:
11214     case ROUND_DIV_EXPR:
11215     case EXACT_DIV_EXPR:
11216       doing_div_or_mod = true;
11217       warn_for_div_by_zero (location, op1);
11218
11219       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
11220            || code0 == FIXED_POINT_TYPE
11221            || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
11222           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
11223               || code1 == FIXED_POINT_TYPE
11224               || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
11225         {
11226           enum tree_code tcode0 = code0, tcode1 = code1;
11227
11228           if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
11229             tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
11230           if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
11231             tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
11232
11233           if (!((tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE)
11234               || (tcode0 == FIXED_POINT_TYPE && tcode1 == FIXED_POINT_TYPE)))
11235             resultcode = RDIV_EXPR;
11236           else
11237             /* Although it would be tempting to shorten always here, that
11238                loses on some targets, since the modulo instruction is
11239                undefined if the quotient can't be represented in the
11240                computation mode.  We shorten only if unsigned or if
11241                dividing by something we know != -1.  */
11242             shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
11243                        || (TREE_CODE (op1) == INTEGER_CST
11244                            && !integer_all_onesp (op1)));
11245           common = 1;
11246         }
11247       break;
11248
11249     case BIT_AND_EXPR:
11250     case BIT_IOR_EXPR:
11251     case BIT_XOR_EXPR:
11252       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
11253         shorten = -1;
11254       /* Allow vector types which are not floating point types.   */
11255       else if (code0 == VECTOR_TYPE
11256                && code1 == VECTOR_TYPE
11257                && !VECTOR_FLOAT_TYPE_P (type0)
11258                && !VECTOR_FLOAT_TYPE_P (type1))
11259         common = 1;
11260       break;
11261
11262     case TRUNC_MOD_EXPR:
11263     case FLOOR_MOD_EXPR:
11264       doing_div_or_mod = true;
11265       warn_for_div_by_zero (location, op1);
11266
11267       if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
11268           && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE
11269           && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE)
11270         common = 1;
11271       else if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
11272         {
11273           /* Although it would be tempting to shorten always here, that loses
11274              on some targets, since the modulo instruction is undefined if the
11275              quotient can't be represented in the computation mode.  We shorten
11276              only if unsigned or if dividing by something we know != -1.  */
11277           shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
11278                      || (TREE_CODE (op1) == INTEGER_CST
11279                          && !integer_all_onesp (op1)));
11280           common = 1;
11281         }
11282       break;
11283
11284     case TRUTH_ANDIF_EXPR:
11285     case TRUTH_ORIF_EXPR:
11286     case TRUTH_AND_EXPR:
11287     case TRUTH_OR_EXPR:
11288     case TRUTH_XOR_EXPR:
11289       if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
11290            || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
11291            || code0 == FIXED_POINT_TYPE)
11292           && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
11293               || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
11294               || code1 == FIXED_POINT_TYPE))
11295         {
11296           /* Result of these operations is always an int,
11297              but that does not mean the operands should be
11298              converted to ints!  */
11299           result_type = integer_type_node;
11300           if (op0_int_operands)
11301             {
11302               op0 = c_objc_common_truthvalue_conversion (location, orig_op0);
11303               op0 = remove_c_maybe_const_expr (op0);
11304             }
11305           else
11306             op0 = c_objc_common_truthvalue_conversion (location, op0);
11307           if (op1_int_operands)
11308             {
11309               op1 = c_objc_common_truthvalue_conversion (location, orig_op1);
11310               op1 = remove_c_maybe_const_expr (op1);
11311             }
11312           else
11313             op1 = c_objc_common_truthvalue_conversion (location, op1);
11314           converted = 1;
11315           boolean_op = true;
11316         }
11317       if (code == TRUTH_ANDIF_EXPR)
11318         {
11319           int_const_or_overflow = (int_operands
11320                                    && TREE_CODE (orig_op0) == INTEGER_CST
11321                                    && (op0 == truthvalue_false_node
11322                                        || TREE_CODE (orig_op1) == INTEGER_CST));
11323           int_const = (int_const_or_overflow
11324                        && !TREE_OVERFLOW (orig_op0)
11325                        && (op0 == truthvalue_false_node
11326                            || !TREE_OVERFLOW (orig_op1)));
11327         }
11328       else if (code == TRUTH_ORIF_EXPR)
11329         {
11330           int_const_or_overflow = (int_operands
11331                                    && TREE_CODE (orig_op0) == INTEGER_CST
11332                                    && (op0 == truthvalue_true_node
11333                                        || TREE_CODE (orig_op1) == INTEGER_CST));
11334           int_const = (int_const_or_overflow
11335                        && !TREE_OVERFLOW (orig_op0)
11336                        && (op0 == truthvalue_true_node
11337                            || !TREE_OVERFLOW (orig_op1)));
11338         }
11339       break;
11340
11341       /* Shift operations: result has same type as first operand;
11342          always convert second operand to int.
11343          Also set SHORT_SHIFT if shifting rightward.  */
11344
11345     case RSHIFT_EXPR:
11346       if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
11347           && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE
11348           && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE
11349           && TYPE_VECTOR_SUBPARTS (type0) == TYPE_VECTOR_SUBPARTS (type1))
11350         {
11351           result_type = type0;
11352           converted = 1;
11353         }
11354       else if ((code0 == INTEGER_TYPE || code0 == FIXED_POINT_TYPE
11355                 || code0 == VECTOR_TYPE)
11356                && code1 == INTEGER_TYPE)
11357         {
11358           doing_shift = true;
11359           if (TREE_CODE (op1) == INTEGER_CST)
11360             {
11361               if (tree_int_cst_sgn (op1) < 0)
11362                 {
11363                   int_const = false;
11364                   if (c_inhibit_evaluation_warnings == 0)
11365                     warning_at (location, OPT_Wshift_count_negative,
11366                                 "right shift count is negative");
11367                 }
11368               else if (code0 == VECTOR_TYPE)
11369                 {
11370                   if (compare_tree_int (op1,
11371                                         TYPE_PRECISION (TREE_TYPE (type0)))
11372                       >= 0)
11373                     {
11374                       int_const = false;
11375                       if (c_inhibit_evaluation_warnings == 0)
11376                         warning_at (location, OPT_Wshift_count_overflow,
11377                                     "right shift count >= width of vector element");
11378                     }
11379                 }
11380               else
11381                 {
11382                   if (!integer_zerop (op1))
11383                     short_shift = 1;
11384
11385                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
11386                     {
11387                       int_const = false;
11388                       if (c_inhibit_evaluation_warnings == 0)
11389                         warning_at (location, OPT_Wshift_count_overflow,
11390                                     "right shift count >= width of type");
11391                     }
11392                 }
11393             }
11394
11395           /* Use the type of the value to be shifted.  */
11396           result_type = type0;
11397           /* Avoid converting op1 to result_type later.  */
11398           converted = 1;
11399         }
11400       break;
11401
11402     case LSHIFT_EXPR:
11403       if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
11404           && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE
11405           && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE
11406           && TYPE_VECTOR_SUBPARTS (type0) == TYPE_VECTOR_SUBPARTS (type1))
11407         {
11408           result_type = type0;
11409           converted = 1;
11410         }
11411       else if ((code0 == INTEGER_TYPE || code0 == FIXED_POINT_TYPE
11412                 || code0 == VECTOR_TYPE)
11413                && code1 == INTEGER_TYPE)
11414         {
11415           doing_shift = true;
11416           if (TREE_CODE (op0) == INTEGER_CST
11417               && tree_int_cst_sgn (op0) < 0)
11418             {
11419               /* Don't reject a left shift of a negative value in a context
11420                  where a constant expression is needed in C90.  */
11421               if (flag_isoc99)
11422                 int_const = false;
11423               if (c_inhibit_evaluation_warnings == 0)
11424                 warning_at (location, OPT_Wshift_negative_value,
11425                             "left shift of negative value");
11426             }
11427           if (TREE_CODE (op1) == INTEGER_CST)
11428             {
11429               if (tree_int_cst_sgn (op1) < 0)
11430                 {
11431                   int_const = false;
11432                   if (c_inhibit_evaluation_warnings == 0)
11433                     warning_at (location, OPT_Wshift_count_negative,
11434                                 "left shift count is negative");
11435                 }
11436               else if (code0 == VECTOR_TYPE)
11437                 {
11438                   if (compare_tree_int (op1,
11439                                         TYPE_PRECISION (TREE_TYPE (type0)))
11440                       >= 0)
11441                     {
11442                       int_const = false;
11443                       if (c_inhibit_evaluation_warnings == 0)
11444                         warning_at (location, OPT_Wshift_count_overflow,
11445                                     "left shift count >= width of vector element");
11446                     }
11447                 }
11448               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
11449                 {
11450                   int_const = false;
11451                   if (c_inhibit_evaluation_warnings == 0)
11452                     warning_at (location, OPT_Wshift_count_overflow,
11453                                 "left shift count >= width of type");
11454                 }
11455               else if (TREE_CODE (op0) == INTEGER_CST
11456                        && maybe_warn_shift_overflow (location, op0, op1)
11457                        && flag_isoc99)
11458                 int_const = false;
11459             }
11460
11461           /* Use the type of the value to be shifted.  */
11462           result_type = type0;
11463           /* Avoid converting op1 to result_type later.  */
11464           converted = 1;
11465         }
11466       break;
11467
11468     case EQ_EXPR:
11469     case NE_EXPR:
11470       if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
11471         {
11472           tree intt;
11473           if (!vector_types_compatible_elements_p (type0, type1))
11474             {
11475               error_at (location, "comparing vectors with different "
11476                                   "element types");
11477               return error_mark_node;
11478             }
11479
11480           if (TYPE_VECTOR_SUBPARTS (type0) != TYPE_VECTOR_SUBPARTS (type1))
11481             {
11482               error_at (location, "comparing vectors with different "
11483                                   "number of elements");
11484               return error_mark_node;
11485             }
11486
11487           /* It's not precisely specified how the usual arithmetic
11488              conversions apply to the vector types.  Here, we use
11489              the unsigned type if one of the operands is signed and
11490              the other one is unsigned.  */
11491           if (TYPE_UNSIGNED (type0) != TYPE_UNSIGNED (type1))
11492             {
11493               if (!TYPE_UNSIGNED (type0))
11494                 op0 = build1 (VIEW_CONVERT_EXPR, type1, op0);
11495               else
11496                 op1 = build1 (VIEW_CONVERT_EXPR, type0, op1);
11497               warning_at (location, OPT_Wsign_compare, "comparison between "
11498                           "types %qT and %qT", type0, type1);
11499             }
11500
11501           /* Always construct signed integer vector type.  */
11502           intt = c_common_type_for_size (GET_MODE_BITSIZE
11503                                          (SCALAR_TYPE_MODE
11504                                           (TREE_TYPE (type0))), 0);
11505           result_type = build_opaque_vector_type (intt,
11506                                                   TYPE_VECTOR_SUBPARTS (type0));
11507           converted = 1;
11508           ret = build_vec_cmp (resultcode, result_type, op0, op1);
11509           goto return_build_binary_op;
11510         }
11511       if (FLOAT_TYPE_P (type0) || FLOAT_TYPE_P (type1))
11512         warning_at (location,
11513                     OPT_Wfloat_equal,
11514                     "comparing floating point with == or != is unsafe");
11515       /* Result of comparison is always int,
11516          but don't convert the args to int!  */
11517       build_type = integer_type_node;
11518       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
11519            || code0 == FIXED_POINT_TYPE || code0 == COMPLEX_TYPE)
11520           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
11521               || code1 == FIXED_POINT_TYPE || code1 == COMPLEX_TYPE))
11522         short_compare = 1;
11523       else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
11524         {
11525           if (TREE_CODE (op0) == ADDR_EXPR
11526               && decl_with_nonnull_addr_p (TREE_OPERAND (op0, 0))
11527               && !from_macro_expansion_at (location))
11528             {
11529               if (code == EQ_EXPR)
11530                 warning_at (location,
11531                             OPT_Waddress,
11532                             "the comparison will always evaluate as %<false%> "
11533                             "for the address of %qD will never be NULL",
11534                             TREE_OPERAND (op0, 0));
11535               else
11536                 warning_at (location,
11537                             OPT_Waddress,
11538                             "the comparison will always evaluate as %<true%> "
11539                             "for the address of %qD will never be NULL",
11540                             TREE_OPERAND (op0, 0));
11541             }
11542           result_type = type0;
11543         }
11544       else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0))
11545         {
11546           if (TREE_CODE (op1) == ADDR_EXPR
11547               && decl_with_nonnull_addr_p (TREE_OPERAND (op1, 0))
11548               && !from_macro_expansion_at (location))
11549             {
11550               if (code == EQ_EXPR)
11551                 warning_at (location,
11552                             OPT_Waddress,
11553                             "the comparison will always evaluate as %<false%> "
11554                             "for the address of %qD will never be NULL",
11555                             TREE_OPERAND (op1, 0));
11556               else
11557                 warning_at (location,
11558                             OPT_Waddress,
11559                             "the comparison will always evaluate as %<true%> "
11560                             "for the address of %qD will never be NULL",
11561                             TREE_OPERAND (op1, 0));
11562             }
11563           result_type = type1;
11564         }
11565       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
11566         {
11567           tree tt0 = TREE_TYPE (type0);
11568           tree tt1 = TREE_TYPE (type1);
11569           addr_space_t as0 = TYPE_ADDR_SPACE (tt0);
11570           addr_space_t as1 = TYPE_ADDR_SPACE (tt1);
11571           addr_space_t as_common = ADDR_SPACE_GENERIC;
11572
11573           /* Anything compares with void *.  void * compares with anything.
11574              Otherwise, the targets must be compatible
11575              and both must be object or both incomplete.  */
11576           if (comp_target_types (location, type0, type1))
11577             result_type = common_pointer_type (type0, type1);
11578           else if (!addr_space_superset (as0, as1, &as_common))
11579             {
11580               error_at (location, "comparison of pointers to "
11581                         "disjoint address spaces");
11582               return error_mark_node;
11583             }
11584           else if (VOID_TYPE_P (tt0) && !TYPE_ATOMIC (tt0))
11585             {
11586               if (pedantic && TREE_CODE (tt1) == FUNCTION_TYPE)
11587                 pedwarn (location, OPT_Wpedantic, "ISO C forbids "
11588                          "comparison of %<void *%> with function pointer");
11589             }
11590           else if (VOID_TYPE_P (tt1) && !TYPE_ATOMIC (tt1))
11591             {
11592               if (pedantic && TREE_CODE (tt0) == FUNCTION_TYPE)
11593                 pedwarn (location, OPT_Wpedantic, "ISO C forbids "
11594                          "comparison of %<void *%> with function pointer");
11595             }
11596           else
11597             /* Avoid warning about the volatile ObjC EH puts on decls.  */
11598             if (!objc_ok)
11599               pedwarn (location, 0,
11600                        "comparison of distinct pointer types lacks a cast");
11601
11602           if (result_type == NULL_TREE)
11603             {
11604               int qual = ENCODE_QUAL_ADDR_SPACE (as_common);
11605               result_type = build_pointer_type
11606                               (build_qualified_type (void_type_node, qual));
11607             }
11608         }
11609       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
11610         {
11611           result_type = type0;
11612           pedwarn (location, 0, "comparison between pointer and integer");
11613         }
11614       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
11615         {
11616           result_type = type1;
11617           pedwarn (location, 0, "comparison between pointer and integer");
11618         }
11619       if ((TREE_CODE (TREE_TYPE (orig_op0)) == BOOLEAN_TYPE
11620            || truth_value_p (TREE_CODE (orig_op0)))
11621           ^ (TREE_CODE (TREE_TYPE (orig_op1)) == BOOLEAN_TYPE
11622              || truth_value_p (TREE_CODE (orig_op1))))
11623         maybe_warn_bool_compare (location, code, orig_op0, orig_op1);
11624       break;
11625
11626     case LE_EXPR:
11627     case GE_EXPR:
11628     case LT_EXPR:
11629     case GT_EXPR:
11630       if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
11631         {
11632           tree intt;
11633           if (!vector_types_compatible_elements_p (type0, type1))
11634             {
11635               error_at (location, "comparing vectors with different "
11636                                   "element types");
11637               return error_mark_node;
11638             }
11639
11640           if (TYPE_VECTOR_SUBPARTS (type0) != TYPE_VECTOR_SUBPARTS (type1))
11641             {
11642               error_at (location, "comparing vectors with different "
11643                                   "number of elements");
11644               return error_mark_node;
11645             }
11646
11647           /* It's not precisely specified how the usual arithmetic
11648              conversions apply to the vector types.  Here, we use
11649              the unsigned type if one of the operands is signed and
11650              the other one is unsigned.  */
11651           if (TYPE_UNSIGNED (type0) != TYPE_UNSIGNED (type1))
11652             {
11653               if (!TYPE_UNSIGNED (type0))
11654                 op0 = build1 (VIEW_CONVERT_EXPR, type1, op0);
11655               else
11656                 op1 = build1 (VIEW_CONVERT_EXPR, type0, op1);
11657               warning_at (location, OPT_Wsign_compare, "comparison between "
11658                           "types %qT and %qT", type0, type1);
11659             }
11660
11661           /* Always construct signed integer vector type.  */
11662           intt = c_common_type_for_size (GET_MODE_BITSIZE
11663                                          (SCALAR_TYPE_MODE
11664                                           (TREE_TYPE (type0))), 0);
11665           result_type = build_opaque_vector_type (intt,
11666                                                   TYPE_VECTOR_SUBPARTS (type0));
11667           converted = 1;
11668           ret = build_vec_cmp (resultcode, result_type, op0, op1);
11669           goto return_build_binary_op;
11670         }
11671       build_type = integer_type_node;
11672       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
11673            || code0 == FIXED_POINT_TYPE)
11674           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
11675               || code1 == FIXED_POINT_TYPE))
11676         short_compare = 1;
11677       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
11678         {
11679           addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (type0));
11680           addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (type1));
11681           addr_space_t as_common;
11682
11683           if (comp_target_types (location, type0, type1))
11684             {
11685               result_type = common_pointer_type (type0, type1);
11686               if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
11687                   != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
11688                 pedwarn (location, 0,
11689                          "comparison of complete and incomplete pointers");
11690               else if (TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
11691                 pedwarn (location, OPT_Wpedantic, "ISO C forbids "
11692                          "ordered comparisons of pointers to functions");
11693               else if (null_pointer_constant_p (orig_op0)
11694                        || null_pointer_constant_p (orig_op1))
11695                 warning_at (location, OPT_Wextra,
11696                             "ordered comparison of pointer with null pointer");
11697
11698             }
11699           else if (!addr_space_superset (as0, as1, &as_common))
11700             {
11701               error_at (location, "comparison of pointers to "
11702                         "disjoint address spaces");
11703               return error_mark_node;
11704             }
11705           else
11706             {
11707               int qual = ENCODE_QUAL_ADDR_SPACE (as_common);
11708               result_type = build_pointer_type
11709                               (build_qualified_type (void_type_node, qual));
11710               pedwarn (location, 0,
11711                        "comparison of distinct pointer types lacks a cast");
11712             }
11713         }
11714       else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
11715         {
11716           result_type = type0;
11717           if (pedantic)
11718             pedwarn (location, OPT_Wpedantic,
11719                      "ordered comparison of pointer with integer zero");
11720           else if (extra_warnings)
11721             warning_at (location, OPT_Wextra,
11722                         "ordered comparison of pointer with integer zero");
11723         }
11724       else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0))
11725         {
11726           result_type = type1;
11727           if (pedantic)
11728             pedwarn (location, OPT_Wpedantic,
11729                      "ordered comparison of pointer with integer zero");
11730           else if (extra_warnings)
11731             warning_at (location, OPT_Wextra,
11732                         "ordered comparison of pointer with integer zero");
11733         }
11734       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
11735         {
11736           result_type = type0;
11737           pedwarn (location, 0, "comparison between pointer and integer");
11738         }
11739       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
11740         {
11741           result_type = type1;
11742           pedwarn (location, 0, "comparison between pointer and integer");
11743         }
11744
11745       if ((code0 == POINTER_TYPE || code1 == POINTER_TYPE)
11746           && sanitize_flags_p (SANITIZE_POINTER_COMPARE))
11747         {
11748           op0 = save_expr (op0);
11749           op1 = save_expr (op1);
11750
11751           tree tt = builtin_decl_explicit (BUILT_IN_ASAN_POINTER_COMPARE);
11752           instrument_expr = build_call_expr_loc (location, tt, 2, op0, op1);
11753         }
11754
11755       if ((TREE_CODE (TREE_TYPE (orig_op0)) == BOOLEAN_TYPE
11756            || truth_value_p (TREE_CODE (orig_op0)))
11757           ^ (TREE_CODE (TREE_TYPE (orig_op1)) == BOOLEAN_TYPE
11758              || truth_value_p (TREE_CODE (orig_op1))))
11759         maybe_warn_bool_compare (location, code, orig_op0, orig_op1);
11760       break;
11761
11762     default:
11763       gcc_unreachable ();
11764     }
11765
11766   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
11767     return error_mark_node;
11768
11769   if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
11770       && (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
11771           || !vector_types_compatible_elements_p (type0, type1)))
11772     {
11773       gcc_rich_location richloc (location);
11774       richloc.maybe_add_expr (orig_op0);
11775       richloc.maybe_add_expr (orig_op1);
11776       binary_op_error (&richloc, code, type0, type1);
11777       return error_mark_node;
11778     }
11779
11780   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
11781        || code0 == FIXED_POINT_TYPE || code0 == VECTOR_TYPE)
11782       &&
11783       (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
11784        || code1 == FIXED_POINT_TYPE || code1 == VECTOR_TYPE))
11785     {
11786       bool first_complex = (code0 == COMPLEX_TYPE);
11787       bool second_complex = (code1 == COMPLEX_TYPE);
11788       int none_complex = (!first_complex && !second_complex);
11789
11790       if (shorten || common || short_compare)
11791         {
11792           result_type = c_common_type (type0, type1);
11793           do_warn_double_promotion (result_type, type0, type1,
11794                                     "implicit conversion from %qT to %qT "
11795                                     "to match other operand of binary "
11796                                     "expression",
11797                                     location);
11798           if (result_type == error_mark_node)
11799             return error_mark_node;
11800         }
11801
11802       if (first_complex != second_complex
11803           && (code == PLUS_EXPR
11804               || code == MINUS_EXPR
11805               || code == MULT_EXPR
11806               || (code == TRUNC_DIV_EXPR && first_complex))
11807           && TREE_CODE (TREE_TYPE (result_type)) == REAL_TYPE
11808           && flag_signed_zeros)
11809         {
11810           /* An operation on mixed real/complex operands must be
11811              handled specially, but the language-independent code can
11812              more easily optimize the plain complex arithmetic if
11813              -fno-signed-zeros.  */
11814           tree real_type = TREE_TYPE (result_type);
11815           tree real, imag;
11816           if (type0 != orig_type0 || type1 != orig_type1)
11817             {
11818               gcc_assert (may_need_excess_precision && common);
11819               semantic_result_type = c_common_type (orig_type0, orig_type1);
11820             }
11821           if (first_complex)
11822             {
11823               if (TREE_TYPE (op0) != result_type)
11824                 op0 = convert_and_check (location, result_type, op0);
11825               if (TREE_TYPE (op1) != real_type)
11826                 op1 = convert_and_check (location, real_type, op1);
11827             }
11828           else
11829             {
11830               if (TREE_TYPE (op0) != real_type)
11831                 op0 = convert_and_check (location, real_type, op0);
11832               if (TREE_TYPE (op1) != result_type)
11833                 op1 = convert_and_check (location, result_type, op1);
11834             }
11835           if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
11836             return error_mark_node;
11837           if (first_complex)
11838             {
11839               op0 = save_expr (op0);
11840               real = build_unary_op (EXPR_LOCATION (orig_op0), REALPART_EXPR,
11841                                      op0, true);
11842               imag = build_unary_op (EXPR_LOCATION (orig_op0), IMAGPART_EXPR,
11843                                      op0, true);
11844               switch (code)
11845                 {
11846                 case MULT_EXPR:
11847                 case TRUNC_DIV_EXPR:
11848                   op1 = save_expr (op1);
11849                   imag = build2 (resultcode, real_type, imag, op1);
11850                   /* Fall through.  */
11851                 case PLUS_EXPR:
11852                 case MINUS_EXPR:
11853                   real = build2 (resultcode, real_type, real, op1);
11854                   break;
11855                 default:
11856                   gcc_unreachable();
11857                 }
11858             }
11859           else
11860             {
11861               op1 = save_expr (op1);
11862               real = build_unary_op (EXPR_LOCATION (orig_op1), REALPART_EXPR,
11863                                      op1, true);
11864               imag = build_unary_op (EXPR_LOCATION (orig_op1), IMAGPART_EXPR,
11865                                      op1, true);
11866               switch (code)
11867                 {
11868                 case MULT_EXPR:
11869                   op0 = save_expr (op0);
11870                   imag = build2 (resultcode, real_type, op0, imag);
11871                   /* Fall through.  */
11872                 case PLUS_EXPR:
11873                   real = build2 (resultcode, real_type, op0, real);
11874                   break;
11875                 case MINUS_EXPR:
11876                   real = build2 (resultcode, real_type, op0, real);
11877                   imag = build1 (NEGATE_EXPR, real_type, imag);
11878                   break;
11879                 default:
11880                   gcc_unreachable();
11881                 }
11882             }
11883           ret = build2 (COMPLEX_EXPR, result_type, real, imag);
11884           goto return_build_binary_op;
11885         }
11886
11887       /* For certain operations (which identify themselves by shorten != 0)
11888          if both args were extended from the same smaller type,
11889          do the arithmetic in that type and then extend.
11890
11891          shorten !=0 and !=1 indicates a bitwise operation.
11892          For them, this optimization is safe only if
11893          both args are zero-extended or both are sign-extended.
11894          Otherwise, we might change the result.
11895          Eg, (short)-1 | (unsigned short)-1 is (int)-1
11896          but calculated in (unsigned short) it would be (unsigned short)-1.  */
11897
11898       if (shorten && none_complex)
11899         {
11900           final_type = result_type;
11901           result_type = shorten_binary_op (result_type, op0, op1,
11902                                            shorten == -1);
11903         }
11904
11905       /* Shifts can be shortened if shifting right.  */
11906
11907       if (short_shift)
11908         {
11909           int unsigned_arg;
11910           tree arg0 = get_narrower (op0, &unsigned_arg);
11911
11912           final_type = result_type;
11913
11914           if (arg0 == op0 && final_type == TREE_TYPE (op0))
11915             unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
11916
11917           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
11918               && tree_int_cst_sgn (op1) > 0
11919               /* We can shorten only if the shift count is less than the
11920                  number of bits in the smaller type size.  */
11921               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
11922               /* We cannot drop an unsigned shift after sign-extension.  */
11923               && (!TYPE_UNSIGNED (final_type) || unsigned_arg))
11924             {
11925               /* Do an unsigned shift if the operand was zero-extended.  */
11926               result_type
11927                 = c_common_signed_or_unsigned_type (unsigned_arg,
11928                                                     TREE_TYPE (arg0));
11929               /* Convert value-to-be-shifted to that type.  */
11930               if (TREE_TYPE (op0) != result_type)
11931                 op0 = convert (result_type, op0);
11932               converted = 1;
11933             }
11934         }
11935
11936       /* Comparison operations are shortened too but differently.
11937          They identify themselves by setting short_compare = 1.  */
11938
11939       if (short_compare)
11940         {
11941           /* Don't write &op0, etc., because that would prevent op0
11942              from being kept in a register.
11943              Instead, make copies of the our local variables and
11944              pass the copies by reference, then copy them back afterward.  */
11945           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
11946           enum tree_code xresultcode = resultcode;
11947           tree val
11948             = shorten_compare (location, &xop0, &xop1, &xresult_type,
11949                                &xresultcode);
11950
11951           if (val != NULL_TREE)
11952             {
11953               ret = val;
11954               goto return_build_binary_op;
11955             }
11956
11957           op0 = xop0, op1 = xop1;
11958           converted = 1;
11959           resultcode = xresultcode;
11960
11961           if (c_inhibit_evaluation_warnings == 0)
11962             {
11963               bool op0_maybe_const = true;
11964               bool op1_maybe_const = true;
11965               tree orig_op0_folded, orig_op1_folded;
11966
11967               if (in_late_binary_op)
11968                 {
11969                   orig_op0_folded = orig_op0;
11970                   orig_op1_folded = orig_op1;
11971                 }
11972               else
11973                 {
11974                   /* Fold for the sake of possible warnings, as in
11975                      build_conditional_expr.  This requires the
11976                      "original" values to be folded, not just op0 and
11977                      op1.  */
11978                   c_inhibit_evaluation_warnings++;
11979                   op0 = c_fully_fold (op0, require_constant_value,
11980                                       &op0_maybe_const);
11981                   op1 = c_fully_fold (op1, require_constant_value,
11982                                       &op1_maybe_const);
11983                   c_inhibit_evaluation_warnings--;
11984                   orig_op0_folded = c_fully_fold (orig_op0,
11985                                                   require_constant_value,
11986                                                   NULL);
11987                   orig_op1_folded = c_fully_fold (orig_op1,
11988                                                   require_constant_value,
11989                                                   NULL);
11990                 }
11991
11992               if (warn_sign_compare)
11993                 warn_for_sign_compare (location, orig_op0_folded,
11994                                        orig_op1_folded, op0, op1,
11995                                        result_type, resultcode);
11996               if (!in_late_binary_op && !int_operands)
11997                 {
11998                   if (!op0_maybe_const || TREE_CODE (op0) != INTEGER_CST)
11999                     op0 = c_wrap_maybe_const (op0, !op0_maybe_const);
12000                   if (!op1_maybe_const || TREE_CODE (op1) != INTEGER_CST)
12001                     op1 = c_wrap_maybe_const (op1, !op1_maybe_const);
12002                 }
12003             }
12004         }
12005     }
12006
12007   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
12008      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
12009      Then the expression will be built.
12010      It will be given type FINAL_TYPE if that is nonzero;
12011      otherwise, it will be given type RESULT_TYPE.  */
12012
12013   if (!result_type)
12014     {
12015       gcc_rich_location richloc (location);
12016       richloc.maybe_add_expr (orig_op0);
12017       richloc.maybe_add_expr (orig_op1);
12018       binary_op_error (&richloc, code, TREE_TYPE (op0), TREE_TYPE (op1));
12019       return error_mark_node;
12020     }
12021
12022   if (build_type == NULL_TREE)
12023     {
12024       build_type = result_type;
12025       if ((type0 != orig_type0 || type1 != orig_type1)
12026           && !boolean_op)
12027         {
12028           gcc_assert (may_need_excess_precision && common);
12029           semantic_result_type = c_common_type (orig_type0, orig_type1);
12030         }
12031     }
12032
12033   if (!converted)
12034     {
12035       op0 = ep_convert_and_check (location, result_type, op0,
12036                                   semantic_result_type);
12037       op1 = ep_convert_and_check (location, result_type, op1,
12038                                   semantic_result_type);
12039
12040       /* This can happen if one operand has a vector type, and the other
12041          has a different type.  */
12042       if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
12043         return error_mark_node;
12044     }
12045
12046   if (sanitize_flags_p ((SANITIZE_SHIFT
12047                          | SANITIZE_DIVIDE | SANITIZE_FLOAT_DIVIDE))
12048       && current_function_decl != NULL_TREE
12049       && (doing_div_or_mod || doing_shift)
12050       && !require_constant_value)
12051     {
12052       /* OP0 and/or OP1 might have side-effects.  */
12053       op0 = save_expr (op0);
12054       op1 = save_expr (op1);
12055       op0 = c_fully_fold (op0, false, NULL);
12056       op1 = c_fully_fold (op1, false, NULL);
12057       if (doing_div_or_mod && (sanitize_flags_p ((SANITIZE_DIVIDE
12058                                                   | SANITIZE_FLOAT_DIVIDE))))
12059         instrument_expr = ubsan_instrument_division (location, op0, op1);
12060       else if (doing_shift && sanitize_flags_p (SANITIZE_SHIFT))
12061         instrument_expr = ubsan_instrument_shift (location, code, op0, op1);
12062     }
12063
12064   /* Treat expressions in initializers specially as they can't trap.  */
12065   if (int_const_or_overflow)
12066     ret = (require_constant_value
12067            ? fold_build2_initializer_loc (location, resultcode, build_type,
12068                                           op0, op1)
12069            : fold_build2_loc (location, resultcode, build_type, op0, op1));
12070   else
12071     ret = build2 (resultcode, build_type, op0, op1);
12072   if (final_type != NULL_TREE)
12073     ret = convert (final_type, ret);
12074
12075  return_build_binary_op:
12076   gcc_assert (ret != error_mark_node);
12077   if (TREE_CODE (ret) == INTEGER_CST && !TREE_OVERFLOW (ret) && !int_const)
12078     ret = (int_operands
12079            ? note_integer_operands (ret)
12080            : build1 (NOP_EXPR, TREE_TYPE (ret), ret));
12081   else if (TREE_CODE (ret) != INTEGER_CST && int_operands
12082            && !in_late_binary_op)
12083     ret = note_integer_operands (ret);
12084   protected_set_expr_location (ret, location);
12085
12086   if (instrument_expr != NULL)
12087     ret = fold_build2 (COMPOUND_EXPR, TREE_TYPE (ret),
12088                        instrument_expr, ret);
12089
12090   if (semantic_result_type)
12091     ret = build1_loc (location, EXCESS_PRECISION_EXPR,
12092                       semantic_result_type, ret);
12093
12094   return ret;
12095 }
12096
12097
12098 /* Convert EXPR to be a truth-value, validating its type for this
12099    purpose.  LOCATION is the source location for the expression.  */
12100
12101 tree
12102 c_objc_common_truthvalue_conversion (location_t location, tree expr)
12103 {
12104   bool int_const, int_operands;
12105
12106   switch (TREE_CODE (TREE_TYPE (expr)))
12107     {
12108     case ARRAY_TYPE:
12109       error_at (location, "used array that cannot be converted to pointer where scalar is required");
12110       return error_mark_node;
12111
12112     case RECORD_TYPE:
12113       error_at (location, "used struct type value where scalar is required");
12114       return error_mark_node;
12115
12116     case UNION_TYPE:
12117       error_at (location, "used union type value where scalar is required");
12118       return error_mark_node;
12119
12120     case VOID_TYPE:
12121       error_at (location, "void value not ignored as it ought to be");
12122       return error_mark_node;
12123
12124     case POINTER_TYPE:
12125       if (reject_gcc_builtin (expr))
12126         return error_mark_node;
12127       break;
12128
12129     case FUNCTION_TYPE:
12130       gcc_unreachable ();
12131
12132     case VECTOR_TYPE:
12133       error_at (location, "used vector type where scalar is required");
12134       return error_mark_node;
12135
12136     default:
12137       break;
12138     }
12139
12140   int_const = (TREE_CODE (expr) == INTEGER_CST && !TREE_OVERFLOW (expr));
12141   int_operands = EXPR_INT_CONST_OPERANDS (expr);
12142   if (int_operands && TREE_CODE (expr) != INTEGER_CST)
12143     {
12144       expr = remove_c_maybe_const_expr (expr);
12145       expr = build2 (NE_EXPR, integer_type_node, expr,
12146                      convert (TREE_TYPE (expr), integer_zero_node));
12147       expr = note_integer_operands (expr);
12148     }
12149   else
12150     /* ??? Should we also give an error for vectors rather than leaving
12151        those to give errors later?  */
12152     expr = c_common_truthvalue_conversion (location, expr);
12153
12154   if (TREE_CODE (expr) == INTEGER_CST && int_operands && !int_const)
12155     {
12156       if (TREE_OVERFLOW (expr))
12157         return expr;
12158       else
12159         return note_integer_operands (expr);
12160     }
12161   if (TREE_CODE (expr) == INTEGER_CST && !int_const)
12162     return build1 (NOP_EXPR, TREE_TYPE (expr), expr);
12163   return expr;
12164 }
12165 \f
12166
12167 /* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as
12168    required.  */
12169
12170 tree
12171 c_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se)
12172 {
12173   if (TREE_CODE (expr) == COMPOUND_LITERAL_EXPR)
12174     {
12175       tree decl = COMPOUND_LITERAL_EXPR_DECL (expr);
12176       /* Executing a compound literal inside a function reinitializes
12177          it.  */
12178       if (!TREE_STATIC (decl))
12179         *se = true;
12180       return decl;
12181     }
12182   else
12183     return expr;
12184 }
12185 \f
12186 /* Generate OMP construct CODE, with BODY and CLAUSES as its compound
12187    statement.  LOC is the location of the construct.  */
12188
12189 tree
12190 c_finish_omp_construct (location_t loc, enum tree_code code, tree body,
12191                         tree clauses)
12192 {
12193   body = c_end_compound_stmt (loc, body, true);
12194
12195   tree stmt = make_node (code);
12196   TREE_TYPE (stmt) = void_type_node;
12197   OMP_BODY (stmt) = body;
12198   OMP_CLAUSES (stmt) = clauses;
12199   SET_EXPR_LOCATION (stmt, loc);
12200
12201   return add_stmt (stmt);
12202 }
12203
12204 /* Generate OACC_DATA, with CLAUSES and BLOCK as its compound
12205    statement.  LOC is the location of the OACC_DATA.  */
12206
12207 tree
12208 c_finish_oacc_data (location_t loc, tree clauses, tree block)
12209 {
12210   tree stmt;
12211
12212   block = c_end_compound_stmt (loc, block, true);
12213
12214   stmt = make_node (OACC_DATA);
12215   TREE_TYPE (stmt) = void_type_node;
12216   OACC_DATA_CLAUSES (stmt) = clauses;
12217   OACC_DATA_BODY (stmt) = block;
12218   SET_EXPR_LOCATION (stmt, loc);
12219
12220   return add_stmt (stmt);
12221 }
12222
12223 /* Generate OACC_HOST_DATA, with CLAUSES and BLOCK as its compound
12224    statement.  LOC is the location of the OACC_HOST_DATA.  */
12225
12226 tree
12227 c_finish_oacc_host_data (location_t loc, tree clauses, tree block)
12228 {
12229   tree stmt;
12230
12231   block = c_end_compound_stmt (loc, block, true);
12232
12233   stmt = make_node (OACC_HOST_DATA);
12234   TREE_TYPE (stmt) = void_type_node;
12235   OACC_HOST_DATA_CLAUSES (stmt) = clauses;
12236   OACC_HOST_DATA_BODY (stmt) = block;
12237   SET_EXPR_LOCATION (stmt, loc);
12238
12239   return add_stmt (stmt);
12240 }
12241
12242 /* Like c_begin_compound_stmt, except force the retention of the BLOCK.  */
12243
12244 tree
12245 c_begin_omp_parallel (void)
12246 {
12247   tree block;
12248
12249   keep_next_level ();
12250   block = c_begin_compound_stmt (true);
12251
12252   return block;
12253 }
12254
12255 /* Generate OMP_PARALLEL, with CLAUSES and BLOCK as its compound
12256    statement.  LOC is the location of the OMP_PARALLEL.  */
12257
12258 tree
12259 c_finish_omp_parallel (location_t loc, tree clauses, tree block)
12260 {
12261   tree stmt;
12262
12263   block = c_end_compound_stmt (loc, block, true);
12264
12265   stmt = make_node (OMP_PARALLEL);
12266   TREE_TYPE (stmt) = void_type_node;
12267   OMP_PARALLEL_CLAUSES (stmt) = clauses;
12268   OMP_PARALLEL_BODY (stmt) = block;
12269   SET_EXPR_LOCATION (stmt, loc);
12270
12271   return add_stmt (stmt);
12272 }
12273
12274 /* Like c_begin_compound_stmt, except force the retention of the BLOCK.  */
12275
12276 tree
12277 c_begin_omp_task (void)
12278 {
12279   tree block;
12280
12281   keep_next_level ();
12282   block = c_begin_compound_stmt (true);
12283
12284   return block;
12285 }
12286
12287 /* Generate OMP_TASK, with CLAUSES and BLOCK as its compound
12288    statement.  LOC is the location of the #pragma.  */
12289
12290 tree
12291 c_finish_omp_task (location_t loc, tree clauses, tree block)
12292 {
12293   tree stmt;
12294
12295   block = c_end_compound_stmt (loc, block, true);
12296
12297   stmt = make_node (OMP_TASK);
12298   TREE_TYPE (stmt) = void_type_node;
12299   OMP_TASK_CLAUSES (stmt) = clauses;
12300   OMP_TASK_BODY (stmt) = block;
12301   SET_EXPR_LOCATION (stmt, loc);
12302
12303   return add_stmt (stmt);
12304 }
12305
12306 /* Generate GOMP_cancel call for #pragma omp cancel.  */
12307
12308 void
12309 c_finish_omp_cancel (location_t loc, tree clauses)
12310 {
12311   tree fn = builtin_decl_explicit (BUILT_IN_GOMP_CANCEL);
12312   int mask = 0;
12313   if (omp_find_clause (clauses, OMP_CLAUSE_PARALLEL))
12314     mask = 1;
12315   else if (omp_find_clause (clauses, OMP_CLAUSE_FOR))
12316     mask = 2;
12317   else if (omp_find_clause (clauses, OMP_CLAUSE_SECTIONS))
12318     mask = 4;
12319   else if (omp_find_clause (clauses, OMP_CLAUSE_TASKGROUP))
12320     mask = 8;
12321   else
12322     {
12323       error_at (loc, "%<#pragma omp cancel%> must specify one of "
12324                      "%<parallel%>, %<for%>, %<sections%> or %<taskgroup%> "
12325                      "clauses");
12326       return;
12327     }
12328   tree ifc = omp_find_clause (clauses, OMP_CLAUSE_IF);
12329   if (ifc != NULL_TREE)
12330     {
12331       tree type = TREE_TYPE (OMP_CLAUSE_IF_EXPR (ifc));
12332       ifc = fold_build2_loc (OMP_CLAUSE_LOCATION (ifc), NE_EXPR,
12333                              boolean_type_node, OMP_CLAUSE_IF_EXPR (ifc),
12334                              build_zero_cst (type));
12335     }
12336   else
12337     ifc = boolean_true_node;
12338   tree stmt = build_call_expr_loc (loc, fn, 2,
12339                                    build_int_cst (integer_type_node, mask),
12340                                    ifc);
12341   add_stmt (stmt);
12342 }
12343
12344 /* Generate GOMP_cancellation_point call for
12345    #pragma omp cancellation point.  */
12346
12347 void
12348 c_finish_omp_cancellation_point (location_t loc, tree clauses)
12349 {
12350   tree fn = builtin_decl_explicit (BUILT_IN_GOMP_CANCELLATION_POINT);
12351   int mask = 0;
12352   if (omp_find_clause (clauses, OMP_CLAUSE_PARALLEL))
12353     mask = 1;
12354   else if (omp_find_clause (clauses, OMP_CLAUSE_FOR))
12355     mask = 2;
12356   else if (omp_find_clause (clauses, OMP_CLAUSE_SECTIONS))
12357     mask = 4;
12358   else if (omp_find_clause (clauses, OMP_CLAUSE_TASKGROUP))
12359     mask = 8;
12360   else
12361     {
12362       error_at (loc, "%<#pragma omp cancellation point%> must specify one of "
12363                      "%<parallel%>, %<for%>, %<sections%> or %<taskgroup%> "
12364                      "clauses");
12365       return;
12366     }
12367   tree stmt = build_call_expr_loc (loc, fn, 1,
12368                                    build_int_cst (integer_type_node, mask));
12369   add_stmt (stmt);
12370 }
12371
12372 /* Helper function for handle_omp_array_sections.  Called recursively
12373    to handle multiple array-section-subscripts.  C is the clause,
12374    T current expression (initially OMP_CLAUSE_DECL), which is either
12375    a TREE_LIST for array-section-subscript (TREE_PURPOSE is low-bound
12376    expression if specified, TREE_VALUE length expression if specified,
12377    TREE_CHAIN is what it has been specified after, or some decl.
12378    TYPES vector is populated with array section types, MAYBE_ZERO_LEN
12379    set to true if any of the array-section-subscript could have length
12380    of zero (explicit or implicit), FIRST_NON_ONE is the index of the
12381    first array-section-subscript which is known not to have length
12382    of one.  Given say:
12383    map(a[:b][2:1][:c][:2][:d][e:f][2:5])
12384    FIRST_NON_ONE will be 3, array-section-subscript [:b], [2:1] and [:c]
12385    all are or may have length of 1, array-section-subscript [:2] is the
12386    first one known not to have length 1.  For array-section-subscript
12387    <= FIRST_NON_ONE we diagnose non-contiguous arrays if low bound isn't
12388    0 or length isn't the array domain max + 1, for > FIRST_NON_ONE we
12389    can if MAYBE_ZERO_LEN is false.  MAYBE_ZERO_LEN will be true in the above
12390    case though, as some lengths could be zero.  */
12391
12392 static tree
12393 handle_omp_array_sections_1 (tree c, tree t, vec<tree> &types,
12394                              bool &maybe_zero_len, unsigned int &first_non_one,
12395                              enum c_omp_region_type ort)
12396 {
12397   tree ret, low_bound, length, type;
12398   if (TREE_CODE (t) != TREE_LIST)
12399     {
12400       if (error_operand_p (t))
12401         return error_mark_node;
12402       ret = t;
12403       if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
12404           && TYPE_ATOMIC (strip_array_types (TREE_TYPE (t))))
12405         {
12406           error_at (OMP_CLAUSE_LOCATION (c), "%<_Atomic%> %qE in %qs clause",
12407                     t, omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12408           return error_mark_node;
12409         }
12410       if (TREE_CODE (t) == COMPONENT_REF
12411           && ort == C_ORT_OMP
12412           && (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
12413               || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TO
12414               || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FROM))
12415         {
12416           if (DECL_BIT_FIELD (TREE_OPERAND (t, 1)))
12417             {
12418               error_at (OMP_CLAUSE_LOCATION (c),
12419                         "bit-field %qE in %qs clause",
12420                         t, omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12421               return error_mark_node;
12422             }
12423           while (TREE_CODE (t) == COMPONENT_REF)
12424             {
12425               if (TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == UNION_TYPE)
12426                 {
12427                   error_at (OMP_CLAUSE_LOCATION (c),
12428                             "%qE is a member of a union", t);
12429                   return error_mark_node;
12430                 }
12431               t = TREE_OPERAND (t, 0);
12432             }
12433         }
12434       if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
12435         {
12436           if (DECL_P (t))
12437             error_at (OMP_CLAUSE_LOCATION (c),
12438                       "%qD is not a variable in %qs clause", t,
12439                       omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12440           else
12441             error_at (OMP_CLAUSE_LOCATION (c),
12442                       "%qE is not a variable in %qs clause", t,
12443                       omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12444           return error_mark_node;
12445         }
12446       else if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
12447                && TYPE_ATOMIC (TREE_TYPE (t)))
12448         {
12449           error_at (OMP_CLAUSE_LOCATION (c), "%<_Atomic%> %qD in %qs clause",
12450                     t, omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12451           return error_mark_node;
12452         }
12453       else if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
12454                && VAR_P (t)
12455                && DECL_THREAD_LOCAL_P (t))
12456         {
12457           error_at (OMP_CLAUSE_LOCATION (c),
12458                     "%qD is threadprivate variable in %qs clause", t,
12459                     omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12460           return error_mark_node;
12461         }
12462       if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
12463           && TYPE_ATOMIC (TREE_TYPE (t))
12464           && POINTER_TYPE_P (TREE_TYPE (t)))
12465         {
12466           /* If the array section is pointer based and the pointer
12467              itself is _Atomic qualified, we need to atomically load
12468              the pointer.  */
12469           c_expr expr;
12470           memset (&expr, 0, sizeof (expr));
12471           expr.value = ret;
12472           expr = convert_lvalue_to_rvalue (OMP_CLAUSE_LOCATION (c),
12473                                            expr, false, false);
12474           ret = expr.value;
12475         }
12476       return ret;
12477     }
12478
12479   ret = handle_omp_array_sections_1 (c, TREE_CHAIN (t), types,
12480                                      maybe_zero_len, first_non_one, ort);
12481   if (ret == error_mark_node || ret == NULL_TREE)
12482     return ret;
12483
12484   type = TREE_TYPE (ret);
12485   low_bound = TREE_PURPOSE (t);
12486   length = TREE_VALUE (t);
12487
12488   if (low_bound == error_mark_node || length == error_mark_node)
12489     return error_mark_node;
12490
12491   if (low_bound && !INTEGRAL_TYPE_P (TREE_TYPE (low_bound)))
12492     {
12493       error_at (OMP_CLAUSE_LOCATION (c),
12494                 "low bound %qE of array section does not have integral type",
12495                 low_bound);
12496       return error_mark_node;
12497     }
12498   if (length && !INTEGRAL_TYPE_P (TREE_TYPE (length)))
12499     {
12500       error_at (OMP_CLAUSE_LOCATION (c),
12501                 "length %qE of array section does not have integral type",
12502                 length);
12503       return error_mark_node;
12504     }
12505   if (low_bound
12506       && TREE_CODE (low_bound) == INTEGER_CST
12507       && TYPE_PRECISION (TREE_TYPE (low_bound))
12508          > TYPE_PRECISION (sizetype))
12509     low_bound = fold_convert (sizetype, low_bound);
12510   if (length
12511       && TREE_CODE (length) == INTEGER_CST
12512       && TYPE_PRECISION (TREE_TYPE (length))
12513          > TYPE_PRECISION (sizetype))
12514     length = fold_convert (sizetype, length);
12515   if (low_bound == NULL_TREE)
12516     low_bound = integer_zero_node;
12517
12518   if (length != NULL_TREE)
12519     {
12520       if (!integer_nonzerop (length))
12521         {
12522           if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
12523               || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION)
12524             {
12525               if (integer_zerop (length))
12526                 {
12527                   error_at (OMP_CLAUSE_LOCATION (c),
12528                             "zero length array section in %qs clause",
12529                             omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12530                   return error_mark_node;
12531                 }
12532             }
12533           else
12534             maybe_zero_len = true;
12535         }
12536       if (first_non_one == types.length ()
12537           && (TREE_CODE (length) != INTEGER_CST || integer_onep (length)))
12538         first_non_one++;
12539     }
12540   if (TREE_CODE (type) == ARRAY_TYPE)
12541     {
12542       if (length == NULL_TREE
12543           && (TYPE_DOMAIN (type) == NULL_TREE
12544               || TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL_TREE))
12545         {
12546           error_at (OMP_CLAUSE_LOCATION (c),
12547                     "for unknown bound array type length expression must "
12548                     "be specified");
12549           return error_mark_node;
12550         }
12551       if (TREE_CODE (low_bound) == INTEGER_CST
12552           && tree_int_cst_sgn (low_bound) == -1)
12553         {
12554           error_at (OMP_CLAUSE_LOCATION (c),
12555                     "negative low bound in array section in %qs clause",
12556                     omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12557           return error_mark_node;
12558         }
12559       if (length != NULL_TREE
12560           && TREE_CODE (length) == INTEGER_CST
12561           && tree_int_cst_sgn (length) == -1)
12562         {
12563           error_at (OMP_CLAUSE_LOCATION (c),
12564                     "negative length in array section in %qs clause",
12565                     omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12566           return error_mark_node;
12567         }
12568       if (TYPE_DOMAIN (type)
12569           && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
12570           && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
12571                         == INTEGER_CST)
12572         {
12573           tree size
12574             = fold_convert (sizetype, TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
12575           size = size_binop (PLUS_EXPR, size, size_one_node);
12576           if (TREE_CODE (low_bound) == INTEGER_CST)
12577             {
12578               if (tree_int_cst_lt (size, low_bound))
12579                 {
12580                   error_at (OMP_CLAUSE_LOCATION (c),
12581                             "low bound %qE above array section size "
12582                             "in %qs clause", low_bound,
12583                             omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12584                   return error_mark_node;
12585                 }
12586               if (tree_int_cst_equal (size, low_bound))
12587                 {
12588                   if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
12589                       || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION)
12590                     {
12591                       error_at (OMP_CLAUSE_LOCATION (c),
12592                                 "zero length array section in %qs clause",
12593                                 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12594                       return error_mark_node;
12595                     }
12596                   maybe_zero_len = true;
12597                 }
12598               else if (length == NULL_TREE
12599                        && first_non_one == types.length ()
12600                        && tree_int_cst_equal
12601                             (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
12602                              low_bound))
12603                 first_non_one++;
12604             }
12605           else if (length == NULL_TREE)
12606             {
12607               if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
12608                   && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_REDUCTION)
12609                 maybe_zero_len = true;
12610               if (first_non_one == types.length ())
12611                 first_non_one++;
12612             }
12613           if (length && TREE_CODE (length) == INTEGER_CST)
12614             {
12615               if (tree_int_cst_lt (size, length))
12616                 {
12617                   error_at (OMP_CLAUSE_LOCATION (c),
12618                             "length %qE above array section size "
12619                             "in %qs clause", length,
12620                             omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12621                   return error_mark_node;
12622                 }
12623               if (TREE_CODE (low_bound) == INTEGER_CST)
12624                 {
12625                   tree lbpluslen
12626                     = size_binop (PLUS_EXPR,
12627                                   fold_convert (sizetype, low_bound),
12628                                   fold_convert (sizetype, length));
12629                   if (TREE_CODE (lbpluslen) == INTEGER_CST
12630                       && tree_int_cst_lt (size, lbpluslen))
12631                     {
12632                       error_at (OMP_CLAUSE_LOCATION (c),
12633                                 "high bound %qE above array section size "
12634                                 "in %qs clause", lbpluslen,
12635                                 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12636                       return error_mark_node;
12637                     }
12638                 }
12639             }
12640         }
12641       else if (length == NULL_TREE)
12642         {
12643           if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
12644               && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_REDUCTION)
12645             maybe_zero_len = true;
12646           if (first_non_one == types.length ())
12647             first_non_one++;
12648         }
12649
12650       /* For [lb:] we will need to evaluate lb more than once.  */
12651       if (length == NULL_TREE && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND)
12652         {
12653           tree lb = save_expr (low_bound);
12654           if (lb != low_bound)
12655             {
12656               TREE_PURPOSE (t) = lb;
12657               low_bound = lb;
12658             }
12659         }
12660     }
12661   else if (TREE_CODE (type) == POINTER_TYPE)
12662     {
12663       if (length == NULL_TREE)
12664         {
12665           error_at (OMP_CLAUSE_LOCATION (c),
12666                     "for pointer type length expression must be specified");
12667           return error_mark_node;
12668         }
12669       if (length != NULL_TREE
12670           && TREE_CODE (length) == INTEGER_CST
12671           && tree_int_cst_sgn (length) == -1)
12672         {
12673           error_at (OMP_CLAUSE_LOCATION (c),
12674                     "negative length in array section in %qs clause",
12675                     omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12676           return error_mark_node;
12677         }
12678       /* If there is a pointer type anywhere but in the very first
12679          array-section-subscript, the array section can't be contiguous.  */
12680       if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
12681           && TREE_CODE (TREE_CHAIN (t)) == TREE_LIST)
12682         {
12683           error_at (OMP_CLAUSE_LOCATION (c),
12684                     "array section is not contiguous in %qs clause",
12685                     omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12686           return error_mark_node;
12687         }
12688     }
12689   else
12690     {
12691       error_at (OMP_CLAUSE_LOCATION (c),
12692                 "%qE does not have pointer or array type", ret);
12693       return error_mark_node;
12694     }
12695   if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND)
12696     types.safe_push (TREE_TYPE (ret));
12697   /* We will need to evaluate lb more than once.  */
12698   tree lb = save_expr (low_bound);
12699   if (lb != low_bound)
12700     {
12701       TREE_PURPOSE (t) = lb;
12702       low_bound = lb;
12703     }
12704   ret = build_array_ref (OMP_CLAUSE_LOCATION (c), ret, low_bound);
12705   return ret;
12706 }
12707
12708 /* Handle array sections for clause C.  */
12709
12710 static bool
12711 handle_omp_array_sections (tree c, enum c_omp_region_type ort)
12712 {
12713   bool maybe_zero_len = false;
12714   unsigned int first_non_one = 0;
12715   auto_vec<tree, 10> types;
12716   tree first = handle_omp_array_sections_1 (c, OMP_CLAUSE_DECL (c), types,
12717                                             maybe_zero_len, first_non_one,
12718                                             ort);
12719   if (first == error_mark_node)
12720     return true;
12721   if (first == NULL_TREE)
12722     return false;
12723   if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND)
12724     {
12725       tree t = OMP_CLAUSE_DECL (c);
12726       tree tem = NULL_TREE;
12727       /* Need to evaluate side effects in the length expressions
12728          if any.  */
12729       while (TREE_CODE (t) == TREE_LIST)
12730         {
12731           if (TREE_VALUE (t) && TREE_SIDE_EFFECTS (TREE_VALUE (t)))
12732             {
12733               if (tem == NULL_TREE)
12734                 tem = TREE_VALUE (t);
12735               else
12736                 tem = build2 (COMPOUND_EXPR, TREE_TYPE (tem),
12737                               TREE_VALUE (t), tem);
12738             }
12739           t = TREE_CHAIN (t);
12740         }
12741       if (tem)
12742         first = build2 (COMPOUND_EXPR, TREE_TYPE (first), tem, first);
12743       first = c_fully_fold (first, false, NULL, true);
12744       OMP_CLAUSE_DECL (c) = first;
12745     }
12746   else
12747     {
12748       unsigned int num = types.length (), i;
12749       tree t, side_effects = NULL_TREE, size = NULL_TREE;
12750       tree condition = NULL_TREE;
12751
12752       if (int_size_in_bytes (TREE_TYPE (first)) <= 0)
12753         maybe_zero_len = true;
12754
12755       for (i = num, t = OMP_CLAUSE_DECL (c); i > 0;
12756            t = TREE_CHAIN (t))
12757         {
12758           tree low_bound = TREE_PURPOSE (t);
12759           tree length = TREE_VALUE (t);
12760
12761           i--;
12762           if (low_bound
12763               && TREE_CODE (low_bound) == INTEGER_CST
12764               && TYPE_PRECISION (TREE_TYPE (low_bound))
12765                  > TYPE_PRECISION (sizetype))
12766             low_bound = fold_convert (sizetype, low_bound);
12767           if (length
12768               && TREE_CODE (length) == INTEGER_CST
12769               && TYPE_PRECISION (TREE_TYPE (length))
12770                  > TYPE_PRECISION (sizetype))
12771             length = fold_convert (sizetype, length);
12772           if (low_bound == NULL_TREE)
12773             low_bound = integer_zero_node;
12774           if (!maybe_zero_len && i > first_non_one)
12775             {
12776               if (integer_nonzerop (low_bound))
12777                 goto do_warn_noncontiguous;
12778               if (length != NULL_TREE
12779                   && TREE_CODE (length) == INTEGER_CST
12780                   && TYPE_DOMAIN (types[i])
12781                   && TYPE_MAX_VALUE (TYPE_DOMAIN (types[i]))
12782                   && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (types[i])))
12783                      == INTEGER_CST)
12784                 {
12785                   tree size;
12786                   size = size_binop (PLUS_EXPR,
12787                                      TYPE_MAX_VALUE (TYPE_DOMAIN (types[i])),
12788                                      size_one_node);
12789                   if (!tree_int_cst_equal (length, size))
12790                     {
12791                      do_warn_noncontiguous:
12792                       error_at (OMP_CLAUSE_LOCATION (c),
12793                                 "array section is not contiguous in %qs "
12794                                 "clause",
12795                                 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12796                       return true;
12797                     }
12798                 }
12799               if (length != NULL_TREE
12800                   && TREE_SIDE_EFFECTS (length))
12801                 {
12802                   if (side_effects == NULL_TREE)
12803                     side_effects = length;
12804                   else
12805                     side_effects = build2 (COMPOUND_EXPR,
12806                                            TREE_TYPE (side_effects),
12807                                            length, side_effects);
12808                 }
12809             }
12810           else
12811             {
12812               tree l;
12813
12814               if (i > first_non_one
12815                   && ((length && integer_nonzerop (length))
12816                       || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION))
12817                 continue;
12818               if (length)
12819                 l = fold_convert (sizetype, length);
12820               else
12821                 {
12822                   l = size_binop (PLUS_EXPR,
12823                                   TYPE_MAX_VALUE (TYPE_DOMAIN (types[i])),
12824                                   size_one_node);
12825                   l = size_binop (MINUS_EXPR, l,
12826                                   fold_convert (sizetype, low_bound));
12827                 }
12828               if (i > first_non_one)
12829                 {
12830                   l = fold_build2 (NE_EXPR, boolean_type_node, l,
12831                                    size_zero_node);
12832                   if (condition == NULL_TREE)
12833                     condition = l;
12834                   else
12835                     condition = fold_build2 (BIT_AND_EXPR, boolean_type_node,
12836                                              l, condition);
12837                 }
12838               else if (size == NULL_TREE)
12839                 {
12840                   size = size_in_bytes (TREE_TYPE (types[i]));
12841                   tree eltype = TREE_TYPE (types[num - 1]);
12842                   while (TREE_CODE (eltype) == ARRAY_TYPE)
12843                     eltype = TREE_TYPE (eltype);
12844                   if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION)
12845                     {
12846                       if (integer_zerop (size)
12847                           || integer_zerop (size_in_bytes (eltype)))
12848                         {
12849                           error_at (OMP_CLAUSE_LOCATION (c),
12850                                     "zero length array section in %qs clause",
12851                                     omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12852                           return error_mark_node;
12853                         }
12854                       size = size_binop (EXACT_DIV_EXPR, size,
12855                                          size_in_bytes (eltype));
12856                     }
12857                   size = size_binop (MULT_EXPR, size, l);
12858                   if (condition)
12859                     size = fold_build3 (COND_EXPR, sizetype, condition,
12860                                         size, size_zero_node);
12861                 }
12862               else
12863                 size = size_binop (MULT_EXPR, size, l);
12864             }
12865         }
12866       if (side_effects)
12867         size = build2 (COMPOUND_EXPR, sizetype, side_effects, size);
12868       if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION)
12869         {
12870           size = size_binop (MINUS_EXPR, size, size_one_node);
12871           size = c_fully_fold (size, false, NULL);
12872           tree index_type = build_index_type (size);
12873           tree eltype = TREE_TYPE (first);
12874           while (TREE_CODE (eltype) == ARRAY_TYPE)
12875             eltype = TREE_TYPE (eltype);
12876           tree type = build_array_type (eltype, index_type);
12877           tree ptype = build_pointer_type (eltype);
12878           if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
12879             t = build_fold_addr_expr (t);
12880           tree t2 = build_fold_addr_expr (first);
12881           t2 = fold_convert_loc (OMP_CLAUSE_LOCATION (c),
12882                                  ptrdiff_type_node, t2);
12883           t2 = fold_build2_loc (OMP_CLAUSE_LOCATION (c), MINUS_EXPR,
12884                                 ptrdiff_type_node, t2,
12885                                 fold_convert_loc (OMP_CLAUSE_LOCATION (c),
12886                                                   ptrdiff_type_node, t));
12887           t2 = c_fully_fold (t2, false, NULL);
12888           if (tree_fits_shwi_p (t2))
12889             t = build2 (MEM_REF, type, t,
12890                         build_int_cst (ptype, tree_to_shwi (t2)));
12891           else
12892             {
12893               t2 = fold_convert_loc (OMP_CLAUSE_LOCATION (c), sizetype, t2);
12894               t = build2_loc (OMP_CLAUSE_LOCATION (c), POINTER_PLUS_EXPR,
12895                               TREE_TYPE (t), t, t2);
12896               t = build2 (MEM_REF, type, t, build_int_cst (ptype, 0));
12897             }
12898           OMP_CLAUSE_DECL (c) = t;
12899           return false;
12900         }
12901       first = c_fully_fold (first, false, NULL);
12902       OMP_CLAUSE_DECL (c) = first;
12903       if (size)
12904         size = c_fully_fold (size, false, NULL);
12905       OMP_CLAUSE_SIZE (c) = size;
12906       if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_MAP
12907           || (TREE_CODE (t) == COMPONENT_REF
12908               && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE))
12909         return false;
12910       gcc_assert (OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_FORCE_DEVICEPTR);
12911       if (ort == C_ORT_OMP || ort == C_ORT_ACC)
12912         switch (OMP_CLAUSE_MAP_KIND (c))
12913           {
12914           case GOMP_MAP_ALLOC:
12915           case GOMP_MAP_TO:
12916           case GOMP_MAP_FROM:
12917           case GOMP_MAP_TOFROM:
12918           case GOMP_MAP_ALWAYS_TO:
12919           case GOMP_MAP_ALWAYS_FROM:
12920           case GOMP_MAP_ALWAYS_TOFROM:
12921           case GOMP_MAP_RELEASE:
12922           case GOMP_MAP_DELETE:
12923           case GOMP_MAP_FORCE_TO:
12924           case GOMP_MAP_FORCE_FROM:
12925           case GOMP_MAP_FORCE_TOFROM:
12926           case GOMP_MAP_FORCE_PRESENT:
12927             OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION (c) = 1;
12928             break;
12929           default:
12930             break;
12931           }
12932       tree c2 = build_omp_clause (OMP_CLAUSE_LOCATION (c), OMP_CLAUSE_MAP);
12933       if (ort != C_ORT_OMP && ort != C_ORT_ACC)
12934         OMP_CLAUSE_SET_MAP_KIND (c2, GOMP_MAP_POINTER);
12935       else if (TREE_CODE (t) == COMPONENT_REF)
12936         OMP_CLAUSE_SET_MAP_KIND (c2, GOMP_MAP_ALWAYS_POINTER);
12937       else
12938         OMP_CLAUSE_SET_MAP_KIND (c2, GOMP_MAP_FIRSTPRIVATE_POINTER);
12939       if (OMP_CLAUSE_MAP_KIND (c2) != GOMP_MAP_FIRSTPRIVATE_POINTER
12940           && !c_mark_addressable (t))
12941         return false;
12942       OMP_CLAUSE_DECL (c2) = t;
12943       t = build_fold_addr_expr (first);
12944       t = fold_convert_loc (OMP_CLAUSE_LOCATION (c), ptrdiff_type_node, t);
12945       tree ptr = OMP_CLAUSE_DECL (c2);
12946       if (!POINTER_TYPE_P (TREE_TYPE (ptr)))
12947         ptr = build_fold_addr_expr (ptr);
12948       t = fold_build2_loc (OMP_CLAUSE_LOCATION (c), MINUS_EXPR,
12949                            ptrdiff_type_node, t,
12950                            fold_convert_loc (OMP_CLAUSE_LOCATION (c),
12951                                              ptrdiff_type_node, ptr));
12952       t = c_fully_fold (t, false, NULL);
12953       OMP_CLAUSE_SIZE (c2) = t;
12954       OMP_CLAUSE_CHAIN (c2) = OMP_CLAUSE_CHAIN (c);
12955       OMP_CLAUSE_CHAIN (c) = c2;
12956     }
12957   return false;
12958 }
12959
12960 /* Helper function of finish_omp_clauses.  Clone STMT as if we were making
12961    an inline call.  But, remap
12962    the OMP_DECL1 VAR_DECL (omp_out resp. omp_orig) to PLACEHOLDER
12963    and OMP_DECL2 VAR_DECL (omp_in resp. omp_priv) to DECL.  */
12964
12965 static tree
12966 c_clone_omp_udr (tree stmt, tree omp_decl1, tree omp_decl2,
12967                  tree decl, tree placeholder)
12968 {
12969   copy_body_data id;
12970   hash_map<tree, tree> decl_map;
12971
12972   decl_map.put (omp_decl1, placeholder);
12973   decl_map.put (omp_decl2, decl);
12974   memset (&id, 0, sizeof (id));
12975   id.src_fn = DECL_CONTEXT (omp_decl1);
12976   id.dst_fn = current_function_decl;
12977   id.src_cfun = DECL_STRUCT_FUNCTION (id.src_fn);
12978   id.decl_map = &decl_map;
12979
12980   id.copy_decl = copy_decl_no_change;
12981   id.transform_call_graph_edges = CB_CGE_DUPLICATE;
12982   id.transform_new_cfg = true;
12983   id.transform_return_to_modify = false;
12984   id.transform_lang_insert_block = NULL;
12985   id.eh_lp_nr = 0;
12986   walk_tree (&stmt, copy_tree_body_r, &id, NULL);
12987   return stmt;
12988 }
12989
12990 /* Helper function of c_finish_omp_clauses, called via walk_tree.
12991    Find OMP_CLAUSE_PLACEHOLDER (passed in DATA) in *TP.  */
12992
12993 static tree
12994 c_find_omp_placeholder_r (tree *tp, int *, void *data)
12995 {
12996   if (*tp == (tree) data)
12997     return *tp;
12998   return NULL_TREE;
12999 }
13000
13001 /* For all elements of CLAUSES, validate them against their constraints.
13002    Remove any elements from the list that are invalid.  */
13003
13004 tree
13005 c_finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
13006 {
13007   bitmap_head generic_head, firstprivate_head, lastprivate_head;
13008   bitmap_head aligned_head, map_head, map_field_head, oacc_reduction_head;
13009   tree c, t, type, *pc;
13010   tree simdlen = NULL_TREE, safelen = NULL_TREE;
13011   bool branch_seen = false;
13012   bool copyprivate_seen = false;
13013   bool linear_variable_step_check = false;
13014   tree *nowait_clause = NULL;
13015   bool ordered_seen = false;
13016   tree schedule_clause = NULL_TREE;
13017   bool oacc_async = false;
13018
13019   bitmap_obstack_initialize (NULL);
13020   bitmap_initialize (&generic_head, &bitmap_default_obstack);
13021   bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
13022   bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);
13023   bitmap_initialize (&aligned_head, &bitmap_default_obstack);
13024   bitmap_initialize (&map_head, &bitmap_default_obstack);
13025   bitmap_initialize (&map_field_head, &bitmap_default_obstack);
13026   bitmap_initialize (&oacc_reduction_head, &bitmap_default_obstack);
13027
13028   if (ort & C_ORT_ACC)
13029     for (c = clauses; c; c = OMP_CLAUSE_CHAIN (c))
13030       if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_ASYNC)
13031         {
13032           oacc_async = true;
13033           break;
13034         }
13035
13036   for (pc = &clauses, c = clauses; c ; c = *pc)
13037     {
13038       bool remove = false;
13039       bool need_complete = false;
13040       bool need_implicitly_determined = false;
13041
13042       switch (OMP_CLAUSE_CODE (c))
13043         {
13044         case OMP_CLAUSE_SHARED:
13045           need_implicitly_determined = true;
13046           goto check_dup_generic;
13047
13048         case OMP_CLAUSE_PRIVATE:
13049           need_complete = true;
13050           need_implicitly_determined = true;
13051           goto check_dup_generic;
13052
13053         case OMP_CLAUSE_REDUCTION:
13054           need_implicitly_determined = true;
13055           t = OMP_CLAUSE_DECL (c);
13056           if (TREE_CODE (t) == TREE_LIST)
13057             {
13058               if (handle_omp_array_sections (c, ort))
13059                 {
13060                   remove = true;
13061                   break;
13062                 }
13063
13064               t = OMP_CLAUSE_DECL (c);
13065             }
13066           t = require_complete_type (OMP_CLAUSE_LOCATION (c), t);
13067           if (t == error_mark_node)
13068             {
13069               remove = true;
13070               break;
13071             }
13072           if (oacc_async)
13073             c_mark_addressable (t);
13074           type = TREE_TYPE (t);
13075           if (TREE_CODE (t) == MEM_REF)
13076             type = TREE_TYPE (type);
13077           if (TREE_CODE (type) == ARRAY_TYPE)
13078             {
13079               tree oatype = type;
13080               gcc_assert (TREE_CODE (t) != MEM_REF);
13081               while (TREE_CODE (type) == ARRAY_TYPE)
13082                 type = TREE_TYPE (type);
13083               if (integer_zerop (TYPE_SIZE_UNIT (type)))
13084                 {
13085                   error_at (OMP_CLAUSE_LOCATION (c),
13086                             "%qD in %<reduction%> clause is a zero size array",
13087                             t);
13088                   remove = true;
13089                   break;
13090                 }
13091               tree size = size_binop (EXACT_DIV_EXPR, TYPE_SIZE_UNIT (oatype),
13092                                       TYPE_SIZE_UNIT (type));
13093               if (integer_zerop (size))
13094                 {
13095                   error_at (OMP_CLAUSE_LOCATION (c),
13096                             "%qD in %<reduction%> clause is a zero size array",
13097                             t);
13098                   remove = true;
13099                   break;
13100                 }
13101               size = size_binop (MINUS_EXPR, size, size_one_node);
13102               tree index_type = build_index_type (size);
13103               tree atype = build_array_type (type, index_type);
13104               tree ptype = build_pointer_type (type);
13105               if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
13106                 t = build_fold_addr_expr (t);
13107               t = build2 (MEM_REF, atype, t, build_int_cst (ptype, 0));
13108               OMP_CLAUSE_DECL (c) = t;
13109             }
13110           if (TYPE_ATOMIC (type))
13111             {
13112               error_at (OMP_CLAUSE_LOCATION (c),
13113                         "%<_Atomic%> %qE in %<reduction%> clause", t);
13114               remove = true;
13115               break;
13116             }
13117           if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c) == NULL_TREE
13118               && (FLOAT_TYPE_P (type)
13119                   || TREE_CODE (type) == COMPLEX_TYPE))
13120             {
13121               enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c);
13122               const char *r_name = NULL;
13123
13124               switch (r_code)
13125                 {
13126                 case PLUS_EXPR:
13127                 case MULT_EXPR:
13128                 case MINUS_EXPR:
13129                   break;
13130                 case MIN_EXPR:
13131                   if (TREE_CODE (type) == COMPLEX_TYPE)
13132                     r_name = "min";
13133                   break;
13134                 case MAX_EXPR:
13135                   if (TREE_CODE (type) == COMPLEX_TYPE)
13136                     r_name = "max";
13137                   break;
13138                 case BIT_AND_EXPR:
13139                   r_name = "&";
13140                   break;
13141                 case BIT_XOR_EXPR:
13142                   r_name = "^";
13143                   break;
13144                 case BIT_IOR_EXPR:
13145                   r_name = "|";
13146                   break;
13147                 case TRUTH_ANDIF_EXPR:
13148                   if (FLOAT_TYPE_P (type))
13149                     r_name = "&&";
13150                   break;
13151                 case TRUTH_ORIF_EXPR:
13152                   if (FLOAT_TYPE_P (type))
13153                     r_name = "||";
13154                   break;
13155                 default:
13156                   gcc_unreachable ();
13157                 }
13158               if (r_name)
13159                 {
13160                   error_at (OMP_CLAUSE_LOCATION (c),
13161                             "%qE has invalid type for %<reduction(%s)%>",
13162                             t, r_name);
13163                   remove = true;
13164                   break;
13165                 }
13166             }
13167           else if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c) == error_mark_node)
13168             {
13169               error_at (OMP_CLAUSE_LOCATION (c),
13170                         "user defined reduction not found for %qE", t);
13171               remove = true;
13172               break;
13173             }
13174           else if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c))
13175             {
13176               tree list = OMP_CLAUSE_REDUCTION_PLACEHOLDER (c);
13177               type = TYPE_MAIN_VARIANT (type);
13178               tree placeholder = build_decl (OMP_CLAUSE_LOCATION (c),
13179                                              VAR_DECL, NULL_TREE, type);
13180               tree decl_placeholder = NULL_TREE;
13181               OMP_CLAUSE_REDUCTION_PLACEHOLDER (c) = placeholder;
13182               DECL_ARTIFICIAL (placeholder) = 1;
13183               DECL_IGNORED_P (placeholder) = 1;
13184               if (TREE_CODE (t) == MEM_REF)
13185                 {
13186                   decl_placeholder = build_decl (OMP_CLAUSE_LOCATION (c),
13187                                                  VAR_DECL, NULL_TREE, type);
13188                   OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c) = decl_placeholder;
13189                   DECL_ARTIFICIAL (decl_placeholder) = 1;
13190                   DECL_IGNORED_P (decl_placeholder) = 1;
13191                 }
13192               if (TREE_ADDRESSABLE (TREE_VEC_ELT (list, 0)))
13193                 c_mark_addressable (placeholder);
13194               if (TREE_ADDRESSABLE (TREE_VEC_ELT (list, 1)))
13195                 c_mark_addressable (decl_placeholder ? decl_placeholder
13196                                     : OMP_CLAUSE_DECL (c));
13197               OMP_CLAUSE_REDUCTION_MERGE (c)
13198                 = c_clone_omp_udr (TREE_VEC_ELT (list, 2),
13199                                    TREE_VEC_ELT (list, 0),
13200                                    TREE_VEC_ELT (list, 1),
13201                                    decl_placeholder ? decl_placeholder
13202                                    : OMP_CLAUSE_DECL (c), placeholder);
13203               OMP_CLAUSE_REDUCTION_MERGE (c)
13204                 = build3_loc (OMP_CLAUSE_LOCATION (c), BIND_EXPR,
13205                               void_type_node, NULL_TREE,
13206                               OMP_CLAUSE_REDUCTION_MERGE (c), NULL_TREE);
13207               TREE_SIDE_EFFECTS (OMP_CLAUSE_REDUCTION_MERGE (c)) = 1;
13208               if (TREE_VEC_LENGTH (list) == 6)
13209                 {
13210                   if (TREE_ADDRESSABLE (TREE_VEC_ELT (list, 3)))
13211                     c_mark_addressable (decl_placeholder ? decl_placeholder
13212                                         : OMP_CLAUSE_DECL (c));
13213                   if (TREE_ADDRESSABLE (TREE_VEC_ELT (list, 4)))
13214                     c_mark_addressable (placeholder);
13215                   tree init = TREE_VEC_ELT (list, 5);
13216                   if (init == error_mark_node)
13217                     init = DECL_INITIAL (TREE_VEC_ELT (list, 3));
13218                   OMP_CLAUSE_REDUCTION_INIT (c)
13219                     = c_clone_omp_udr (init, TREE_VEC_ELT (list, 4),
13220                                        TREE_VEC_ELT (list, 3),
13221                                        decl_placeholder ? decl_placeholder
13222                                        : OMP_CLAUSE_DECL (c), placeholder);
13223                   if (TREE_VEC_ELT (list, 5) == error_mark_node)
13224                     {
13225                       tree v = decl_placeholder ? decl_placeholder : t;
13226                       OMP_CLAUSE_REDUCTION_INIT (c)
13227                         = build2 (INIT_EXPR, TREE_TYPE (v), v,
13228                                   OMP_CLAUSE_REDUCTION_INIT (c));
13229                     }
13230                   if (walk_tree (&OMP_CLAUSE_REDUCTION_INIT (c),
13231                                  c_find_omp_placeholder_r,
13232                                  placeholder, NULL))
13233                     OMP_CLAUSE_REDUCTION_OMP_ORIG_REF (c) = 1;
13234                 }
13235               else
13236                 {
13237                   tree init;
13238                   tree v = decl_placeholder ? decl_placeholder : t;
13239                   if (AGGREGATE_TYPE_P (TREE_TYPE (v)))
13240                     init = build_constructor (TREE_TYPE (v), NULL);
13241                   else
13242                     init = fold_convert (TREE_TYPE (v), integer_zero_node);
13243                   OMP_CLAUSE_REDUCTION_INIT (c)
13244                     = build2 (INIT_EXPR, TREE_TYPE (v), v, init);
13245                 }
13246               OMP_CLAUSE_REDUCTION_INIT (c)
13247                 = build3_loc (OMP_CLAUSE_LOCATION (c), BIND_EXPR,
13248                               void_type_node, NULL_TREE,
13249                                OMP_CLAUSE_REDUCTION_INIT (c), NULL_TREE);
13250               TREE_SIDE_EFFECTS (OMP_CLAUSE_REDUCTION_INIT (c)) = 1;
13251             }
13252           if (TREE_CODE (t) == MEM_REF)
13253             {
13254               if (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (t))) == NULL_TREE
13255                   || TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (t))))
13256                      != INTEGER_CST)
13257                 {
13258                   sorry ("variable length element type in array "
13259                          "%<reduction%> clause");
13260                   remove = true;
13261                   break;
13262                 }
13263               t = TREE_OPERAND (t, 0);
13264               if (TREE_CODE (t) == POINTER_PLUS_EXPR)
13265                 t = TREE_OPERAND (t, 0);
13266               if (TREE_CODE (t) == ADDR_EXPR)
13267                 t = TREE_OPERAND (t, 0);
13268             }
13269           goto check_dup_generic_t;
13270
13271         case OMP_CLAUSE_COPYPRIVATE:
13272           copyprivate_seen = true;
13273           if (nowait_clause)
13274             {
13275               error_at (OMP_CLAUSE_LOCATION (*nowait_clause),
13276                         "%<nowait%> clause must not be used together "
13277                         "with %<copyprivate%>");
13278               *nowait_clause = OMP_CLAUSE_CHAIN (*nowait_clause);
13279               nowait_clause = NULL;
13280             }
13281           goto check_dup_generic;
13282
13283         case OMP_CLAUSE_COPYIN:
13284           t = OMP_CLAUSE_DECL (c);
13285           if (!VAR_P (t) || !DECL_THREAD_LOCAL_P (t))
13286             {
13287               error_at (OMP_CLAUSE_LOCATION (c),
13288                         "%qE must be %<threadprivate%> for %<copyin%>", t);
13289               remove = true;
13290               break;
13291             }
13292           goto check_dup_generic;
13293
13294         case OMP_CLAUSE_LINEAR:
13295           if (ort != C_ORT_OMP_DECLARE_SIMD)
13296             need_implicitly_determined = true;
13297           t = OMP_CLAUSE_DECL (c);
13298           if (ort != C_ORT_OMP_DECLARE_SIMD
13299               && OMP_CLAUSE_LINEAR_KIND (c) != OMP_CLAUSE_LINEAR_DEFAULT)
13300             {
13301               error_at (OMP_CLAUSE_LOCATION (c),
13302                         "modifier should not be specified in %<linear%> "
13303                         "clause on %<simd%> or %<for%> constructs");
13304               OMP_CLAUSE_LINEAR_KIND (c) = OMP_CLAUSE_LINEAR_DEFAULT;
13305             }
13306           if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
13307               && TREE_CODE (TREE_TYPE (t)) != POINTER_TYPE)
13308             {
13309               error_at (OMP_CLAUSE_LOCATION (c),
13310                         "linear clause applied to non-integral non-pointer "
13311                         "variable with type %qT", TREE_TYPE (t));
13312               remove = true;
13313               break;
13314             }
13315           if (TYPE_ATOMIC (TREE_TYPE (t)))
13316             {
13317               error_at (OMP_CLAUSE_LOCATION (c),
13318                     "%<_Atomic%> %qD in %<linear%> clause", t);
13319               remove = true;
13320               break;
13321             }
13322           if (ort == C_ORT_OMP_DECLARE_SIMD)
13323             {
13324               tree s = OMP_CLAUSE_LINEAR_STEP (c);
13325               if (TREE_CODE (s) == PARM_DECL)
13326                 {
13327                   OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (c) = 1;
13328                   /* map_head bitmap is used as uniform_head if
13329                      declare_simd.  */
13330                   if (!bitmap_bit_p (&map_head, DECL_UID (s)))
13331                     linear_variable_step_check = true;
13332                   goto check_dup_generic;
13333                 }
13334               if (TREE_CODE (s) != INTEGER_CST)
13335                 {
13336                   error_at (OMP_CLAUSE_LOCATION (c),
13337                             "%<linear%> clause step %qE is neither constant "
13338                             "nor a parameter", s);
13339                   remove = true;
13340                   break;
13341                 }
13342             }
13343           if (TREE_CODE (TREE_TYPE (OMP_CLAUSE_DECL (c))) == POINTER_TYPE)
13344             {
13345               tree s = OMP_CLAUSE_LINEAR_STEP (c);
13346               s = pointer_int_sum (OMP_CLAUSE_LOCATION (c), PLUS_EXPR,
13347                                    OMP_CLAUSE_DECL (c), s);
13348               s = fold_build2_loc (OMP_CLAUSE_LOCATION (c), MINUS_EXPR,
13349                                    sizetype, fold_convert (sizetype, s),
13350                                    fold_convert
13351                                      (sizetype, OMP_CLAUSE_DECL (c)));
13352               if (s == error_mark_node)
13353                 s = size_one_node;
13354               OMP_CLAUSE_LINEAR_STEP (c) = s;
13355             }
13356           else
13357             OMP_CLAUSE_LINEAR_STEP (c)
13358               = fold_convert (TREE_TYPE (t), OMP_CLAUSE_LINEAR_STEP (c));
13359           goto check_dup_generic;
13360
13361         check_dup_generic:
13362           t = OMP_CLAUSE_DECL (c);
13363         check_dup_generic_t:
13364           if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
13365             {
13366               error_at (OMP_CLAUSE_LOCATION (c),
13367                         "%qE is not a variable in clause %qs", t,
13368                         omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13369               remove = true;
13370             }
13371           else if (ort == C_ORT_ACC
13372                    && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION)
13373             {
13374               if (bitmap_bit_p (&oacc_reduction_head, DECL_UID (t)))
13375                 {
13376                   error ("%qD appears more than once in reduction clauses", t);
13377                   remove = true;
13378                 }
13379               else
13380                 bitmap_set_bit (&oacc_reduction_head, DECL_UID (t));
13381             }
13382           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
13383                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t))
13384                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
13385             {
13386               error_at (OMP_CLAUSE_LOCATION (c),
13387                         "%qE appears more than once in data clauses", t);
13388               remove = true;
13389             }
13390           else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_PRIVATE
13391                    && bitmap_bit_p (&map_head, DECL_UID (t)))
13392             {
13393               if (ort == C_ORT_ACC)
13394                 error ("%qD appears more than once in data clauses", t);
13395               else
13396                 error ("%qD appears both in data and map clauses", t);
13397               remove = true;
13398             }
13399           else
13400             bitmap_set_bit (&generic_head, DECL_UID (t));
13401           break;
13402
13403         case OMP_CLAUSE_FIRSTPRIVATE:
13404           t = OMP_CLAUSE_DECL (c);
13405           need_complete = true;
13406           need_implicitly_determined = true;
13407           if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
13408             {
13409               error_at (OMP_CLAUSE_LOCATION (c),
13410                         "%qE is not a variable in clause %<firstprivate%>", t);
13411               remove = true;
13412             }
13413           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
13414                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
13415             {
13416               error_at (OMP_CLAUSE_LOCATION (c),
13417                         "%qE appears more than once in data clauses", t);
13418               remove = true;
13419             }
13420           else if (bitmap_bit_p (&map_head, DECL_UID (t)))
13421             {
13422               if (ort == C_ORT_ACC)
13423                 error ("%qD appears more than once in data clauses", t);
13424               else
13425                 error ("%qD appears both in data and map clauses", t);
13426               remove = true;
13427             }
13428           else
13429             bitmap_set_bit (&firstprivate_head, DECL_UID (t));
13430           break;
13431
13432         case OMP_CLAUSE_LASTPRIVATE:
13433           t = OMP_CLAUSE_DECL (c);
13434           need_complete = true;
13435           need_implicitly_determined = true;
13436           if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
13437             {
13438               error_at (OMP_CLAUSE_LOCATION (c),
13439                         "%qE is not a variable in clause %<lastprivate%>", t);
13440               remove = true;
13441             }
13442           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
13443                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
13444             {
13445               error_at (OMP_CLAUSE_LOCATION (c),
13446                      "%qE appears more than once in data clauses", t);
13447               remove = true;
13448             }
13449           else
13450             bitmap_set_bit (&lastprivate_head, DECL_UID (t));
13451           break;
13452
13453         case OMP_CLAUSE_ALIGNED:
13454           t = OMP_CLAUSE_DECL (c);
13455           if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
13456             {
13457               error_at (OMP_CLAUSE_LOCATION (c),
13458                         "%qE is not a variable in %<aligned%> clause", t);
13459               remove = true;
13460             }
13461           else if (!POINTER_TYPE_P (TREE_TYPE (t))
13462                    && TREE_CODE (TREE_TYPE (t)) != ARRAY_TYPE)
13463             {
13464               error_at (OMP_CLAUSE_LOCATION (c),
13465                         "%qE in %<aligned%> clause is neither a pointer nor "
13466                         "an array", t);
13467               remove = true;
13468             }
13469           else if (TYPE_ATOMIC (TREE_TYPE (t)))
13470             {
13471               error_at (OMP_CLAUSE_LOCATION (c),
13472                         "%<_Atomic%> %qD in %<aligned%> clause", t);
13473               remove = true;
13474               break;
13475             }
13476           else if (bitmap_bit_p (&aligned_head, DECL_UID (t)))
13477             {
13478               error_at (OMP_CLAUSE_LOCATION (c),
13479                         "%qE appears more than once in %<aligned%> clauses",
13480                         t);
13481               remove = true;
13482             }
13483           else
13484             bitmap_set_bit (&aligned_head, DECL_UID (t));
13485           break;
13486
13487         case OMP_CLAUSE_DEPEND:
13488           t = OMP_CLAUSE_DECL (c);
13489           if (t == NULL_TREE)
13490             {
13491               gcc_assert (OMP_CLAUSE_DEPEND_KIND (c)
13492                           == OMP_CLAUSE_DEPEND_SOURCE);
13493               break;
13494             }
13495           if (OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SINK)
13496             {
13497               gcc_assert (TREE_CODE (t) == TREE_LIST);
13498               for (; t; t = TREE_CHAIN (t))
13499                 {
13500                   tree decl = TREE_VALUE (t);
13501                   if (TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE)
13502                     {
13503                       tree offset = TREE_PURPOSE (t);
13504                       bool neg = wi::neg_p (wi::to_wide (offset));
13505                       offset = fold_unary (ABS_EXPR, TREE_TYPE (offset), offset);
13506                       tree t2 = pointer_int_sum (OMP_CLAUSE_LOCATION (c),
13507                                                  neg ? MINUS_EXPR : PLUS_EXPR,
13508                                                  decl, offset);
13509                       t2 = fold_build2_loc (OMP_CLAUSE_LOCATION (c), MINUS_EXPR,
13510                                             sizetype,
13511                                             fold_convert (sizetype, t2),
13512                                             fold_convert (sizetype, decl));
13513                       if (t2 == error_mark_node)
13514                         {
13515                           remove = true;
13516                           break;
13517                         }
13518                       TREE_PURPOSE (t) = t2;
13519                     }
13520                 }
13521               break;
13522             }
13523           if (TREE_CODE (t) == TREE_LIST)
13524             {
13525               if (handle_omp_array_sections (c, ort))
13526                 remove = true;
13527               break;
13528             }
13529           if (t == error_mark_node)
13530             remove = true;
13531           else if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
13532             {
13533               error_at (OMP_CLAUSE_LOCATION (c),
13534                         "%qE is not a variable in %<depend%> clause", t);
13535               remove = true;
13536             }
13537           else if (!c_mark_addressable (t))
13538             remove = true;
13539           break;
13540
13541         case OMP_CLAUSE_MAP:
13542         case OMP_CLAUSE_TO:
13543         case OMP_CLAUSE_FROM:
13544         case OMP_CLAUSE__CACHE_:
13545           t = OMP_CLAUSE_DECL (c);
13546           if (TREE_CODE (t) == TREE_LIST)
13547             {
13548               if (handle_omp_array_sections (c, ort))
13549                 remove = true;
13550               else
13551                 {
13552                   t = OMP_CLAUSE_DECL (c);
13553                   if (!lang_hooks.types.omp_mappable_type (TREE_TYPE (t)))
13554                     {
13555                       error_at (OMP_CLAUSE_LOCATION (c),
13556                                 "array section does not have mappable type "
13557                                 "in %qs clause",
13558                                 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13559                       remove = true;
13560                     }
13561                   else if (TYPE_ATOMIC (TREE_TYPE (t)))
13562                     {
13563                       error_at (OMP_CLAUSE_LOCATION (c),
13564                                 "%<_Atomic%> %qE in %qs clause", t,
13565                                 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13566                       remove = true;
13567                     }
13568                   while (TREE_CODE (t) == ARRAY_REF)
13569                     t = TREE_OPERAND (t, 0);
13570                   if (TREE_CODE (t) == COMPONENT_REF
13571                       && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
13572                     {
13573                       while (TREE_CODE (t) == COMPONENT_REF)
13574                         t = TREE_OPERAND (t, 0);
13575                       if (bitmap_bit_p (&map_field_head, DECL_UID (t)))
13576                         break;
13577                       if (bitmap_bit_p (&map_head, DECL_UID (t)))
13578                         {
13579                           if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_MAP)
13580                             error ("%qD appears more than once in motion"
13581                                    " clauses", t);
13582                           else if (ort == C_ORT_ACC)
13583                             error ("%qD appears more than once in data"
13584                                    " clauses", t);
13585                           else
13586                             error ("%qD appears more than once in map"
13587                                    " clauses", t);
13588                           remove = true;
13589                         }
13590                       else
13591                         {
13592                           bitmap_set_bit (&map_head, DECL_UID (t));
13593                           bitmap_set_bit (&map_field_head, DECL_UID (t));
13594                         }
13595                     }
13596                 }
13597               break;
13598             }
13599           if (t == error_mark_node)
13600             {
13601               remove = true;
13602               break;
13603             }
13604           if (TREE_CODE (t) == COMPONENT_REF
13605               && (ort & C_ORT_OMP)
13606               && OMP_CLAUSE_CODE (c) != OMP_CLAUSE__CACHE_)
13607             {
13608               if (DECL_BIT_FIELD (TREE_OPERAND (t, 1)))
13609                 {
13610                   error_at (OMP_CLAUSE_LOCATION (c),
13611                             "bit-field %qE in %qs clause",
13612                             t, omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13613                   remove = true;
13614                 }
13615               else if (!lang_hooks.types.omp_mappable_type (TREE_TYPE (t)))
13616                 {
13617                   error_at (OMP_CLAUSE_LOCATION (c),
13618                             "%qE does not have a mappable type in %qs clause",
13619                             t, omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13620                   remove = true;
13621                 }
13622               else if (TYPE_ATOMIC (TREE_TYPE (t)))
13623                 {
13624                   error_at (OMP_CLAUSE_LOCATION (c),
13625                             "%<_Atomic%> %qE in %qs clause", t,
13626                             omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13627                   remove = true;
13628                 }
13629               while (TREE_CODE (t) == COMPONENT_REF)
13630                 {
13631                   if (TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0)))
13632                       == UNION_TYPE)
13633                     {
13634                       error_at (OMP_CLAUSE_LOCATION (c),
13635                                 "%qE is a member of a union", t);
13636                       remove = true;
13637                       break;
13638                     }
13639                   t = TREE_OPERAND (t, 0);
13640                 }
13641               if (remove)
13642                 break;
13643               if (VAR_P (t) || TREE_CODE (t) == PARM_DECL)
13644                 {
13645                   if (bitmap_bit_p (&map_field_head, DECL_UID (t)))
13646                     break;
13647                 }
13648             }
13649           if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
13650             {
13651               error_at (OMP_CLAUSE_LOCATION (c),
13652                         "%qE is not a variable in %qs clause", t,
13653                         omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13654               remove = true;
13655             }
13656           else if (VAR_P (t) && DECL_THREAD_LOCAL_P (t))
13657             {
13658               error_at (OMP_CLAUSE_LOCATION (c),
13659                         "%qD is threadprivate variable in %qs clause", t,
13660                         omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13661               remove = true;
13662             }
13663           else if ((OMP_CLAUSE_CODE (c) != OMP_CLAUSE_MAP
13664                     || (OMP_CLAUSE_MAP_KIND (c)
13665                         != GOMP_MAP_FIRSTPRIVATE_POINTER))
13666                    && !c_mark_addressable (t))
13667             remove = true;
13668           else if (!(OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
13669                      && (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_POINTER
13670                          || (OMP_CLAUSE_MAP_KIND (c)
13671                              == GOMP_MAP_FIRSTPRIVATE_POINTER)
13672                          || (OMP_CLAUSE_MAP_KIND (c)
13673                              == GOMP_MAP_FORCE_DEVICEPTR)))
13674                    && t == OMP_CLAUSE_DECL (c)
13675                    && !lang_hooks.types.omp_mappable_type (TREE_TYPE (t)))
13676             {
13677               error_at (OMP_CLAUSE_LOCATION (c),
13678                         "%qD does not have a mappable type in %qs clause", t,
13679                         omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13680               remove = true;
13681             }
13682           else if (TREE_TYPE (t) == error_mark_node)
13683             remove = true;
13684           else if (TYPE_ATOMIC (strip_array_types (TREE_TYPE (t))))
13685             {
13686               error_at (OMP_CLAUSE_LOCATION (c),
13687                         "%<_Atomic%> %qE in %qs clause", t,
13688                         omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13689               remove = true;
13690             }
13691           else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
13692                    && OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FIRSTPRIVATE_POINTER)
13693             {
13694               if (bitmap_bit_p (&generic_head, DECL_UID (t))
13695                   || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
13696                 {
13697                   error ("%qD appears more than once in data clauses", t);
13698                   remove = true;
13699                 }
13700               else if (bitmap_bit_p (&map_head, DECL_UID (t)))
13701                 {
13702                   if (ort == C_ORT_ACC)
13703                     error ("%qD appears more than once in data clauses", t);
13704                   else
13705                     error ("%qD appears both in data and map clauses", t);
13706                   remove = true;
13707                 }
13708               else
13709                 bitmap_set_bit (&generic_head, DECL_UID (t));
13710             }
13711           else if (bitmap_bit_p (&map_head, DECL_UID (t)))
13712             {
13713               if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_MAP)
13714                 error ("%qD appears more than once in motion clauses", t);
13715               else if (ort == C_ORT_ACC)
13716                 error ("%qD appears more than once in data clauses", t);
13717               else
13718                 error ("%qD appears more than once in map clauses", t);
13719               remove = true;
13720             }
13721           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
13722                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
13723             {
13724               if (ort == C_ORT_ACC)
13725                 error ("%qD appears more than once in data clauses", t);
13726               else
13727                 error ("%qD appears both in data and map clauses", t);
13728               remove = true;
13729             }
13730           else
13731             {
13732               bitmap_set_bit (&map_head, DECL_UID (t));
13733               if (t != OMP_CLAUSE_DECL (c)
13734                   && TREE_CODE (OMP_CLAUSE_DECL (c)) == COMPONENT_REF)
13735                 bitmap_set_bit (&map_field_head, DECL_UID (t));
13736             }
13737           break;
13738
13739         case OMP_CLAUSE_TO_DECLARE:
13740         case OMP_CLAUSE_LINK:
13741           t = OMP_CLAUSE_DECL (c);
13742           if (TREE_CODE (t) == FUNCTION_DECL
13743               && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TO_DECLARE)
13744             ;
13745           else if (!VAR_P (t))
13746             {
13747               if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TO_DECLARE)
13748                 error_at (OMP_CLAUSE_LOCATION (c),
13749                           "%qE is neither a variable nor a function name in "
13750                           "clause %qs", t,
13751                           omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13752               else
13753                 error_at (OMP_CLAUSE_LOCATION (c),
13754                           "%qE is not a variable in clause %qs", t,
13755                           omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13756               remove = true;
13757             }
13758           else if (DECL_THREAD_LOCAL_P (t))
13759             {
13760               error_at (OMP_CLAUSE_LOCATION (c),
13761                         "%qD is threadprivate variable in %qs clause", t,
13762                         omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13763               remove = true;
13764             }
13765           else if (!lang_hooks.types.omp_mappable_type (TREE_TYPE (t)))
13766             {
13767               error_at (OMP_CLAUSE_LOCATION (c),
13768                         "%qD does not have a mappable type in %qs clause", t,
13769                         omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13770               remove = true;
13771             }
13772           if (remove)
13773             break;
13774           if (bitmap_bit_p (&generic_head, DECL_UID (t)))
13775             {
13776               error_at (OMP_CLAUSE_LOCATION (c),
13777                         "%qE appears more than once on the same "
13778                         "%<declare target%> directive", t);
13779               remove = true;
13780             }
13781           else
13782             bitmap_set_bit (&generic_head, DECL_UID (t));
13783           break;
13784
13785         case OMP_CLAUSE_UNIFORM:
13786           t = OMP_CLAUSE_DECL (c);
13787           if (TREE_CODE (t) != PARM_DECL)
13788             {
13789               if (DECL_P (t))
13790                 error_at (OMP_CLAUSE_LOCATION (c),
13791                           "%qD is not an argument in %<uniform%> clause", t);
13792               else
13793                 error_at (OMP_CLAUSE_LOCATION (c),
13794                           "%qE is not an argument in %<uniform%> clause", t);
13795               remove = true;
13796               break;
13797             }
13798           /* map_head bitmap is used as uniform_head if declare_simd.  */
13799           bitmap_set_bit (&map_head, DECL_UID (t));
13800           goto check_dup_generic;
13801
13802         case OMP_CLAUSE_IS_DEVICE_PTR:
13803         case OMP_CLAUSE_USE_DEVICE_PTR:
13804           t = OMP_CLAUSE_DECL (c);
13805           if (TREE_CODE (TREE_TYPE (t)) != POINTER_TYPE
13806               && TREE_CODE (TREE_TYPE (t)) != ARRAY_TYPE)
13807             {
13808               error_at (OMP_CLAUSE_LOCATION (c),
13809                         "%qs variable is neither a pointer nor an array",
13810                         omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13811               remove = true;
13812             }
13813           goto check_dup_generic;
13814
13815         case OMP_CLAUSE_NOWAIT:
13816           if (copyprivate_seen)
13817             {
13818               error_at (OMP_CLAUSE_LOCATION (c),
13819                         "%<nowait%> clause must not be used together "
13820                         "with %<copyprivate%>");
13821               remove = true;
13822               break;
13823             }
13824           nowait_clause = pc;
13825           pc = &OMP_CLAUSE_CHAIN (c);
13826           continue;
13827
13828         case OMP_CLAUSE_IF:
13829         case OMP_CLAUSE_NUM_THREADS:
13830         case OMP_CLAUSE_NUM_TEAMS:
13831         case OMP_CLAUSE_THREAD_LIMIT:
13832         case OMP_CLAUSE_DEFAULT:
13833         case OMP_CLAUSE_UNTIED:
13834         case OMP_CLAUSE_COLLAPSE:
13835         case OMP_CLAUSE_FINAL:
13836         case OMP_CLAUSE_MERGEABLE:
13837         case OMP_CLAUSE_DEVICE:
13838         case OMP_CLAUSE_DIST_SCHEDULE:
13839         case OMP_CLAUSE_PARALLEL:
13840         case OMP_CLAUSE_FOR:
13841         case OMP_CLAUSE_SECTIONS:
13842         case OMP_CLAUSE_TASKGROUP:
13843         case OMP_CLAUSE_PROC_BIND:
13844         case OMP_CLAUSE_PRIORITY:
13845         case OMP_CLAUSE_GRAINSIZE:
13846         case OMP_CLAUSE_NUM_TASKS:
13847         case OMP_CLAUSE_NOGROUP:
13848         case OMP_CLAUSE_THREADS:
13849         case OMP_CLAUSE_SIMD:
13850         case OMP_CLAUSE_HINT:
13851         case OMP_CLAUSE_DEFAULTMAP:
13852         case OMP_CLAUSE_NUM_GANGS:
13853         case OMP_CLAUSE_NUM_WORKERS:
13854         case OMP_CLAUSE_VECTOR_LENGTH:
13855         case OMP_CLAUSE_ASYNC:
13856         case OMP_CLAUSE_WAIT:
13857         case OMP_CLAUSE_AUTO:
13858         case OMP_CLAUSE_INDEPENDENT:
13859         case OMP_CLAUSE_SEQ:
13860         case OMP_CLAUSE_GANG:
13861         case OMP_CLAUSE_WORKER:
13862         case OMP_CLAUSE_VECTOR:
13863         case OMP_CLAUSE_TILE:
13864           pc = &OMP_CLAUSE_CHAIN (c);
13865           continue;
13866
13867         case OMP_CLAUSE_SCHEDULE:
13868           if (OMP_CLAUSE_SCHEDULE_KIND (c) & OMP_CLAUSE_SCHEDULE_NONMONOTONIC)
13869             {
13870               const char *p = NULL;
13871               switch (OMP_CLAUSE_SCHEDULE_KIND (c) & OMP_CLAUSE_SCHEDULE_MASK)
13872                 {
13873                 case OMP_CLAUSE_SCHEDULE_STATIC: p = "static"; break;
13874                 case OMP_CLAUSE_SCHEDULE_DYNAMIC: break;
13875                 case OMP_CLAUSE_SCHEDULE_GUIDED: break;
13876                 case OMP_CLAUSE_SCHEDULE_AUTO: p = "auto"; break;
13877                 case OMP_CLAUSE_SCHEDULE_RUNTIME: p = "runtime"; break;
13878                 default: gcc_unreachable ();
13879                 }
13880               if (p)
13881                 {
13882                   error_at (OMP_CLAUSE_LOCATION (c),
13883                             "%<nonmonotonic%> modifier specified for %qs "
13884                             "schedule kind", p);
13885                   OMP_CLAUSE_SCHEDULE_KIND (c)
13886                     = (enum omp_clause_schedule_kind)
13887                       (OMP_CLAUSE_SCHEDULE_KIND (c)
13888                        & ~OMP_CLAUSE_SCHEDULE_NONMONOTONIC);
13889                 }
13890             }
13891           schedule_clause = c;
13892           pc = &OMP_CLAUSE_CHAIN (c);
13893           continue;
13894
13895         case OMP_CLAUSE_ORDERED:
13896           ordered_seen = true;
13897           pc = &OMP_CLAUSE_CHAIN (c);
13898           continue;
13899
13900         case OMP_CLAUSE_SAFELEN:
13901           safelen = c;
13902           pc = &OMP_CLAUSE_CHAIN (c);
13903           continue;
13904         case OMP_CLAUSE_SIMDLEN:
13905           simdlen = c;
13906           pc = &OMP_CLAUSE_CHAIN (c);
13907           continue;
13908
13909         case OMP_CLAUSE_INBRANCH:
13910         case OMP_CLAUSE_NOTINBRANCH:
13911           if (branch_seen)
13912             {
13913               error_at (OMP_CLAUSE_LOCATION (c),
13914                         "%<inbranch%> clause is incompatible with "
13915                         "%<notinbranch%>");
13916               remove = true;
13917               break;
13918             }
13919           branch_seen = true;
13920           pc = &OMP_CLAUSE_CHAIN (c);
13921           continue;
13922
13923         default:
13924           gcc_unreachable ();
13925         }
13926
13927       if (!remove)
13928         {
13929           t = OMP_CLAUSE_DECL (c);
13930
13931           if (need_complete)
13932             {
13933               t = require_complete_type (OMP_CLAUSE_LOCATION (c), t);
13934               if (t == error_mark_node)
13935                 remove = true;
13936             }
13937
13938           if (need_implicitly_determined)
13939             {
13940               const char *share_name = NULL;
13941
13942               if (VAR_P (t) && DECL_THREAD_LOCAL_P (t))
13943                 share_name = "threadprivate";
13944               else switch (c_omp_predetermined_sharing (t))
13945                 {
13946                 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
13947                   break;
13948                 case OMP_CLAUSE_DEFAULT_SHARED:
13949                   /* const vars may be specified in firstprivate clause.  */
13950                   if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
13951                       && TREE_READONLY (t))
13952                     break;
13953                   share_name = "shared";
13954                   break;
13955                 case OMP_CLAUSE_DEFAULT_PRIVATE:
13956                   share_name = "private";
13957                   break;
13958                 default:
13959                   gcc_unreachable ();
13960                 }
13961               if (share_name)
13962                 {
13963                   error_at (OMP_CLAUSE_LOCATION (c),
13964                             "%qE is predetermined %qs for %qs",
13965                             t, share_name,
13966                             omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13967                   remove = true;
13968                 }
13969             }
13970         }
13971
13972       if (remove)
13973         *pc = OMP_CLAUSE_CHAIN (c);
13974       else
13975         pc = &OMP_CLAUSE_CHAIN (c);
13976     }
13977
13978   if (simdlen
13979       && safelen
13980       && tree_int_cst_lt (OMP_CLAUSE_SAFELEN_EXPR (safelen),
13981                           OMP_CLAUSE_SIMDLEN_EXPR (simdlen)))
13982     {
13983       error_at (OMP_CLAUSE_LOCATION (simdlen),
13984                 "%<simdlen%> clause value is bigger than "
13985                 "%<safelen%> clause value");
13986       OMP_CLAUSE_SIMDLEN_EXPR (simdlen)
13987         = OMP_CLAUSE_SAFELEN_EXPR (safelen);
13988     }
13989
13990   if (ordered_seen
13991       && schedule_clause
13992       && (OMP_CLAUSE_SCHEDULE_KIND (schedule_clause)
13993           & OMP_CLAUSE_SCHEDULE_NONMONOTONIC))
13994     {
13995       error_at (OMP_CLAUSE_LOCATION (schedule_clause),
13996                 "%<nonmonotonic%> schedule modifier specified together "
13997                 "with %<ordered%> clause");
13998       OMP_CLAUSE_SCHEDULE_KIND (schedule_clause)
13999         = (enum omp_clause_schedule_kind)
14000           (OMP_CLAUSE_SCHEDULE_KIND (schedule_clause)
14001            & ~OMP_CLAUSE_SCHEDULE_NONMONOTONIC);
14002     }
14003
14004   if (linear_variable_step_check)
14005     for (pc = &clauses, c = clauses; c ; c = *pc)
14006       {
14007         bool remove = false;
14008         if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR
14009             && OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (c)
14010             && !bitmap_bit_p (&map_head,
14011                               DECL_UID (OMP_CLAUSE_LINEAR_STEP (c))))
14012           {
14013             error_at (OMP_CLAUSE_LOCATION (c),
14014                       "%<linear%> clause step is a parameter %qD not "
14015                       "specified in %<uniform%> clause",
14016                       OMP_CLAUSE_LINEAR_STEP (c));
14017             remove = true;
14018           }
14019
14020         if (remove)
14021           *pc = OMP_CLAUSE_CHAIN (c);
14022         else
14023           pc = &OMP_CLAUSE_CHAIN (c);
14024       }
14025
14026   bitmap_obstack_release (NULL);
14027   return clauses;
14028 }
14029
14030 /* Return code to initialize DST with a copy constructor from SRC.
14031    C doesn't have copy constructors nor assignment operators, only for
14032    _Atomic vars we need to perform __atomic_load from src into a temporary
14033    followed by __atomic_store of the temporary to dst.  */
14034
14035 tree
14036 c_omp_clause_copy_ctor (tree clause, tree dst, tree src)
14037 {
14038   if (!really_atomic_lvalue (dst) && !really_atomic_lvalue (src))
14039     return build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
14040
14041   location_t loc = OMP_CLAUSE_LOCATION (clause);
14042   tree type = TREE_TYPE (dst);
14043   tree nonatomic_type = build_qualified_type (type, TYPE_UNQUALIFIED);
14044   tree tmp = create_tmp_var (nonatomic_type);
14045   tree tmp_addr = build_fold_addr_expr (tmp);
14046   TREE_ADDRESSABLE (tmp) = 1;
14047   TREE_NO_WARNING (tmp) = 1;
14048   tree src_addr = build_fold_addr_expr (src);
14049   tree dst_addr = build_fold_addr_expr (dst);
14050   tree seq_cst = build_int_cst (integer_type_node, MEMMODEL_SEQ_CST);
14051   vec<tree, va_gc> *params;
14052   /* Expansion of a generic atomic load may require an addition
14053      element, so allocate enough to prevent a resize.  */
14054   vec_alloc (params, 4);
14055
14056   /* Build __atomic_load (&src, &tmp, SEQ_CST);  */
14057   tree fndecl = builtin_decl_explicit (BUILT_IN_ATOMIC_LOAD);
14058   params->quick_push (src_addr);
14059   params->quick_push (tmp_addr);
14060   params->quick_push (seq_cst);
14061   tree load = c_build_function_call_vec (loc, vNULL, fndecl, params, NULL);
14062
14063   vec_alloc (params, 4);
14064
14065   /* Build __atomic_store (&dst, &tmp, SEQ_CST);  */
14066   fndecl = builtin_decl_explicit (BUILT_IN_ATOMIC_STORE);
14067   params->quick_push (dst_addr);
14068   params->quick_push (tmp_addr);
14069   params->quick_push (seq_cst);
14070   tree store = c_build_function_call_vec (loc, vNULL, fndecl, params, NULL);
14071   return build2 (COMPOUND_EXPR, void_type_node, load, store);
14072 }
14073
14074 /* Create a transaction node.  */
14075
14076 tree
14077 c_finish_transaction (location_t loc, tree block, int flags)
14078 {
14079   tree stmt = build_stmt (loc, TRANSACTION_EXPR, block);
14080   if (flags & TM_STMT_ATTR_OUTER)
14081     TRANSACTION_EXPR_OUTER (stmt) = 1;
14082   if (flags & TM_STMT_ATTR_RELAXED)
14083     TRANSACTION_EXPR_RELAXED (stmt) = 1;
14084   return add_stmt (stmt);
14085 }
14086
14087 /* Make a variant type in the proper way for C/C++, propagating qualifiers
14088    down to the element type of an array.  If ORIG_QUAL_TYPE is not
14089    NULL, then it should be used as the qualified type
14090    ORIG_QUAL_INDIRECT levels down in array type derivation (to
14091    preserve information about the typedef name from which an array
14092    type was derived).  */
14093
14094 tree
14095 c_build_qualified_type (tree type, int type_quals, tree orig_qual_type,
14096                         size_t orig_qual_indirect)
14097 {
14098   if (type == error_mark_node)
14099     return type;
14100
14101   if (TREE_CODE (type) == ARRAY_TYPE)
14102     {
14103       tree t;
14104       tree element_type = c_build_qualified_type (TREE_TYPE (type),
14105                                                   type_quals, orig_qual_type,
14106                                                   orig_qual_indirect - 1);
14107
14108       /* See if we already have an identically qualified type.  */
14109       if (orig_qual_type && orig_qual_indirect == 0)
14110         t = orig_qual_type;
14111       else
14112         for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
14113           {
14114             if (TYPE_QUALS (strip_array_types (t)) == type_quals
14115                 && TYPE_NAME (t) == TYPE_NAME (type)
14116                 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
14117                 && attribute_list_equal (TYPE_ATTRIBUTES (t),
14118                                          TYPE_ATTRIBUTES (type)))
14119               break;
14120           }
14121       if (!t)
14122         {
14123           tree domain = TYPE_DOMAIN (type);
14124
14125           t = build_variant_type_copy (type);
14126           TREE_TYPE (t) = element_type;
14127
14128           if (TYPE_STRUCTURAL_EQUALITY_P (element_type)
14129               || (domain && TYPE_STRUCTURAL_EQUALITY_P (domain)))
14130             SET_TYPE_STRUCTURAL_EQUALITY (t);
14131           else if (TYPE_CANONICAL (element_type) != element_type
14132                    || (domain && TYPE_CANONICAL (domain) != domain))
14133             {
14134               tree unqualified_canon
14135                 = build_array_type (TYPE_CANONICAL (element_type),
14136                                     domain? TYPE_CANONICAL (domain)
14137                                           : NULL_TREE);
14138               if (TYPE_REVERSE_STORAGE_ORDER (type))
14139                 {
14140                   unqualified_canon
14141                     = build_distinct_type_copy (unqualified_canon);
14142                   TYPE_REVERSE_STORAGE_ORDER (unqualified_canon) = 1;
14143                 }
14144               TYPE_CANONICAL (t)
14145                 = c_build_qualified_type (unqualified_canon, type_quals);
14146             }
14147           else
14148             TYPE_CANONICAL (t) = t;
14149         }
14150       return t;
14151     }
14152
14153   /* A restrict-qualified pointer type must be a pointer to object or
14154      incomplete type.  Note that the use of POINTER_TYPE_P also allows
14155      REFERENCE_TYPEs, which is appropriate for C++.  */
14156   if ((type_quals & TYPE_QUAL_RESTRICT)
14157       && (!POINTER_TYPE_P (type)
14158           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
14159     {
14160       error ("invalid use of %<restrict%>");
14161       type_quals &= ~TYPE_QUAL_RESTRICT;
14162     }
14163
14164   tree var_type = (orig_qual_type && orig_qual_indirect == 0
14165                    ? orig_qual_type
14166                    : build_qualified_type (type, type_quals));
14167   /* A variant type does not inherit the list of incomplete vars from the
14168      type main variant.  */
14169   if (RECORD_OR_UNION_TYPE_P (var_type)
14170       && TYPE_MAIN_VARIANT (var_type) != var_type)
14171     C_TYPE_INCOMPLETE_VARS (var_type) = 0;
14172   return var_type;
14173 }
14174
14175 /* Build a VA_ARG_EXPR for the C parser.  */
14176
14177 tree
14178 c_build_va_arg (location_t loc1, tree expr, location_t loc2, tree type)
14179 {
14180   if (error_operand_p (type))
14181     return error_mark_node;
14182   /* VA_ARG_EXPR cannot be used for a scalar va_list with reverse storage
14183      order because it takes the address of the expression.  */
14184   else if (handled_component_p (expr)
14185            && reverse_storage_order_for_component_p (expr))
14186     {
14187       error_at (loc1, "cannot use %<va_arg%> with reverse storage order");
14188       return error_mark_node;
14189     }
14190   else if (!COMPLETE_TYPE_P (type))
14191     {
14192       error_at (loc2, "second argument to %<va_arg%> is of incomplete "
14193                 "type %qT", type);
14194       return error_mark_node;
14195     }
14196   else if (warn_cxx_compat && TREE_CODE (type) == ENUMERAL_TYPE)
14197     warning_at (loc2, OPT_Wc___compat,
14198                 "C++ requires promoted type, not enum type, in %<va_arg%>");
14199   return build_va_arg (loc2, expr, type);
14200 }
14201
14202 /* Return truthvalue of whether T1 is the same tree structure as T2.
14203    Return 1 if they are the same. Return false if they are different.  */
14204
14205 bool
14206 c_tree_equal (tree t1, tree t2)
14207 {
14208   enum tree_code code1, code2;
14209
14210   if (t1 == t2)
14211     return true;
14212   if (!t1 || !t2)
14213     return false;
14214
14215   for (code1 = TREE_CODE (t1);
14216        CONVERT_EXPR_CODE_P (code1)
14217          || code1 == NON_LVALUE_EXPR;
14218        code1 = TREE_CODE (t1))
14219     t1 = TREE_OPERAND (t1, 0);
14220   for (code2 = TREE_CODE (t2);
14221        CONVERT_EXPR_CODE_P (code2)
14222          || code2 == NON_LVALUE_EXPR;
14223        code2 = TREE_CODE (t2))
14224     t2 = TREE_OPERAND (t2, 0);
14225
14226   /* They might have become equal now.  */
14227   if (t1 == t2)
14228     return true;
14229
14230   if (code1 != code2)
14231     return false;
14232
14233   switch (code1)
14234     {
14235     case INTEGER_CST:
14236       return wi::to_wide (t1) == wi::to_wide (t2);
14237
14238     case REAL_CST:
14239       return real_equal (&TREE_REAL_CST (t1), &TREE_REAL_CST (t2));
14240
14241     case STRING_CST:
14242       return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
14243         && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
14244                     TREE_STRING_LENGTH (t1));
14245
14246     case FIXED_CST:
14247       return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1),
14248                                      TREE_FIXED_CST (t2));
14249
14250     case COMPLEX_CST:
14251       return c_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
14252              && c_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
14253
14254     case VECTOR_CST:
14255       return operand_equal_p (t1, t2, OEP_ONLY_CONST);
14256
14257     case CONSTRUCTOR:
14258       /* We need to do this when determining whether or not two
14259          non-type pointer to member function template arguments
14260          are the same.  */
14261       if (!comptypes (TREE_TYPE (t1), TREE_TYPE (t2))
14262           || CONSTRUCTOR_NELTS (t1) != CONSTRUCTOR_NELTS (t2))
14263         return false;
14264       {
14265         tree field, value;
14266         unsigned int i;
14267         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, field, value)
14268           {
14269             constructor_elt *elt2 = CONSTRUCTOR_ELT (t2, i);
14270             if (!c_tree_equal (field, elt2->index)
14271                 || !c_tree_equal (value, elt2->value))
14272               return false;
14273           }
14274       }
14275       return true;
14276
14277     case TREE_LIST:
14278       if (!c_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
14279         return false;
14280       if (!c_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
14281         return false;
14282       return c_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
14283
14284     case SAVE_EXPR:
14285       return c_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
14286
14287     case CALL_EXPR:
14288       {
14289         tree arg1, arg2;
14290         call_expr_arg_iterator iter1, iter2;
14291         if (!c_tree_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
14292           return false;
14293         for (arg1 = first_call_expr_arg (t1, &iter1),
14294                arg2 = first_call_expr_arg (t2, &iter2);
14295              arg1 && arg2;
14296              arg1 = next_call_expr_arg (&iter1),
14297                arg2 = next_call_expr_arg (&iter2))
14298           if (!c_tree_equal (arg1, arg2))
14299             return false;
14300         if (arg1 || arg2)
14301           return false;
14302         return true;
14303       }
14304
14305     case TARGET_EXPR:
14306       {
14307         tree o1 = TREE_OPERAND (t1, 0);
14308         tree o2 = TREE_OPERAND (t2, 0);
14309
14310         /* Special case: if either target is an unallocated VAR_DECL,
14311            it means that it's going to be unified with whatever the
14312            TARGET_EXPR is really supposed to initialize, so treat it
14313            as being equivalent to anything.  */
14314         if (VAR_P (o1) && DECL_NAME (o1) == NULL_TREE
14315             && !DECL_RTL_SET_P (o1))
14316           /*Nop*/;
14317         else if (VAR_P (o2) && DECL_NAME (o2) == NULL_TREE
14318                  && !DECL_RTL_SET_P (o2))
14319           /*Nop*/;
14320         else if (!c_tree_equal (o1, o2))
14321           return false;
14322
14323         return c_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
14324       }
14325
14326     case COMPONENT_REF:
14327       if (TREE_OPERAND (t1, 1) != TREE_OPERAND (t2, 1))
14328         return false;
14329       return c_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
14330
14331     case PARM_DECL:
14332     case VAR_DECL:
14333     case CONST_DECL:
14334     case FIELD_DECL:
14335     case FUNCTION_DECL:
14336     case IDENTIFIER_NODE:
14337     case SSA_NAME:
14338       return false;
14339
14340     case TREE_VEC:
14341       {
14342         unsigned ix;
14343         if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
14344           return false;
14345         for (ix = TREE_VEC_LENGTH (t1); ix--;)
14346           if (!c_tree_equal (TREE_VEC_ELT (t1, ix),
14347                              TREE_VEC_ELT (t2, ix)))
14348             return false;
14349         return true;
14350       }
14351
14352     default:
14353       break;
14354     }
14355
14356   switch (TREE_CODE_CLASS (code1))
14357     {
14358     case tcc_unary:
14359     case tcc_binary:
14360     case tcc_comparison:
14361     case tcc_expression:
14362     case tcc_vl_exp:
14363     case tcc_reference:
14364     case tcc_statement:
14365       {
14366         int i, n = TREE_OPERAND_LENGTH (t1);
14367
14368         switch (code1)
14369           {
14370           case PREINCREMENT_EXPR:
14371           case PREDECREMENT_EXPR:
14372           case POSTINCREMENT_EXPR:
14373           case POSTDECREMENT_EXPR:
14374             n = 1;
14375             break;
14376           case ARRAY_REF:
14377             n = 2;
14378             break;
14379           default:
14380             break;
14381           }
14382
14383         if (TREE_CODE_CLASS (code1) == tcc_vl_exp
14384             && n != TREE_OPERAND_LENGTH (t2))
14385           return false;
14386
14387         for (i = 0; i < n; ++i)
14388           if (!c_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
14389             return false;
14390
14391         return true;
14392       }
14393
14394     case tcc_type:
14395       return comptypes (t1, t2);
14396     default:
14397       gcc_unreachable ();
14398     }
14399   /* We can get here with --disable-checking.  */
14400   return false;
14401 }
14402
14403 /* Returns true when the function declaration FNDECL is implicit,
14404    introduced as a result of a call to an otherwise undeclared
14405    function, and false otherwise.  */
14406
14407 bool
14408 c_decl_implicit (const_tree fndecl)
14409 {
14410   return C_DECL_IMPLICIT (fndecl);
14411 }