gcc/c-typeck.c

   1 /* Build expressions with type checking for C compiler.
   2    Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   3    1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22
  23 /* This file is part of the C front end.
  24    It contains routines to build C expressions given their operands,
  25    including computing the types of the result, C-specific error checks,
  26    and some optimization.  */
  27
  28 #include "config.h"
  29 #include "system.h"
  30 #include "coretypes.h"
  31 #include "tm.h"
  32 #include "rtl.h"
  33 #include "tree.h"
  34 #include "langhooks.h"
  35 #include "c-tree.h"
  36 #include "tm_p.h"
  37 #include "flags.h"
  38 #include "output.h"
  39 #include "expr.h"
  40 #include "toplev.h"
  41 #include "intl.h"
  42 #include "ggc.h"
  43 #include "target.h"
  44 #include "tree-iterator.h"
  45 #include "tree-gimple.h"
  46
  47 /* Places where an lvalue, or modifiable lvalue, may be required.
  48    Used to select diagnostic messages in lvalue_or_else and
  49    readonly_error.  */
  50 enum lvalue_use {
  51   lv_assign,
  52   lv_increment,
  53   lv_decrement,
  54   lv_addressof,
  55   lv_asm
  56 };
  57
  58 /* Possible cases of implicit bad conversions.  Used to select
  59    diagnostic messages in convert_for_assignment.  */
  60 enum impl_conv {
  61   ic_argpass,
  62   ic_argpass_nonproto,
  63   ic_assign,
  64   ic_init,
  65   ic_return
  66 };
  67
  68 /* The level of nesting inside "__alignof__".  */
  69 int in_alignof;
  70
  71 /* The level of nesting inside "sizeof".  */
  72 int in_sizeof;
  73
  74 /* The level of nesting inside "typeof".  */
  75 int in_typeof;
  76
  77 /* Nonzero if we've already printed a "missing braces around initializer"
  78    message within this initializer.  */
  79 static int missing_braces_mentioned;
  80
  81 static int require_constant_value;
  82 static int require_constant_elements;
  83
  84 static tree qualify_type (tree, tree);
  85 static int tagged_types_tu_compatible_p (tree, tree);
  86 static int comp_target_types (tree, tree, int);
  87 static int function_types_compatible_p (tree, tree);
  88 static int type_lists_compatible_p (tree, tree);
  89 static tree decl_constant_value_for_broken_optimization (tree);
  90 static tree default_function_array_conversion (tree);
  91 static tree lookup_field (tree, tree);
  92 static tree convert_arguments (tree, tree, tree, tree);
  93 static tree pointer_diff (tree, tree);
  94 static tree convert_for_assignment (tree, tree, enum impl_conv, tree, tree,
  95                                     int);
  96 static tree valid_compound_expr_initializer (tree, tree);
  97 static void push_string (const char *);
  98 static void push_member_name (tree);
  99 static void push_array_bounds (int);
 100 static int spelling_length (void);
 101 static char *print_spelling (char *);
 102 static void warning_init (const char *);
 103 static tree digest_init (tree, tree, bool, int);
 104 static void output_init_element (tree, bool, tree, tree, int);
 105 static void output_pending_init_elements (int);
 106 static int set_designator (int);
 107 static void push_range_stack (tree);
 108 static void add_pending_init (tree, tree);
 109 static void set_nonincremental_init (void);
 110 static void set_nonincremental_init_from_string (tree);
 111 static tree find_init_member (tree);
 112 static int lvalue_or_else (tree, enum lvalue_use);
 113 static void readonly_error (tree, enum lvalue_use);
 114 \f
 115 /* Do `exp = require_complete_type (exp);' to make sure exp
 116    does not have an incomplete type.  (That includes void types.)  */
 117
 118 tree
 119 require_complete_type (tree value)
 120 {
 121   tree type = TREE_TYPE (value);
 122
 123   if (value == error_mark_node || type == error_mark_node)
 124     return error_mark_node;
 125
 126   /* First, detect a valid value with a complete type.  */
 127   if (COMPLETE_TYPE_P (type))
 128     return value;
 129
 130   c_incomplete_type_error (value, type);
 131   return error_mark_node;
 132 }
 133
 134 /* Print an error message for invalid use of an incomplete type.
 135    VALUE is the expression that was used (or 0 if that isn't known)
 136    and TYPE is the type that was invalid.  */
 137
 138 void
 139 c_incomplete_type_error (tree value, tree type)
 140 {
 141   const char *type_code_string;
 142
 143   /* Avoid duplicate error message.  */
 144   if (TREE_CODE (type) == ERROR_MARK)
 145     return;
 146
 147   if (value != 0 && (TREE_CODE (value) == VAR_DECL
 148                      || TREE_CODE (value) == PARM_DECL))
 149     error ("%qs has an incomplete type",
 150            IDENTIFIER_POINTER (DECL_NAME (value)));
 151   else
 152     {
 153     retry:
 154       /* We must print an error message.  Be clever about what it says.  */
 155
 156       switch (TREE_CODE (type))
 157         {
 158         case RECORD_TYPE:
 159           type_code_string = "struct";
 160           break;
 161
 162         case UNION_TYPE:
 163           type_code_string = "union";
 164           break;
 165
 166         case ENUMERAL_TYPE:
 167           type_code_string = "enum";
 168           break;
 169
 170         case VOID_TYPE:
 171           error ("invalid use of void expression");
 172           return;
 173
 174         case ARRAY_TYPE:
 175           if (TYPE_DOMAIN (type))
 176             {
 177               if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL)
 178                 {
 179                   error ("invalid use of flexible array member");
 180                   return;
 181                 }
 182               type = TREE_TYPE (type);
 183               goto retry;
 184             }
 185           error ("invalid use of array with unspecified bounds");
 186           return;
 187
 188         default:
 189           gcc_unreachable ();
 190         }
 191
 192       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
 193         error ("invalid use of undefined type %<%s %s%>",
 194                type_code_string, IDENTIFIER_POINTER (TYPE_NAME (type)));
 195       else
 196         /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL.  */
 197         error ("invalid use of incomplete typedef %qs",
 198                IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
 199     }
 200 }
 201
 202 /* Given a type, apply default promotions wrt unnamed function
 203    arguments and return the new type.  */
 204
 205 tree
 206 c_type_promotes_to (tree type)
 207 {
 208   if (TYPE_MAIN_VARIANT (type) == float_type_node)
 209     return double_type_node;
 210
 211   if (c_promoting_integer_type_p (type))
 212     {
 213       /* Preserve unsignedness if not really getting any wider.  */
 214       if (TYPE_UNSIGNED (type)
 215           && (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
 216         return unsigned_type_node;
 217       return integer_type_node;
 218     }
 219
 220   return type;
 221 }
 222
 223 /* Return a variant of TYPE which has all the type qualifiers of LIKE
 224    as well as those of TYPE.  */
 225
 226 static tree
 227 qualify_type (tree type, tree like)
 228 {
 229   return c_build_qualified_type (type,
 230                                  TYPE_QUALS (type) | TYPE_QUALS (like));
 231 }
 232 \f
 233 /* Return the composite type of two compatible types.
 234
 235    We assume that comptypes has already been done and returned
 236    nonzero; if that isn't so, this may crash.  In particular, we
 237    assume that qualifiers match.  */
 238
 239 tree
 240 composite_type (tree t1, tree t2)
 241 {
 242   enum tree_code code1;
 243   enum tree_code code2;
 244   tree attributes;
 245
 246   /* Save time if the two types are the same.  */
 247
 248   if (t1 == t2) return t1;
 249
 250   /* If one type is nonsense, use the other.  */
 251   if (t1 == error_mark_node)
 252     return t2;
 253   if (t2 == error_mark_node)
 254     return t1;
 255
 256   code1 = TREE_CODE (t1);
 257   code2 = TREE_CODE (t2);
 258
 259   /* Merge the attributes.  */
 260   attributes = targetm.merge_type_attributes (t1, t2);
 261
 262   /* If one is an enumerated type and the other is the compatible
 263      integer type, the composite type might be either of the two
 264      (DR#013 question 3).  For consistency, use the enumerated type as
 265      the composite type.  */
 266
 267   if (code1 == ENUMERAL_TYPE && code2 == INTEGER_TYPE)
 268     return t1;
 269   if (code2 == ENUMERAL_TYPE && code1 == INTEGER_TYPE)
 270     return t2;
 271
 272   gcc_assert (code1 == code2);
 273
 274   switch (code1)
 275     {
 276     case POINTER_TYPE:
 277       /* For two pointers, do this recursively on the target type.  */
 278       {
 279         tree pointed_to_1 = TREE_TYPE (t1);
 280         tree pointed_to_2 = TREE_TYPE (t2);
 281         tree target = composite_type (pointed_to_1, pointed_to_2);
 282         t1 = build_pointer_type (target);
 283         t1 = build_type_attribute_variant (t1, attributes);
 284         return qualify_type (t1, t2);
 285       }
 286
 287     case ARRAY_TYPE:
 288       {
 289         tree elt = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
 290
 291         /* We should not have any type quals on arrays at all.  */
 292         gcc_assert (!TYPE_QUALS (t1) && !TYPE_QUALS (t2));
 293
 294         /* Save space: see if the result is identical to one of the args.  */
 295         if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
 296           return build_type_attribute_variant (t1, attributes);
 297         if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
 298           return build_type_attribute_variant (t2, attributes);
 299
 300         if (elt == TREE_TYPE (t1) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
 301           return build_type_attribute_variant (t1, attributes);
 302         if (elt == TREE_TYPE (t2) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
 303           return build_type_attribute_variant (t2, attributes);
 304
 305         /* Merge the element types, and have a size if either arg has one.  */
 306         t1 = build_array_type (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
 307         return build_type_attribute_variant (t1, attributes);
 308       }
 309
 310     case FUNCTION_TYPE:
 311       /* Function types: prefer the one that specified arg types.
 312          If both do, merge the arg types.  Also merge the return types.  */
 313       {
 314         tree valtype = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
 315         tree p1 = TYPE_ARG_TYPES (t1);
 316         tree p2 = TYPE_ARG_TYPES (t2);
 317         int len;
 318         tree newargs, n;
 319         int i;
 320
 321         /* Save space: see if the result is identical to one of the args.  */
 322         if (valtype == TREE_TYPE (t1) && !TYPE_ARG_TYPES (t2))
 323           return build_type_attribute_variant (t1, attributes);
 324         if (valtype == TREE_TYPE (t2) && !TYPE_ARG_TYPES (t1))
 325           return build_type_attribute_variant (t2, attributes);
 326
 327         /* Simple way if one arg fails to specify argument types.  */
 328         if (TYPE_ARG_TYPES (t1) == 0)
 329          {
 330             t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
 331             t1 = build_type_attribute_variant (t1, attributes);
 332             return qualify_type (t1, t2);
 333          }
 334         if (TYPE_ARG_TYPES (t2) == 0)
 335          {
 336            t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
 337            t1 = build_type_attribute_variant (t1, attributes);
 338            return qualify_type (t1, t2);
 339          }
 340
 341         /* If both args specify argument types, we must merge the two
 342            lists, argument by argument.  */
 343         /* Tell global_bindings_p to return false so that variable_size
 344            doesn't abort on VLAs in parameter types.  */
 345         c_override_global_bindings_to_false = true;
 346
 347         len = list_length (p1);
 348         newargs = 0;
 349
 350         for (i = 0; i < len; i++)
 351           newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
 352
 353         n = newargs;
 354
 355         for (; p1;
 356              p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
 357           {
 358             /* A null type means arg type is not specified.
 359                Take whatever the other function type has.  */
 360             if (TREE_VALUE (p1) == 0)
 361               {
 362                 TREE_VALUE (n) = TREE_VALUE (p2);
 363                 goto parm_done;
 364               }
 365             if (TREE_VALUE (p2) == 0)
 366               {
 367                 TREE_VALUE (n) = TREE_VALUE (p1);
 368                 goto parm_done;
 369               }
 370
 371             /* Given  wait (union {union wait *u; int *i} *)
 372                and  wait (union wait *),
 373                prefer  union wait *  as type of parm.  */
 374             if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
 375                 && TREE_VALUE (p1) != TREE_VALUE (p2))
 376               {
 377                 tree memb;
 378                 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
 379                      memb; memb = TREE_CHAIN (memb))
 380                   if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2)))
 381                     {
 382                       TREE_VALUE (n) = TREE_VALUE (p2);
 383                       if (pedantic)
 384                         pedwarn ("function types not truly compatible in ISO C");
 385                       goto parm_done;
 386                     }
 387               }
 388             if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
 389                 && TREE_VALUE (p2) != TREE_VALUE (p1))
 390               {
 391                 tree memb;
 392                 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
 393                      memb; memb = TREE_CHAIN (memb))
 394                   if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1)))
 395                     {
 396                       TREE_VALUE (n) = TREE_VALUE (p1);
 397                       if (pedantic)
 398                         pedwarn ("function types not truly compatible in ISO C");
 399                       goto parm_done;
 400                     }
 401               }
 402             TREE_VALUE (n) = composite_type (TREE_VALUE (p1), TREE_VALUE (p2));
 403           parm_done: ;
 404           }
 405
 406         c_override_global_bindings_to_false = false;
 407         t1 = build_function_type (valtype, newargs);
 408         t1 = qualify_type (t1, t2);
 409         /* ... falls through ...  */
 410       }
 411
 412     default:
 413       return build_type_attribute_variant (t1, attributes);
 414     }
 415
 416 }
 417
 418 /* Return the type of a conditional expression between pointers to
 419    possibly differently qualified versions of compatible types.
 420
 421    We assume that comp_target_types has already been done and returned
 422    nonzero; if that isn't so, this may crash.  */
 423
 424 static tree
 425 common_pointer_type (tree t1, tree t2)
 426 {
 427   tree attributes;
 428   tree pointed_to_1;
 429   tree pointed_to_2;
 430   tree target;
 431
 432   /* Save time if the two types are the same.  */
 433
 434   if (t1 == t2) return t1;
 435
 436   /* If one type is nonsense, use the other.  */
 437   if (t1 == error_mark_node)
 438     return t2;
 439   if (t2 == error_mark_node)
 440     return t1;
 441
 442   gcc_assert (TREE_CODE (t1) == POINTER_TYPE
 443               && TREE_CODE (t2) == POINTER_TYPE);
 444
 445   /* Merge the attributes.  */
 446   attributes = targetm.merge_type_attributes (t1, t2);
 447
 448   /* Find the composite type of the target types, and combine the
 449      qualifiers of the two types' targets.  */
 450   pointed_to_1 = TREE_TYPE (t1);
 451   pointed_to_2 = TREE_TYPE (t2);
 452   target = composite_type (TYPE_MAIN_VARIANT (pointed_to_1),
 453                            TYPE_MAIN_VARIANT (pointed_to_2));
 454   t1 = build_pointer_type (c_build_qualified_type
 455                            (target,
 456                             TYPE_QUALS (pointed_to_1) |
 457                             TYPE_QUALS (pointed_to_2)));
 458   return build_type_attribute_variant (t1, attributes);
 459 }
 460
 461 /* Return the common type for two arithmetic types under the usual
 462    arithmetic conversions.  The default conversions have already been
 463    applied, and enumerated types converted to their compatible integer
 464    types.  The resulting type is unqualified and has no attributes.
 465
 466    This is the type for the result of most arithmetic operations
 467    if the operands have the given two types.  */
 468
 469 tree
 470 common_type (tree t1, tree t2)
 471 {
 472   enum tree_code code1;
 473   enum tree_code code2;
 474
 475   /* If one type is nonsense, use the other.  */
 476   if (t1 == error_mark_node)
 477     return t2;
 478   if (t2 == error_mark_node)
 479     return t1;
 480
 481   if (TYPE_QUALS (t1) != TYPE_UNQUALIFIED)
 482     t1 = TYPE_MAIN_VARIANT (t1);
 483
 484   if (TYPE_QUALS (t2) != TYPE_UNQUALIFIED)
 485     t2 = TYPE_MAIN_VARIANT (t2);
 486
 487   if (TYPE_ATTRIBUTES (t1) != NULL_TREE)
 488     t1 = build_type_attribute_variant (t1, NULL_TREE);
 489
 490   if (TYPE_ATTRIBUTES (t2) != NULL_TREE)
 491     t2 = build_type_attribute_variant (t2, NULL_TREE);
 492
 493   /* Save time if the two types are the same.  */
 494
 495   if (t1 == t2) return t1;
 496
 497   code1 = TREE_CODE (t1);
 498   code2 = TREE_CODE (t2);
 499
 500   gcc_assert (code1 == VECTOR_TYPE || code1 == COMPLEX_TYPE
 501               || code1 == REAL_TYPE || code1 == INTEGER_TYPE);
 502   gcc_assert (code2 == VECTOR_TYPE || code2 == COMPLEX_TYPE
 503               || code2 == REAL_TYPE || code2 == INTEGER_TYPE);
 504
 505   /* If one type is a vector type, return that type.  (How the usual
 506      arithmetic conversions apply to the vector types extension is not
 507      precisely specified.)  */
 508   if (code1 == VECTOR_TYPE)
 509     return t1;
 510
 511   if (code2 == VECTOR_TYPE)
 512     return t2;
 513
 514   /* If one type is complex, form the common type of the non-complex
 515      components, then make that complex.  Use T1 or T2 if it is the
 516      required type.  */
 517   if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
 518     {
 519       tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
 520       tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
 521       tree subtype = common_type (subtype1, subtype2);
 522
 523       if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
 524         return t1;
 525       else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
 526         return t2;
 527       else
 528         return build_complex_type (subtype);
 529     }
 530
 531   /* If only one is real, use it as the result.  */
 532
 533   if (code1 == REAL_TYPE && code2 != REAL_TYPE)
 534     return t1;
 535
 536   if (code2 == REAL_TYPE && code1 != REAL_TYPE)
 537     return t2;
 538
 539   /* Both real or both integers; use the one with greater precision.  */
 540
 541   if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
 542     return t1;
 543   else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
 544     return t2;
 545
 546   /* Same precision.  Prefer long longs to longs to ints when the
 547      same precision, following the C99 rules on integer type rank
 548      (which are equivalent to the C90 rules for C90 types).  */
 549
 550   if (TYPE_MAIN_VARIANT (t1) == long_long_unsigned_type_node
 551       || TYPE_MAIN_VARIANT (t2) == long_long_unsigned_type_node)
 552     return long_long_unsigned_type_node;
 553
 554   if (TYPE_MAIN_VARIANT (t1) == long_long_integer_type_node
 555       || TYPE_MAIN_VARIANT (t2) == long_long_integer_type_node)
 556     {
 557       if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
 558         return long_long_unsigned_type_node;
 559       else
 560         return long_long_integer_type_node;
 561     }
 562
 563   if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
 564       || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
 565     return long_unsigned_type_node;
 566
 567   if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
 568       || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
 569     {
 570       /* But preserve unsignedness from the other type,
 571          since long cannot hold all the values of an unsigned int.  */
 572       if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
 573         return long_unsigned_type_node;
 574       else
 575         return long_integer_type_node;
 576     }
 577
 578   /* Likewise, prefer long double to double even if same size.  */
 579   if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
 580       || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
 581     return long_double_type_node;
 582
 583   /* Otherwise prefer the unsigned one.  */
 584
 585   if (TYPE_UNSIGNED (t1))
 586     return t1;
 587   else
 588     return t2;
 589 }
 590 \f
 591 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
 592    or various other operations.  Return 2 if they are compatible
 593    but a warning may be needed if you use them together.  */
 594
 595 int
 596 comptypes (tree type1, tree type2)
 597 {
 598   tree t1 = type1;
 599   tree t2 = type2;
 600   int attrval, val;
 601
 602   /* Suppress errors caused by previously reported errors.  */
 603
 604   if (t1 == t2 || !t1 || !t2
 605       || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
 606     return 1;
 607
 608   /* If either type is the internal version of sizetype, return the
 609      language version.  */
 610   if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
 611       && TYPE_ORIG_SIZE_TYPE (t1))
 612     t1 = TYPE_ORIG_SIZE_TYPE (t1);
 613
 614   if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
 615       && TYPE_ORIG_SIZE_TYPE (t2))
 616     t2 = TYPE_ORIG_SIZE_TYPE (t2);
 617
 618
 619   /* Enumerated types are compatible with integer types, but this is
 620      not transitive: two enumerated types in the same translation unit
 621      are compatible with each other only if they are the same type.  */
 622
 623   if (TREE_CODE (t1) == ENUMERAL_TYPE && TREE_CODE (t2) != ENUMERAL_TYPE)
 624     t1 = c_common_type_for_size (TYPE_PRECISION (t1), TYPE_UNSIGNED (t1));
 625   else if (TREE_CODE (t2) == ENUMERAL_TYPE && TREE_CODE (t1) != ENUMERAL_TYPE)
 626     t2 = c_common_type_for_size (TYPE_PRECISION (t2), TYPE_UNSIGNED (t2));
 627
 628   if (t1 == t2)
 629     return 1;
 630
 631   /* Different classes of types can't be compatible.  */
 632
 633   if (TREE_CODE (t1) != TREE_CODE (t2))
 634     return 0;
 635
 636   /* Qualifiers must match. C99 6.7.3p9 */
 637
 638   if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
 639     return 0;
 640
 641   /* Allow for two different type nodes which have essentially the same
 642      definition.  Note that we already checked for equality of the type
 643      qualifiers (just above).  */
 644
 645   if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
 646     return 1;
 647
 648   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 649   if (!(attrval = targetm.comp_type_attributes (t1, t2)))
 650      return 0;
 651
 652   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 653   val = 0;
 654
 655   switch (TREE_CODE (t1))
 656     {
 657     case POINTER_TYPE:
 658       /* We must give ObjC the first crack at comparing pointers, since
 659            protocol qualifiers may be involved.  */
 660       if (c_dialect_objc () && (val = objc_comptypes (t1, t2, 0)) >= 0)
 661         break;
 662       val = (TREE_TYPE (t1) == TREE_TYPE (t2)
 663              ? 1 : comptypes (TREE_TYPE (t1), TREE_TYPE (t2)));
 664       break;
 665
 666     case FUNCTION_TYPE:
 667       val = function_types_compatible_p (t1, t2);
 668       break;
 669
 670     case ARRAY_TYPE:
 671       {
 672         tree d1 = TYPE_DOMAIN (t1);
 673         tree d2 = TYPE_DOMAIN (t2);
 674         bool d1_variable, d2_variable;
 675         bool d1_zero, d2_zero;
 676         val = 1;
 677
 678         /* Target types must match incl. qualifiers.  */
 679         if (TREE_TYPE (t1) != TREE_TYPE (t2)
 680             && 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2))))
 681           return 0;
 682
 683         /* Sizes must match unless one is missing or variable.  */
 684         if (d1 == 0 || d2 == 0 || d1 == d2)
 685           break;
 686
 687         d1_zero = !TYPE_MAX_VALUE (d1);
 688         d2_zero = !TYPE_MAX_VALUE (d2);
 689
 690         d1_variable = (!d1_zero
 691                        && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
 692                            || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
 693         d2_variable = (!d2_zero
 694                        && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
 695                            || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
 696
 697         if (d1_variable || d2_variable)
 698           break;
 699         if (d1_zero && d2_zero)
 700           break;
 701         if (d1_zero || d2_zero
 702             || !tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
 703             || !tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
 704           val = 0;
 705
 706         break;
 707       }
 708
 709     case RECORD_TYPE:
 710       /* We are dealing with two distinct structs.  In assorted Objective-C
 711          corner cases, however, these can still be deemed equivalent.  */
 712       if (c_dialect_objc () && objc_comptypes (t1, t2, 0) == 1)
 713         val = 1;
 714
 715     case ENUMERAL_TYPE:
 716     case UNION_TYPE:
 717       if (val != 1 && !same_translation_unit_p (t1, t2))
 718         val = tagged_types_tu_compatible_p (t1, t2);
 719       break;
 720
 721     case VECTOR_TYPE:
 722       val = TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
 723             && comptypes (TREE_TYPE (t1), TREE_TYPE (t2));
 724       break;
 725
 726     default:
 727       break;
 728     }
 729   return attrval == 2 && val == 1 ? 2 : val;
 730 }
 731
 732 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
 733    ignoring their qualifiers.  REFLEXIVE is only used by ObjC - set it
 734    to 1 or 0 depending if the check of the pointer types is meant to
 735    be reflexive or not (typically, assignments are not reflexive,
 736    while comparisons are reflexive).
 737 */
 738
 739 static int
 740 comp_target_types (tree ttl, tree ttr, int reflexive)
 741 {
 742   int val;
 743
 744   /* Give objc_comptypes a crack at letting these types through.  */
 745   if ((val = objc_comptypes (ttl, ttr, reflexive)) >= 0)
 746     return val;
 747
 748   val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)),
 749                    TYPE_MAIN_VARIANT (TREE_TYPE (ttr)));
 750
 751   if (val == 2 && pedantic)
 752     pedwarn ("types are not quite compatible");
 753   return val;
 754 }
 755 \f
 756 /* Subroutines of `comptypes'.  */
 757
 758 /* Determine whether two trees derive from the same translation unit.
 759    If the CONTEXT chain ends in a null, that tree's context is still
 760    being parsed, so if two trees have context chains ending in null,
 761    they're in the same translation unit.  */
 762 int
 763 same_translation_unit_p (tree t1, tree t2)
 764 {
 765   while (t1 && TREE_CODE (t1) != TRANSLATION_UNIT_DECL)
 766     switch (TREE_CODE_CLASS (TREE_CODE (t1)))
 767       {
 768       case tcc_declaration:
 769         t1 = DECL_CONTEXT (t1); break;
 770       case tcc_type:
 771         t1 = TYPE_CONTEXT (t1); break;
 772       case tcc_exceptional:
 773         t1 = BLOCK_SUPERCONTEXT (t1); break;  /* assume block */
 774       default: gcc_unreachable ();
 775       }
 776
 777   while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL)
 778     switch (TREE_CODE_CLASS (TREE_CODE (t2)))
 779       {
 780       case tcc_declaration:
 781         t2 = DECL_CONTEXT (t2); break;
 782       case tcc_type:
 783         t2 = TYPE_CONTEXT (t2); break;
 784       case tcc_exceptional:
 785         t2 = BLOCK_SUPERCONTEXT (t2); break;  /* assume block */
 786       default: gcc_unreachable ();
 787       }
 788
 789   return t1 == t2;
 790 }
 791
 792 /* The C standard says that two structures in different translation
 793    units are compatible with each other only if the types of their
 794    fields are compatible (among other things).  So, consider two copies
 795    of this structure:  */
 796
 797 struct tagged_tu_seen {
 798   const struct tagged_tu_seen * next;
 799   tree t1;
 800   tree t2;
 801 };
 802
 803 /* Can they be compatible with each other?  We choose to break the
 804    recursion by allowing those types to be compatible.  */
 805
 806 static const struct tagged_tu_seen * tagged_tu_seen_base;
 807
 808 /* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are
 809    compatible.  If the two types are not the same (which has been
 810    checked earlier), this can only happen when multiple translation
 811    units are being compiled.  See C99 6.2.7 paragraph 1 for the exact
 812    rules.  */
 813
 814 static int
 815 tagged_types_tu_compatible_p (tree t1, tree t2)
 816 {
 817   tree s1, s2;
 818   bool needs_warning = false;
 819
 820   /* We have to verify that the tags of the types are the same.  This
 821      is harder than it looks because this may be a typedef, so we have
 822      to go look at the original type.  It may even be a typedef of a
 823      typedef...
 824      In the case of compiler-created builtin structs the TYPE_DECL
 825      may be a dummy, with no DECL_ORIGINAL_TYPE.  Don't fault.  */
 826   while (TYPE_NAME (t1)
 827          && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL
 828          && DECL_ORIGINAL_TYPE (TYPE_NAME (t1)))
 829     t1 = DECL_ORIGINAL_TYPE (TYPE_NAME (t1));
 830
 831   while (TYPE_NAME (t2)
 832          && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL
 833          && DECL_ORIGINAL_TYPE (TYPE_NAME (t2)))
 834     t2 = DECL_ORIGINAL_TYPE (TYPE_NAME (t2));
 835
 836   /* C90 didn't have the requirement that the two tags be the same.  */
 837   if (flag_isoc99 && TYPE_NAME (t1) != TYPE_NAME (t2))
 838     return 0;
 839
 840   /* C90 didn't say what happened if one or both of the types were
 841      incomplete; we choose to follow C99 rules here, which is that they
 842      are compatible.  */
 843   if (TYPE_SIZE (t1) == NULL
 844       || TYPE_SIZE (t2) == NULL)
 845     return 1;
 846
 847   {
 848     const struct tagged_tu_seen * tts_i;
 849     for (tts_i = tagged_tu_seen_base; tts_i != NULL; tts_i = tts_i->next)
 850       if (tts_i->t1 == t1 && tts_i->t2 == t2)
 851         return 1;
 852   }
 853
 854   switch (TREE_CODE (t1))
 855     {
 856     case ENUMERAL_TYPE:
 857       {
 858
 859         /* Speed up the case where the type values are in the same order.  */
 860         tree tv1 = TYPE_VALUES (t1);
 861         tree tv2 = TYPE_VALUES (t2);
 862
 863         if (tv1 == tv2)
 864           return 1;
 865
 866         for (;tv1 && tv2; tv1 = TREE_CHAIN (tv1), tv2 = TREE_CHAIN (tv2))
 867           {
 868             if (TREE_PURPOSE (tv1) != TREE_PURPOSE (tv2))
 869               break;
 870             if (simple_cst_equal (TREE_VALUE (tv1), TREE_VALUE (tv2)) != 1)
 871               return 0;
 872           }
 873
 874         if (tv1 == NULL_TREE && tv2 == NULL_TREE)
 875           return 1;
 876         if (tv1 == NULL_TREE || tv2 == NULL_TREE)
 877           return 0;
 878
 879         if (list_length (TYPE_VALUES (t1)) != list_length (TYPE_VALUES (t2)))
 880           return 0;
 881
 882         for (s1 = TYPE_VALUES (t1); s1; s1 = TREE_CHAIN (s1))
 883           {
 884             s2 = purpose_member (TREE_PURPOSE (s1), TYPE_VALUES (t2));
 885             if (s2 == NULL
 886                 || simple_cst_equal (TREE_VALUE (s1), TREE_VALUE (s2)) != 1)
 887               return 0;
 888           }
 889         return 1;
 890       }
 891
 892     case UNION_TYPE:
 893       {
 894         if (list_length (TYPE_FIELDS (t1)) != list_length (TYPE_FIELDS (t2)))
 895           return 0;
 896
 897         for (s1 = TYPE_FIELDS (t1); s1; s1 = TREE_CHAIN (s1))
 898           {
 899             bool ok = false;
 900             struct tagged_tu_seen tts;
 901
 902             tts.next = tagged_tu_seen_base;
 903             tts.t1 = t1;
 904             tts.t2 = t2;
 905             tagged_tu_seen_base = &tts;
 906
 907             if (DECL_NAME (s1) != NULL)
 908               for (s2 = TYPE_FIELDS (t2); s2; s2 = TREE_CHAIN (s2))
 909                 if (DECL_NAME (s1) == DECL_NAME (s2))
 910                   {
 911                     int result;
 912                     result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2));
 913                     if (result == 0)
 914                       break;
 915                     if (result == 2)
 916                       needs_warning = true;
 917
 918                     if (TREE_CODE (s1) == FIELD_DECL
 919                         && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
 920                                              DECL_FIELD_BIT_OFFSET (s2)) != 1)
 921                       break;
 922
 923                     ok = true;
 924                     break;
 925                   }
 926             tagged_tu_seen_base = tts.next;
 927             if (!ok)
 928               return 0;
 929           }
 930         return needs_warning ? 2 : 1;
 931       }
 932
 933     case RECORD_TYPE:
 934       {
 935         struct tagged_tu_seen tts;
 936
 937         tts.next = tagged_tu_seen_base;
 938         tts.t1 = t1;
 939         tts.t2 = t2;
 940         tagged_tu_seen_base = &tts;
 941
 942         for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2);
 943              s1 && s2;
 944              s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2))
 945           {
 946             int result;
 947             if (TREE_CODE (s1) != TREE_CODE (s2)
 948                 || DECL_NAME (s1) != DECL_NAME (s2))
 949               break;
 950             result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2));
 951             if (result == 0)
 952               break;
 953             if (result == 2)
 954               needs_warning = true;
 955
 956             if (TREE_CODE (s1) == FIELD_DECL
 957                 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
 958                                      DECL_FIELD_BIT_OFFSET (s2)) != 1)
 959               break;
 960           }
 961         tagged_tu_seen_base = tts.next;
 962         if (s1 && s2)
 963           return 0;
 964         return needs_warning ? 2 : 1;
 965       }
 966
 967     default:
 968       gcc_unreachable ();
 969     }
 970 }
 971
 972 /* Return 1 if two function types F1 and F2 are compatible.
 973    If either type specifies no argument types,
 974    the other must specify a fixed number of self-promoting arg types.
 975    Otherwise, if one type specifies only the number of arguments,
 976    the other must specify that number of self-promoting arg types.
 977    Otherwise, the argument types must match.  */
 978
 979 static int
 980 function_types_compatible_p (tree f1, tree f2)
 981 {
 982   tree args1, args2;
 983   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 984   int val = 1;
 985   int val1;
 986   tree ret1, ret2;
 987
 988   ret1 = TREE_TYPE (f1);
 989   ret2 = TREE_TYPE (f2);
 990
 991   /* 'volatile' qualifiers on a function's return type used to mean
 992      the function is noreturn.  */
 993   if (TYPE_VOLATILE (ret1) != TYPE_VOLATILE (ret2))
 994     pedwarn ("function return types not compatible due to %<volatile%>");
 995   if (TYPE_VOLATILE (ret1))
 996     ret1 = build_qualified_type (TYPE_MAIN_VARIANT (ret1),
 997                                  TYPE_QUALS (ret1) & ~TYPE_QUAL_VOLATILE);
 998   if (TYPE_VOLATILE (ret2))
 999     ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2),
1000                                  TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE);
1001   val = comptypes (ret1, ret2);
1002   if (val == 0)
1003     return 0;
1004
1005   args1 = TYPE_ARG_TYPES (f1);
1006   args2 = TYPE_ARG_TYPES (f2);
1007
1008   /* An unspecified parmlist matches any specified parmlist
1009      whose argument types don't need default promotions.  */
1010
1011   if (args1 == 0)
1012     {
1013       if (!self_promoting_args_p (args2))
1014         return 0;
1015       /* If one of these types comes from a non-prototype fn definition,
1016          compare that with the other type's arglist.
1017          If they don't match, ask for a warning (but no error).  */
1018       if (TYPE_ACTUAL_ARG_TYPES (f1)
1019           && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
1020         val = 2;
1021       return val;
1022     }
1023   if (args2 == 0)
1024     {
1025       if (!self_promoting_args_p (args1))
1026         return 0;
1027       if (TYPE_ACTUAL_ARG_TYPES (f2)
1028           && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
1029         val = 2;
1030       return val;
1031     }
1032
1033   /* Both types have argument lists: compare them and propagate results.  */
1034   val1 = type_lists_compatible_p (args1, args2);
1035   return val1 != 1 ? val1 : val;
1036 }
1037
1038 /* Check two lists of types for compatibility,
1039    returning 0 for incompatible, 1 for compatible,
1040    or 2 for compatible with warning.  */
1041
1042 static int
1043 type_lists_compatible_p (tree args1, tree args2)
1044 {
1045   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
1046   int val = 1;
1047   int newval = 0;
1048
1049   while (1)
1050     {
1051       if (args1 == 0 && args2 == 0)
1052         return val;
1053       /* If one list is shorter than the other,
1054          they fail to match.  */
1055       if (args1 == 0 || args2 == 0)
1056         return 0;
1057       /* A null pointer instead of a type
1058          means there is supposed to be an argument
1059          but nothing is specified about what type it has.
1060          So match anything that self-promotes.  */
1061       if (TREE_VALUE (args1) == 0)
1062         {
1063           if (c_type_promotes_to (TREE_VALUE (args2)) != TREE_VALUE (args2))
1064             return 0;
1065         }
1066       else if (TREE_VALUE (args2) == 0)
1067         {
1068           if (c_type_promotes_to (TREE_VALUE (args1)) != TREE_VALUE (args1))
1069             return 0;
1070         }
1071       /* If one of the lists has an error marker, ignore this arg.  */
1072       else if (TREE_CODE (TREE_VALUE (args1)) == ERROR_MARK
1073                || TREE_CODE (TREE_VALUE (args2)) == ERROR_MARK)
1074         ;
1075       else if (!(newval = comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1)),
1076                                      TYPE_MAIN_VARIANT (TREE_VALUE (args2)))))
1077         {
1078           /* Allow  wait (union {union wait *u; int *i} *)
1079              and  wait (union wait *)  to be compatible.  */
1080           if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE
1081               && (TYPE_NAME (TREE_VALUE (args1)) == 0
1082                   || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1)))
1083               && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST
1084               && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)),
1085                                      TYPE_SIZE (TREE_VALUE (args2))))
1086             {
1087               tree memb;
1088               for (memb = TYPE_FIELDS (TREE_VALUE (args1));
1089                    memb; memb = TREE_CHAIN (memb))
1090                 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2)))
1091                   break;
1092               if (memb == 0)
1093                 return 0;
1094             }
1095           else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE
1096                    && (TYPE_NAME (TREE_VALUE (args2)) == 0
1097                        || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2)))
1098                    && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST
1099                    && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)),
1100                                           TYPE_SIZE (TREE_VALUE (args1))))
1101             {
1102               tree memb;
1103               for (memb = TYPE_FIELDS (TREE_VALUE (args2));
1104                    memb; memb = TREE_CHAIN (memb))
1105                 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1)))
1106                   break;
1107               if (memb == 0)
1108                 return 0;
1109             }
1110           else
1111             return 0;
1112         }
1113
1114       /* comptypes said ok, but record if it said to warn.  */
1115       if (newval > val)
1116         val = newval;
1117
1118       args1 = TREE_CHAIN (args1);
1119       args2 = TREE_CHAIN (args2);
1120     }
1121 }
1122 \f
1123 /* Compute the size to increment a pointer by.  */
1124
1125 tree
1126 c_size_in_bytes (tree type)
1127 {
1128   enum tree_code code = TREE_CODE (type);
1129
1130   if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
1131     return size_one_node;
1132
1133   if (!COMPLETE_OR_VOID_TYPE_P (type))
1134     {
1135       error ("arithmetic on pointer to an incomplete type");
1136       return size_one_node;
1137     }
1138
1139   /* Convert in case a char is more than one unit.  */
1140   return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
1141                      size_int (TYPE_PRECISION (char_type_node)
1142                                / BITS_PER_UNIT));
1143 }
1144 \f
1145 /* Return either DECL or its known constant value (if it has one).  */
1146
1147 tree
1148 decl_constant_value (tree decl)
1149 {
1150   if (/* Don't change a variable array bound or initial value to a constant
1151          in a place where a variable is invalid.  Note that DECL_INITIAL
1152          isn't valid for a PARM_DECL.  */
1153       current_function_decl != 0
1154       && TREE_CODE (decl) != PARM_DECL
1155       && !TREE_THIS_VOLATILE (decl)
1156       && TREE_READONLY (decl)
1157       && DECL_INITIAL (decl) != 0
1158       && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
1159       /* This is invalid if initial value is not constant.
1160          If it has either a function call, a memory reference,
1161          or a variable, then re-evaluating it could give different results.  */
1162       && TREE_CONSTANT (DECL_INITIAL (decl))
1163       /* Check for cases where this is sub-optimal, even though valid.  */
1164       && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
1165     return DECL_INITIAL (decl);
1166   return decl;
1167 }
1168
1169 /* Return either DECL or its known constant value (if it has one), but
1170    return DECL if pedantic or DECL has mode BLKmode.  This is for
1171    bug-compatibility with the old behavior of decl_constant_value
1172    (before GCC 3.0); every use of this function is a bug and it should
1173    be removed before GCC 3.1.  It is not appropriate to use pedantic
1174    in a way that affects optimization, and BLKmode is probably not the
1175    right test for avoiding misoptimizations either.  */
1176
1177 static tree
1178 decl_constant_value_for_broken_optimization (tree decl)
1179 {
1180   if (pedantic || DECL_MODE (decl) == BLKmode)
1181     return decl;
1182   else
1183     return decl_constant_value (decl);
1184 }
1185
1186
1187 /* Perform the default conversion of arrays and functions to pointers.
1188    Return the result of converting EXP.  For any other expression, just
1189    return EXP.  */
1190
1191 static tree
1192 default_function_array_conversion (tree exp)
1193 {
1194   tree orig_exp;
1195   tree type = TREE_TYPE (exp);
1196   enum tree_code code = TREE_CODE (type);
1197   int not_lvalue = 0;
1198
1199   /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1200      an lvalue.
1201
1202      Do not use STRIP_NOPS here!  It will remove conversions from pointer
1203      to integer and cause infinite recursion.  */
1204   orig_exp = exp;
1205   while (TREE_CODE (exp) == NON_LVALUE_EXPR
1206          || (TREE_CODE (exp) == NOP_EXPR
1207              && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
1208     {
1209       if (TREE_CODE (exp) == NON_LVALUE_EXPR)
1210         not_lvalue = 1;
1211       exp = TREE_OPERAND (exp, 0);
1212     }
1213
1214   if (TREE_NO_WARNING (orig_exp))
1215     TREE_NO_WARNING (exp) = 1;
1216
1217   if (code == FUNCTION_TYPE)
1218     {
1219       return build_unary_op (ADDR_EXPR, exp, 0);
1220     }
1221   if (code == ARRAY_TYPE)
1222     {
1223       tree adr;
1224       tree restype = TREE_TYPE (type);
1225       tree ptrtype;
1226       int constp = 0;
1227       int volatilep = 0;
1228       int lvalue_array_p;
1229
1230       if (REFERENCE_CLASS_P (exp) || DECL_P (exp))
1231         {
1232           constp = TREE_READONLY (exp);
1233           volatilep = TREE_THIS_VOLATILE (exp);
1234         }
1235
1236       if (TYPE_QUALS (type) || constp || volatilep)
1237         restype
1238           = c_build_qualified_type (restype,
1239                                     TYPE_QUALS (type)
1240                                     | (constp * TYPE_QUAL_CONST)
1241                                     | (volatilep * TYPE_QUAL_VOLATILE));
1242
1243       if (TREE_CODE (exp) == INDIRECT_REF)
1244         return convert (build_pointer_type (restype),
1245                         TREE_OPERAND (exp, 0));
1246
1247       if (TREE_CODE (exp) == COMPOUND_EXPR)
1248         {
1249           tree op1 = default_conversion (TREE_OPERAND (exp, 1));
1250           return build2 (COMPOUND_EXPR, TREE_TYPE (op1),
1251                          TREE_OPERAND (exp, 0), op1);
1252         }
1253
1254       lvalue_array_p = !not_lvalue && lvalue_p (exp);
1255       if (!flag_isoc99 && !lvalue_array_p)
1256         {
1257           /* Before C99, non-lvalue arrays do not decay to pointers.
1258              Normally, using such an array would be invalid; but it can
1259              be used correctly inside sizeof or as a statement expression.
1260              Thus, do not give an error here; an error will result later.  */
1261           return exp;
1262         }
1263
1264       ptrtype = build_pointer_type (restype);
1265
1266       if (TREE_CODE (exp) == VAR_DECL)
1267         {
1268           /* We are making an ADDR_EXPR of ptrtype.  This is a valid
1269              ADDR_EXPR because it's the best way of representing what
1270              happens in C when we take the address of an array and place
1271              it in a pointer to the element type.  */
1272           adr = build1 (ADDR_EXPR, ptrtype, exp);
1273           if (!c_mark_addressable (exp))
1274             return error_mark_node;
1275           TREE_SIDE_EFFECTS (adr) = 0;   /* Default would be, same as EXP.  */
1276           return adr;
1277         }
1278       /* This way is better for a COMPONENT_REF since it can
1279          simplify the offset for a component.  */
1280       adr = build_unary_op (ADDR_EXPR, exp, 1);
1281       return convert (ptrtype, adr);
1282     }
1283   return exp;
1284 }
1285
1286 /* Perform default promotions for C data used in expressions.
1287    Arrays and functions are converted to pointers;
1288    enumeral types or short or char, to int.
1289    In addition, manifest constants symbols are replaced by their values.  */
1290
1291 tree
1292 default_conversion (tree exp)
1293 {
1294   tree orig_exp;
1295   tree type = TREE_TYPE (exp);
1296   enum tree_code code = TREE_CODE (type);
1297
1298   if (code == FUNCTION_TYPE || code == ARRAY_TYPE)
1299     return default_function_array_conversion (exp);
1300
1301   /* Constants can be used directly unless they're not loadable.  */
1302   if (TREE_CODE (exp) == CONST_DECL)
1303     exp = DECL_INITIAL (exp);
1304
1305   /* Replace a nonvolatile const static variable with its value unless
1306      it is an array, in which case we must be sure that taking the
1307      address of the array produces consistent results.  */
1308   else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
1309     {
1310       exp = decl_constant_value_for_broken_optimization (exp);
1311       type = TREE_TYPE (exp);
1312     }
1313
1314   /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1315      an lvalue.
1316
1317      Do not use STRIP_NOPS here!  It will remove conversions from pointer
1318      to integer and cause infinite recursion.  */
1319   orig_exp = exp;
1320   while (TREE_CODE (exp) == NON_LVALUE_EXPR
1321          || (TREE_CODE (exp) == NOP_EXPR
1322              && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
1323     exp = TREE_OPERAND (exp, 0);
1324
1325   if (TREE_NO_WARNING (orig_exp))
1326     TREE_NO_WARNING (exp) = 1;
1327
1328   /* Normally convert enums to int,
1329      but convert wide enums to something wider.  */
1330   if (code == ENUMERAL_TYPE)
1331     {
1332       type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
1333                                           TYPE_PRECISION (integer_type_node)),
1334                                      ((TYPE_PRECISION (type)
1335                                        >= TYPE_PRECISION (integer_type_node))
1336                                       && TYPE_UNSIGNED (type)));
1337
1338       return convert (type, exp);
1339     }
1340
1341   if (TREE_CODE (exp) == COMPONENT_REF
1342       && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
1343       /* If it's thinner than an int, promote it like a
1344          c_promoting_integer_type_p, otherwise leave it alone.  */
1345       && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
1346                                TYPE_PRECISION (integer_type_node)))
1347     return convert (integer_type_node, exp);
1348
1349   if (c_promoting_integer_type_p (type))
1350     {
1351       /* Preserve unsignedness if not really getting any wider.  */
1352       if (TYPE_UNSIGNED (type)
1353           && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1354         return convert (unsigned_type_node, exp);
1355
1356       return convert (integer_type_node, exp);
1357     }
1358
1359   if (code == VOID_TYPE)
1360     {
1361       error ("void value not ignored as it ought to be");
1362       return error_mark_node;
1363     }
1364   return exp;
1365 }
1366 \f
1367 /* Look up COMPONENT in a structure or union DECL.
1368
1369    If the component name is not found, returns NULL_TREE.  Otherwise,
1370    the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
1371    stepping down the chain to the component, which is in the last
1372    TREE_VALUE of the list.  Normally the list is of length one, but if
1373    the component is embedded within (nested) anonymous structures or
1374    unions, the list steps down the chain to the component.  */
1375
1376 static tree
1377 lookup_field (tree decl, tree component)
1378 {
1379   tree type = TREE_TYPE (decl);
1380   tree field;
1381
1382   /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1383      to the field elements.  Use a binary search on this array to quickly
1384      find the element.  Otherwise, do a linear search.  TYPE_LANG_SPECIFIC
1385      will always be set for structures which have many elements.  */
1386
1387   if (TYPE_LANG_SPECIFIC (type))
1388     {
1389       int bot, top, half;
1390       tree *field_array = &TYPE_LANG_SPECIFIC (type)->s->elts[0];
1391
1392       field = TYPE_FIELDS (type);
1393       bot = 0;
1394       top = TYPE_LANG_SPECIFIC (type)->s->len;
1395       while (top - bot > 1)
1396         {
1397           half = (top - bot + 1) >> 1;
1398           field = field_array[bot+half];
1399
1400           if (DECL_NAME (field) == NULL_TREE)
1401             {
1402               /* Step through all anon unions in linear fashion.  */
1403               while (DECL_NAME (field_array[bot]) == NULL_TREE)
1404                 {
1405                   field = field_array[bot++];
1406                   if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1407                       || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1408                     {
1409                       tree anon = lookup_field (field, component);
1410
1411                       if (anon)
1412                         return tree_cons (NULL_TREE, field, anon);
1413                     }
1414                 }
1415
1416               /* Entire record is only anon unions.  */
1417               if (bot > top)
1418                 return NULL_TREE;
1419
1420               /* Restart the binary search, with new lower bound.  */
1421               continue;
1422             }
1423
1424           if (DECL_NAME (field) == component)
1425             break;
1426           if (DECL_NAME (field) < component)
1427             bot += half;
1428           else
1429             top = bot + half;
1430         }
1431
1432       if (DECL_NAME (field_array[bot]) == component)
1433         field = field_array[bot];
1434       else if (DECL_NAME (field) != component)
1435         return NULL_TREE;
1436     }
1437   else
1438     {
1439       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1440         {
1441           if (DECL_NAME (field) == NULL_TREE
1442               && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1443                   || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE))
1444             {
1445               tree anon = lookup_field (field, component);
1446
1447               if (anon)
1448                 return tree_cons (NULL_TREE, field, anon);
1449             }
1450
1451           if (DECL_NAME (field) == component)
1452             break;
1453         }
1454
1455       if (field == NULL_TREE)
1456         return NULL_TREE;
1457     }
1458
1459   return tree_cons (NULL_TREE, field, NULL_TREE);
1460 }
1461
1462 /* Make an expression to refer to the COMPONENT field of
1463    structure or union value DATUM.  COMPONENT is an IDENTIFIER_NODE.  */
1464
1465 tree
1466 build_component_ref (tree datum, tree component)
1467 {
1468   tree type = TREE_TYPE (datum);
1469   enum tree_code code = TREE_CODE (type);
1470   tree field = NULL;
1471   tree ref;
1472
1473   if (!objc_is_public (datum, component))
1474     return error_mark_node;
1475
1476   /* See if there is a field or component with name COMPONENT.  */
1477
1478   if (code == RECORD_TYPE || code == UNION_TYPE)
1479     {
1480       if (!COMPLETE_TYPE_P (type))
1481         {
1482           c_incomplete_type_error (NULL_TREE, type);
1483           return error_mark_node;
1484         }
1485
1486       field = lookup_field (datum, component);
1487
1488       if (!field)
1489         {
1490           error ("%qT has no member named %qs", type,
1491                  IDENTIFIER_POINTER (component));
1492           return error_mark_node;
1493         }
1494
1495       /* Chain the COMPONENT_REFs if necessary down to the FIELD.
1496          This might be better solved in future the way the C++ front
1497          end does it - by giving the anonymous entities each a
1498          separate name and type, and then have build_component_ref
1499          recursively call itself.  We can't do that here.  */
1500       do
1501         {
1502           tree subdatum = TREE_VALUE (field);
1503
1504           if (TREE_TYPE (subdatum) == error_mark_node)
1505             return error_mark_node;
1506
1507           ref = build3 (COMPONENT_REF, TREE_TYPE (subdatum), datum, subdatum,
1508                         NULL_TREE);
1509           if (TREE_READONLY (datum) || TREE_READONLY (subdatum))
1510             TREE_READONLY (ref) = 1;
1511           if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (subdatum))
1512             TREE_THIS_VOLATILE (ref) = 1;
1513
1514           if (TREE_DEPRECATED (subdatum))
1515             warn_deprecated_use (subdatum);
1516
1517           datum = ref;
1518
1519           field = TREE_CHAIN (field);
1520         }
1521       while (field);
1522
1523       return ref;
1524     }
1525   else if (code != ERROR_MARK)
1526     error ("request for member %qs in something not a structure or union",
1527             IDENTIFIER_POINTER (component));
1528
1529   return error_mark_node;
1530 }
1531 \f
1532 /* Given an expression PTR for a pointer, return an expression
1533    for the value pointed to.
1534    ERRORSTRING is the name of the operator to appear in error messages.  */
1535
1536 tree
1537 build_indirect_ref (tree ptr, const char *errorstring)
1538 {
1539   tree pointer = default_conversion (ptr);
1540   tree type = TREE_TYPE (pointer);
1541
1542   if (TREE_CODE (type) == POINTER_TYPE)
1543     {
1544       if (TREE_CODE (pointer) == ADDR_EXPR
1545           && (TREE_TYPE (TREE_OPERAND (pointer, 0))
1546               == TREE_TYPE (type)))
1547         return TREE_OPERAND (pointer, 0);
1548       else
1549         {
1550           tree t = TREE_TYPE (type);
1551           tree ref = build1 (INDIRECT_REF, TYPE_MAIN_VARIANT (t), pointer);
1552
1553           if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
1554             {
1555               error ("dereferencing pointer to incomplete type");
1556               return error_mark_node;
1557             }
1558           if (VOID_TYPE_P (t) && skip_evaluation == 0)
1559             warning ("dereferencing %<void *%> pointer");
1560
1561           /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1562              so that we get the proper error message if the result is used
1563              to assign to.  Also, &* is supposed to be a no-op.
1564              And ANSI C seems to specify that the type of the result
1565              should be the const type.  */
1566           /* A de-reference of a pointer to const is not a const.  It is valid
1567              to change it via some other pointer.  */
1568           TREE_READONLY (ref) = TYPE_READONLY (t);
1569           TREE_SIDE_EFFECTS (ref)
1570             = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer);
1571           TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
1572           return ref;
1573         }
1574     }
1575   else if (TREE_CODE (pointer) != ERROR_MARK)
1576     error ("invalid type argument of %qs", errorstring);
1577   return error_mark_node;
1578 }
1579
1580 /* This handles expressions of the form "a[i]", which denotes
1581    an array reference.
1582
1583    This is logically equivalent in C to *(a+i), but we may do it differently.
1584    If A is a variable or a member, we generate a primitive ARRAY_REF.
1585    This avoids forcing the array out of registers, and can work on
1586    arrays that are not lvalues (for example, members of structures returned
1587    by functions).  */
1588
1589 tree
1590 build_array_ref (tree array, tree index)
1591 {
1592   if (index == 0)
1593     {
1594       error ("subscript missing in array reference");
1595       return error_mark_node;
1596     }
1597
1598   if (TREE_TYPE (array) == error_mark_node
1599       || TREE_TYPE (index) == error_mark_node)
1600     return error_mark_node;
1601
1602   if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
1603     {
1604       tree rval, type;
1605
1606       /* Subscripting with type char is likely to lose
1607          on a machine where chars are signed.
1608          So warn on any machine, but optionally.
1609          Don't warn for unsigned char since that type is safe.
1610          Don't warn for signed char because anyone who uses that
1611          must have done so deliberately.  */
1612       if (warn_char_subscripts
1613           && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1614         warning ("array subscript has type %<char%>");
1615
1616       /* Apply default promotions *after* noticing character types.  */
1617       index = default_conversion (index);
1618
1619       /* Require integer *after* promotion, for sake of enums.  */
1620       if (TREE_CODE (TREE_TYPE (index)) != INTEGER_TYPE)
1621         {
1622           error ("array subscript is not an integer");
1623           return error_mark_node;
1624         }
1625
1626       /* An array that is indexed by a non-constant
1627          cannot be stored in a register; we must be able to do
1628          address arithmetic on its address.
1629          Likewise an array of elements of variable size.  */
1630       if (TREE_CODE (index) != INTEGER_CST
1631           || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
1632               && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
1633         {
1634           if (!c_mark_addressable (array))
1635             return error_mark_node;
1636         }
1637       /* An array that is indexed by a constant value which is not within
1638          the array bounds cannot be stored in a register either; because we
1639          would get a crash in store_bit_field/extract_bit_field when trying
1640          to access a non-existent part of the register.  */
1641       if (TREE_CODE (index) == INTEGER_CST
1642           && TYPE_DOMAIN (TREE_TYPE (array))
1643           && !int_fits_type_p (index, TYPE_DOMAIN (TREE_TYPE (array))))
1644         {
1645           if (!c_mark_addressable (array))
1646             return error_mark_node;
1647         }
1648
1649       if (pedantic)
1650         {
1651           tree foo = array;
1652           while (TREE_CODE (foo) == COMPONENT_REF)
1653             foo = TREE_OPERAND (foo, 0);
1654           if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo))
1655             pedwarn ("ISO C forbids subscripting %<register%> array");
1656           else if (!flag_isoc99 && !lvalue_p (foo))
1657             pedwarn ("ISO C90 forbids subscripting non-lvalue array");
1658         }
1659
1660       type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
1661       rval = build4 (ARRAY_REF, type, array, index, NULL_TREE, NULL_TREE);
1662       /* Array ref is const/volatile if the array elements are
1663          or if the array is.  */
1664       TREE_READONLY (rval)
1665         |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
1666             | TREE_READONLY (array));
1667       TREE_SIDE_EFFECTS (rval)
1668         |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1669             | TREE_SIDE_EFFECTS (array));
1670       TREE_THIS_VOLATILE (rval)
1671         |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1672             /* This was added by rms on 16 Nov 91.
1673                It fixes  vol struct foo *a;  a->elts[1]
1674                in an inline function.
1675                Hope it doesn't break something else.  */
1676             | TREE_THIS_VOLATILE (array));
1677       return require_complete_type (fold (rval));
1678     }
1679
1680   {
1681     tree ar = default_conversion (array);
1682     tree ind = default_conversion (index);
1683
1684     /* Do the same warning check as above, but only on the part that's
1685        syntactically the index and only if it is also semantically
1686        the index.  */
1687     if (warn_char_subscripts
1688         && TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE
1689         && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1690       warning ("subscript has type %<char%>");
1691
1692     /* Put the integer in IND to simplify error checking.  */
1693     if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
1694       {
1695         tree temp = ar;
1696         ar = ind;
1697         ind = temp;
1698       }
1699
1700     if (ar == error_mark_node)
1701       return ar;
1702
1703     if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE
1704         || TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) == FUNCTION_TYPE)
1705       {
1706         error ("subscripted value is neither array nor pointer");
1707         return error_mark_node;
1708       }
1709     if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
1710       {
1711         error ("array subscript is not an integer");
1712         return error_mark_node;
1713       }
1714
1715     return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, ind, 0),
1716                                "array indexing");
1717   }
1718 }
1719 \f
1720 /* Build an external reference to identifier ID.  FUN indicates
1721    whether this will be used for a function call.  */
1722 tree
1723 build_external_ref (tree id, int fun)
1724 {
1725   tree ref;
1726   tree decl = lookup_name (id);
1727   tree objc_ivar = objc_lookup_ivar (id);
1728
1729   if (decl && decl != error_mark_node)
1730     {
1731       /* Properly declared variable or function reference.  */
1732       if (!objc_ivar)
1733         ref = decl;
1734       else if (decl != objc_ivar && !DECL_FILE_SCOPE_P (decl))
1735         {
1736           warning ("local declaration of %qs hides instance variable",
1737                    IDENTIFIER_POINTER (id));
1738           ref = decl;
1739         }
1740       else
1741         ref = objc_ivar;
1742     }
1743   else if (objc_ivar)
1744     ref = objc_ivar;
1745   else if (fun)
1746     /* Implicit function declaration.  */
1747     ref = implicitly_declare (id);
1748   else if (decl == error_mark_node)
1749     /* Don't complain about something that's already been
1750        complained about.  */
1751     return error_mark_node;
1752   else
1753     {
1754       undeclared_variable (id);
1755       return error_mark_node;
1756     }
1757
1758   if (TREE_TYPE (ref) == error_mark_node)
1759     return error_mark_node;
1760
1761   if (TREE_DEPRECATED (ref))
1762     warn_deprecated_use (ref);
1763
1764   if (!skip_evaluation)
1765     assemble_external (ref);
1766   TREE_USED (ref) = 1;
1767
1768   if (TREE_CODE (ref) == FUNCTION_DECL && !in_alignof)
1769     {
1770       if (!in_sizeof && !in_typeof)
1771         C_DECL_USED (ref) = 1;
1772       else if (DECL_INITIAL (ref) == 0
1773                && DECL_EXTERNAL (ref)
1774                && !TREE_PUBLIC (ref))
1775         record_maybe_used_decl (ref);
1776     }
1777
1778   if (TREE_CODE (ref) == CONST_DECL)
1779     {
1780       ref = DECL_INITIAL (ref);
1781       TREE_CONSTANT (ref) = 1;
1782       TREE_INVARIANT (ref) = 1;
1783     }
1784   else if (current_function_decl != 0
1785            && !DECL_FILE_SCOPE_P (current_function_decl)
1786            && (TREE_CODE (ref) == VAR_DECL
1787                || TREE_CODE (ref) == PARM_DECL
1788                || TREE_CODE (ref) == FUNCTION_DECL))
1789     {
1790       tree context = decl_function_context (ref);
1791
1792       if (context != 0 && context != current_function_decl)
1793         DECL_NONLOCAL (ref) = 1;
1794     }
1795
1796   return ref;
1797 }
1798
1799 /* Record details of decls possibly used inside sizeof or typeof.  */
1800 struct maybe_used_decl
1801 {
1802   /* The decl.  */
1803   tree decl;
1804   /* The level seen at (in_sizeof + in_typeof).  */
1805   int level;
1806   /* The next one at this level or above, or NULL.  */
1807   struct maybe_used_decl *next;
1808 };
1809
1810 static struct maybe_used_decl *maybe_used_decls;
1811
1812 /* Record that DECL, an undefined static function reference seen
1813    inside sizeof or typeof, might be used if the operand of sizeof is
1814    a VLA type or the operand of typeof is a variably modified
1815    type.  */
1816
1817 void
1818 record_maybe_used_decl (tree decl)
1819 {
1820   struct maybe_used_decl *t = XOBNEW (&parser_obstack, struct maybe_used_decl);
1821   t->decl = decl;
1822   t->level = in_sizeof + in_typeof;
1823   t->next = maybe_used_decls;
1824   maybe_used_decls = t;
1825 }
1826
1827 /* Pop the stack of decls possibly used inside sizeof or typeof.  If
1828    USED is false, just discard them.  If it is true, mark them used
1829    (if no longer inside sizeof or typeof) or move them to the next
1830    level up (if still inside sizeof or typeof).  */
1831
1832 void
1833 pop_maybe_used (bool used)
1834 {
1835   struct maybe_used_decl *p = maybe_used_decls;
1836   int cur_level = in_sizeof + in_typeof;
1837   while (p && p->level > cur_level)
1838     {
1839       if (used)
1840         {
1841           if (cur_level == 0)
1842             C_DECL_USED (p->decl) = 1;
1843           else
1844             p->level = cur_level;
1845         }
1846       p = p->next;
1847     }
1848   if (!used || cur_level == 0)
1849     maybe_used_decls = p;
1850 }
1851
1852 /* Return the result of sizeof applied to EXPR.  */
1853
1854 struct c_expr
1855 c_expr_sizeof_expr (struct c_expr expr)
1856 {
1857   struct c_expr ret;
1858   if (expr.value == error_mark_node)
1859     {
1860       ret.value = error_mark_node;
1861       ret.original_code = ERROR_MARK;
1862       pop_maybe_used (false);
1863     }
1864   else
1865     {
1866       ret.value = c_sizeof (TREE_TYPE (expr.value));
1867       ret.original_code = ERROR_MARK;
1868       pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (expr.value)));
1869     }
1870   return ret;
1871 }
1872
1873 /* Return the result of sizeof applied to T, a structure for the type
1874    name passed to sizeof (rather than the type itself).  */
1875
1876 struct c_expr
1877 c_expr_sizeof_type (struct c_type_name *t)
1878 {
1879   tree type;
1880   struct c_expr ret;
1881   type = groktypename (t);
1882   ret.value = c_sizeof (type);
1883   ret.original_code = ERROR_MARK;
1884   pop_maybe_used (C_TYPE_VARIABLE_SIZE (type));
1885   return ret;
1886 }
1887
1888 /* Build a function call to function FUNCTION with parameters PARAMS.
1889    PARAMS is a list--a chain of TREE_LIST nodes--in which the
1890    TREE_VALUE of each node is a parameter-expression.
1891    FUNCTION's data type may be a function type or a pointer-to-function.  */
1892
1893 tree
1894 build_function_call (tree function, tree params)
1895 {
1896   tree fntype, fundecl = 0;
1897   tree coerced_params;
1898   tree name = NULL_TREE, result;
1899   tree tem;
1900
1901   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
1902   STRIP_TYPE_NOPS (function);
1903
1904   /* Convert anything with function type to a pointer-to-function.  */
1905   if (TREE_CODE (function) == FUNCTION_DECL)
1906     {
1907       name = DECL_NAME (function);
1908
1909       /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1910          (because calling an inline function does not mean the function
1911          needs to be separately compiled).  */
1912       fntype = build_type_variant (TREE_TYPE (function),
1913                                    TREE_READONLY (function),
1914                                    TREE_THIS_VOLATILE (function));
1915       fundecl = function;
1916       function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
1917     }
1918   else
1919     function = default_conversion (function);
1920
1921   fntype = TREE_TYPE (function);
1922
1923   if (TREE_CODE (fntype) == ERROR_MARK)
1924     return error_mark_node;
1925
1926   if (!(TREE_CODE (fntype) == POINTER_TYPE
1927         && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
1928     {
1929       error ("called object %qE is not a function", function);
1930       return error_mark_node;
1931     }
1932
1933   if (fundecl && TREE_THIS_VOLATILE (fundecl))
1934     current_function_returns_abnormally = 1;
1935
1936   /* fntype now gets the type of function pointed to.  */
1937   fntype = TREE_TYPE (fntype);
1938
1939   /* Check that the function is called through a compatible prototype.
1940      If it is not, replace the call by a trap, wrapped up in a compound
1941      expression if necessary.  This has the nice side-effect to prevent
1942      the tree-inliner from generating invalid assignment trees which may
1943      blow up in the RTL expander later.
1944
1945      ??? This doesn't work for Objective-C because objc_comptypes
1946      refuses to compare function prototypes, yet the compiler appears
1947      to build calls that are flagged as invalid by C's comptypes.  */
1948   if (!c_dialect_objc ()
1949       && TREE_CODE (function) == NOP_EXPR
1950       && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR
1951       && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL
1952       && !comptypes (fntype, TREE_TYPE (tem)))
1953     {
1954       tree return_type = TREE_TYPE (fntype);
1955       tree trap = build_function_call (built_in_decls[BUILT_IN_TRAP],
1956                                        NULL_TREE);
1957
1958       /* This situation leads to run-time undefined behavior.  We can't,
1959          therefore, simply error unless we can prove that all possible
1960          executions of the program must execute the code.  */
1961       warning ("function called through a non-compatible type");
1962
1963       /* We can, however, treat "undefined" any way we please.
1964          Call abort to encourage the user to fix the program.  */
1965       inform ("if this code is reached, the program will abort");
1966
1967       if (VOID_TYPE_P (return_type))
1968         return trap;
1969       else
1970         {
1971           tree rhs;
1972
1973           if (AGGREGATE_TYPE_P (return_type))
1974             rhs = build_compound_literal (return_type,
1975                                           build_constructor (return_type,
1976                                                              NULL_TREE));
1977           else
1978             rhs = fold (build1 (NOP_EXPR, return_type, integer_zero_node));
1979
1980           return build2 (COMPOUND_EXPR, return_type, trap, rhs);
1981         }
1982     }
1983
1984   /* Convert the parameters to the types declared in the
1985      function prototype, or apply default promotions.  */
1986
1987   coerced_params
1988     = convert_arguments (TYPE_ARG_TYPES (fntype), params, function, fundecl);
1989
1990   /* Check that the arguments to the function are valid.  */
1991
1992   check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params);
1993
1994   result = build3 (CALL_EXPR, TREE_TYPE (fntype),
1995                    function, coerced_params, NULL_TREE);
1996   TREE_SIDE_EFFECTS (result) = 1;
1997
1998   if (require_constant_value)
1999     {
2000       result = fold_initializer (result);
2001
2002       if (TREE_CONSTANT (result)
2003           && (name == NULL_TREE
2004               || strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10) != 0))
2005         pedwarn_init ("initializer element is not constant");
2006     }
2007   else
2008     result = fold (result);
2009
2010   if (VOID_TYPE_P (TREE_TYPE (result)))
2011     return result;
2012   return require_complete_type (result);
2013 }
2014 \f
2015 /* Convert the argument expressions in the list VALUES
2016    to the types in the list TYPELIST.  The result is a list of converted
2017    argument expressions.
2018
2019    If TYPELIST is exhausted, or when an element has NULL as its type,
2020    perform the default conversions.
2021
2022    PARMLIST is the chain of parm decls for the function being called.
2023    It may be 0, if that info is not available.
2024    It is used only for generating error messages.
2025
2026    FUNCTION is a tree for the called function.  It is used only for
2027    error messages, where it is formatted with %qE.
2028
2029    This is also where warnings about wrong number of args are generated.
2030
2031    Both VALUES and the returned value are chains of TREE_LIST nodes
2032    with the elements of the list in the TREE_VALUE slots of those nodes.  */
2033
2034 static tree
2035 convert_arguments (tree typelist, tree values, tree function, tree fundecl)
2036 {
2037   tree typetail, valtail;
2038   tree result = NULL;
2039   int parmnum;
2040   tree selector;
2041
2042   /* Change pointer to function to the function itself for
2043      diagnostics.  */
2044   if (TREE_CODE (function) == ADDR_EXPR
2045       && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
2046     function = TREE_OPERAND (function, 0);
2047
2048   /* Handle an ObjC selector specially for diagnostics.  */
2049   selector = objc_message_selector ();
2050
2051   /* Scan the given expressions and types, producing individual
2052      converted arguments and pushing them on RESULT in reverse order.  */
2053
2054   for (valtail = values, typetail = typelist, parmnum = 0;
2055        valtail;
2056        valtail = TREE_CHAIN (valtail), parmnum++)
2057     {
2058       tree type = typetail ? TREE_VALUE (typetail) : 0;
2059       tree val = TREE_VALUE (valtail);
2060       tree rname = function;
2061       int argnum = parmnum + 1;
2062
2063       if (type == void_type_node)
2064         {
2065           error ("too many arguments to function %qE", function);
2066           break;
2067         }
2068
2069       if (selector && argnum > 2)
2070         {
2071           rname = selector;
2072           argnum -= 2;
2073         }
2074
2075       /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
2076       /* Do not use STRIP_NOPS here!  We do not want an enumerator with value 0
2077          to convert automatically to a pointer.  */
2078       if (TREE_CODE (val) == NON_LVALUE_EXPR)
2079         val = TREE_OPERAND (val, 0);
2080
2081       val = default_function_array_conversion (val);
2082
2083       val = require_complete_type (val);
2084
2085       if (type != 0)
2086         {
2087           /* Formal parm type is specified by a function prototype.  */
2088           tree parmval;
2089
2090           if (!COMPLETE_TYPE_P (type))
2091             {
2092               error ("type of formal parameter %d is incomplete", parmnum + 1);
2093               parmval = val;
2094             }
2095           else
2096             {
2097               /* Optionally warn about conversions that
2098                  differ from the default conversions.  */
2099               if (warn_conversion || warn_traditional)
2100                 {
2101                   unsigned int formal_prec = TYPE_PRECISION (type);
2102
2103                   if (INTEGRAL_TYPE_P (type)
2104                       && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
2105                     warning ("passing argument %d of %qE as integer "
2106                              "rather than floating due to prototype",
2107                              argnum, rname);
2108                   if (INTEGRAL_TYPE_P (type)
2109                       && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
2110                     warning ("passing argument %d of %qE as integer "
2111                              "rather than complex due to prototype",
2112                              argnum, rname);
2113                   else if (TREE_CODE (type) == COMPLEX_TYPE
2114                            && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
2115                     warning ("passing argument %d of %qE as complex "
2116                              "rather than floating due to prototype",
2117                              argnum, rname);
2118                   else if (TREE_CODE (type) == REAL_TYPE
2119                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
2120                     warning ("passing argument %d of %qE as floating "
2121                              "rather than integer due to prototype",
2122                              argnum, rname);
2123                   else if (TREE_CODE (type) == COMPLEX_TYPE
2124                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
2125                     warning ("passing argument %d of %qE as complex "
2126                              "rather than integer due to prototype",
2127                              argnum, rname);
2128                   else if (TREE_CODE (type) == REAL_TYPE
2129                            && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
2130                     warning ("passing argument %d of %qE as floating "
2131                              "rather than complex due to prototype",
2132                              argnum, rname);
2133                   /* ??? At some point, messages should be written about
2134                      conversions between complex types, but that's too messy
2135                      to do now.  */
2136                   else if (TREE_CODE (type) == REAL_TYPE
2137                            && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
2138                     {
2139                       /* Warn if any argument is passed as `float',
2140                          since without a prototype it would be `double'.  */
2141                       if (formal_prec == TYPE_PRECISION (float_type_node))
2142                         warning ("passing argument %d of %qE as %<float%> "
2143                                  "rather than %<double%> due to prototype",
2144                                  argnum, rname);
2145                     }
2146                   /* Detect integer changing in width or signedness.
2147                      These warnings are only activated with
2148                      -Wconversion, not with -Wtraditional.  */
2149                   else if (warn_conversion && INTEGRAL_TYPE_P (type)
2150                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
2151                     {
2152                       tree would_have_been = default_conversion (val);
2153                       tree type1 = TREE_TYPE (would_have_been);
2154
2155                       if (TREE_CODE (type) == ENUMERAL_TYPE
2156                           && (TYPE_MAIN_VARIANT (type)
2157                               == TYPE_MAIN_VARIANT (TREE_TYPE (val))))
2158                         /* No warning if function asks for enum
2159                            and the actual arg is that enum type.  */
2160                         ;
2161                       else if (formal_prec != TYPE_PRECISION (type1))
2162                         warning ("passing argument %d of %qE with different "
2163                                  "width due to prototype", argnum, rname);
2164                       else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1))
2165                         ;
2166                       /* Don't complain if the formal parameter type
2167                          is an enum, because we can't tell now whether
2168                          the value was an enum--even the same enum.  */
2169                       else if (TREE_CODE (type) == ENUMERAL_TYPE)
2170                         ;
2171                       else if (TREE_CODE (val) == INTEGER_CST
2172                                && int_fits_type_p (val, type))
2173                         /* Change in signedness doesn't matter
2174                            if a constant value is unaffected.  */
2175                         ;
2176                       /* Likewise for a constant in a NOP_EXPR.  */
2177                       else if (TREE_CODE (val) == NOP_EXPR
2178                                && TREE_CODE (TREE_OPERAND (val, 0)) == INTEGER_CST
2179                                && int_fits_type_p (TREE_OPERAND (val, 0), type))
2180                         ;
2181                       /* If the value is extended from a narrower
2182                          unsigned type, it doesn't matter whether we
2183                          pass it as signed or unsigned; the value
2184                          certainly is the same either way.  */
2185                       else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
2186                                && TYPE_UNSIGNED (TREE_TYPE (val)))
2187                         ;
2188                       else if (TYPE_UNSIGNED (type))
2189                         warning ("passing argument %d of %qE as unsigned "
2190                                  "due to prototype", argnum, rname);
2191                       else
2192                         warning ("passing argument %d of %qE as signed "
2193                                  "due to prototype", argnum, rname);
2194                     }
2195                 }
2196
2197               parmval = convert_for_assignment (type, val, ic_argpass,
2198                                                 fundecl, function,
2199                                                 parmnum + 1);
2200
2201               if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0)
2202                   && INTEGRAL_TYPE_P (type)
2203                   && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
2204                 parmval = default_conversion (parmval);
2205             }
2206           result = tree_cons (NULL_TREE, parmval, result);
2207         }
2208       else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
2209                && (TYPE_PRECISION (TREE_TYPE (val))
2210                    < TYPE_PRECISION (double_type_node)))
2211         /* Convert `float' to `double'.  */
2212         result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
2213       else
2214         /* Convert `short' and `char' to full-size `int'.  */
2215         result = tree_cons (NULL_TREE, default_conversion (val), result);
2216
2217       if (typetail)
2218         typetail = TREE_CHAIN (typetail);
2219     }
2220
2221   if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
2222     error ("too few arguments to function %qE", function);
2223
2224   return nreverse (result);
2225 }
2226 \f
2227 /* This is the entry point used by the parser
2228    for binary operators in the input.
2229    In addition to constructing the expression,
2230    we check for operands that were written with other binary operators
2231    in a way that is likely to confuse the user.  */
2232
2233 struct c_expr
2234 parser_build_binary_op (enum tree_code code, struct c_expr arg1,
2235                         struct c_expr arg2)
2236 {
2237   struct c_expr result;
2238
2239   enum tree_code code1 = arg1.original_code;
2240   enum tree_code code2 = arg2.original_code;
2241
2242   result.value = build_binary_op (code, arg1.value, arg2.value, 1);
2243   result.original_code = code;
2244
2245   if (TREE_CODE (result.value) == ERROR_MARK)
2246     return result;
2247
2248   /* Check for cases such as x+y<<z which users are likely
2249      to misinterpret.  */
2250   if (warn_parentheses)
2251     {
2252       if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
2253         {
2254           if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
2255               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2256             warning ("suggest parentheses around + or - inside shift");
2257         }
2258
2259       if (code == TRUTH_ORIF_EXPR)
2260         {
2261           if (code1 == TRUTH_ANDIF_EXPR
2262               || code2 == TRUTH_ANDIF_EXPR)
2263             warning ("suggest parentheses around && within ||");
2264         }
2265
2266       if (code == BIT_IOR_EXPR)
2267         {
2268           if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
2269               || code1 == PLUS_EXPR || code1 == MINUS_EXPR
2270               || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
2271               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2272             warning ("suggest parentheses around arithmetic in operand of |");
2273           /* Check cases like x|y==z */
2274           if (TREE_CODE_CLASS (code1) == tcc_comparison
2275               || TREE_CODE_CLASS (code2) == tcc_comparison)
2276             warning ("suggest parentheses around comparison in operand of |");
2277         }
2278
2279       if (code == BIT_XOR_EXPR)
2280         {
2281           if (code1 == BIT_AND_EXPR
2282               || code1 == PLUS_EXPR || code1 == MINUS_EXPR
2283               || code2 == BIT_AND_EXPR
2284               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2285             warning ("suggest parentheses around arithmetic in operand of ^");
2286           /* Check cases like x^y==z */
2287           if (TREE_CODE_CLASS (code1) == tcc_comparison
2288               || TREE_CODE_CLASS (code2) == tcc_comparison)
2289             warning ("suggest parentheses around comparison in operand of ^");
2290         }
2291
2292       if (code == BIT_AND_EXPR)
2293         {
2294           if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
2295               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2296             warning ("suggest parentheses around + or - in operand of &");
2297           /* Check cases like x&y==z */
2298           if (TREE_CODE_CLASS (code1) == tcc_comparison
2299               || TREE_CODE_CLASS (code2) == tcc_comparison)
2300             warning ("suggest parentheses around comparison in operand of &");
2301         }
2302       /* Similarly, check for cases like 1<=i<=10 that are probably errors.  */
2303       if (TREE_CODE_CLASS (code) == tcc_comparison
2304           && (TREE_CODE_CLASS (code1) == tcc_comparison
2305               || TREE_CODE_CLASS (code2) == tcc_comparison))
2306         warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
2307
2308     }
2309
2310   unsigned_conversion_warning (result.value, arg1.value);
2311   unsigned_conversion_warning (result.value, arg2.value);
2312   overflow_warning (result.value);
2313
2314   return result;
2315 }
2316 \f
2317 /* Return a tree for the difference of pointers OP0 and OP1.
2318    The resulting tree has type int.  */
2319
2320 static tree
2321 pointer_diff (tree op0, tree op1)
2322 {
2323   tree restype = ptrdiff_type_node;
2324
2325   tree target_type = TREE_TYPE (TREE_TYPE (op0));
2326   tree con0, con1, lit0, lit1;
2327   tree orig_op1 = op1;
2328
2329   if (pedantic || warn_pointer_arith)
2330     {
2331       if (TREE_CODE (target_type) == VOID_TYPE)
2332         pedwarn ("pointer of type %<void *%> used in subtraction");
2333       if (TREE_CODE (target_type) == FUNCTION_TYPE)
2334         pedwarn ("pointer to a function used in subtraction");
2335     }
2336
2337   /* If the conversion to ptrdiff_type does anything like widening or
2338      converting a partial to an integral mode, we get a convert_expression
2339      that is in the way to do any simplifications.
2340      (fold-const.c doesn't know that the extra bits won't be needed.
2341      split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
2342      different mode in place.)
2343      So first try to find a common term here 'by hand'; we want to cover
2344      at least the cases that occur in legal static initializers.  */
2345   con0 = TREE_CODE (op0) == NOP_EXPR ? TREE_OPERAND (op0, 0) : op0;
2346   con1 = TREE_CODE (op1) == NOP_EXPR ? TREE_OPERAND (op1, 0) : op1;
2347
2348   if (TREE_CODE (con0) == PLUS_EXPR)
2349     {
2350       lit0 = TREE_OPERAND (con0, 1);
2351       con0 = TREE_OPERAND (con0, 0);
2352     }
2353   else
2354     lit0 = integer_zero_node;
2355
2356   if (TREE_CODE (con1) == PLUS_EXPR)
2357     {
2358       lit1 = TREE_OPERAND (con1, 1);
2359       con1 = TREE_OPERAND (con1, 0);
2360     }
2361   else
2362     lit1 = integer_zero_node;
2363
2364   if (operand_equal_p (con0, con1, 0))
2365     {
2366       op0 = lit0;
2367       op1 = lit1;
2368     }
2369
2370
2371   /* First do the subtraction as integers;
2372      then drop through to build the divide operator.
2373      Do not do default conversions on the minus operator
2374      in case restype is a short type.  */
2375
2376   op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2377                          convert (restype, op1), 0);
2378   /* This generates an error if op1 is pointer to incomplete type.  */
2379   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
2380     error ("arithmetic on pointer to an incomplete type");
2381
2382   /* This generates an error if op0 is pointer to incomplete type.  */
2383   op1 = c_size_in_bytes (target_type);
2384
2385   /* Divide by the size, in easiest possible way.  */
2386   return fold (build2 (EXACT_DIV_EXPR, restype, op0, convert (restype, op1)));
2387 }
2388 \f
2389 /* Construct and perhaps optimize a tree representation
2390    for a unary operation.  CODE, a tree_code, specifies the operation
2391    and XARG is the operand.
2392    For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
2393    the default promotions (such as from short to int).
2394    For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
2395    allows non-lvalues; this is only used to handle conversion of non-lvalue
2396    arrays to pointers in C99.  */
2397
2398 tree
2399 build_unary_op (enum tree_code code, tree xarg, int flag)
2400 {
2401   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
2402   tree arg = xarg;
2403   tree argtype = 0;
2404   enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
2405   tree val;
2406   int noconvert = flag;
2407
2408   if (typecode == ERROR_MARK)
2409     return error_mark_node;
2410   if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
2411     typecode = INTEGER_TYPE;
2412
2413   switch (code)
2414     {
2415     case CONVERT_EXPR:
2416       /* This is used for unary plus, because a CONVERT_EXPR
2417          is enough to prevent anybody from looking inside for
2418          associativity, but won't generate any code.  */
2419       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2420             || typecode == COMPLEX_TYPE
2421             || typecode == VECTOR_TYPE))
2422         {
2423           error ("wrong type argument to unary plus");
2424           return error_mark_node;
2425         }
2426       else if (!noconvert)
2427         arg = default_conversion (arg);
2428       arg = non_lvalue (arg);
2429       break;
2430
2431     case NEGATE_EXPR:
2432       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2433             || typecode == COMPLEX_TYPE
2434             || typecode == VECTOR_TYPE))
2435         {
2436           error ("wrong type argument to unary minus");
2437           return error_mark_node;
2438         }
2439       else if (!noconvert)
2440         arg = default_conversion (arg);
2441       break;
2442
2443     case BIT_NOT_EXPR:
2444       if (typecode == INTEGER_TYPE || typecode == VECTOR_TYPE)
2445         {
2446           if (!noconvert)
2447             arg = default_conversion (arg);
2448         }
2449       else if (typecode == COMPLEX_TYPE)
2450         {
2451           code = CONJ_EXPR;
2452           if (pedantic)
2453             pedwarn ("ISO C does not support %<~%> for complex conjugation");
2454           if (!noconvert)
2455             arg = default_conversion (arg);
2456         }
2457       else
2458         {
2459           error ("wrong type argument to bit-complement");
2460           return error_mark_node;
2461         }
2462       break;
2463
2464     case ABS_EXPR:
2465       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
2466         {
2467           error ("wrong type argument to abs");
2468           return error_mark_node;
2469         }
2470       else if (!noconvert)
2471         arg = default_conversion (arg);
2472       break;
2473
2474     case CONJ_EXPR:
2475       /* Conjugating a real value is a no-op, but allow it anyway.  */
2476       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2477             || typecode == COMPLEX_TYPE))
2478         {
2479           error ("wrong type argument to conjugation");
2480           return error_mark_node;
2481         }
2482       else if (!noconvert)
2483         arg = default_conversion (arg);
2484       break;
2485
2486     case TRUTH_NOT_EXPR:
2487       if (typecode != INTEGER_TYPE
2488           && typecode != REAL_TYPE && typecode != POINTER_TYPE
2489           && typecode != COMPLEX_TYPE
2490           /* These will convert to a pointer.  */
2491           && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2492         {
2493           error ("wrong type argument to unary exclamation mark");
2494           return error_mark_node;
2495         }
2496       arg = lang_hooks.truthvalue_conversion (arg);
2497       return invert_truthvalue (arg);
2498
2499     case NOP_EXPR:
2500       break;
2501
2502     case REALPART_EXPR:
2503       if (TREE_CODE (arg) == COMPLEX_CST)
2504         return TREE_REALPART (arg);
2505       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2506         return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2507       else
2508         return arg;
2509
2510     case IMAGPART_EXPR:
2511       if (TREE_CODE (arg) == COMPLEX_CST)
2512         return TREE_IMAGPART (arg);
2513       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2514         return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2515       else
2516         return convert (TREE_TYPE (arg), integer_zero_node);
2517
2518     case PREINCREMENT_EXPR:
2519     case POSTINCREMENT_EXPR:
2520     case PREDECREMENT_EXPR:
2521     case POSTDECREMENT_EXPR:
2522
2523       /* Increment or decrement the real part of the value,
2524          and don't change the imaginary part.  */
2525       if (typecode == COMPLEX_TYPE)
2526         {
2527           tree real, imag;
2528
2529           if (pedantic)
2530             pedwarn ("ISO C does not support %<++%> and %<--%>"
2531                      " on complex types");
2532
2533           arg = stabilize_reference (arg);
2534           real = build_unary_op (REALPART_EXPR, arg, 1);
2535           imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2536           return build2 (COMPLEX_EXPR, TREE_TYPE (arg),
2537                          build_unary_op (code, real, 1), imag);
2538         }
2539
2540       /* Report invalid types.  */
2541
2542       if (typecode != POINTER_TYPE
2543           && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2544         {
2545           if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2546             error ("wrong type argument to increment");
2547           else
2548             error ("wrong type argument to decrement");
2549
2550           return error_mark_node;
2551         }
2552
2553       {
2554         tree inc;
2555         tree result_type = TREE_TYPE (arg);
2556
2557         arg = get_unwidened (arg, 0);
2558         argtype = TREE_TYPE (arg);
2559
2560         /* Compute the increment.  */
2561
2562         if (typecode == POINTER_TYPE)
2563           {
2564             /* If pointer target is an undefined struct,
2565                we just cannot know how to do the arithmetic.  */
2566             if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
2567               {
2568                 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2569                   error ("increment of pointer to unknown structure");
2570                 else
2571                   error ("decrement of pointer to unknown structure");
2572               }
2573             else if ((pedantic || warn_pointer_arith)
2574                      && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2575                          || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
2576               {
2577                 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2578                   pedwarn ("wrong type argument to increment");
2579                 else
2580                   pedwarn ("wrong type argument to decrement");
2581               }
2582
2583             inc = c_size_in_bytes (TREE_TYPE (result_type));
2584           }
2585         else
2586           inc = integer_one_node;
2587
2588         inc = convert (argtype, inc);
2589
2590         /* Complain about anything else that is not a true lvalue.  */
2591         if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
2592                                     || code == POSTINCREMENT_EXPR)
2593                                    ? lv_increment
2594                                    : lv_decrement)))
2595           return error_mark_node;
2596
2597         /* Report a read-only lvalue.  */
2598         if (TREE_READONLY (arg))
2599           readonly_error (arg,
2600                           ((code == PREINCREMENT_EXPR
2601                             || code == POSTINCREMENT_EXPR)
2602                            ? lv_increment : lv_decrement));
2603
2604         if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
2605           val = boolean_increment (code, arg);
2606         else
2607           val = build2 (code, TREE_TYPE (arg), arg, inc);
2608         TREE_SIDE_EFFECTS (val) = 1;
2609         val = convert (result_type, val);
2610         if (TREE_CODE (val) != code)
2611           TREE_NO_WARNING (val) = 1;
2612         return val;
2613       }
2614
2615     case ADDR_EXPR:
2616       /* Note that this operation never does default_conversion.  */
2617
2618       /* Let &* cancel out to simplify resulting code.  */
2619       if (TREE_CODE (arg) == INDIRECT_REF)
2620         {
2621           /* Don't let this be an lvalue.  */
2622           if (lvalue_p (TREE_OPERAND (arg, 0)))
2623             return non_lvalue (TREE_OPERAND (arg, 0));
2624           return TREE_OPERAND (arg, 0);
2625         }
2626
2627       /* For &x[y], return x+y */
2628       if (TREE_CODE (arg) == ARRAY_REF)
2629         {
2630           if (!c_mark_addressable (TREE_OPERAND (arg, 0)))
2631             return error_mark_node;
2632           return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
2633                                   TREE_OPERAND (arg, 1), 1);
2634         }
2635
2636       /* Anything not already handled and not a true memory reference
2637          or a non-lvalue array is an error.  */
2638       else if (typecode != FUNCTION_TYPE && !flag
2639                && !lvalue_or_else (arg, lv_addressof))
2640         return error_mark_node;
2641
2642       /* Ordinary case; arg is a COMPONENT_REF or a decl.  */
2643       argtype = TREE_TYPE (arg);
2644
2645       /* If the lvalue is const or volatile, merge that into the type
2646          to which the address will point.  Note that you can't get a
2647          restricted pointer by taking the address of something, so we
2648          only have to deal with `const' and `volatile' here.  */
2649       if ((DECL_P (arg) || REFERENCE_CLASS_P (arg))
2650           && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)))
2651           argtype = c_build_type_variant (argtype,
2652                                           TREE_READONLY (arg),
2653                                           TREE_THIS_VOLATILE (arg));
2654
2655       if (!c_mark_addressable (arg))
2656         return error_mark_node;
2657
2658       if (TREE_CODE (arg) == COMPONENT_REF
2659           && DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
2660         {
2661           error ("attempt to take address of bit-field structure member %qD",
2662                  TREE_OPERAND (arg, 1));
2663           return error_mark_node;
2664         }
2665
2666       argtype = build_pointer_type (argtype);
2667
2668       /* ??? Cope with user tricks that amount to offsetof.  Delete this
2669          when we have proper support for integer constant expressions.  */
2670       val = get_base_address (arg);
2671       if (val && TREE_CODE (val) == INDIRECT_REF
2672           && integer_zerop (TREE_OPERAND (val, 0)))
2673         return fold_convert (argtype, fold_offsetof (arg));
2674
2675       val = build1 (ADDR_EXPR, argtype, arg);
2676
2677       if (TREE_CODE (arg) == COMPOUND_LITERAL_EXPR)
2678         TREE_INVARIANT (val) = TREE_CONSTANT (val) = 1;
2679
2680       return val;
2681
2682     default:
2683       break;
2684     }
2685
2686   if (argtype == 0)
2687     argtype = TREE_TYPE (arg);
2688   val = build1 (code, argtype, arg);
2689   return require_constant_value ? fold_initializer (val) : fold (val);
2690 }
2691
2692 /* Return nonzero if REF is an lvalue valid for this language.
2693    Lvalues can be assigned, unless their type has TYPE_READONLY.
2694    Lvalues can have their address taken, unless they have C_DECL_REGISTER.  */
2695
2696 int
2697 lvalue_p (tree ref)
2698 {
2699   enum tree_code code = TREE_CODE (ref);
2700
2701   switch (code)
2702     {
2703     case REALPART_EXPR:
2704     case IMAGPART_EXPR:
2705     case COMPONENT_REF:
2706       return lvalue_p (TREE_OPERAND (ref, 0));
2707
2708     case COMPOUND_LITERAL_EXPR:
2709     case STRING_CST:
2710       return 1;
2711
2712     case INDIRECT_REF:
2713     case ARRAY_REF:
2714     case VAR_DECL:
2715     case PARM_DECL:
2716     case RESULT_DECL:
2717     case ERROR_MARK:
2718       return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
2719               && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
2720
2721     case BIND_EXPR:
2722       return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
2723
2724     default:
2725       return 0;
2726     }
2727 }
2728
2729 /* Return nonzero if REF is an lvalue valid for this language;
2730    otherwise, print an error message and return zero.  USE says
2731    how the lvalue is being used and so selects the error message.  */
2732
2733 static int
2734 lvalue_or_else (tree ref, enum lvalue_use use)
2735 {
2736   int win = lvalue_p (ref);
2737
2738   if (!win)
2739     {
2740       switch (use)
2741         {
2742         case lv_assign:
2743           error ("invalid lvalue in assignment");
2744           break;
2745         case lv_increment:
2746           error ("invalid lvalue in increment");
2747           break;
2748         case lv_decrement:
2749           error ("invalid lvalue in decrement");
2750           break;
2751         case lv_addressof:
2752           error ("invalid lvalue in unary %<&%>");
2753           break;
2754         case lv_asm:
2755           error ("invalid lvalue in asm statement");
2756           break;
2757         default:
2758           gcc_unreachable ();
2759         }
2760     }
2761
2762   return win;
2763 }
2764
2765 \f
2766 /* Give an error for storing in something that is 'const'.  */
2767
2768 static void
2769 readonly_error (tree arg, enum lvalue_use use)
2770 {
2771   gcc_assert (use == lv_assign || use == lv_increment || use == lv_decrement);
2772   /* Using this macro rather than (for example) arrays of messages
2773      ensures that all the format strings are checked at compile
2774      time.  */
2775 #define READONLY_MSG(A, I, D) (use == lv_assign                         \
2776                                ? (A)                                    \
2777                                : (use == lv_increment ? (I) : (D)))
2778   if (TREE_CODE (arg) == COMPONENT_REF)
2779     {
2780       if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
2781         readonly_error (TREE_OPERAND (arg, 0), use);
2782       else
2783         error (READONLY_MSG (N_("assignment of read-only member %qs"),
2784                              N_("increment of read-only member %qs"),
2785                              N_("decrement of read-only member %qs")),
2786                IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
2787     }
2788   else if (TREE_CODE (arg) == VAR_DECL)
2789     error (READONLY_MSG (N_("assignment of read-only variable %qs"),
2790                          N_("increment of read-only variable %qs"),
2791                          N_("decrement of read-only variable %qs")),
2792            IDENTIFIER_POINTER (DECL_NAME (arg)));
2793   else
2794     error (READONLY_MSG (N_("assignment of read-only location"),
2795                          N_("increment of read-only location"),
2796                          N_("decrement of read-only location")));
2797 }
2798 \f
2799 /* Mark EXP saying that we need to be able to take the
2800    address of it; it should not be allocated in a register.
2801    Returns true if successful.  */
2802
2803 bool
2804 c_mark_addressable (tree exp)
2805 {
2806   tree x = exp;
2807
2808   while (1)
2809     switch (TREE_CODE (x))
2810       {
2811       case COMPONENT_REF:
2812         if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
2813           {
2814             error ("cannot take address of bit-field %qs",
2815                    IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
2816             return false;
2817           }
2818
2819         /* ... fall through ...  */
2820
2821       case ADDR_EXPR:
2822       case ARRAY_REF:
2823       case REALPART_EXPR:
2824       case IMAGPART_EXPR:
2825         x = TREE_OPERAND (x, 0);
2826         break;
2827
2828       case COMPOUND_LITERAL_EXPR:
2829       case CONSTRUCTOR:
2830         TREE_ADDRESSABLE (x) = 1;
2831         return true;
2832
2833       case VAR_DECL:
2834       case CONST_DECL:
2835       case PARM_DECL:
2836       case RESULT_DECL:
2837         if (C_DECL_REGISTER (x)
2838             && DECL_NONLOCAL (x))
2839           {
2840             if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
2841               {
2842                 error ("global register variable %qs used in nested function",
2843                        IDENTIFIER_POINTER (DECL_NAME (x)));
2844                 return false;
2845               }
2846             pedwarn ("register variable %qs used in nested function",
2847                      IDENTIFIER_POINTER (DECL_NAME (x)));
2848           }
2849         else if (C_DECL_REGISTER (x))
2850           {
2851             if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
2852               {
2853                 error ("address of global register variable %qs requested",
2854                        IDENTIFIER_POINTER (DECL_NAME (x)));
2855                 return false;
2856               }
2857
2858             pedwarn ("address of register variable %qs requested",
2859                      IDENTIFIER_POINTER (DECL_NAME (x)));
2860           }
2861
2862         /* drops in */
2863       case FUNCTION_DECL:
2864         TREE_ADDRESSABLE (x) = 1;
2865         /* drops out */
2866       default:
2867         return true;
2868     }
2869 }
2870 \f
2871 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
2872
2873 tree
2874 build_conditional_expr (tree ifexp, tree op1, tree op2)
2875 {
2876   tree type1;
2877   tree type2;
2878   enum tree_code code1;
2879   enum tree_code code2;
2880   tree result_type = NULL;
2881   tree orig_op1 = op1, orig_op2 = op2;
2882
2883   ifexp = lang_hooks.truthvalue_conversion (default_conversion (ifexp));
2884
2885   /* Promote both alternatives.  */
2886
2887   if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
2888     op1 = default_conversion (op1);
2889   if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
2890     op2 = default_conversion (op2);
2891
2892   if (TREE_CODE (ifexp) == ERROR_MARK
2893       || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
2894       || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
2895     return error_mark_node;
2896
2897   type1 = TREE_TYPE (op1);
2898   code1 = TREE_CODE (type1);
2899   type2 = TREE_TYPE (op2);
2900   code2 = TREE_CODE (type2);
2901
2902   /* C90 does not permit non-lvalue arrays in conditional expressions.
2903      In C99 they will be pointers by now.  */
2904   if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE)
2905     {
2906       error ("non-lvalue array in conditional expression");
2907       return error_mark_node;
2908     }
2909
2910   /* Quickly detect the usual case where op1 and op2 have the same type
2911      after promotion.  */
2912   if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
2913     {
2914       if (type1 == type2)
2915         result_type = type1;
2916       else
2917         result_type = TYPE_MAIN_VARIANT (type1);
2918     }
2919   else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
2920             || code1 == COMPLEX_TYPE)
2921            && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
2922                || code2 == COMPLEX_TYPE))
2923     {
2924       result_type = common_type (type1, type2);
2925
2926       /* If -Wsign-compare, warn here if type1 and type2 have
2927          different signedness.  We'll promote the signed to unsigned
2928          and later code won't know it used to be different.
2929          Do this check on the original types, so that explicit casts
2930          will be considered, but default promotions won't.  */
2931       if (warn_sign_compare && !skip_evaluation)
2932         {
2933           int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1));
2934           int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2));
2935
2936           if (unsigned_op1 ^ unsigned_op2)
2937             {
2938               /* Do not warn if the result type is signed, since the
2939                  signed type will only be chosen if it can represent
2940                  all the values of the unsigned type.  */
2941               if (!TYPE_UNSIGNED (result_type))
2942                 /* OK */;
2943               /* Do not warn if the signed quantity is an unsuffixed
2944                  integer literal (or some static constant expression
2945                  involving such literals) and it is non-negative.  */
2946               else if ((unsigned_op2 && tree_expr_nonnegative_p (op1))
2947                        || (unsigned_op1 && tree_expr_nonnegative_p (op2)))
2948                 /* OK */;
2949               else
2950                 warning ("signed and unsigned type in conditional expression");
2951             }
2952         }
2953     }
2954   else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
2955     {
2956       if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
2957         pedwarn ("ISO C forbids conditional expr with only one void side");
2958       result_type = void_type_node;
2959     }
2960   else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
2961     {
2962       if (comp_target_types (type1, type2, 1))
2963         result_type = common_pointer_type (type1, type2);
2964       else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
2965                && TREE_CODE (orig_op1) != NOP_EXPR)
2966         result_type = qualify_type (type2, type1);
2967       else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
2968                && TREE_CODE (orig_op2) != NOP_EXPR)
2969         result_type = qualify_type (type1, type2);
2970       else if (VOID_TYPE_P (TREE_TYPE (type1)))
2971         {
2972           if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
2973             pedwarn ("ISO C forbids conditional expr between "
2974                      "%<void *%> and function pointer");
2975           result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
2976                                                           TREE_TYPE (type2)));
2977         }
2978       else if (VOID_TYPE_P (TREE_TYPE (type2)))
2979         {
2980           if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
2981             pedwarn ("ISO C forbids conditional expr between "
2982                      "%<void *%> and function pointer");
2983           result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
2984                                                           TREE_TYPE (type1)));
2985         }
2986       else
2987         {
2988           pedwarn ("pointer type mismatch in conditional expression");
2989           result_type = build_pointer_type (void_type_node);
2990         }
2991     }
2992   else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
2993     {
2994       if (!integer_zerop (op2))
2995         pedwarn ("pointer/integer type mismatch in conditional expression");
2996       else
2997         {
2998           op2 = null_pointer_node;
2999         }
3000       result_type = type1;
3001     }
3002   else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
3003     {
3004       if (!integer_zerop (op1))
3005         pedwarn ("pointer/integer type mismatch in conditional expression");
3006       else
3007         {
3008           op1 = null_pointer_node;
3009         }
3010       result_type = type2;
3011     }
3012
3013   if (!result_type)
3014     {
3015       if (flag_cond_mismatch)
3016         result_type = void_type_node;
3017       else
3018         {
3019           error ("type mismatch in conditional expression");
3020           return error_mark_node;
3021         }
3022     }
3023
3024   /* Merge const and volatile flags of the incoming types.  */
3025   result_type
3026     = build_type_variant (result_type,
3027                           TREE_READONLY (op1) || TREE_READONLY (op2),
3028                           TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
3029
3030   if (result_type != TREE_TYPE (op1))
3031     op1 = convert_and_check (result_type, op1);
3032   if (result_type != TREE_TYPE (op2))
3033     op2 = convert_and_check (result_type, op2);
3034
3035   if (TREE_CODE (ifexp) == INTEGER_CST)
3036     return non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3037
3038   return fold (build3 (COND_EXPR, result_type, ifexp, op1, op2));
3039 }
3040 \f
3041 /* Return a compound expression that performs two expressions and
3042    returns the value of the second of them.  */
3043
3044 tree
3045 build_compound_expr (tree expr1, tree expr2)
3046 {
3047   /* Convert arrays and functions to pointers.  */
3048   expr2 = default_function_array_conversion (expr2);
3049
3050   /* Don't let (0, 0) be null pointer constant.  */
3051   if (integer_zerop (expr2))
3052     expr2 = non_lvalue (expr2);
3053
3054   if (!TREE_SIDE_EFFECTS (expr1))
3055     {
3056       /* The left-hand operand of a comma expression is like an expression
3057          statement: with -Wextra or -Wunused, we should warn if it doesn't have
3058          any side-effects, unless it was explicitly cast to (void).  */
3059       if (warn_unused_value
3060            && !(TREE_CODE (expr1) == CONVERT_EXPR
3061                 && VOID_TYPE_P (TREE_TYPE (expr1))))
3062         warning ("left-hand operand of comma expression has no effect");
3063     }
3064
3065   /* With -Wunused, we should also warn if the left-hand operand does have
3066      side-effects, but computes a value which is not used.  For example, in
3067      `foo() + bar(), baz()' the result of the `+' operator is not used,
3068      so we should issue a warning.  */
3069   else if (warn_unused_value)
3070     warn_if_unused_value (expr1, input_location);
3071
3072   return build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2);
3073 }
3074
3075 /* Build an expression representing a cast to type TYPE of expression EXPR.  */
3076
3077 tree
3078 build_c_cast (tree type, tree expr)
3079 {
3080   tree value = expr;
3081
3082   if (type == error_mark_node || expr == error_mark_node)
3083     return error_mark_node;
3084
3085   /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
3086      only in <protocol> qualifications.  But when constructing cast expressions,
3087      the protocols do matter and must be kept around.  */
3088   if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr)))
3089     return build1 (NOP_EXPR, type, expr);
3090
3091   type = TYPE_MAIN_VARIANT (type);
3092
3093   if (TREE_CODE (type) == ARRAY_TYPE)
3094     {
3095       error ("cast specifies array type");
3096       return error_mark_node;
3097     }
3098
3099   if (TREE_CODE (type) == FUNCTION_TYPE)
3100     {
3101       error ("cast specifies function type");
3102       return error_mark_node;
3103     }
3104
3105   if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
3106     {
3107       if (pedantic)
3108         {
3109           if (TREE_CODE (type) == RECORD_TYPE
3110               || TREE_CODE (type) == UNION_TYPE)
3111             pedwarn ("ISO C forbids casting nonscalar to the same type");
3112         }
3113     }
3114   else if (TREE_CODE (type) == UNION_TYPE)
3115     {
3116       tree field;
3117       value = default_function_array_conversion (value);
3118
3119       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3120         if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3121                        TYPE_MAIN_VARIANT (TREE_TYPE (value))))
3122           break;
3123
3124       if (field)
3125         {
3126           tree t;
3127
3128           if (pedantic)
3129             pedwarn ("ISO C forbids casts to union type");
3130           t = digest_init (type,
3131                            build_constructor (type,
3132                                               build_tree_list (field, value)),
3133                            true, 0);
3134           TREE_CONSTANT (t) = TREE_CONSTANT (value);
3135           TREE_INVARIANT (t) = TREE_INVARIANT (value);
3136           return t;
3137         }
3138       error ("cast to union type from type not present in union");
3139       return error_mark_node;
3140     }
3141   else
3142     {
3143       tree otype, ovalue;
3144
3145       /* If casting to void, avoid the error that would come
3146          from default_conversion in the case of a non-lvalue array.  */
3147       if (type == void_type_node)
3148         return build1 (CONVERT_EXPR, type, value);
3149
3150       /* Convert functions and arrays to pointers,
3151          but don't convert any other types.  */
3152       value = default_function_array_conversion (value);
3153       otype = TREE_TYPE (value);
3154
3155       /* Optionally warn about potentially worrisome casts.  */
3156
3157       if (warn_cast_qual
3158           && TREE_CODE (type) == POINTER_TYPE
3159           && TREE_CODE (otype) == POINTER_TYPE)
3160         {
3161           tree in_type = type;
3162           tree in_otype = otype;
3163           int added = 0;
3164           int discarded = 0;
3165
3166           /* Check that the qualifiers on IN_TYPE are a superset of
3167              the qualifiers of IN_OTYPE.  The outermost level of
3168              POINTER_TYPE nodes is uninteresting and we stop as soon
3169              as we hit a non-POINTER_TYPE node on either type.  */
3170           do
3171             {
3172               in_otype = TREE_TYPE (in_otype);
3173               in_type = TREE_TYPE (in_type);
3174
3175               /* GNU C allows cv-qualified function types.  'const'
3176                  means the function is very pure, 'volatile' means it
3177                  can't return.  We need to warn when such qualifiers
3178                  are added, not when they're taken away.  */
3179               if (TREE_CODE (in_otype) == FUNCTION_TYPE
3180                   && TREE_CODE (in_type) == FUNCTION_TYPE)
3181                 added |= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype));
3182               else
3183                 discarded |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
3184             }
3185           while (TREE_CODE (in_type) == POINTER_TYPE
3186                  && TREE_CODE (in_otype) == POINTER_TYPE);
3187
3188           if (added)
3189             warning ("cast adds new qualifiers to function type");
3190
3191           if (discarded)
3192             /* There are qualifiers present in IN_OTYPE that are not
3193                present in IN_TYPE.  */
3194             warning ("cast discards qualifiers from pointer target type");
3195         }
3196
3197       /* Warn about possible alignment problems.  */
3198       if (STRICT_ALIGNMENT && warn_cast_align
3199           && TREE_CODE (type) == POINTER_TYPE
3200           && TREE_CODE (otype) == POINTER_TYPE
3201           && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3202           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3203           /* Don't warn about opaque types, where the actual alignment
3204              restriction is unknown.  */
3205           && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3206                 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3207                && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3208           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3209         warning ("cast increases required alignment of target type");
3210
3211       if (TREE_CODE (type) == INTEGER_TYPE
3212           && TREE_CODE (otype) == POINTER_TYPE
3213           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3214           && !TREE_CONSTANT (value))
3215         warning ("cast from pointer to integer of different size");
3216
3217       if (warn_bad_function_cast
3218           && TREE_CODE (value) == CALL_EXPR
3219           && TREE_CODE (type) != TREE_CODE (otype))
3220         warning ("cast from function call of type %qT to non-matching "
3221                  "type %qT", otype, type);
3222
3223       if (TREE_CODE (type) == POINTER_TYPE
3224           && TREE_CODE (otype) == INTEGER_TYPE
3225           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3226           /* Don't warn about converting any constant.  */
3227           && !TREE_CONSTANT (value))
3228         warning ("cast to pointer from integer of different size");
3229
3230       if (TREE_CODE (type) == POINTER_TYPE
3231           && TREE_CODE (otype) == POINTER_TYPE
3232           && TREE_CODE (expr) == ADDR_EXPR
3233           && DECL_P (TREE_OPERAND (expr, 0))
3234           && flag_strict_aliasing && warn_strict_aliasing
3235           && !VOID_TYPE_P (TREE_TYPE (type)))
3236         {
3237           /* Casting the address of a decl to non void pointer. Warn
3238              if the cast breaks type based aliasing.  */
3239           if (!COMPLETE_TYPE_P (TREE_TYPE (type)))
3240             warning ("type-punning to incomplete type might break strict-aliasing rules");
3241           else
3242             {
3243               HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
3244               HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
3245
3246               if (!alias_sets_conflict_p (set1, set2))
3247                 warning ("dereferencing type-punned pointer will break strict-aliasing rules");
3248               else if (warn_strict_aliasing > 1
3249                        && !alias_sets_might_conflict_p (set1, set2))
3250                 warning ("dereferencing type-punned pointer might break strict-aliasing rules");
3251             }
3252         }
3253
3254       /* If pedantic, warn for conversions between function and object
3255          pointer types, except for converting a null pointer constant
3256          to function pointer type.  */
3257       if (pedantic
3258           && TREE_CODE (type) == POINTER_TYPE
3259           && TREE_CODE (otype) == POINTER_TYPE
3260           && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
3261           && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
3262         pedwarn ("ISO C forbids conversion of function pointer to object pointer type");
3263
3264       if (pedantic
3265           && TREE_CODE (type) == POINTER_TYPE
3266           && TREE_CODE (otype) == POINTER_TYPE
3267           && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
3268           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3269           && !(integer_zerop (value) && TREE_TYPE (otype) == void_type_node
3270                && TREE_CODE (expr) != NOP_EXPR))
3271         pedwarn ("ISO C forbids conversion of object pointer to function pointer type");
3272
3273       ovalue = value;
3274       /* Replace a nonvolatile const static variable with its value.  */
3275       if (optimize && TREE_CODE (value) == VAR_DECL)
3276         value = decl_constant_value (value);
3277       value = convert (type, value);
3278
3279       /* Ignore any integer overflow caused by the cast.  */
3280       if (TREE_CODE (value) == INTEGER_CST)
3281         {
3282           if (EXPR_P (ovalue))
3283             /* If OVALUE had overflow set, then so will VALUE, so it
3284                is safe to overwrite.  */
3285             TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3286           else
3287             TREE_OVERFLOW (value) = 0;
3288
3289           if (CONSTANT_CLASS_P (ovalue))
3290             /* Similarly, constant_overflow cannot have become
3291                cleared.  */
3292             TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3293         }
3294     }
3295
3296   /* Don't let (void *) (FOO *) 0 be a null pointer constant.  */
3297   if (TREE_CODE (value) == INTEGER_CST
3298       && TREE_CODE (expr) == INTEGER_CST
3299       && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3300     value = non_lvalue (value);
3301
3302   /* Don't let a cast be an lvalue.  */
3303   if (value == expr)
3304     value = non_lvalue (value);
3305
3306   return value;
3307 }
3308
3309 /* Interpret a cast of expression EXPR to type TYPE.  */
3310 tree
3311 c_cast_expr (struct c_type_name *type_name, tree expr)
3312 {
3313   tree type;
3314   int saved_wsp = warn_strict_prototypes;
3315
3316   /* This avoids warnings about unprototyped casts on
3317      integers.  E.g. "#define SIG_DFL (void(*)())0".  */
3318   if (TREE_CODE (expr) == INTEGER_CST)
3319     warn_strict_prototypes = 0;
3320   type = groktypename (type_name);
3321   warn_strict_prototypes = saved_wsp;
3322
3323   return build_c_cast (type, expr);
3324 }
3325
3326 \f
3327 /* Build an assignment expression of lvalue LHS from value RHS.
3328    MODIFYCODE is the code for a binary operator that we use
3329    to combine the old value of LHS with RHS to get the new value.
3330    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.  */
3331
3332 tree
3333 build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
3334 {
3335   tree result;
3336   tree newrhs;
3337   tree lhstype = TREE_TYPE (lhs);
3338   tree olhstype = lhstype;
3339
3340   /* Types that aren't fully specified cannot be used in assignments.  */
3341   lhs = require_complete_type (lhs);
3342
3343   /* Avoid duplicate error messages from operands that had errors.  */
3344   if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3345     return error_mark_node;
3346
3347   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3348   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3349      whose value is 0 to count as a null pointer constant.  */
3350   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3351     rhs = TREE_OPERAND (rhs, 0);
3352
3353   newrhs = rhs;
3354
3355   /* If a binary op has been requested, combine the old LHS value with the RHS
3356      producing the value we should actually store into the LHS.  */
3357
3358   if (modifycode != NOP_EXPR)
3359     {
3360       lhs = stabilize_reference (lhs);
3361       newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3362     }
3363
3364   if (!lvalue_or_else (lhs, lv_assign))
3365     return error_mark_node;
3366
3367   /* Give an error for storing in something that is 'const'.  */
3368
3369   if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3370       || ((TREE_CODE (lhstype) == RECORD_TYPE
3371            || TREE_CODE (lhstype) == UNION_TYPE)
3372           && C_TYPE_FIELDS_READONLY (lhstype)))
3373     readonly_error (lhs, lv_assign);
3374
3375   /* If storing into a structure or union member,
3376      it has probably been given type `int'.
3377      Compute the type that would go with
3378      the actual amount of storage the member occupies.  */
3379
3380   if (TREE_CODE (lhs) == COMPONENT_REF
3381       && (TREE_CODE (lhstype) == INTEGER_TYPE
3382           || TREE_CODE (lhstype) == BOOLEAN_TYPE
3383           || TREE_CODE (lhstype) == REAL_TYPE
3384           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3385     lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3386
3387   /* If storing in a field that is in actuality a short or narrower than one,
3388      we must store in the field in its actual type.  */
3389
3390   if (lhstype != TREE_TYPE (lhs))
3391     {
3392       lhs = copy_node (lhs);
3393       TREE_TYPE (lhs) = lhstype;
3394     }
3395
3396   /* Convert new value to destination type.  */
3397
3398   newrhs = convert_for_assignment (lhstype, newrhs, ic_assign,
3399                                    NULL_TREE, NULL_TREE, 0);
3400   if (TREE_CODE (newrhs) == ERROR_MARK)
3401     return error_mark_node;
3402
3403   /* Scan operands.  */
3404
3405   result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs);
3406   TREE_SIDE_EFFECTS (result) = 1;
3407
3408   /* If we got the LHS in a different type for storing in,
3409      convert the result back to the nominal type of LHS
3410      so that the value we return always has the same type
3411      as the LHS argument.  */
3412
3413   if (olhstype == TREE_TYPE (result))
3414     return result;
3415   return convert_for_assignment (olhstype, result, ic_assign,
3416                                  NULL_TREE, NULL_TREE, 0);
3417 }
3418 \f
3419 /* Convert value RHS to type TYPE as preparation for an assignment
3420    to an lvalue of type TYPE.
3421    The real work of conversion is done by `convert'.
3422    The purpose of this function is to generate error messages
3423    for assignments that are not allowed in C.
3424    ERRTYPE says whether it is argument passing, assignment,
3425    initialization or return.
3426
3427    FUNCTION is a tree for the function being called.
3428    PARMNUM is the number of the argument, for printing in error messages.  */
3429
3430 static tree
3431 convert_for_assignment (tree type, tree rhs, enum impl_conv errtype,
3432                         tree fundecl, tree function, int parmnum)
3433 {
3434   enum tree_code codel = TREE_CODE (type);
3435   tree rhstype;
3436   enum tree_code coder;
3437   tree rname = NULL_TREE;
3438
3439   if (errtype == ic_argpass || errtype == ic_argpass_nonproto)
3440     {
3441       tree selector;
3442       /* Change pointer to function to the function itself for
3443          diagnostics.  */
3444       if (TREE_CODE (function) == ADDR_EXPR
3445           && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
3446         function = TREE_OPERAND (function, 0);
3447
3448       /* Handle an ObjC selector specially for diagnostics.  */
3449       selector = objc_message_selector ();
3450       rname = function;
3451       if (selector && parmnum > 2)
3452         {
3453           rname = selector;
3454           parmnum -= 2;
3455         }
3456     }
3457
3458   /* This macro is used to emit diagnostics to ensure that all format
3459      strings are complete sentences, visible to gettext and checked at
3460      compile time.  */
3461 #define WARN_FOR_ASSIGNMENT(AR, AS, IN, RE)     \
3462   do {                                          \
3463     switch (errtype)                            \
3464       {                                         \
3465       case ic_argpass:                          \
3466         pedwarn (AR, parmnum, rname);           \
3467         break;                                  \
3468       case ic_argpass_nonproto:                 \
3469         warning (AR, parmnum, rname);           \
3470         break;                                  \
3471       case ic_assign:                           \
3472         pedwarn (AS);                           \
3473         break;                                  \
3474       case ic_init:                             \
3475         pedwarn (IN);                           \
3476         break;                                  \
3477       case ic_return:                           \
3478         pedwarn (RE);                           \
3479         break;                                  \
3480       default:                                  \
3481         gcc_unreachable ();                     \
3482       }                                         \
3483   } while (0)
3484
3485   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3486   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3487      whose value is 0 to count as a null pointer constant.  */
3488   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3489     rhs = TREE_OPERAND (rhs, 0);
3490
3491   if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
3492       || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
3493     rhs = default_conversion (rhs);
3494   else if (optimize && TREE_CODE (rhs) == VAR_DECL)
3495     rhs = decl_constant_value_for_broken_optimization (rhs);
3496
3497   rhstype = TREE_TYPE (rhs);
3498   coder = TREE_CODE (rhstype);
3499
3500   if (coder == ERROR_MARK)
3501     return error_mark_node;
3502
3503   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
3504     {
3505       overflow_warning (rhs);
3506       /* Check for Objective-C protocols.  This will automatically
3507          issue a warning if there are protocol violations.  No need to
3508          use the return value.  */
3509       if (c_dialect_objc ())
3510         objc_comptypes (type, rhstype, 0);
3511       return rhs;
3512     }
3513
3514   if (coder == VOID_TYPE)
3515     {
3516       /* Except for passing an argument to an unprototyped function,
3517          this is a constraint violation.  When passing an argument to
3518          an unprototyped function, it is compile-time undefined;
3519          making it a constraint in that case was rejected in
3520          DR#252.  */
3521       error ("void value not ignored as it ought to be");
3522       return error_mark_node;
3523     }
3524   /* A type converts to a reference to it.
3525      This code doesn't fully support references, it's just for the
3526      special case of va_start and va_copy.  */
3527   if (codel == REFERENCE_TYPE
3528       && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
3529     {
3530       if (!lvalue_p (rhs))
3531         {
3532           error ("cannot pass rvalue to reference parameter");
3533           return error_mark_node;
3534         }
3535       if (!c_mark_addressable (rhs))
3536         return error_mark_node;
3537       rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
3538
3539       /* We already know that these two types are compatible, but they
3540          may not be exactly identical.  In fact, `TREE_TYPE (type)' is
3541          likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
3542          likely to be va_list, a typedef to __builtin_va_list, which
3543          is different enough that it will cause problems later.  */
3544       if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
3545         rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
3546
3547       rhs = build1 (NOP_EXPR, type, rhs);
3548       return rhs;
3549     }
3550   /* Some types can interconvert without explicit casts.  */
3551   else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE
3552            && vector_types_convertible_p (type, TREE_TYPE (rhs)))
3553     return convert (type, rhs);
3554   /* Arithmetic types all interconvert, and enum is treated like int.  */
3555   else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
3556             || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
3557             || codel == BOOLEAN_TYPE)
3558            && (coder == INTEGER_TYPE || coder == REAL_TYPE
3559                || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
3560                || coder == BOOLEAN_TYPE))
3561     return convert_and_check (type, rhs);
3562
3563   /* Conversion to a transparent union from its member types.
3564      This applies only to function arguments.  */
3565   else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type)
3566            && (errtype == ic_argpass || errtype == ic_argpass_nonproto))
3567     {
3568       tree memb_types;
3569       tree marginal_memb_type = 0;
3570
3571       for (memb_types = TYPE_FIELDS (type); memb_types;
3572            memb_types = TREE_CHAIN (memb_types))
3573         {
3574           tree memb_type = TREE_TYPE (memb_types);
3575
3576           if (comptypes (TYPE_MAIN_VARIANT (memb_type),
3577                          TYPE_MAIN_VARIANT (rhstype)))
3578             break;
3579
3580           if (TREE_CODE (memb_type) != POINTER_TYPE)
3581             continue;
3582
3583           if (coder == POINTER_TYPE)
3584             {
3585               tree ttl = TREE_TYPE (memb_type);
3586               tree ttr = TREE_TYPE (rhstype);
3587
3588               /* Any non-function converts to a [const][volatile] void *
3589                  and vice versa; otherwise, targets must be the same.
3590                  Meanwhile, the lhs target must have all the qualifiers of
3591                  the rhs.  */
3592               if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3593                   || comp_target_types (memb_type, rhstype, 0))
3594                 {
3595                   /* If this type won't generate any warnings, use it.  */
3596                   if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
3597                       || ((TREE_CODE (ttr) == FUNCTION_TYPE
3598                            && TREE_CODE (ttl) == FUNCTION_TYPE)
3599                           ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3600                              == TYPE_QUALS (ttr))
3601                           : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3602                              == TYPE_QUALS (ttl))))
3603                     break;
3604
3605                   /* Keep looking for a better type, but remember this one.  */
3606                   if (!marginal_memb_type)
3607                     marginal_memb_type = memb_type;
3608                 }
3609             }
3610
3611           /* Can convert integer zero to any pointer type.  */
3612           if (integer_zerop (rhs)
3613               || (TREE_CODE (rhs) == NOP_EXPR
3614                   && integer_zerop (TREE_OPERAND (rhs, 0))))
3615             {
3616               rhs = null_pointer_node;
3617               break;
3618             }
3619         }
3620
3621       if (memb_types || marginal_memb_type)
3622         {
3623           if (!memb_types)
3624             {
3625               /* We have only a marginally acceptable member type;
3626                  it needs a warning.  */
3627               tree ttl = TREE_TYPE (marginal_memb_type);
3628               tree ttr = TREE_TYPE (rhstype);
3629
3630               /* Const and volatile mean something different for function
3631                  types, so the usual warnings are not appropriate.  */
3632               if (TREE_CODE (ttr) == FUNCTION_TYPE
3633                   && TREE_CODE (ttl) == FUNCTION_TYPE)
3634                 {
3635                   /* Because const and volatile on functions are
3636                      restrictions that say the function will not do
3637                      certain things, it is okay to use a const or volatile
3638                      function where an ordinary one is wanted, but not
3639                      vice-versa.  */
3640                   if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
3641                     WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE "
3642                                             "makes qualified function "
3643                                             "pointer from unqualified"),
3644                                          N_("assignment makes qualified "
3645                                             "function pointer from "
3646                                             "unqualified"),
3647                                          N_("initialization makes qualified "
3648                                             "function pointer from "
3649                                             "unqualified"),
3650                                          N_("return makes qualified function "
3651                                             "pointer from unqualified"));
3652                 }
3653               else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
3654                 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE discards "
3655                                         "qualifiers from pointer target type"),
3656                                      N_("assignment discards qualifiers "
3657                                         "from pointer target type"),
3658                                      N_("initialization discards qualifiers "
3659                                         "from pointer target type"),
3660                                      N_("return discards qualifiers from "
3661                                         "pointer target type"));
3662             }
3663
3664           if (pedantic && !DECL_IN_SYSTEM_HEADER (fundecl))
3665             pedwarn ("ISO C prohibits argument conversion to union type");
3666
3667           return build1 (NOP_EXPR, type, rhs);
3668         }
3669     }
3670
3671   /* Conversions among pointers */
3672   else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
3673            && (coder == codel))
3674     {
3675       tree ttl = TREE_TYPE (type);
3676       tree ttr = TREE_TYPE (rhstype);
3677       bool is_opaque_pointer;
3678       int target_cmp = 0;   /* Cache comp_target_types () result.  */
3679
3680       /* Opaque pointers are treated like void pointers.  */
3681       is_opaque_pointer = (targetm.vector_opaque_p (type)
3682                            || targetm.vector_opaque_p (rhstype))
3683         && TREE_CODE (ttl) == VECTOR_TYPE
3684         && TREE_CODE (ttr) == VECTOR_TYPE;
3685
3686       /* Any non-function converts to a [const][volatile] void *
3687          and vice versa; otherwise, targets must be the same.
3688          Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
3689       if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3690           || (target_cmp = comp_target_types (type, rhstype, 0))
3691           || is_opaque_pointer
3692           || (c_common_unsigned_type (TYPE_MAIN_VARIANT (ttl))
3693               == c_common_unsigned_type (TYPE_MAIN_VARIANT (ttr))))
3694         {
3695           if (pedantic
3696               && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
3697                   ||
3698                   (VOID_TYPE_P (ttr)
3699                    /* Check TREE_CODE to catch cases like (void *) (char *) 0
3700                       which are not ANSI null ptr constants.  */
3701                    && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
3702                    && TREE_CODE (ttl) == FUNCTION_TYPE)))
3703             WARN_FOR_ASSIGNMENT (N_("ISO C forbids passing argument %d of "
3704                                     "%qE between function pointer "
3705                                     "and %<void *%>"),
3706                                  N_("ISO C forbids assignment between "
3707                                     "function pointer and %<void *%>"),
3708                                  N_("ISO C forbids initialization between "
3709                                     "function pointer and %<void *%>"),
3710                                  N_("ISO C forbids return between function "
3711                                     "pointer and %<void *%>"));
3712           /* Const and volatile mean something different for function types,
3713              so the usual warnings are not appropriate.  */
3714           else if (TREE_CODE (ttr) != FUNCTION_TYPE
3715                    && TREE_CODE (ttl) != FUNCTION_TYPE)
3716             {
3717               if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
3718                 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE discards "
3719                                         "qualifiers from pointer target type"),
3720                                      N_("assignment discards qualifiers "
3721                                         "from pointer target type"),
3722                                      N_("initialization discards qualifiers "
3723                                         "from pointer target type"),
3724                                      N_("return discards qualifiers from "
3725                                         "pointer target type"));
3726               /* If this is not a case of ignoring a mismatch in signedness,
3727                  no warning.  */
3728               else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3729                        || target_cmp)
3730                 ;
3731               /* If there is a mismatch, do warn.  */
3732               else
3733                 WARN_FOR_ASSIGNMENT (N_("pointer targets in passing argument "
3734                                         "%d of %qE differ in signedness"),
3735                                      N_("pointer targets in assignment "
3736                                         "differ in signedness"),
3737                                      N_("pointer targets in initialization "
3738                                         "differ in signedness"),
3739                                      N_("pointer targets in return differ "
3740                                         "in signedness"));
3741             }
3742           else if (TREE_CODE (ttl) == FUNCTION_TYPE
3743                    && TREE_CODE (ttr) == FUNCTION_TYPE)
3744             {
3745               /* Because const and volatile on functions are restrictions
3746                  that say the function will not do certain things,
3747                  it is okay to use a const or volatile function
3748                  where an ordinary one is wanted, but not vice-versa.  */
3749               if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
3750                 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes "
3751                                         "qualified function pointer "
3752                                         "from unqualified"),
3753                                      N_("assignment makes qualified function "
3754                                         "pointer from unqualified"),
3755                                      N_("initialization makes qualified "
3756                                         "function pointer from unqualified"),
3757                                      N_("return makes qualified function "
3758                                         "pointer from unqualified"));
3759             }
3760         }
3761       else
3762         WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE from "
3763                                 "incompatible pointer type"),
3764                              N_("assignment from incompatible pointer type"),
3765                              N_("initialization from incompatible "
3766                                 "pointer type"),
3767                              N_("return from incompatible pointer type"));
3768       return convert (type, rhs);
3769     }
3770   else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
3771     {
3772       /* ??? This should not be an error when inlining calls to
3773          unprototyped functions.  */
3774       error ("invalid use of non-lvalue array");
3775       return error_mark_node;
3776     }
3777   else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
3778     {
3779       /* An explicit constant 0 can convert to a pointer,
3780          or one that results from arithmetic, even including
3781          a cast to integer type.  */
3782       if (!(TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
3783           &&
3784           !(TREE_CODE (rhs) == NOP_EXPR
3785             && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
3786             && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
3787             && integer_zerop (TREE_OPERAND (rhs, 0))))
3788         WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes "
3789                                 "pointer from integer without a cast"),
3790                              N_("assignment makes pointer from integer "
3791                                 "without a cast"),
3792                              N_("initialization makes pointer from "
3793                                 "integer without a cast"),
3794                              N_("return makes pointer from integer "
3795                                 "without a cast"));
3796
3797       return convert (type, rhs);
3798     }
3799   else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
3800     {
3801       WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes integer "
3802                               "from pointer without a cast"),
3803                            N_("assignment makes integer from pointer "
3804                               "without a cast"),
3805                            N_("initialization makes integer from pointer "
3806                               "without a cast"),
3807                            N_("return makes integer from pointer "
3808                               "without a cast"));
3809       return convert (type, rhs);
3810     }
3811   else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
3812     return convert (type, rhs);
3813
3814   switch (errtype)
3815     {
3816     case ic_argpass:
3817     case ic_argpass_nonproto:
3818       /* ??? This should not be an error when inlining calls to
3819          unprototyped functions.  */
3820       error ("incompatible type for argument %d of %qE", parmnum, rname);
3821       break;
3822     case ic_assign:
3823       error ("incompatible types in assignment");
3824       break;
3825     case ic_init:
3826       error ("incompatible types in initialization");
3827       break;
3828     case ic_return:
3829       error ("incompatible types in return");
3830       break;
3831     default:
3832       gcc_unreachable ();
3833     }
3834
3835   return error_mark_node;
3836 }
3837
3838 /* Convert VALUE for assignment into inlined parameter PARM.  ARGNUM
3839    is used for error and waring reporting and indicates which argument
3840    is being processed.  */
3841
3842 tree
3843 c_convert_parm_for_inlining (tree parm, tree value, tree fn, int argnum)
3844 {
3845   tree ret, type;
3846
3847   /* If FN was prototyped, the value has been converted already
3848      in convert_arguments.  */
3849   if (!value || TYPE_ARG_TYPES (TREE_TYPE (fn)))
3850     return value;
3851
3852   type = TREE_TYPE (parm);
3853   ret = convert_for_assignment (type, value,
3854                                 ic_argpass_nonproto, fn,
3855                                 fn, argnum);
3856   if (targetm.calls.promote_prototypes (TREE_TYPE (fn))
3857       && INTEGRAL_TYPE_P (type)
3858       && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
3859     ret = default_conversion (ret);
3860   return ret;
3861 }
3862 \f
3863 /* If VALUE is a compound expr all of whose expressions are constant, then
3864    return its value.  Otherwise, return error_mark_node.
3865
3866    This is for handling COMPOUND_EXPRs as initializer elements
3867    which is allowed with a warning when -pedantic is specified.  */
3868
3869 static tree
3870 valid_compound_expr_initializer (tree value, tree endtype)
3871 {
3872   if (TREE_CODE (value) == COMPOUND_EXPR)
3873     {
3874       if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
3875           == error_mark_node)
3876         return error_mark_node;
3877       return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
3878                                               endtype);
3879     }
3880   else if (!initializer_constant_valid_p (value, endtype))
3881     return error_mark_node;
3882   else
3883     return value;
3884 }
3885 \f
3886 /* Perform appropriate conversions on the initial value of a variable,
3887    store it in the declaration DECL,
3888    and print any error messages that are appropriate.
3889    If the init is invalid, store an ERROR_MARK.  */
3890
3891 void
3892 store_init_value (tree decl, tree init)
3893 {
3894   tree value, type;
3895
3896   /* If variable's type was invalidly declared, just ignore it.  */
3897
3898   type = TREE_TYPE (decl);
3899   if (TREE_CODE (type) == ERROR_MARK)
3900     return;
3901
3902   /* Digest the specified initializer into an expression.  */
3903
3904   value = digest_init (type, init, true, TREE_STATIC (decl));
3905
3906   /* Store the expression if valid; else report error.  */
3907
3908   if (warn_traditional && !in_system_header
3909       && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl))
3910     warning ("traditional C rejects automatic aggregate initialization");
3911
3912   DECL_INITIAL (decl) = value;
3913
3914   /* ANSI wants warnings about out-of-range constant initializers.  */
3915   STRIP_TYPE_NOPS (value);
3916   constant_expression_warning (value);
3917
3918   /* Check if we need to set array size from compound literal size.  */
3919   if (TREE_CODE (type) == ARRAY_TYPE
3920       && TYPE_DOMAIN (type) == 0
3921       && value != error_mark_node)
3922     {
3923       tree inside_init = init;
3924
3925       if (TREE_CODE (init) == NON_LVALUE_EXPR)
3926         inside_init = TREE_OPERAND (init, 0);
3927       inside_init = fold (inside_init);
3928
3929       if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
3930         {
3931           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
3932
3933           if (TYPE_DOMAIN (TREE_TYPE (decl)))
3934             {
3935               /* For int foo[] = (int [3]){1}; we need to set array size
3936                  now since later on array initializer will be just the
3937                  brace enclosed list of the compound literal.  */
3938               TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (decl));
3939               layout_type (type);
3940               layout_decl (decl, 0);
3941             }
3942         }
3943     }
3944 }
3945 \f
3946 /* Methods for storing and printing names for error messages.  */
3947
3948 /* Implement a spelling stack that allows components of a name to be pushed
3949    and popped.  Each element on the stack is this structure.  */
3950
3951 struct spelling
3952 {
3953   int kind;
3954   union
3955     {
3956       int i;
3957       const char *s;
3958     } u;
3959 };
3960
3961 #define SPELLING_STRING 1
3962 #define SPELLING_MEMBER 2
3963 #define SPELLING_BOUNDS 3
3964
3965 static struct spelling *spelling;       /* Next stack element (unused).  */
3966 static struct spelling *spelling_base;  /* Spelling stack base.  */
3967 static int spelling_size;               /* Size of the spelling stack.  */
3968
3969 /* Macros to save and restore the spelling stack around push_... functions.
3970    Alternative to SAVE_SPELLING_STACK.  */
3971
3972 #define SPELLING_DEPTH() (spelling - spelling_base)
3973 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
3974
3975 /* Push an element on the spelling stack with type KIND and assign VALUE
3976    to MEMBER.  */
3977
3978 #define PUSH_SPELLING(KIND, VALUE, MEMBER)                              \
3979 {                                                                       \
3980   int depth = SPELLING_DEPTH ();                                        \
3981                                                                         \
3982   if (depth >= spelling_size)                                           \
3983     {                                                                   \
3984       spelling_size += 10;                                              \
3985       spelling_base = XRESIZEVEC (struct spelling, spelling_base,       \
3986                                   spelling_size);                       \
3987       RESTORE_SPELLING_DEPTH (depth);                                   \
3988     }                                                                   \
3989                                                                         \
3990   spelling->kind = (KIND);                                              \
3991   spelling->MEMBER = (VALUE);                                           \
3992   spelling++;                                                           \
3993 }
3994
3995 /* Push STRING on the stack.  Printed literally.  */
3996
3997 static void
3998 push_string (const char *string)
3999 {
4000   PUSH_SPELLING (SPELLING_STRING, string, u.s);
4001 }
4002
4003 /* Push a member name on the stack.  Printed as '.' STRING.  */
4004
4005 static void
4006 push_member_name (tree decl)
4007 {
4008   const char *const string
4009     = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
4010   PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
4011 }
4012
4013 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
4014
4015 static void
4016 push_array_bounds (int bounds)
4017 {
4018   PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
4019 }
4020
4021 /* Compute the maximum size in bytes of the printed spelling.  */
4022
4023 static int
4024 spelling_length (void)
4025 {
4026   int size = 0;
4027   struct spelling *p;
4028
4029   for (p = spelling_base; p < spelling; p++)
4030     {
4031       if (p->kind == SPELLING_BOUNDS)
4032         size += 25;
4033       else
4034         size += strlen (p->u.s) + 1;
4035     }
4036
4037   return size;
4038 }
4039
4040 /* Print the spelling to BUFFER and return it.  */
4041
4042 static char *
4043 print_spelling (char *buffer)
4044 {
4045   char *d = buffer;
4046   struct spelling *p;
4047
4048   for (p = spelling_base; p < spelling; p++)
4049     if (p->kind == SPELLING_BOUNDS)
4050       {
4051         sprintf (d, "[%d]", p->u.i);
4052         d += strlen (d);
4053       }
4054     else
4055       {
4056         const char *s;
4057         if (p->kind == SPELLING_MEMBER)
4058           *d++ = '.';
4059         for (s = p->u.s; (*d = *s++); d++)
4060           ;
4061       }
4062   *d++ = '\0';
4063   return buffer;
4064 }
4065
4066 /* Issue an error message for a bad initializer component.
4067    MSGID identifies the message.
4068    The component name is taken from the spelling stack.  */
4069
4070 void
4071 error_init (const char *msgid)
4072 {
4073   char *ofwhat;
4074
4075   error ("%s", _(msgid));
4076   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4077   if (*ofwhat)
4078     error ("(near initialization for %qs)", ofwhat);
4079 }
4080
4081 /* Issue a pedantic warning for a bad initializer component.
4082    MSGID identifies the message.
4083    The component name is taken from the spelling stack.  */
4084
4085 void
4086 pedwarn_init (const char *msgid)
4087 {
4088   char *ofwhat;
4089
4090   pedwarn ("%s", _(msgid));
4091   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4092   if (*ofwhat)
4093     pedwarn ("(near initialization for %qs)", ofwhat);
4094 }
4095
4096 /* Issue a warning for a bad initializer component.
4097    MSGID identifies the message.
4098    The component name is taken from the spelling stack.  */
4099
4100 static void
4101 warning_init (const char *msgid)
4102 {
4103   char *ofwhat;
4104
4105   warning ("%s", _(msgid));
4106   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4107   if (*ofwhat)
4108     warning ("(near initialization for %qs)", ofwhat);
4109 }
4110 \f
4111 /* If TYPE is an array type and EXPR is a parenthesized string
4112    constant, warn if pedantic that EXPR is being used to initialize an
4113    object of type TYPE.  */
4114
4115 void
4116 maybe_warn_string_init (tree type, struct c_expr expr)
4117 {
4118   if (pedantic
4119       && TREE_CODE (type) == ARRAY_TYPE
4120       && TREE_CODE (expr.value) == STRING_CST
4121       && expr.original_code != STRING_CST)
4122     pedwarn_init ("array initialized from parenthesized string constant");
4123 }
4124
4125 /* Digest the parser output INIT as an initializer for type TYPE.
4126    Return a C expression of type TYPE to represent the initial value.
4127
4128    If INIT is a string constant, STRICT_STRING is true if it is
4129    unparenthesized or we should not warn here for it being parenthesized.
4130    For other types of INIT, STRICT_STRING is not used.
4131
4132    REQUIRE_CONSTANT requests an error if non-constant initializers or
4133    elements are seen.  */
4134
4135 static tree
4136 digest_init (tree type, tree init, bool strict_string, int require_constant)
4137 {
4138   enum tree_code code = TREE_CODE (type);
4139   tree inside_init = init;
4140
4141   if (type == error_mark_node
4142       || init == error_mark_node
4143       || TREE_TYPE (init) == error_mark_node)
4144     return error_mark_node;
4145
4146   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4147   /* Do not use STRIP_NOPS here.  We do not want an enumerator
4148      whose value is 0 to count as a null pointer constant.  */
4149   if (TREE_CODE (init) == NON_LVALUE_EXPR)
4150     inside_init = TREE_OPERAND (init, 0);
4151
4152   inside_init = fold (inside_init);
4153
4154   /* Initialization of an array of chars from a string constant
4155      optionally enclosed in braces.  */
4156
4157   if (code == ARRAY_TYPE && inside_init
4158       && TREE_CODE (inside_init) == STRING_CST)
4159     {
4160       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4161       /* Note that an array could be both an array of character type
4162          and an array of wchar_t if wchar_t is signed char or unsigned
4163          char.  */
4164       bool char_array = (typ1 == char_type_node
4165                          || typ1 == signed_char_type_node
4166                          || typ1 == unsigned_char_type_node);
4167       bool wchar_array = !!comptypes (typ1, wchar_type_node);
4168       if (char_array || wchar_array)
4169         {
4170           struct c_expr expr;
4171           bool char_string;
4172           expr.value = inside_init;
4173           expr.original_code = (strict_string ? STRING_CST : ERROR_MARK);
4174           maybe_warn_string_init (type, expr);
4175
4176           char_string
4177             = (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4178                == char_type_node);
4179
4180           if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4181                          TYPE_MAIN_VARIANT (type)))
4182             return inside_init;
4183
4184           if (!wchar_array && !char_string)
4185             {
4186               error_init ("char-array initialized from wide string");
4187               return error_mark_node;
4188             }
4189           if (char_string && !char_array)
4190             {
4191               error_init ("wchar_t-array initialized from non-wide string");
4192               return error_mark_node;
4193             }
4194
4195           TREE_TYPE (inside_init) = type;
4196           if (TYPE_DOMAIN (type) != 0
4197               && TYPE_SIZE (type) != 0
4198               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
4199               /* Subtract 1 (or sizeof (wchar_t))
4200                  because it's ok to ignore the terminating null char
4201                  that is counted in the length of the constant.  */
4202               && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
4203                                        TREE_STRING_LENGTH (inside_init)
4204                                        - ((TYPE_PRECISION (typ1)
4205                                            != TYPE_PRECISION (char_type_node))
4206                                           ? (TYPE_PRECISION (wchar_type_node)
4207                                              / BITS_PER_UNIT)
4208                                           : 1)))
4209             pedwarn_init ("initializer-string for array of chars is too long");
4210
4211           return inside_init;
4212         }
4213       else if (INTEGRAL_TYPE_P (typ1))
4214         {
4215           error_init ("array of inappropriate type initialized "
4216                       "from string constant");
4217           return error_mark_node;
4218         }
4219     }
4220
4221   /* Build a VECTOR_CST from a *constant* vector constructor.  If the
4222      vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
4223      below and handle as a constructor.  */
4224     if (code == VECTOR_TYPE
4225         && TREE_CODE (TREE_TYPE (inside_init)) == VECTOR_TYPE
4226         && vector_types_convertible_p (TREE_TYPE (inside_init), type)
4227         && TREE_CONSTANT (inside_init))
4228       {
4229         if (TREE_CODE (inside_init) == VECTOR_CST
4230             && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4231                           TYPE_MAIN_VARIANT (type)))
4232           return inside_init;
4233         else
4234           return build_vector (type, CONSTRUCTOR_ELTS (inside_init));
4235       }
4236
4237   /* Any type can be initialized
4238      from an expression of the same type, optionally with braces.  */
4239
4240   if (inside_init && TREE_TYPE (inside_init) != 0
4241       && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4242                      TYPE_MAIN_VARIANT (type))
4243           || (code == ARRAY_TYPE
4244               && comptypes (TREE_TYPE (inside_init), type))
4245           || (code == VECTOR_TYPE
4246               && comptypes (TREE_TYPE (inside_init), type))
4247           || (code == POINTER_TYPE
4248               && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4249               && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4250                             TREE_TYPE (type)))
4251           || (code == POINTER_TYPE
4252               && TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE
4253               && comptypes (TREE_TYPE (inside_init),
4254                             TREE_TYPE (type)))))
4255     {
4256       if (code == POINTER_TYPE)
4257         {
4258           inside_init = default_function_array_conversion (inside_init);
4259
4260           if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE)
4261             {
4262               error_init ("invalid use of non-lvalue array");
4263               return error_mark_node;
4264             }
4265          }
4266
4267       if (code == VECTOR_TYPE)
4268         /* Although the types are compatible, we may require a
4269            conversion.  */
4270         inside_init = convert (type, inside_init);
4271
4272       if (require_constant && !flag_isoc99
4273           && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4274         {
4275           /* As an extension, allow initializing objects with static storage
4276              duration with compound literals (which are then treated just as
4277              the brace enclosed list they contain).  */
4278           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
4279           inside_init = DECL_INITIAL (decl);
4280         }
4281
4282       if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4283           && TREE_CODE (inside_init) != CONSTRUCTOR)
4284         {
4285           error_init ("array initialized from non-constant array expression");
4286           return error_mark_node;
4287         }
4288
4289       if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4290         inside_init = decl_constant_value_for_broken_optimization (inside_init);
4291
4292       /* Compound expressions can only occur here if -pedantic or
4293          -pedantic-errors is specified.  In the later case, we always want
4294          an error.  In the former case, we simply want a warning.  */
4295       if (require_constant && pedantic
4296           && TREE_CODE (inside_init) == COMPOUND_EXPR)
4297         {
4298           inside_init
4299             = valid_compound_expr_initializer (inside_init,
4300                                                TREE_TYPE (inside_init));
4301           if (inside_init == error_mark_node)
4302             error_init ("initializer element is not constant");
4303           else
4304             pedwarn_init ("initializer element is not constant");
4305           if (flag_pedantic_errors)
4306             inside_init = error_mark_node;
4307         }
4308       else if (require_constant
4309                && !initializer_constant_valid_p (inside_init,
4310                                                  TREE_TYPE (inside_init)))
4311         {
4312           error_init ("initializer element is not constant");
4313           inside_init = error_mark_node;
4314         }
4315
4316       return inside_init;
4317     }
4318
4319   /* Handle scalar types, including conversions.  */
4320
4321   if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4322       || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE
4323       || code == VECTOR_TYPE)
4324     {
4325       /* Note that convert_for_assignment calls default_conversion
4326          for arrays and functions.  We must not call it in the
4327          case where inside_init is a null pointer constant.  */
4328       inside_init
4329         = convert_for_assignment (type, init, ic_init,
4330                                   NULL_TREE, NULL_TREE, 0);
4331
4332       /* Check to see if we have already given an error message.  */
4333       if (inside_init == error_mark_node)
4334         ;
4335       else if (require_constant && !TREE_CONSTANT (inside_init))
4336         {
4337           error_init ("initializer element is not constant");
4338           inside_init = error_mark_node;
4339         }
4340       else if (require_constant
4341                && !initializer_constant_valid_p (inside_init,
4342                                                  TREE_TYPE (inside_init)))
4343         {
4344           error_init ("initializer element is not computable at load time");
4345           inside_init = error_mark_node;
4346         }
4347
4348       return inside_init;
4349     }
4350
4351   /* Come here only for records and arrays.  */
4352
4353   if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4354     {
4355       error_init ("variable-sized object may not be initialized");
4356       return error_mark_node;
4357     }
4358
4359   error_init ("invalid initializer");
4360   return error_mark_node;
4361 }
4362 \f
4363 /* Handle initializers that use braces.  */
4364
4365 /* Type of object we are accumulating a constructor for.
4366    This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE.  */
4367 static tree constructor_type;
4368
4369 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4370    left to fill.  */
4371 static tree constructor_fields;
4372
4373 /* For an ARRAY_TYPE, this is the specified index
4374    at which to store the next element we get.  */
4375 static tree constructor_index;
4376
4377 /* For an ARRAY_TYPE, this is the maximum index.  */
4378 static tree constructor_max_index;
4379
4380 /* For a RECORD_TYPE, this is the first field not yet written out.  */
4381 static tree constructor_unfilled_fields;
4382
4383 /* For an ARRAY_TYPE, this is the index of the first element
4384    not yet written out.  */
4385 static tree constructor_unfilled_index;
4386
4387 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4388    This is so we can generate gaps between fields, when appropriate.  */
4389 static tree constructor_bit_index;
4390
4391 /* If we are saving up the elements rather than allocating them,
4392    this is the list of elements so far (in reverse order,
4393    most recent first).  */
4394 static tree constructor_elements;
4395
4396 /* 1 if constructor should be incrementally stored into a constructor chain,
4397    0 if all the elements should be kept in AVL tree.  */
4398 static int constructor_incremental;
4399
4400 /* 1 if so far this constructor's elements are all compile-time constants.  */
4401 static int constructor_constant;
4402
4403 /* 1 if so far this constructor's elements are all valid address constants.  */
4404 static int constructor_simple;
4405
4406 /* 1 if this constructor is erroneous so far.  */
4407 static int constructor_erroneous;
4408
4409 /* Structure for managing pending initializer elements, organized as an
4410    AVL tree.  */
4411
4412 struct init_node
4413 {
4414   struct init_node *left, *right;
4415   struct init_node *parent;
4416   int balance;
4417   tree purpose;
4418   tree value;
4419 };
4420
4421 /* Tree of pending elements at this constructor level.
4422    These are elements encountered out of order
4423    which belong at places we haven't reached yet in actually
4424    writing the output.
4425    Will never hold tree nodes across GC runs.  */
4426 static struct init_node *constructor_pending_elts;
4427
4428 /* The SPELLING_DEPTH of this constructor.  */
4429 static int constructor_depth;
4430
4431 /* 0 if implicitly pushing constructor levels is allowed.  */
4432 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages.  */
4433
4434 /* DECL node for which an initializer is being read.
4435    0 means we are reading a constructor expression
4436    such as (struct foo) {...}.  */
4437 static tree constructor_decl;
4438
4439 /* Nonzero if this is an initializer for a top-level decl.  */
4440 static int constructor_top_level;
4441
4442 /* Nonzero if there were any member designators in this initializer.  */
4443 static int constructor_designated;
4444
4445 /* Nesting depth of designator list.  */
4446 static int designator_depth;
4447
4448 /* Nonzero if there were diagnosed errors in this designator list.  */
4449 static int designator_errorneous;
4450
4451 \f
4452 /* This stack has a level for each implicit or explicit level of
4453    structuring in the initializer, including the outermost one.  It
4454    saves the values of most of the variables above.  */
4455
4456 struct constructor_range_stack;
4457
4458 struct constructor_stack
4459 {
4460   struct constructor_stack *next;
4461   tree type;
4462   tree fields;
4463   tree index;
4464   tree max_index;
4465   tree unfilled_index;
4466   tree unfilled_fields;
4467   tree bit_index;
4468   tree elements;
4469   struct init_node *pending_elts;
4470   int offset;
4471   int depth;
4472   /* If value nonzero, this value should replace the entire
4473      constructor at this level.  */
4474   struct c_expr replacement_value;
4475   struct constructor_range_stack *range_stack;
4476   char constant;
4477   char simple;
4478   char implicit;
4479   char erroneous;
4480   char outer;
4481   char incremental;
4482   char designated;
4483 };
4484
4485 struct constructor_stack *constructor_stack;
4486
4487 /* This stack represents designators from some range designator up to
4488    the last designator in the list.  */
4489
4490 struct constructor_range_stack
4491 {
4492   struct constructor_range_stack *next, *prev;
4493   struct constructor_stack *stack;
4494   tree range_start;
4495   tree index;
4496   tree range_end;
4497   tree fields;
4498 };
4499
4500 struct constructor_range_stack *constructor_range_stack;
4501
4502 /* This stack records separate initializers that are nested.
4503    Nested initializers can't happen in ANSI C, but GNU C allows them
4504    in cases like { ... (struct foo) { ... } ... }.  */
4505
4506 struct initializer_stack
4507 {
4508   struct initializer_stack *next;
4509   tree decl;
4510   struct constructor_stack *constructor_stack;
4511   struct constructor_range_stack *constructor_range_stack;
4512   tree elements;
4513   struct spelling *spelling;
4514   struct spelling *spelling_base;
4515   int spelling_size;
4516   char top_level;
4517   char require_constant_value;
4518   char require_constant_elements;
4519 };
4520
4521 struct initializer_stack *initializer_stack;
4522 \f
4523 /* Prepare to parse and output the initializer for variable DECL.  */
4524
4525 void
4526 start_init (tree decl, tree asmspec_tree ATTRIBUTE_UNUSED, int top_level)
4527 {
4528   const char *locus;
4529   struct initializer_stack *p = xmalloc (sizeof (struct initializer_stack));
4530
4531   p->decl = constructor_decl;
4532   p->require_constant_value = require_constant_value;
4533   p->require_constant_elements = require_constant_elements;
4534   p->constructor_stack = constructor_stack;
4535   p->constructor_range_stack = constructor_range_stack;
4536   p->elements = constructor_elements;
4537   p->spelling = spelling;
4538   p->spelling_base = spelling_base;
4539   p->spelling_size = spelling_size;
4540   p->top_level = constructor_top_level;
4541   p->next = initializer_stack;
4542   initializer_stack = p;
4543
4544   constructor_decl = decl;
4545   constructor_designated = 0;
4546   constructor_top_level = top_level;
4547
4548   if (decl != 0)
4549     {
4550       require_constant_value = TREE_STATIC (decl);
4551       require_constant_elements
4552         = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
4553            /* For a scalar, you can always use any value to initialize,
4554               even within braces.  */
4555            && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
4556                || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
4557                || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
4558                || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
4559       locus = IDENTIFIER_POINTER (DECL_NAME (decl));
4560     }
4561   else
4562     {
4563       require_constant_value = 0;
4564       require_constant_elements = 0;
4565       locus = "(anonymous)";
4566     }
4567
4568   constructor_stack = 0;
4569   constructor_range_stack = 0;
4570
4571   missing_braces_mentioned = 0;
4572
4573   spelling_base = 0;
4574   spelling_size = 0;
4575   RESTORE_SPELLING_DEPTH (0);
4576
4577   if (locus)
4578     push_string (locus);
4579 }
4580
4581 void
4582 finish_init (void)
4583 {
4584   struct initializer_stack *p = initializer_stack;
4585
4586   /* Free the whole constructor stack of this initializer.  */
4587   while (constructor_stack)
4588     {
4589       struct constructor_stack *q = constructor_stack;
4590       constructor_stack = q->next;
4591       free (q);
4592     }
4593
4594   gcc_assert (!constructor_range_stack);
4595
4596   /* Pop back to the data of the outer initializer (if any).  */
4597   free (spelling_base);
4598
4599   constructor_decl = p->decl;
4600   require_constant_value = p->require_constant_value;
4601   require_constant_elements = p->require_constant_elements;
4602   constructor_stack = p->constructor_stack;
4603   constructor_range_stack = p->constructor_range_stack;
4604   constructor_elements = p->elements;
4605   spelling = p->spelling;
4606   spelling_base = p->spelling_base;
4607   spelling_size = p->spelling_size;
4608   constructor_top_level = p->top_level;
4609   initializer_stack = p->next;
4610   free (p);
4611 }
4612 \f
4613 /* Call here when we see the initializer is surrounded by braces.
4614    This is instead of a call to push_init_level;
4615    it is matched by a call to pop_init_level.
4616
4617    TYPE is the type to initialize, for a constructor expression.
4618    For an initializer for a decl, TYPE is zero.  */
4619
4620 void
4621 really_start_incremental_init (tree type)
4622 {
4623   struct constructor_stack *p = XNEW (struct constructor_stack);
4624
4625   if (type == 0)
4626     type = TREE_TYPE (constructor_decl);
4627
4628   if (targetm.vector_opaque_p (type))
4629     error ("opaque vector types cannot be initialized");
4630
4631   p->type = constructor_type;
4632   p->fields = constructor_fields;
4633   p->index = constructor_index;
4634   p->max_index = constructor_max_index;
4635   p->unfilled_index = constructor_unfilled_index;
4636   p->unfilled_fields = constructor_unfilled_fields;
4637   p->bit_index = constructor_bit_index;
4638   p->elements = constructor_elements;
4639   p->constant = constructor_constant;
4640   p->simple = constructor_simple;
4641   p->erroneous = constructor_erroneous;
4642   p->pending_elts = constructor_pending_elts;
4643   p->depth = constructor_depth;
4644   p->replacement_value.value = 0;
4645   p->replacement_value.original_code = ERROR_MARK;
4646   p->implicit = 0;
4647   p->range_stack = 0;
4648   p->outer = 0;
4649   p->incremental = constructor_incremental;
4650   p->designated = constructor_designated;
4651   p->next = 0;
4652   constructor_stack = p;
4653
4654   constructor_constant = 1;
4655   constructor_simple = 1;
4656   constructor_depth = SPELLING_DEPTH ();
4657   constructor_elements = 0;
4658   constructor_pending_elts = 0;
4659   constructor_type = type;
4660   constructor_incremental = 1;
4661   constructor_designated = 0;
4662   designator_depth = 0;
4663   designator_errorneous = 0;
4664
4665   if (TREE_CODE (constructor_type) == RECORD_TYPE
4666       || TREE_CODE (constructor_type) == UNION_TYPE)
4667     {
4668       constructor_fields = TYPE_FIELDS (constructor_type);
4669       /* Skip any nameless bit fields at the beginning.  */
4670       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4671              && DECL_NAME (constructor_fields) == 0)
4672         constructor_fields = TREE_CHAIN (constructor_fields);
4673
4674       constructor_unfilled_fields = constructor_fields;
4675       constructor_bit_index = bitsize_zero_node;
4676     }
4677   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4678     {
4679       if (TYPE_DOMAIN (constructor_type))
4680         {
4681           constructor_max_index
4682             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4683
4684           /* Detect non-empty initializations of zero-length arrays.  */
4685           if (constructor_max_index == NULL_TREE
4686               && TYPE_SIZE (constructor_type))
4687             constructor_max_index = build_int_cst (NULL_TREE, -1);
4688
4689           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
4690              to initialize VLAs will cause a proper error; avoid tree
4691              checking errors as well by setting a safe value.  */
4692           if (constructor_max_index
4693               && TREE_CODE (constructor_max_index) != INTEGER_CST)
4694             constructor_max_index = build_int_cst (NULL_TREE, -1);
4695
4696           constructor_index
4697             = convert (bitsizetype,
4698                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4699         }
4700       else
4701         constructor_index = bitsize_zero_node;
4702
4703       constructor_unfilled_index = constructor_index;
4704     }
4705   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4706     {
4707       /* Vectors are like simple fixed-size arrays.  */
4708       constructor_max_index =
4709         build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
4710       constructor_index = convert (bitsizetype, bitsize_zero_node);
4711       constructor_unfilled_index = constructor_index;
4712     }
4713   else
4714     {
4715       /* Handle the case of int x = {5}; */
4716       constructor_fields = constructor_type;
4717       constructor_unfilled_fields = constructor_type;
4718     }
4719 }
4720 \f
4721 /* Push down into a subobject, for initialization.
4722    If this is for an explicit set of braces, IMPLICIT is 0.
4723    If it is because the next element belongs at a lower level,
4724    IMPLICIT is 1 (or 2 if the push is because of designator list).  */
4725
4726 void
4727 push_init_level (int implicit)
4728 {
4729   struct constructor_stack *p;
4730   tree value = NULL_TREE;
4731
4732   /* If we've exhausted any levels that didn't have braces,
4733      pop them now.  */
4734   while (constructor_stack->implicit)
4735     {
4736       if ((TREE_CODE (constructor_type) == RECORD_TYPE
4737            || TREE_CODE (constructor_type) == UNION_TYPE)
4738           && constructor_fields == 0)
4739         process_init_element (pop_init_level (1));
4740       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
4741                && constructor_max_index
4742                && tree_int_cst_lt (constructor_max_index, constructor_index))
4743         process_init_element (pop_init_level (1));
4744       else
4745         break;
4746     }
4747
4748   /* Unless this is an explicit brace, we need to preserve previous
4749      content if any.  */
4750   if (implicit)
4751     {
4752       if ((TREE_CODE (constructor_type) == RECORD_TYPE
4753            || TREE_CODE (constructor_type) == UNION_TYPE)
4754           && constructor_fields)
4755         value = find_init_member (constructor_fields);
4756       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4757         value = find_init_member (constructor_index);
4758     }
4759
4760   p = XNEW (struct constructor_stack);
4761   p->type = constructor_type;
4762   p->fields = constructor_fields;
4763   p->index = constructor_index;
4764   p->max_index = constructor_max_index;
4765   p->unfilled_index = constructor_unfilled_index;
4766   p->unfilled_fields = constructor_unfilled_fields;
4767   p->bit_index = constructor_bit_index;
4768   p->elements = constructor_elements;
4769   p->constant = constructor_constant;
4770   p->simple = constructor_simple;
4771   p->erroneous = constructor_erroneous;
4772   p->pending_elts = constructor_pending_elts;
4773   p->depth = constructor_depth;
4774   p->replacement_value.value = 0;
4775   p->replacement_value.original_code = ERROR_MARK;
4776   p->implicit = implicit;
4777   p->outer = 0;
4778   p->incremental = constructor_incremental;
4779   p->designated = constructor_designated;
4780   p->next = constructor_stack;
4781   p->range_stack = 0;
4782   constructor_stack = p;
4783
4784   constructor_constant = 1;
4785   constructor_simple = 1;
4786   constructor_depth = SPELLING_DEPTH ();
4787   constructor_elements = 0;
4788   constructor_incremental = 1;
4789   constructor_designated = 0;
4790   constructor_pending_elts = 0;
4791   if (!implicit)
4792     {
4793       p->range_stack = constructor_range_stack;
4794       constructor_range_stack = 0;
4795       designator_depth = 0;
4796       designator_errorneous = 0;
4797     }
4798
4799   /* Don't die if an entire brace-pair level is superfluous
4800      in the containing level.  */
4801   if (constructor_type == 0)
4802     ;
4803   else if (TREE_CODE (constructor_type) == RECORD_TYPE
4804            || TREE_CODE (constructor_type) == UNION_TYPE)
4805     {
4806       /* Don't die if there are extra init elts at the end.  */
4807       if (constructor_fields == 0)
4808         constructor_type = 0;
4809       else
4810         {
4811           constructor_type = TREE_TYPE (constructor_fields);
4812           push_member_name (constructor_fields);
4813           constructor_depth++;
4814         }
4815     }
4816   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4817     {
4818       constructor_type = TREE_TYPE (constructor_type);
4819       push_array_bounds (tree_low_cst (constructor_index, 0));
4820       constructor_depth++;
4821     }
4822
4823   if (constructor_type == 0)
4824     {
4825       error_init ("extra brace group at end of initializer");
4826       constructor_fields = 0;
4827       constructor_unfilled_fields = 0;
4828       return;
4829     }
4830
4831   if (value && TREE_CODE (value) == CONSTRUCTOR)
4832     {
4833       constructor_constant = TREE_CONSTANT (value);
4834       constructor_simple = TREE_STATIC (value);
4835       constructor_elements = CONSTRUCTOR_ELTS (value);
4836       if (constructor_elements
4837           && (TREE_CODE (constructor_type) == RECORD_TYPE
4838               || TREE_CODE (constructor_type) == ARRAY_TYPE))
4839         set_nonincremental_init ();
4840     }
4841
4842   if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
4843     {
4844       missing_braces_mentioned = 1;
4845       warning_init ("missing braces around initializer");
4846     }
4847
4848   if (TREE_CODE (constructor_type) == RECORD_TYPE
4849            || TREE_CODE (constructor_type) == UNION_TYPE)
4850     {
4851       constructor_fields = TYPE_FIELDS (constructor_type);
4852       /* Skip any nameless bit fields at the beginning.  */
4853       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4854              && DECL_NAME (constructor_fields) == 0)
4855         constructor_fields = TREE_CHAIN (constructor_fields);
4856
4857       constructor_unfilled_fields = constructor_fields;
4858       constructor_bit_index = bitsize_zero_node;
4859     }
4860   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4861     {
4862       /* Vectors are like simple fixed-size arrays.  */
4863       constructor_max_index =
4864         build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
4865       constructor_index = convert (bitsizetype, integer_zero_node);
4866       constructor_unfilled_index = constructor_index;
4867     }
4868   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4869     {
4870       if (TYPE_DOMAIN (constructor_type))
4871         {
4872           constructor_max_index
4873             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4874
4875           /* Detect non-empty initializations of zero-length arrays.  */
4876           if (constructor_max_index == NULL_TREE
4877               && TYPE_SIZE (constructor_type))
4878             constructor_max_index = build_int_cst (NULL_TREE, -1);
4879
4880           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
4881              to initialize VLAs will cause a proper error; avoid tree
4882              checking errors as well by setting a safe value.  */
4883           if (constructor_max_index
4884               && TREE_CODE (constructor_max_index) != INTEGER_CST)
4885             constructor_max_index = build_int_cst (NULL_TREE, -1);
4886
4887           constructor_index
4888             = convert (bitsizetype,
4889                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4890         }
4891       else
4892         constructor_index = bitsize_zero_node;
4893
4894       constructor_unfilled_index = constructor_index;
4895       if (value && TREE_CODE (value) == STRING_CST)
4896         {
4897           /* We need to split the char/wchar array into individual
4898              characters, so that we don't have to special case it
4899              everywhere.  */
4900           set_nonincremental_init_from_string (value);
4901         }
4902     }
4903   else
4904     {
4905       warning_init ("braces around scalar initializer");
4906       constructor_fields = constructor_type;
4907       constructor_unfilled_fields = constructor_type;
4908     }
4909 }
4910
4911 /* At the end of an implicit or explicit brace level,
4912    finish up that level of constructor.  If a single expression
4913    with redundant braces initialized that level, return the
4914    c_expr structure for that expression.  Otherwise, the original_code
4915    element is set to ERROR_MARK.
4916    If we were outputting the elements as they are read, return 0 as the value
4917    from inner levels (process_init_element ignores that),
4918    but return error_mark_node as the value from the outermost level
4919    (that's what we want to put in DECL_INITIAL).
4920    Otherwise, return a CONSTRUCTOR expression as the value.  */
4921
4922 struct c_expr
4923 pop_init_level (int implicit)
4924 {
4925   struct constructor_stack *p;
4926   struct c_expr ret;
4927   ret.value = 0;
4928   ret.original_code = ERROR_MARK;
4929
4930   if (implicit == 0)
4931     {
4932       /* When we come to an explicit close brace,
4933          pop any inner levels that didn't have explicit braces.  */
4934       while (constructor_stack->implicit)
4935         process_init_element (pop_init_level (1));
4936
4937       gcc_assert (!constructor_range_stack);
4938     }
4939
4940   /* Now output all pending elements.  */
4941   constructor_incremental = 1;
4942   output_pending_init_elements (1);
4943
4944   p = constructor_stack;
4945
4946   /* Error for initializing a flexible array member, or a zero-length
4947      array member in an inappropriate context.  */
4948   if (constructor_type && constructor_fields
4949       && TREE_CODE (constructor_type) == ARRAY_TYPE
4950       && TYPE_DOMAIN (constructor_type)
4951       && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
4952     {
4953       /* Silently discard empty initializations.  The parser will
4954          already have pedwarned for empty brackets.  */
4955       if (integer_zerop (constructor_unfilled_index))
4956         constructor_type = NULL_TREE;
4957       else
4958         {
4959           gcc_assert (!TYPE_SIZE (constructor_type));
4960
4961           if (constructor_depth > 2)
4962             error_init ("initialization of flexible array member in a nested context");
4963           else if (pedantic)
4964             pedwarn_init ("initialization of a flexible array member");
4965
4966           /* We have already issued an error message for the existence
4967              of a flexible array member not at the end of the structure.
4968              Discard the initializer so that we do not abort later.  */
4969           if (TREE_CHAIN (constructor_fields) != NULL_TREE)
4970             constructor_type = NULL_TREE;
4971         }
4972     }
4973
4974   /* Warn when some struct elements are implicitly initialized to zero.  */
4975   if (warn_missing_field_initializers
4976       && constructor_type
4977       && TREE_CODE (constructor_type) == RECORD_TYPE
4978       && constructor_unfilled_fields)
4979     {
4980         /* Do not warn for flexible array members or zero-length arrays.  */
4981         while (constructor_unfilled_fields
4982                && (!DECL_SIZE (constructor_unfilled_fields)
4983                    || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
4984           constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
4985
4986         /* Do not warn if this level of the initializer uses member
4987            designators; it is likely to be deliberate.  */
4988         if (constructor_unfilled_fields && !constructor_designated)
4989           {
4990             push_member_name (constructor_unfilled_fields);
4991             warning_init ("missing initializer");
4992             RESTORE_SPELLING_DEPTH (constructor_depth);
4993           }
4994     }
4995
4996   /* Pad out the end of the structure.  */
4997   if (p->replacement_value.value)
4998     /* If this closes a superfluous brace pair,
4999        just pass out the element between them.  */
5000     ret = p->replacement_value;
5001   else if (constructor_type == 0)
5002     ;
5003   else if (TREE_CODE (constructor_type) != RECORD_TYPE
5004            && TREE_CODE (constructor_type) != UNION_TYPE
5005            && TREE_CODE (constructor_type) != ARRAY_TYPE
5006            && TREE_CODE (constructor_type) != VECTOR_TYPE)
5007     {
5008       /* A nonincremental scalar initializer--just return
5009          the element, after verifying there is just one.  */
5010       if (constructor_elements == 0)
5011         {
5012           if (!constructor_erroneous)
5013             error_init ("empty scalar initializer");
5014           ret.value = error_mark_node;
5015         }
5016       else if (TREE_CHAIN (constructor_elements) != 0)
5017         {
5018           error_init ("extra elements in scalar initializer");
5019           ret.value = TREE_VALUE (constructor_elements);
5020         }
5021       else
5022         ret.value = TREE_VALUE (constructor_elements);
5023     }
5024   else
5025     {
5026       if (constructor_erroneous)
5027         ret.value = error_mark_node;
5028       else
5029         {
5030           ret.value = build_constructor (constructor_type,
5031                                          nreverse (constructor_elements));
5032           if (constructor_constant)
5033             TREE_CONSTANT (ret.value) = TREE_INVARIANT (ret.value) = 1;
5034           if (constructor_constant && constructor_simple)
5035             TREE_STATIC (ret.value) = 1;
5036         }
5037     }
5038
5039   constructor_type = p->type;
5040   constructor_fields = p->fields;
5041   constructor_index = p->index;
5042   constructor_max_index = p->max_index;
5043   constructor_unfilled_index = p->unfilled_index;
5044   constructor_unfilled_fields = p->unfilled_fields;
5045   constructor_bit_index = p->bit_index;
5046   constructor_elements = p->elements;
5047   constructor_constant = p->constant;
5048   constructor_simple = p->simple;
5049   constructor_erroneous = p->erroneous;
5050   constructor_incremental = p->incremental;
5051   constructor_designated = p->designated;
5052   constructor_pending_elts = p->pending_elts;
5053   constructor_depth = p->depth;
5054   if (!p->implicit)
5055     constructor_range_stack = p->range_stack;
5056   RESTORE_SPELLING_DEPTH (constructor_depth);
5057
5058   constructor_stack = p->next;
5059   free (p);
5060
5061   if (ret.value == 0)
5062     {
5063       if (constructor_stack == 0)
5064         {
5065           ret.value = error_mark_node;
5066           return ret;
5067         }
5068       return ret;
5069     }
5070   return ret;
5071 }
5072
5073 /* Common handling for both array range and field name designators.
5074    ARRAY argument is nonzero for array ranges.  Returns zero for success.  */
5075
5076 static int
5077 set_designator (int array)
5078 {
5079   tree subtype;
5080   enum tree_code subcode;
5081
5082   /* Don't die if an entire brace-pair level is superfluous
5083      in the containing level.  */
5084   if (constructor_type == 0)
5085     return 1;
5086
5087   /* If there were errors in this designator list already, bail out
5088      silently.  */
5089   if (designator_errorneous)
5090     return 1;
5091
5092   if (!designator_depth)
5093     {
5094       gcc_assert (!constructor_range_stack);
5095
5096       /* Designator list starts at the level of closest explicit
5097          braces.  */
5098       while (constructor_stack->implicit)
5099         process_init_element (pop_init_level (1));
5100       constructor_designated = 1;
5101       return 0;
5102     }
5103
5104   if (constructor_no_implicit)
5105     {
5106       error_init ("initialization designators may not nest");
5107       return 1;
5108     }
5109
5110   switch (TREE_CODE (constructor_type))
5111     {
5112     case  RECORD_TYPE:
5113     case  UNION_TYPE:
5114       subtype = TREE_TYPE (constructor_fields);
5115       if (subtype != error_mark_node)
5116         subtype = TYPE_MAIN_VARIANT (subtype);
5117       break;
5118     case ARRAY_TYPE:
5119       subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5120       break;
5121     default:
5122       gcc_unreachable ();
5123     }
5124
5125   subcode = TREE_CODE (subtype);
5126   if (array && subcode != ARRAY_TYPE)
5127     {
5128       error_init ("array index in non-array initializer");
5129       return 1;
5130     }
5131   else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
5132     {
5133       error_init ("field name not in record or union initializer");
5134       return 1;
5135     }
5136
5137   constructor_designated = 1;
5138   push_init_level (2);
5139   return 0;
5140 }
5141
5142 /* If there are range designators in designator list, push a new designator
5143    to constructor_range_stack.  RANGE_END is end of such stack range or
5144    NULL_TREE if there is no range designator at this level.  */
5145
5146 static void
5147 push_range_stack (tree range_end)
5148 {
5149   struct constructor_range_stack *p;
5150
5151   p = GGC_NEW (struct constructor_range_stack);
5152   p->prev = constructor_range_stack;
5153   p->next = 0;
5154   p->fields = constructor_fields;
5155   p->range_start = constructor_index;
5156   p->index = constructor_index;
5157   p->stack = constructor_stack;
5158   p->range_end = range_end;
5159   if (constructor_range_stack)
5160     constructor_range_stack->next = p;
5161   constructor_range_stack = p;
5162 }
5163
5164 /* Within an array initializer, specify the next index to be initialized.
5165    FIRST is that index.  If LAST is nonzero, then initialize a range
5166    of indices, running from FIRST through LAST.  */
5167
5168 void
5169 set_init_index (tree first, tree last)
5170 {
5171   if (set_designator (1))
5172     return;
5173
5174   designator_errorneous = 1;
5175
5176   if (!INTEGRAL_TYPE_P (TREE_TYPE (first))
5177       || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last))))
5178     {
5179       error_init ("array index in initializer not of integer type");
5180       return;
5181     }
5182
5183   while ((TREE_CODE (first) == NOP_EXPR
5184           || TREE_CODE (first) == CONVERT_EXPR
5185           || TREE_CODE (first) == NON_LVALUE_EXPR)
5186          && (TYPE_MODE (TREE_TYPE (first))
5187              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5188     first = TREE_OPERAND (first, 0);
5189
5190   if (last)
5191     while ((TREE_CODE (last) == NOP_EXPR
5192             || TREE_CODE (last) == CONVERT_EXPR
5193             || TREE_CODE (last) == NON_LVALUE_EXPR)
5194            && (TYPE_MODE (TREE_TYPE (last))
5195                == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5196       last = TREE_OPERAND (last, 0);
5197
5198   if (TREE_CODE (first) != INTEGER_CST)
5199     error_init ("nonconstant array index in initializer");
5200   else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5201     error_init ("nonconstant array index in initializer");
5202   else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5203     error_init ("array index in non-array initializer");
5204   else if (tree_int_cst_sgn (first) == -1)
5205     error_init ("array index in initializer exceeds array bounds");
5206   else if (constructor_max_index
5207            && tree_int_cst_lt (constructor_max_index, first))
5208     error_init ("array index in initializer exceeds array bounds");
5209   else
5210     {
5211       constructor_index = convert (bitsizetype, first);
5212
5213       if (last)
5214         {
5215           if (tree_int_cst_equal (first, last))
5216             last = 0;
5217           else if (tree_int_cst_lt (last, first))
5218             {
5219               error_init ("empty index range in initializer");
5220               last = 0;
5221             }
5222           else
5223             {
5224               last = convert (bitsizetype, last);
5225               if (constructor_max_index != 0
5226                   && tree_int_cst_lt (constructor_max_index, last))
5227                 {
5228                   error_init ("array index range in initializer exceeds array bounds");
5229                   last = 0;
5230                 }
5231             }
5232         }
5233
5234       designator_depth++;
5235       designator_errorneous = 0;
5236       if (constructor_range_stack || last)
5237         push_range_stack (last);
5238     }
5239 }
5240
5241 /* Within a struct initializer, specify the next field to be initialized.  */
5242
5243 void
5244 set_init_label (tree fieldname)
5245 {
5246   tree tail;
5247
5248   if (set_designator (0))
5249     return;
5250
5251   designator_errorneous = 1;
5252
5253   if (TREE_CODE (constructor_type) != RECORD_TYPE
5254       && TREE_CODE (constructor_type) != UNION_TYPE)
5255     {
5256       error_init ("field name not in record or union initializer");
5257       return;
5258     }
5259
5260   for (tail = TYPE_FIELDS (constructor_type); tail;
5261        tail = TREE_CHAIN (tail))
5262     {
5263       if (DECL_NAME (tail) == fieldname)
5264         break;
5265     }
5266
5267   if (tail == 0)
5268     error ("unknown field %qs specified in initializer",
5269            IDENTIFIER_POINTER (fieldname));
5270   else
5271     {
5272       constructor_fields = tail;
5273       designator_depth++;
5274       designator_errorneous = 0;
5275       if (constructor_range_stack)
5276         push_range_stack (NULL_TREE);
5277     }
5278 }
5279 \f
5280 /* Add a new initializer to the tree of pending initializers.  PURPOSE
5281    identifies the initializer, either array index or field in a structure.
5282    VALUE is the value of that index or field.  */
5283
5284 static void
5285 add_pending_init (tree purpose, tree value)
5286 {
5287   struct init_node *p, **q, *r;
5288
5289   q = &constructor_pending_elts;
5290   p = 0;
5291
5292   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5293     {
5294       while (*q != 0)
5295         {
5296           p = *q;
5297           if (tree_int_cst_lt (purpose, p->purpose))
5298             q = &p->left;
5299           else if (tree_int_cst_lt (p->purpose, purpose))
5300             q = &p->right;
5301           else
5302             {
5303               if (TREE_SIDE_EFFECTS (p->value))
5304                 warning_init ("initialized field with side-effects overwritten");
5305               p->value = value;
5306               return;
5307             }
5308         }
5309     }
5310   else
5311     {
5312       tree bitpos;
5313
5314       bitpos = bit_position (purpose);
5315       while (*q != NULL)
5316         {
5317           p = *q;
5318           if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5319             q = &p->left;
5320           else if (p->purpose != purpose)
5321             q = &p->right;
5322           else
5323             {
5324               if (TREE_SIDE_EFFECTS (p->value))
5325                 warning_init ("initialized field with side-effects overwritten");
5326               p->value = value;
5327               return;
5328             }
5329         }
5330     }
5331
5332   r = GGC_NEW (struct init_node);
5333   r->purpose = purpose;
5334   r->value = value;
5335
5336   *q = r;
5337   r->parent = p;
5338   r->left = 0;
5339   r->right = 0;
5340   r->balance = 0;
5341
5342   while (p)
5343     {
5344       struct init_node *s;
5345
5346       if (r == p->left)
5347         {
5348           if (p->balance == 0)
5349             p->balance = -1;
5350           else if (p->balance < 0)
5351             {
5352               if (r->balance < 0)
5353                 {
5354                   /* L rotation.  */
5355                   p->left = r->right;
5356                   if (p->left)
5357                     p->left->parent = p;
5358                   r->right = p;
5359
5360                   p->balance = 0;
5361                   r->balance = 0;
5362
5363                   s = p->parent;
5364                   p->parent = r;
5365                   r->parent = s;
5366                   if (s)
5367                     {
5368                       if (s->left == p)
5369                         s->left = r;
5370                       else
5371                         s->right = r;
5372                     }
5373                   else
5374                     constructor_pending_elts = r;
5375                 }
5376               else
5377                 {
5378                   /* LR rotation.  */
5379                   struct init_node *t = r->right;
5380
5381                   r->right = t->left;
5382                   if (r->right)
5383                     r->right->parent = r;
5384                   t->left = r;
5385
5386                   p->left = t->right;
5387                   if (p->left)
5388                     p->left->parent = p;
5389                   t->right = p;
5390
5391                   p->balance = t->balance < 0;
5392                   r->balance = -(t->balance > 0);
5393                   t->balance = 0;
5394
5395                   s = p->parent;
5396                   p->parent = t;
5397                   r->parent = t;
5398                   t->parent = s;
5399                   if (s)
5400                     {
5401                       if (s->left == p)
5402                         s->left = t;
5403                       else
5404                         s->right = t;
5405                     }
5406                   else
5407                     constructor_pending_elts = t;
5408                 }
5409               break;
5410             }
5411           else
5412             {
5413               /* p->balance == +1; growth of left side balances the node.  */
5414               p->balance = 0;
5415               break;
5416             }
5417         }
5418       else /* r == p->right */
5419         {
5420           if (p->balance == 0)
5421             /* Growth propagation from right side.  */
5422             p->balance++;
5423           else if (p->balance > 0)
5424             {
5425               if (r->balance > 0)
5426                 {
5427                   /* R rotation.  */
5428                   p->right = r->left;
5429                   if (p->right)
5430                     p->right->parent = p;
5431                   r->left = p;
5432
5433                   p->balance = 0;
5434                   r->balance = 0;
5435
5436                   s = p->parent;
5437                   p->parent = r;
5438                   r->parent = s;
5439                   if (s)
5440                     {
5441                       if (s->left == p)
5442                         s->left = r;
5443                       else
5444                         s->right = r;
5445                     }
5446                   else
5447                     constructor_pending_elts = r;
5448                 }
5449               else /* r->balance == -1 */
5450                 {
5451                   /* RL rotation */
5452                   struct init_node *t = r->left;
5453
5454                   r->left = t->right;
5455                   if (r->left)
5456                     r->left->parent = r;
5457                   t->right = r;
5458
5459                   p->right = t->left;
5460                   if (p->right)
5461                     p->right->parent = p;
5462                   t->left = p;
5463
5464                   r->balance = (t->balance < 0);
5465                   p->balance = -(t->balance > 0);
5466                   t->balance = 0;
5467
5468                   s = p->parent;
5469                   p->parent = t;
5470                   r->parent = t;
5471                   t->parent = s;
5472                   if (s)
5473                     {
5474                       if (s->left == p)
5475                         s->left = t;
5476                       else
5477                         s->right = t;
5478                     }
5479                   else
5480                     constructor_pending_elts = t;
5481                 }
5482               break;
5483             }
5484           else
5485             {
5486               /* p->balance == -1; growth of right side balances the node.  */
5487               p->balance = 0;
5488               break;
5489             }
5490         }
5491
5492       r = p;
5493       p = p->parent;
5494     }
5495 }
5496
5497 /* Build AVL tree from a sorted chain.  */
5498
5499 static void
5500 set_nonincremental_init (void)
5501 {
5502   tree chain;
5503
5504   if (TREE_CODE (constructor_type) != RECORD_TYPE
5505       && TREE_CODE (constructor_type) != ARRAY_TYPE)
5506     return;
5507
5508   for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
5509     add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
5510   constructor_elements = 0;
5511   if (TREE_CODE (constructor_type) == RECORD_TYPE)
5512     {
5513       constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
5514       /* Skip any nameless bit fields at the beginning.  */
5515       while (constructor_unfilled_fields != 0
5516              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5517              && DECL_NAME (constructor_unfilled_fields) == 0)
5518         constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5519
5520     }
5521   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5522     {
5523       if (TYPE_DOMAIN (constructor_type))
5524         constructor_unfilled_index
5525             = convert (bitsizetype,
5526                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5527       else
5528         constructor_unfilled_index = bitsize_zero_node;
5529     }
5530   constructor_incremental = 0;
5531 }
5532
5533 /* Build AVL tree from a string constant.  */
5534
5535 static void
5536 set_nonincremental_init_from_string (tree str)
5537 {
5538   tree value, purpose, type;
5539   HOST_WIDE_INT val[2];
5540   const char *p, *end;
5541   int byte, wchar_bytes, charwidth, bitpos;
5542
5543   gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE);
5544
5545   if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5546       == TYPE_PRECISION (char_type_node))
5547     wchar_bytes = 1;
5548   else
5549     {
5550       gcc_assert (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5551                   == TYPE_PRECISION (wchar_type_node));
5552       wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
5553     }
5554   charwidth = TYPE_PRECISION (char_type_node);
5555   type = TREE_TYPE (constructor_type);
5556   p = TREE_STRING_POINTER (str);
5557   end = p + TREE_STRING_LENGTH (str);
5558
5559   for (purpose = bitsize_zero_node;
5560        p < end && !tree_int_cst_lt (constructor_max_index, purpose);
5561        purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
5562     {
5563       if (wchar_bytes == 1)
5564         {
5565           val[1] = (unsigned char) *p++;
5566           val[0] = 0;
5567         }
5568       else
5569         {
5570           val[0] = 0;
5571           val[1] = 0;
5572           for (byte = 0; byte < wchar_bytes; byte++)
5573             {
5574               if (BYTES_BIG_ENDIAN)
5575                 bitpos = (wchar_bytes - byte - 1) * charwidth;
5576               else
5577                 bitpos = byte * charwidth;
5578               val[bitpos < HOST_BITS_PER_WIDE_INT]
5579                 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
5580                    << (bitpos % HOST_BITS_PER_WIDE_INT);
5581             }
5582         }
5583
5584       if (!TYPE_UNSIGNED (type))
5585         {
5586           bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
5587           if (bitpos < HOST_BITS_PER_WIDE_INT)
5588             {
5589               if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
5590                 {
5591                   val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
5592                   val[0] = -1;
5593                 }
5594             }
5595           else if (bitpos == HOST_BITS_PER_WIDE_INT)
5596             {
5597               if (val[1] < 0)
5598                 val[0] = -1;
5599             }
5600           else if (val[0] & (((HOST_WIDE_INT) 1)
5601                              << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
5602             val[0] |= ((HOST_WIDE_INT) -1)
5603                       << (bitpos - HOST_BITS_PER_WIDE_INT);
5604         }
5605
5606       value = build_int_cst_wide (type, val[1], val[0]);
5607       add_pending_init (purpose, value);
5608     }
5609
5610   constructor_incremental = 0;
5611 }
5612
5613 /* Return value of FIELD in pending initializer or zero if the field was
5614    not initialized yet.  */
5615
5616 static tree
5617 find_init_member (tree field)
5618 {
5619   struct init_node *p;
5620
5621   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5622     {
5623       if (constructor_incremental
5624           && tree_int_cst_lt (field, constructor_unfilled_index))
5625         set_nonincremental_init ();
5626
5627       p = constructor_pending_elts;
5628       while (p)
5629         {
5630           if (tree_int_cst_lt (field, p->purpose))
5631             p = p->left;
5632           else if (tree_int_cst_lt (p->purpose, field))
5633             p = p->right;
5634           else
5635             return p->value;
5636         }
5637     }
5638   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5639     {
5640       tree bitpos = bit_position (field);
5641
5642       if (constructor_incremental
5643           && (!constructor_unfilled_fields
5644               || tree_int_cst_lt (bitpos,
5645                                   bit_position (constructor_unfilled_fields))))
5646         set_nonincremental_init ();
5647
5648       p = constructor_pending_elts;
5649       while (p)
5650         {
5651           if (field == p->purpose)
5652             return p->value;
5653           else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5654             p = p->left;
5655           else
5656             p = p->right;
5657         }
5658     }
5659   else if (TREE_CODE (constructor_type) == UNION_TYPE)
5660     {
5661       if (constructor_elements
5662           && TREE_PURPOSE (constructor_elements) == field)
5663         return TREE_VALUE (constructor_elements);
5664     }
5665   return 0;
5666 }
5667
5668 /* "Output" the next constructor element.
5669    At top level, really output it to assembler code now.
5670    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
5671    TYPE is the data type that the containing data type wants here.
5672    FIELD is the field (a FIELD_DECL) or the index that this element fills.
5673    If VALUE is a string constant, STRICT_STRING is true if it is
5674    unparenthesized or we should not warn here for it being parenthesized.
5675    For other types of VALUE, STRICT_STRING is not used.
5676
5677    PENDING if non-nil means output pending elements that belong
5678    right after this element.  (PENDING is normally 1;
5679    it is 0 while outputting pending elements, to avoid recursion.)  */
5680
5681 static void
5682 output_init_element (tree value, bool strict_string, tree type, tree field,
5683                      int pending)
5684 {
5685   if (type == error_mark_node)
5686     {
5687       constructor_erroneous = 1;
5688       return;
5689     }
5690   if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
5691       || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
5692           && !(TREE_CODE (value) == STRING_CST
5693                && TREE_CODE (type) == ARRAY_TYPE
5694                && INTEGRAL_TYPE_P (TREE_TYPE (type)))
5695           && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
5696                          TYPE_MAIN_VARIANT (type))))
5697     value = default_conversion (value);
5698
5699   if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
5700       && require_constant_value && !flag_isoc99 && pending)
5701     {
5702       /* As an extension, allow initializing objects with static storage
5703          duration with compound literals (which are then treated just as
5704          the brace enclosed list they contain).  */
5705       tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
5706       value = DECL_INITIAL (decl);
5707     }
5708
5709   if (value == error_mark_node)
5710     constructor_erroneous = 1;
5711   else if (!TREE_CONSTANT (value))
5712     constructor_constant = 0;
5713   else if (!initializer_constant_valid_p (value, TREE_TYPE (value))
5714            || ((TREE_CODE (constructor_type) == RECORD_TYPE
5715                 || TREE_CODE (constructor_type) == UNION_TYPE)
5716                && DECL_C_BIT_FIELD (field)
5717                && TREE_CODE (value) != INTEGER_CST))
5718     constructor_simple = 0;
5719
5720   if (!initializer_constant_valid_p (value, TREE_TYPE (value)))
5721     {
5722       if (require_constant_value)
5723         {
5724           error_init ("initializer element is not constant");
5725           value = error_mark_node;
5726         }
5727       else if (require_constant_elements)
5728         pedwarn ("initializer element is not computable at load time");
5729     }
5730
5731   /* If this field is empty (and not at the end of structure),
5732      don't do anything other than checking the initializer.  */
5733   if (field
5734       && (TREE_TYPE (field) == error_mark_node
5735           || (COMPLETE_TYPE_P (TREE_TYPE (field))
5736               && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
5737               && (TREE_CODE (constructor_type) == ARRAY_TYPE
5738                   || TREE_CHAIN (field)))))
5739     return;
5740
5741   value = digest_init (type, value, strict_string, require_constant_value);
5742   if (value == error_mark_node)
5743     {
5744       constructor_erroneous = 1;
5745       return;
5746     }
5747
5748   /* If this element doesn't come next in sequence,
5749      put it on constructor_pending_elts.  */
5750   if (TREE_CODE (constructor_type) == ARRAY_TYPE
5751       && (!constructor_incremental
5752           || !tree_int_cst_equal (field, constructor_unfilled_index)))
5753     {
5754       if (constructor_incremental
5755           && tree_int_cst_lt (field, constructor_unfilled_index))
5756         set_nonincremental_init ();
5757
5758       add_pending_init (field, value);
5759       return;
5760     }
5761   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5762            && (!constructor_incremental
5763                || field != constructor_unfilled_fields))
5764     {
5765       /* We do this for records but not for unions.  In a union,
5766          no matter which field is specified, it can be initialized
5767          right away since it starts at the beginning of the union.  */
5768       if (constructor_incremental)
5769         {
5770           if (!constructor_unfilled_fields)
5771             set_nonincremental_init ();
5772           else
5773             {
5774               tree bitpos, unfillpos;
5775
5776               bitpos = bit_position (field);
5777               unfillpos = bit_position (constructor_unfilled_fields);
5778
5779               if (tree_int_cst_lt (bitpos, unfillpos))
5780                 set_nonincremental_init ();
5781             }
5782         }
5783
5784       add_pending_init (field, value);
5785       return;
5786     }
5787   else if (TREE_CODE (constructor_type) == UNION_TYPE
5788            && constructor_elements)
5789     {
5790       if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
5791         warning_init ("initialized field with side-effects overwritten");
5792
5793       /* We can have just one union field set.  */
5794       constructor_elements = 0;
5795     }
5796
5797   /* Otherwise, output this element either to
5798      constructor_elements or to the assembler file.  */
5799
5800   if (field && TREE_CODE (field) == INTEGER_CST)
5801     field = copy_node (field);
5802   constructor_elements
5803     = tree_cons (field, value, constructor_elements);
5804
5805   /* Advance the variable that indicates sequential elements output.  */
5806   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5807     constructor_unfilled_index
5808       = size_binop (PLUS_EXPR, constructor_unfilled_index,
5809                     bitsize_one_node);
5810   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5811     {
5812       constructor_unfilled_fields
5813         = TREE_CHAIN (constructor_unfilled_fields);
5814
5815       /* Skip any nameless bit fields.  */
5816       while (constructor_unfilled_fields != 0
5817              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5818              && DECL_NAME (constructor_unfilled_fields) == 0)
5819         constructor_unfilled_fields =
5820           TREE_CHAIN (constructor_unfilled_fields);
5821     }
5822   else if (TREE_CODE (constructor_type) == UNION_TYPE)
5823     constructor_unfilled_fields = 0;
5824
5825   /* Now output any pending elements which have become next.  */
5826   if (pending)
5827     output_pending_init_elements (0);
5828 }
5829
5830 /* Output any pending elements which have become next.
5831    As we output elements, constructor_unfilled_{fields,index}
5832    advances, which may cause other elements to become next;
5833    if so, they too are output.
5834
5835    If ALL is 0, we return when there are
5836    no more pending elements to output now.
5837
5838    If ALL is 1, we output space as necessary so that
5839    we can output all the pending elements.  */
5840
5841 static void
5842 output_pending_init_elements (int all)
5843 {
5844   struct init_node *elt = constructor_pending_elts;
5845   tree next;
5846
5847  retry:
5848
5849   /* Look through the whole pending tree.
5850      If we find an element that should be output now,
5851      output it.  Otherwise, set NEXT to the element
5852      that comes first among those still pending.  */
5853
5854   next = 0;
5855   while (elt)
5856     {
5857       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5858         {
5859           if (tree_int_cst_equal (elt->purpose,
5860                                   constructor_unfilled_index))
5861             output_init_element (elt->value, true,
5862                                  TREE_TYPE (constructor_type),
5863                                  constructor_unfilled_index, 0);
5864           else if (tree_int_cst_lt (constructor_unfilled_index,
5865                                     elt->purpose))
5866             {
5867               /* Advance to the next smaller node.  */
5868               if (elt->left)
5869                 elt = elt->left;
5870               else
5871                 {
5872                   /* We have reached the smallest node bigger than the
5873                      current unfilled index.  Fill the space first.  */
5874                   next = elt->purpose;
5875                   break;
5876                 }
5877             }
5878           else
5879             {
5880               /* Advance to the next bigger node.  */
5881               if (elt->right)
5882                 elt = elt->right;
5883               else
5884                 {
5885                   /* We have reached the biggest node in a subtree.  Find
5886                      the parent of it, which is the next bigger node.  */
5887                   while (elt->parent && elt->parent->right == elt)
5888                     elt = elt->parent;
5889                   elt = elt->parent;
5890                   if (elt && tree_int_cst_lt (constructor_unfilled_index,
5891                                               elt->purpose))
5892                     {
5893                       next = elt->purpose;
5894                       break;
5895                     }
5896                 }
5897             }
5898         }
5899       else if (TREE_CODE (constructor_type) == RECORD_TYPE
5900                || TREE_CODE (constructor_type) == UNION_TYPE)
5901         {
5902           tree ctor_unfilled_bitpos, elt_bitpos;
5903
5904           /* If the current record is complete we are done.  */
5905           if (constructor_unfilled_fields == 0)
5906             break;
5907
5908           ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
5909           elt_bitpos = bit_position (elt->purpose);
5910           /* We can't compare fields here because there might be empty
5911              fields in between.  */
5912           if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
5913             {
5914               constructor_unfilled_fields = elt->purpose;
5915               output_init_element (elt->value, true, TREE_TYPE (elt->purpose),
5916                                    elt->purpose, 0);
5917             }
5918           else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
5919             {
5920               /* Advance to the next smaller node.  */
5921               if (elt->left)
5922                 elt = elt->left;
5923               else
5924                 {
5925                   /* We have reached the smallest node bigger than the
5926                      current unfilled field.  Fill the space first.  */
5927                   next = elt->purpose;
5928                   break;
5929                 }
5930             }
5931           else
5932             {
5933               /* Advance to the next bigger node.  */
5934               if (elt->right)
5935                 elt = elt->right;
5936               else
5937                 {
5938                   /* We have reached the biggest node in a subtree.  Find
5939                      the parent of it, which is the next bigger node.  */
5940                   while (elt->parent && elt->parent->right == elt)
5941                     elt = elt->parent;
5942                   elt = elt->parent;
5943                   if (elt
5944                       && (tree_int_cst_lt (ctor_unfilled_bitpos,
5945                                            bit_position (elt->purpose))))
5946                     {
5947                       next = elt->purpose;
5948                       break;
5949                     }
5950                 }
5951             }
5952         }
5953     }
5954
5955   /* Ordinarily return, but not if we want to output all
5956      and there are elements left.  */
5957   if (!(all && next != 0))
5958     return;
5959
5960   /* If it's not incremental, just skip over the gap, so that after
5961      jumping to retry we will output the next successive element.  */
5962   if (TREE_CODE (constructor_type) == RECORD_TYPE
5963       || TREE_CODE (constructor_type) == UNION_TYPE)
5964     constructor_unfilled_fields = next;
5965   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5966     constructor_unfilled_index = next;
5967
5968   /* ELT now points to the node in the pending tree with the next
5969      initializer to output.  */
5970   goto retry;
5971 }
5972 \f
5973 /* Add one non-braced element to the current constructor level.
5974    This adjusts the current position within the constructor's type.
5975    This may also start or terminate implicit levels
5976    to handle a partly-braced initializer.
5977
5978    Once this has found the correct level for the new element,
5979    it calls output_init_element.  */
5980
5981 void
5982 process_init_element (struct c_expr value)
5983 {
5984   tree orig_value = value.value;
5985   int string_flag = orig_value != 0 && TREE_CODE (orig_value) == STRING_CST;
5986   bool strict_string = value.original_code == STRING_CST;
5987
5988   designator_depth = 0;
5989   designator_errorneous = 0;
5990
5991   /* Handle superfluous braces around string cst as in
5992      char x[] = {"foo"}; */
5993   if (string_flag
5994       && constructor_type
5995       && TREE_CODE (constructor_type) == ARRAY_TYPE
5996       && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type))
5997       && integer_zerop (constructor_unfilled_index))
5998     {
5999       if (constructor_stack->replacement_value.value)
6000         error_init ("excess elements in char array initializer");
6001       constructor_stack->replacement_value = value;
6002       return;
6003     }
6004
6005   if (constructor_stack->replacement_value.value != 0)
6006     {
6007       error_init ("excess elements in struct initializer");
6008       return;
6009     }
6010
6011   /* Ignore elements of a brace group if it is entirely superfluous
6012      and has already been diagnosed.  */
6013   if (constructor_type == 0)
6014     return;
6015
6016   /* If we've exhausted any levels that didn't have braces,
6017      pop them now.  */
6018   while (constructor_stack->implicit)
6019     {
6020       if ((TREE_CODE (constructor_type) == RECORD_TYPE
6021            || TREE_CODE (constructor_type) == UNION_TYPE)
6022           && constructor_fields == 0)
6023         process_init_element (pop_init_level (1));
6024       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6025                && (constructor_max_index == 0
6026                    || tree_int_cst_lt (constructor_max_index,
6027                                        constructor_index)))
6028         process_init_element (pop_init_level (1));
6029       else
6030         break;
6031     }
6032
6033   /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once.  */
6034   if (constructor_range_stack)
6035     {
6036       /* If value is a compound literal and we'll be just using its
6037          content, don't put it into a SAVE_EXPR.  */
6038       if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR
6039           || !require_constant_value
6040           || flag_isoc99)
6041         value.value = save_expr (value.value);
6042     }
6043
6044   while (1)
6045     {
6046       if (TREE_CODE (constructor_type) == RECORD_TYPE)
6047         {
6048           tree fieldtype;
6049           enum tree_code fieldcode;
6050
6051           if (constructor_fields == 0)
6052             {
6053               pedwarn_init ("excess elements in struct initializer");
6054               break;
6055             }
6056
6057           fieldtype = TREE_TYPE (constructor_fields);
6058           if (fieldtype != error_mark_node)
6059             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6060           fieldcode = TREE_CODE (fieldtype);
6061
6062           /* Error for non-static initialization of a flexible array member.  */
6063           if (fieldcode == ARRAY_TYPE
6064               && !require_constant_value
6065               && TYPE_SIZE (fieldtype) == NULL_TREE
6066               && TREE_CHAIN (constructor_fields) == NULL_TREE)
6067             {
6068               error_init ("non-static initialization of a flexible array member");
6069               break;
6070             }
6071
6072           /* Accept a string constant to initialize a subarray.  */
6073           if (value.value != 0
6074               && fieldcode == ARRAY_TYPE
6075               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
6076               && string_flag)
6077             value.value = orig_value;
6078           /* Otherwise, if we have come to a subaggregate,
6079              and we don't have an element of its type, push into it.  */
6080           else if (value.value != 0 && !constructor_no_implicit
6081                    && value.value != error_mark_node
6082                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
6083                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6084                        || fieldcode == UNION_TYPE))
6085             {
6086               push_init_level (1);
6087               continue;
6088             }
6089
6090           if (value.value)
6091             {
6092               push_member_name (constructor_fields);
6093               output_init_element (value.value, strict_string,
6094                                    fieldtype, constructor_fields, 1);
6095               RESTORE_SPELLING_DEPTH (constructor_depth);
6096             }
6097           else
6098             /* Do the bookkeeping for an element that was
6099                directly output as a constructor.  */
6100             {
6101               /* For a record, keep track of end position of last field.  */
6102               if (DECL_SIZE (constructor_fields))
6103                 constructor_bit_index
6104                   = size_binop (PLUS_EXPR,
6105                                 bit_position (constructor_fields),
6106                                 DECL_SIZE (constructor_fields));
6107
6108               /* If the current field was the first one not yet written out,
6109                  it isn't now, so update.  */
6110               if (constructor_unfilled_fields == constructor_fields)
6111                 {
6112                   constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6113                   /* Skip any nameless bit fields.  */
6114                   while (constructor_unfilled_fields != 0
6115                          && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6116                          && DECL_NAME (constructor_unfilled_fields) == 0)
6117                     constructor_unfilled_fields =
6118                       TREE_CHAIN (constructor_unfilled_fields);
6119                 }
6120             }
6121
6122           constructor_fields = TREE_CHAIN (constructor_fields);
6123           /* Skip any nameless bit fields at the beginning.  */
6124           while (constructor_fields != 0
6125                  && DECL_C_BIT_FIELD (constructor_fields)
6126                  && DECL_NAME (constructor_fields) == 0)
6127             constructor_fields = TREE_CHAIN (constructor_fields);
6128         }
6129       else if (TREE_CODE (constructor_type) == UNION_TYPE)
6130         {
6131           tree fieldtype;
6132           enum tree_code fieldcode;
6133
6134           if (constructor_fields == 0)
6135             {
6136               pedwarn_init ("excess elements in union initializer");
6137               break;
6138             }
6139
6140           fieldtype = TREE_TYPE (constructor_fields);
6141           if (fieldtype != error_mark_node)
6142             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6143           fieldcode = TREE_CODE (fieldtype);
6144
6145           /* Warn that traditional C rejects initialization of unions.
6146              We skip the warning if the value is zero.  This is done
6147              under the assumption that the zero initializer in user
6148              code appears conditioned on e.g. __STDC__ to avoid
6149              "missing initializer" warnings and relies on default
6150              initialization to zero in the traditional C case.
6151              We also skip the warning if the initializer is designated,
6152              again on the assumption that this must be conditional on
6153              __STDC__ anyway (and we've already complained about the
6154              member-designator already).  */
6155           if (warn_traditional && !in_system_header && !constructor_designated
6156               && !(value.value && (integer_zerop (value.value)
6157                                    || real_zerop (value.value))))
6158             warning ("traditional C rejects initialization of unions");
6159
6160           /* Accept a string constant to initialize a subarray.  */
6161           if (value.value != 0
6162               && fieldcode == ARRAY_TYPE
6163               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
6164               && string_flag)
6165             value.value = orig_value;
6166           /* Otherwise, if we have come to a subaggregate,
6167              and we don't have an element of its type, push into it.  */
6168           else if (value.value != 0 && !constructor_no_implicit
6169                    && value.value != error_mark_node
6170                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
6171                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6172                        || fieldcode == UNION_TYPE))
6173             {
6174               push_init_level (1);
6175               continue;
6176             }
6177
6178           if (value.value)
6179             {
6180               push_member_name (constructor_fields);
6181               output_init_element (value.value, strict_string,
6182                                    fieldtype, constructor_fields, 1);
6183               RESTORE_SPELLING_DEPTH (constructor_depth);
6184             }
6185           else
6186             /* Do the bookkeeping for an element that was
6187                directly output as a constructor.  */
6188             {
6189               constructor_bit_index = DECL_SIZE (constructor_fields);
6190               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6191             }
6192
6193           constructor_fields = 0;
6194         }
6195       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6196         {
6197           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6198           enum tree_code eltcode = TREE_CODE (elttype);
6199
6200           /* Accept a string constant to initialize a subarray.  */
6201           if (value.value != 0
6202               && eltcode == ARRAY_TYPE
6203               && INTEGRAL_TYPE_P (TREE_TYPE (elttype))
6204               && string_flag)
6205             value.value = orig_value;
6206           /* Otherwise, if we have come to a subaggregate,
6207              and we don't have an element of its type, push into it.  */
6208           else if (value.value != 0 && !constructor_no_implicit
6209                    && value.value != error_mark_node
6210                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype
6211                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6212                        || eltcode == UNION_TYPE))
6213             {
6214               push_init_level (1);
6215               continue;
6216             }
6217
6218           if (constructor_max_index != 0
6219               && (tree_int_cst_lt (constructor_max_index, constructor_index)
6220                   || integer_all_onesp (constructor_max_index)))
6221             {
6222               pedwarn_init ("excess elements in array initializer");
6223               break;
6224             }
6225
6226           /* Now output the actual element.  */
6227           if (value.value)
6228             {
6229               push_array_bounds (tree_low_cst (constructor_index, 0));
6230               output_init_element (value.value, strict_string,
6231                                    elttype, constructor_index, 1);
6232               RESTORE_SPELLING_DEPTH (constructor_depth);
6233             }
6234
6235           constructor_index
6236             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6237
6238           if (!value.value)
6239             /* If we are doing the bookkeeping for an element that was
6240                directly output as a constructor, we must update
6241                constructor_unfilled_index.  */
6242             constructor_unfilled_index = constructor_index;
6243         }
6244       else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
6245         {
6246           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6247
6248          /* Do a basic check of initializer size.  Note that vectors
6249             always have a fixed size derived from their type.  */
6250           if (tree_int_cst_lt (constructor_max_index, constructor_index))
6251             {
6252               pedwarn_init ("excess elements in vector initializer");
6253               break;
6254             }
6255
6256           /* Now output the actual element.  */
6257           if (value.value)
6258             output_init_element (value.value, strict_string,
6259                                  elttype, constructor_index, 1);
6260
6261           constructor_index
6262             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6263
6264           if (!value.value)
6265             /* If we are doing the bookkeeping for an element that was
6266                directly output as a constructor, we must update
6267                constructor_unfilled_index.  */
6268             constructor_unfilled_index = constructor_index;
6269         }
6270
6271       /* Handle the sole element allowed in a braced initializer
6272          for a scalar variable.  */
6273       else if (constructor_fields == 0)
6274         {
6275           pedwarn_init ("excess elements in scalar initializer");
6276           break;
6277         }
6278       else
6279         {
6280           if (value.value)
6281             output_init_element (value.value, strict_string,
6282                                  constructor_type, NULL_TREE, 1);
6283           constructor_fields = 0;
6284         }
6285
6286       /* Handle range initializers either at this level or anywhere higher
6287          in the designator stack.  */
6288       if (constructor_range_stack)
6289         {
6290           struct constructor_range_stack *p, *range_stack;
6291           int finish = 0;
6292
6293           range_stack = constructor_range_stack;
6294           constructor_range_stack = 0;
6295           while (constructor_stack != range_stack->stack)
6296             {
6297               gcc_assert (constructor_stack->implicit);
6298               process_init_element (pop_init_level (1));
6299             }
6300           for (p = range_stack;
6301                !p->range_end || tree_int_cst_equal (p->index, p->range_end);
6302                p = p->prev)
6303             {
6304               gcc_assert (constructor_stack->implicit);
6305               process_init_element (pop_init_level (1));
6306             }
6307
6308           p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
6309           if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
6310             finish = 1;
6311
6312           while (1)
6313             {
6314               constructor_index = p->index;
6315               constructor_fields = p->fields;
6316               if (finish && p->range_end && p->index == p->range_start)
6317                 {
6318                   finish = 0;
6319                   p->prev = 0;
6320                 }
6321               p = p->next;
6322               if (!p)
6323                 break;
6324               push_init_level (2);
6325               p->stack = constructor_stack;
6326               if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
6327                 p->index = p->range_start;
6328             }
6329
6330           if (!finish)
6331             constructor_range_stack = range_stack;
6332           continue;
6333         }
6334
6335       break;
6336     }
6337
6338   constructor_range_stack = 0;
6339 }
6340 \f
6341 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
6342    (guaranteed to be 'volatile' or null) and ARGS (represented using
6343    an ASM_EXPR node).  */
6344 tree
6345 build_asm_stmt (tree cv_qualifier, tree args)
6346 {
6347   if (!ASM_VOLATILE_P (args) && cv_qualifier)
6348     ASM_VOLATILE_P (args) = 1;
6349   return add_stmt (args);
6350 }
6351
6352 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
6353    some INPUTS, and some CLOBBERS.  The latter three may be NULL.
6354    SIMPLE indicates whether there was anything at all after the
6355    string in the asm expression -- asm("blah") and asm("blah" : )
6356    are subtly different.  We use a ASM_EXPR node to represent this.  */
6357 tree
6358 build_asm_expr (tree string, tree outputs, tree inputs, tree clobbers,
6359                 bool simple)
6360 {
6361   tree tail;
6362   tree args;
6363   int i;
6364   const char *constraint;
6365   bool allows_mem, allows_reg, is_inout;
6366   int ninputs;
6367   int noutputs;
6368
6369   ninputs = list_length (inputs);
6370   noutputs = list_length (outputs);
6371
6372   /* Remove output conversions that change the type but not the mode.  */
6373   for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail))
6374     {
6375       tree output = TREE_VALUE (tail);
6376       STRIP_NOPS (output);
6377       TREE_VALUE (tail) = output;
6378       lvalue_or_else (output, lv_asm);
6379
6380       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
6381
6382       if (!parse_output_constraint (&constraint, i, ninputs, noutputs,
6383                                     &allows_mem, &allows_reg, &is_inout))
6384         {
6385           /* By marking this operand as erroneous, we will not try
6386           to process this operand again in expand_asm_operands.  */
6387           TREE_VALUE (tail) = error_mark_node;
6388           continue;
6389         }
6390
6391       /* If the operand is a DECL that is going to end up in
6392         memory, assume it is addressable.  This is a bit more
6393         conservative than it would ideally be; the exact test is
6394         buried deep in expand_asm_operands and depends on the
6395         DECL_RTL for the OPERAND -- which we don't have at this
6396         point.  */
6397       if (!allows_reg && DECL_P (output))
6398         c_mark_addressable (output);
6399     }
6400
6401   /* Perform default conversions on array and function inputs.
6402      Don't do this for other types as it would screw up operands
6403      expected to be in memory.  */
6404   for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6405     TREE_VALUE (tail) = default_function_array_conversion (TREE_VALUE (tail));
6406
6407   args = build_stmt (ASM_EXPR, string, outputs, inputs, clobbers);
6408
6409   /* Simple asm statements are treated as volatile.  */
6410   if (simple)
6411     {
6412       ASM_VOLATILE_P (args) = 1;
6413       ASM_INPUT_P (args) = 1;
6414     }
6415   return args;
6416 }
6417 \f
6418 /* Generate a goto statement to LABEL.  */
6419
6420 tree
6421 c_finish_goto_label (tree label)
6422 {
6423   tree decl = lookup_label (label);
6424   if (!decl)
6425     return NULL_TREE;
6426
6427   TREE_USED (decl) = 1;
6428   return add_stmt (build1 (GOTO_EXPR, void_type_node, decl));
6429 }
6430
6431 /* Generate a computed goto statement to EXPR.  */
6432
6433 tree
6434 c_finish_goto_ptr (tree expr)
6435 {
6436   if (pedantic)
6437     pedwarn ("ISO C forbids %<goto *expr;%>");
6438   expr = convert (ptr_type_node, expr);
6439   return add_stmt (build1 (GOTO_EXPR, void_type_node, expr));
6440 }
6441
6442 /* Generate a C `return' statement.  RETVAL is the expression for what
6443    to return, or a null pointer for `return;' with no value.  */
6444
6445 tree
6446 c_finish_return (tree retval)
6447 {
6448   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6449
6450   if (TREE_THIS_VOLATILE (current_function_decl))
6451     warning ("function declared %<noreturn%> has a %<return%> statement");
6452
6453   if (!retval)
6454     {
6455       current_function_returns_null = 1;
6456       if ((warn_return_type || flag_isoc99)
6457           && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6458         pedwarn_c99 ("%<return%> with no value, in "
6459                      "function returning non-void");
6460     }
6461   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6462     {
6463       current_function_returns_null = 1;
6464       if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6465         pedwarn ("%<return%> with a value, in function returning void");
6466     }
6467   else
6468     {
6469       tree t = convert_for_assignment (valtype, retval, ic_return,
6470                                        NULL_TREE, NULL_TREE, 0);
6471       tree res = DECL_RESULT (current_function_decl);
6472       tree inner;
6473
6474       current_function_returns_value = 1;
6475       if (t == error_mark_node)
6476         return NULL_TREE;
6477
6478       inner = t = convert (TREE_TYPE (res), t);
6479
6480       /* Strip any conversions, additions, and subtractions, and see if
6481          we are returning the address of a local variable.  Warn if so.  */
6482       while (1)
6483         {
6484           switch (TREE_CODE (inner))
6485             {
6486             case NOP_EXPR:   case NON_LVALUE_EXPR:  case CONVERT_EXPR:
6487             case PLUS_EXPR:
6488               inner = TREE_OPERAND (inner, 0);
6489               continue;
6490
6491             case MINUS_EXPR:
6492               /* If the second operand of the MINUS_EXPR has a pointer
6493                  type (or is converted from it), this may be valid, so
6494                  don't give a warning.  */
6495               {
6496                 tree op1 = TREE_OPERAND (inner, 1);
6497
6498                 while (!POINTER_TYPE_P (TREE_TYPE (op1))
6499                        && (TREE_CODE (op1) == NOP_EXPR
6500                            || TREE_CODE (op1) == NON_LVALUE_EXPR
6501                            || TREE_CODE (op1) == CONVERT_EXPR))
6502                   op1 = TREE_OPERAND (op1, 0);
6503
6504                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6505                   break;
6506
6507                 inner = TREE_OPERAND (inner, 0);
6508                 continue;
6509               }
6510
6511             case ADDR_EXPR:
6512               inner = TREE_OPERAND (inner, 0);
6513
6514               while (REFERENCE_CLASS_P (inner)
6515                      && TREE_CODE (inner) != INDIRECT_REF)
6516                 inner = TREE_OPERAND (inner, 0);
6517
6518               if (DECL_P (inner)
6519                   && !DECL_EXTERNAL (inner)
6520                   && !TREE_STATIC (inner)
6521                   && DECL_CONTEXT (inner) == current_function_decl)
6522                 warning ("function returns address of local variable");
6523               break;
6524
6525             default:
6526               break;
6527             }
6528
6529           break;
6530         }
6531
6532       retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t);
6533     }
6534
6535   return add_stmt (build_stmt (RETURN_EXPR, retval));
6536 }
6537 \f
6538 struct c_switch {
6539   /* The SWITCH_STMT being built.  */
6540   tree switch_stmt;
6541
6542   /* The original type of the testing expression, i.e. before the
6543      default conversion is applied.  */
6544   tree orig_type;
6545
6546   /* A splay-tree mapping the low element of a case range to the high
6547      element, or NULL_TREE if there is no high element.  Used to
6548      determine whether or not a new case label duplicates an old case
6549      label.  We need a tree, rather than simply a hash table, because
6550      of the GNU case range extension.  */
6551   splay_tree cases;
6552
6553   /* The next node on the stack.  */
6554   struct c_switch *next;
6555 };
6556
6557 /* A stack of the currently active switch statements.  The innermost
6558    switch statement is on the top of the stack.  There is no need to
6559    mark the stack for garbage collection because it is only active
6560    during the processing of the body of a function, and we never
6561    collect at that point.  */
6562
6563 struct c_switch *c_switch_stack;
6564
6565 /* Start a C switch statement, testing expression EXP.  Return the new
6566    SWITCH_STMT.  */
6567
6568 tree
6569 c_start_case (tree exp)
6570 {
6571   enum tree_code code;
6572   tree type, orig_type = error_mark_node;
6573   struct c_switch *cs;
6574
6575   if (exp != error_mark_node)
6576     {
6577       code = TREE_CODE (TREE_TYPE (exp));
6578       orig_type = TREE_TYPE (exp);
6579
6580       if (!INTEGRAL_TYPE_P (orig_type)
6581           && code != ERROR_MARK)
6582         {
6583           error ("switch quantity not an integer");
6584           exp = integer_zero_node;
6585         }
6586       else
6587         {
6588           type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
6589
6590           if (warn_traditional && !in_system_header
6591               && (type == long_integer_type_node
6592                   || type == long_unsigned_type_node))
6593             warning ("%<long%> switch expression not converted to "
6594                      "%<int%> in ISO C");
6595
6596           exp = default_conversion (exp);
6597           type = TREE_TYPE (exp);
6598         }
6599     }
6600
6601   /* Add this new SWITCH_STMT to the stack.  */
6602   cs = XNEW (struct c_switch);
6603   cs->switch_stmt = build_stmt ((enum tree_code) SWITCH_STMT, exp, NULL_TREE,
6604                                 orig_type);
6605   cs->orig_type = orig_type;
6606   cs->cases = splay_tree_new (case_compare, NULL, NULL);
6607   cs->next = c_switch_stack;
6608   c_switch_stack = cs;
6609
6610   return add_stmt (cs->switch_stmt);
6611 }
6612
6613 /* Process a case label.  */
6614
6615 tree
6616 do_case (tree low_value, tree high_value)
6617 {
6618   tree label = NULL_TREE;
6619
6620   if (c_switch_stack)
6621     {
6622       label = c_add_case_label (c_switch_stack->cases,
6623                                 SWITCH_COND (c_switch_stack->switch_stmt),
6624                                 c_switch_stack->orig_type,
6625                                 low_value, high_value);
6626       if (label == error_mark_node)
6627         label = NULL_TREE;
6628     }
6629   else if (low_value)
6630     error ("case label not within a switch statement");
6631   else
6632     error ("%<default%> label not within a switch statement");
6633
6634   return label;
6635 }
6636
6637 /* Finish the switch statement.  */
6638
6639 void
6640 c_finish_case (tree body)
6641 {
6642   struct c_switch *cs = c_switch_stack;
6643
6644   SWITCH_BODY (cs->switch_stmt) = body;
6645
6646   /* Emit warnings as needed.  */
6647   c_do_switch_warnings (cs->cases, cs->switch_stmt);
6648
6649   /* Pop the stack.  */
6650   c_switch_stack = cs->next;
6651   splay_tree_delete (cs->cases);
6652   XDELETE (cs);
6653 }
6654 \f
6655 /* Emit an if statement.  IF_LOCUS is the location of the 'if'.  COND,
6656    THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
6657    may be null.  NESTED_IF is true if THEN_BLOCK contains another IF
6658    statement, and was not surrounded with parenthesis.  */
6659
6660 void
6661 c_finish_if_stmt (location_t if_locus, tree cond, tree then_block,
6662                   tree else_block, bool nested_if)
6663 {
6664   tree stmt;
6665
6666   /* Diagnose an ambiguous else if if-then-else is nested inside if-then.  */
6667   if (warn_parentheses && nested_if && else_block == NULL)
6668     {
6669       tree inner_if = then_block;
6670
6671       /* We know from the grammar productions that there is an IF nested
6672          within THEN_BLOCK.  Due to labels and c99 conditional declarations,
6673          it might not be exactly THEN_BLOCK, but should be the last
6674          non-container statement within.  */
6675       while (1)
6676         switch (TREE_CODE (inner_if))
6677           {
6678           case COND_EXPR:
6679             goto found;
6680           case BIND_EXPR:
6681             inner_if = BIND_EXPR_BODY (inner_if);
6682             break;
6683           case STATEMENT_LIST:
6684             inner_if = expr_last (then_block);
6685             break;
6686           case TRY_FINALLY_EXPR:
6687           case TRY_CATCH_EXPR:
6688             inner_if = TREE_OPERAND (inner_if, 0);
6689             break;
6690           default:
6691             gcc_unreachable ();
6692           }
6693     found:
6694
6695       if (COND_EXPR_ELSE (inner_if))
6696          warning ("%Hsuggest explicit braces to avoid ambiguous %<else%>",
6697                   &if_locus);
6698     }
6699
6700   /* Diagnose ";" via the special empty statement node that we create.  */
6701   if (extra_warnings)
6702     {
6703       if (TREE_CODE (then_block) == NOP_EXPR && !TREE_TYPE (then_block))
6704         {
6705           if (!else_block)
6706             warning ("%Hempty body in an if-statement",
6707                      EXPR_LOCUS (then_block));
6708           then_block = alloc_stmt_list ();
6709         }
6710       if (else_block
6711           && TREE_CODE (else_block) == NOP_EXPR
6712           && !TREE_TYPE (else_block))
6713         {
6714           warning ("%Hempty body in an else-statement",
6715                    EXPR_LOCUS (else_block));
6716           else_block = alloc_stmt_list ();
6717         }
6718     }
6719
6720   stmt = build3 (COND_EXPR, NULL_TREE, cond, then_block, else_block);
6721   SET_EXPR_LOCATION (stmt, if_locus);
6722   add_stmt (stmt);
6723 }
6724
6725 /* Emit a general-purpose loop construct.  START_LOCUS is the location of
6726    the beginning of the loop.  COND is the loop condition.  COND_IS_FIRST
6727    is false for DO loops.  INCR is the FOR increment expression.  BODY is
6728    the statement controlled by the loop.  BLAB is the break label.  CLAB is
6729    the continue label.  Everything is allowed to be NULL.  */
6730
6731 void
6732 c_finish_loop (location_t start_locus, tree cond, tree incr, tree body,
6733                tree blab, tree clab, bool cond_is_first)
6734 {
6735   tree entry = NULL, exit = NULL, t;
6736
6737   /* Detect do { ... } while (0) and don't generate loop construct.  */
6738   if (cond && !cond_is_first && integer_zerop (cond))
6739     cond = NULL;
6740   if (cond_is_first || cond)
6741     {
6742       tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
6743
6744       /* If we have an exit condition, then we build an IF with gotos either
6745          out of the loop, or to the top of it.  If there's no exit condition,
6746          then we just build a jump back to the top.  */
6747       exit = build_and_jump (&LABEL_EXPR_LABEL (top));
6748
6749       if (cond)
6750         {
6751           /* Canonicalize the loop condition to the end.  This means
6752              generating a branch to the loop condition.  Reuse the
6753              continue label, if possible.  */
6754           if (cond_is_first)
6755             {
6756               if (incr || !clab)
6757                 {
6758                   entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
6759                   t = build_and_jump (&LABEL_EXPR_LABEL (entry));
6760                 }
6761               else
6762                 t = build1 (GOTO_EXPR, void_type_node, clab);
6763               SET_EXPR_LOCATION (t, start_locus);
6764               add_stmt (t);
6765             }
6766
6767           t = build_and_jump (&blab);
6768           exit = build3 (COND_EXPR, void_type_node, cond, exit, t);
6769           exit = fold (exit);
6770           if (cond_is_first)
6771             SET_EXPR_LOCATION (exit, start_locus);
6772           else
6773             SET_EXPR_LOCATION (exit, input_location);
6774         }
6775
6776       add_stmt (top);
6777     }
6778
6779   if (body)
6780     add_stmt (body);
6781   if (clab)
6782     add_stmt (build1 (LABEL_EXPR, void_type_node, clab));
6783   if (incr)
6784     add_stmt (incr);
6785   if (entry)
6786     add_stmt (entry);
6787   if (exit)
6788     add_stmt (exit);
6789   if (blab)
6790     add_stmt (build1 (LABEL_EXPR, void_type_node, blab));
6791 }
6792
6793 tree
6794 c_finish_bc_stmt (tree *label_p, bool is_break)
6795 {
6796   tree label = *label_p;
6797
6798   if (!label)
6799     *label_p = label = create_artificial_label ();
6800   else if (TREE_CODE (label) != LABEL_DECL)
6801     {
6802       if (is_break)
6803         error ("break statement not within loop or switch");
6804       else
6805         error ("continue statement not within a loop");
6806       return NULL_TREE;
6807     }
6808
6809   return add_stmt (build1 (GOTO_EXPR, void_type_node, label));
6810 }
6811
6812 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr.  */
6813
6814 static void
6815 emit_side_effect_warnings (tree expr)
6816 {
6817   if (expr == error_mark_node)
6818     ;
6819   else if (!TREE_SIDE_EFFECTS (expr))
6820     {
6821       if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr))
6822         warning ("%Hstatement with no effect",
6823                  EXPR_HAS_LOCATION (expr) ? EXPR_LOCUS (expr) : &input_location);
6824     }
6825   else if (warn_unused_value)
6826     warn_if_unused_value (expr, input_location);
6827 }
6828
6829 /* Process an expression as if it were a complete statement.  Emit
6830    diagnostics, but do not call ADD_STMT.  */
6831
6832 tree
6833 c_process_expr_stmt (tree expr)
6834 {
6835   if (!expr)
6836     return NULL_TREE;
6837
6838   /* Do default conversion if safe and possibly important,
6839      in case within ({...}).  */
6840   if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
6841        && (flag_isoc99 || lvalue_p (expr)))
6842       || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
6843     expr = default_conversion (expr);
6844
6845   if (warn_sequence_point)
6846     verify_sequence_points (expr);
6847
6848   if (TREE_TYPE (expr) != error_mark_node
6849       && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
6850       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
6851     error ("expression statement has incomplete type");
6852
6853   /* If we're not processing a statement expression, warn about unused values.
6854      Warnings for statement expressions will be emitted later, once we figure
6855      out which is the result.  */
6856   if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
6857       && (extra_warnings || warn_unused_value))
6858     emit_side_effect_warnings (expr);
6859
6860   /* If the expression is not of a type to which we cannot assign a line
6861      number, wrap the thing in a no-op NOP_EXPR.  */
6862   if (DECL_P (expr) || CONSTANT_CLASS_P (expr))
6863     expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr);
6864
6865   if (EXPR_P (expr))
6866     SET_EXPR_LOCATION (expr, input_location);
6867
6868   return expr;
6869 }
6870
6871 /* Emit an expression as a statement.  */
6872
6873 tree
6874 c_finish_expr_stmt (tree expr)
6875 {
6876   if (expr)
6877     return add_stmt (c_process_expr_stmt (expr));
6878   else
6879     return NULL;
6880 }
6881
6882 /* Do the opposite and emit a statement as an expression.  To begin,
6883    create a new binding level and return it.  */
6884
6885 tree
6886 c_begin_stmt_expr (void)
6887 {
6888   tree ret;
6889
6890   /* We must force a BLOCK for this level so that, if it is not expanded
6891      later, there is a way to turn off the entire subtree of blocks that
6892      are contained in it.  */
6893   keep_next_level ();
6894   ret = c_begin_compound_stmt (true);
6895
6896   /* Mark the current statement list as belonging to a statement list.  */
6897   STATEMENT_LIST_STMT_EXPR (ret) = 1;
6898
6899   return ret;
6900 }
6901
6902 tree
6903 c_finish_stmt_expr (tree body)
6904 {
6905   tree last, type, tmp, val;
6906   tree *last_p;
6907
6908   body = c_end_compound_stmt (body, true);
6909
6910   /* Locate the last statement in BODY.  See c_end_compound_stmt
6911      about always returning a BIND_EXPR.  */
6912   last_p = &BIND_EXPR_BODY (body);
6913   last = BIND_EXPR_BODY (body);
6914
6915  continue_searching:
6916   if (TREE_CODE (last) == STATEMENT_LIST)
6917     {
6918       tree_stmt_iterator i;
6919
6920       /* This can happen with degenerate cases like ({ }).  No value.  */
6921       if (!TREE_SIDE_EFFECTS (last))
6922         return body;
6923
6924       /* If we're supposed to generate side effects warnings, process
6925          all of the statements except the last.  */
6926       if (extra_warnings || warn_unused_value)
6927         {
6928           for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i))
6929             emit_side_effect_warnings (tsi_stmt (i));
6930         }
6931       else
6932         i = tsi_last (last);
6933       last_p = tsi_stmt_ptr (i);
6934       last = *last_p;
6935     }
6936
6937   /* If the end of the list is exception related, then the list was split
6938      by a call to push_cleanup.  Continue searching.  */
6939   if (TREE_CODE (last) == TRY_FINALLY_EXPR
6940       || TREE_CODE (last) == TRY_CATCH_EXPR)
6941     {
6942       last_p = &TREE_OPERAND (last, 0);
6943       last = *last_p;
6944       goto continue_searching;
6945     }
6946
6947   /* In the case that the BIND_EXPR is not necessary, return the
6948      expression out from inside it.  */
6949   if (last == error_mark_node
6950       || (last == BIND_EXPR_BODY (body)
6951           && BIND_EXPR_VARS (body) == NULL))
6952     return last;
6953
6954   /* Extract the type of said expression.  */
6955   type = TREE_TYPE (last);
6956
6957   /* If we're not returning a value at all, then the BIND_EXPR that
6958      we already have is a fine expression to return.  */
6959   if (!type || VOID_TYPE_P (type))
6960     return body;
6961
6962   /* Now that we've located the expression containing the value, it seems
6963      silly to make voidify_wrapper_expr repeat the process.  Create a
6964      temporary of the appropriate type and stick it in a TARGET_EXPR.  */
6965   tmp = create_tmp_var_raw (type, NULL);
6966
6967   /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt.  This avoids
6968      tree_expr_nonnegative_p giving up immediately.  */
6969   val = last;
6970   if (TREE_CODE (val) == NOP_EXPR
6971       && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
6972     val = TREE_OPERAND (val, 0);
6973
6974   *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val);
6975   SET_EXPR_LOCUS (*last_p, EXPR_LOCUS (last));
6976
6977   return build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE);
6978 }
6979 \f
6980 /* Begin and end compound statements.  This is as simple as pushing
6981    and popping new statement lists from the tree.  */
6982
6983 tree
6984 c_begin_compound_stmt (bool do_scope)
6985 {
6986   tree stmt = push_stmt_list ();
6987   if (do_scope)
6988     push_scope ();
6989   return stmt;
6990 }
6991
6992 tree
6993 c_end_compound_stmt (tree stmt, bool do_scope)
6994 {
6995   tree block = NULL;
6996
6997   if (do_scope)
6998     {
6999       if (c_dialect_objc ())
7000         objc_clear_super_receiver ();
7001       block = pop_scope ();
7002     }
7003
7004   stmt = pop_stmt_list (stmt);
7005   stmt = c_build_bind_expr (block, stmt);
7006
7007   /* If this compound statement is nested immediately inside a statement
7008      expression, then force a BIND_EXPR to be created.  Otherwise we'll
7009      do the wrong thing for ({ { 1; } }) or ({ 1; { } }).  In particular,
7010      STATEMENT_LISTs merge, and thus we can lose track of what statement
7011      was really last.  */
7012   if (cur_stmt_list
7013       && STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
7014       && TREE_CODE (stmt) != BIND_EXPR)
7015     {
7016       stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL);
7017       TREE_SIDE_EFFECTS (stmt) = 1;
7018     }
7019
7020   return stmt;
7021 }
7022
7023 /* Queue a cleanup.  CLEANUP is an expression/statement to be executed
7024    when the current scope is exited.  EH_ONLY is true when this is not
7025    meant to apply to normal control flow transfer.  */
7026
7027 void
7028 push_cleanup (tree ARG_UNUSED (decl), tree cleanup, bool eh_only)
7029 {
7030   enum tree_code code;
7031   tree stmt, list;
7032   bool stmt_expr;
7033
7034   code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR;
7035   stmt = build_stmt (code, NULL, cleanup);
7036   add_stmt (stmt);
7037   stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list);
7038   list = push_stmt_list ();
7039   TREE_OPERAND (stmt, 0) = list;
7040   STATEMENT_LIST_STMT_EXPR (list) = stmt_expr;
7041 }
7042 \f
7043 /* Build a binary-operation expression without default conversions.
7044    CODE is the kind of expression to build.
7045    This function differs from `build' in several ways:
7046    the data type of the result is computed and recorded in it,
7047    warnings are generated if arg data types are invalid,
7048    special handling for addition and subtraction of pointers is known,
7049    and some optimization is done (operations on narrow ints
7050    are done in the narrower type when that gives the same result).
7051    Constant folding is also done before the result is returned.
7052
7053    Note that the operands will never have enumeral types, or function
7054    or array types, because either they will have the default conversions
7055    performed or they have both just been converted to some other type in which
7056    the arithmetic is to be done.  */
7057
7058 tree
7059 build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
7060                  int convert_p)
7061 {
7062   tree type0, type1;
7063   enum tree_code code0, code1;
7064   tree op0, op1;
7065
7066   /* Expression code to give to the expression when it is built.
7067      Normally this is CODE, which is what the caller asked for,
7068      but in some special cases we change it.  */
7069   enum tree_code resultcode = code;
7070
7071   /* Data type in which the computation is to be performed.
7072      In the simplest cases this is the common type of the arguments.  */
7073   tree result_type = NULL;
7074
7075   /* Nonzero means operands have already been type-converted
7076      in whatever way is necessary.
7077      Zero means they need to be converted to RESULT_TYPE.  */
7078   int converted = 0;
7079
7080   /* Nonzero means create the expression with this type, rather than
7081      RESULT_TYPE.  */
7082   tree build_type = 0;
7083
7084   /* Nonzero means after finally constructing the expression
7085      convert it to this type.  */
7086   tree final_type = 0;
7087
7088   /* Nonzero if this is an operation like MIN or MAX which can
7089      safely be computed in short if both args are promoted shorts.
7090      Also implies COMMON.
7091      -1 indicates a bitwise operation; this makes a difference
7092      in the exact conditions for when it is safe to do the operation
7093      in a narrower mode.  */
7094   int shorten = 0;
7095
7096   /* Nonzero if this is a comparison operation;
7097      if both args are promoted shorts, compare the original shorts.
7098      Also implies COMMON.  */
7099   int short_compare = 0;
7100
7101   /* Nonzero if this is a right-shift operation, which can be computed on the
7102      original short and then promoted if the operand is a promoted short.  */
7103   int short_shift = 0;
7104
7105   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
7106   int common = 0;
7107
7108   if (convert_p)
7109     {
7110       op0 = default_conversion (orig_op0);
7111       op1 = default_conversion (orig_op1);
7112     }
7113   else
7114     {
7115       op0 = orig_op0;
7116       op1 = orig_op1;
7117     }
7118
7119   type0 = TREE_TYPE (op0);
7120   type1 = TREE_TYPE (op1);
7121
7122   /* The expression codes of the data types of the arguments tell us
7123      whether the arguments are integers, floating, pointers, etc.  */
7124   code0 = TREE_CODE (type0);
7125   code1 = TREE_CODE (type1);
7126
7127   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
7128   STRIP_TYPE_NOPS (op0);
7129   STRIP_TYPE_NOPS (op1);
7130
7131   /* If an error was already reported for one of the arguments,
7132      avoid reporting another error.  */
7133
7134   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
7135     return error_mark_node;
7136
7137   switch (code)
7138     {
7139     case PLUS_EXPR:
7140       /* Handle the pointer + int case.  */
7141       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7142         return pointer_int_sum (PLUS_EXPR, op0, op1);
7143       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
7144         return pointer_int_sum (PLUS_EXPR, op1, op0);
7145       else
7146         common = 1;
7147       break;
7148
7149     case MINUS_EXPR:
7150       /* Subtraction of two similar pointers.
7151          We must subtract them as integers, then divide by object size.  */
7152       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
7153           && comp_target_types (type0, type1, 1))
7154         return pointer_diff (op0, op1);
7155       /* Handle pointer minus int.  Just like pointer plus int.  */
7156       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7157         return pointer_int_sum (MINUS_EXPR, op0, op1);
7158       else
7159         common = 1;
7160       break;
7161
7162     case MULT_EXPR:
7163       common = 1;
7164       break;
7165
7166     case TRUNC_DIV_EXPR:
7167     case CEIL_DIV_EXPR:
7168     case FLOOR_DIV_EXPR:
7169     case ROUND_DIV_EXPR:
7170     case EXACT_DIV_EXPR:
7171       /* Floating point division by zero is a legitimate way to obtain
7172          infinities and NaNs.  */
7173       if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
7174         warning ("division by zero");
7175
7176       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
7177            || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
7178           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
7179               || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
7180         {
7181           if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
7182             code0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
7183           if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
7184             code1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
7185
7186           if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
7187             resultcode = RDIV_EXPR;
7188           else
7189             /* Although it would be tempting to shorten always here, that
7190                loses on some targets, since the modulo instruction is
7191                undefined if the quotient can't be represented in the
7192                computation mode.  We shorten only if unsigned or if
7193                dividing by something we know != -1.  */
7194             shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
7195                        || (TREE_CODE (op1) == INTEGER_CST
7196                            && !integer_all_onesp (op1)));
7197           common = 1;
7198         }
7199       break;
7200
7201     case BIT_AND_EXPR:
7202     case BIT_IOR_EXPR:
7203     case BIT_XOR_EXPR:
7204       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7205         shorten = -1;
7206       else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
7207         common = 1;
7208       break;
7209
7210     case TRUNC_MOD_EXPR:
7211     case FLOOR_MOD_EXPR:
7212       if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
7213         warning ("division by zero");
7214
7215       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7216         {
7217           /* Although it would be tempting to shorten always here, that loses
7218              on some targets, since the modulo instruction is undefined if the
7219              quotient can't be represented in the computation mode.  We shorten
7220              only if unsigned or if dividing by something we know != -1.  */
7221           shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
7222                      || (TREE_CODE (op1) == INTEGER_CST
7223                          && !integer_all_onesp (op1)));
7224           common = 1;
7225         }
7226       break;
7227
7228     case TRUTH_ANDIF_EXPR:
7229     case TRUTH_ORIF_EXPR:
7230     case TRUTH_AND_EXPR:
7231     case TRUTH_OR_EXPR:
7232     case TRUTH_XOR_EXPR:
7233       if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
7234            || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
7235           && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
7236               || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
7237         {
7238           /* Result of these operations is always an int,
7239              but that does not mean the operands should be
7240              converted to ints!  */
7241           result_type = integer_type_node;
7242           op0 = lang_hooks.truthvalue_conversion (op0);
7243           op1 = lang_hooks.truthvalue_conversion (op1);
7244           converted = 1;
7245         }
7246       break;
7247
7248       /* Shift operations: result has same type as first operand;
7249          always convert second operand to int.
7250          Also set SHORT_SHIFT if shifting rightward.  */
7251
7252     case RSHIFT_EXPR:
7253       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7254         {
7255           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
7256             {
7257               if (tree_int_cst_sgn (op1) < 0)
7258                 warning ("right shift count is negative");
7259               else
7260                 {
7261                   if (!integer_zerop (op1))
7262                     short_shift = 1;
7263
7264                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
7265                     warning ("right shift count >= width of type");
7266                 }
7267             }
7268
7269           /* Use the type of the value to be shifted.  */
7270           result_type = type0;
7271           /* Convert the shift-count to an integer, regardless of size
7272              of value being shifted.  */
7273           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
7274             op1 = convert (integer_type_node, op1);
7275           /* Avoid converting op1 to result_type later.  */
7276           converted = 1;
7277         }
7278       break;
7279
7280     case LSHIFT_EXPR:
7281       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7282         {
7283           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
7284             {
7285               if (tree_int_cst_sgn (op1) < 0)
7286                 warning ("left shift count is negative");
7287
7288               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
7289                 warning ("left shift count >= width of type");
7290             }
7291
7292           /* Use the type of the value to be shifted.  */
7293           result_type = type0;
7294           /* Convert the shift-count to an integer, regardless of size
7295              of value being shifted.  */
7296           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
7297             op1 = convert (integer_type_node, op1);
7298           /* Avoid converting op1 to result_type later.  */
7299           converted = 1;
7300         }
7301       break;
7302
7303     case RROTATE_EXPR:
7304     case LROTATE_EXPR:
7305       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7306         {
7307           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
7308             {
7309               if (tree_int_cst_sgn (op1) < 0)
7310                 warning ("shift count is negative");
7311               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
7312                 warning ("shift count >= width of type");
7313             }
7314
7315           /* Use the type of the value to be shifted.  */
7316           result_type = type0;
7317           /* Convert the shift-count to an integer, regardless of size
7318              of value being shifted.  */
7319           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
7320             op1 = convert (integer_type_node, op1);
7321           /* Avoid converting op1 to result_type later.  */
7322           converted = 1;
7323         }
7324       break;
7325
7326     case EQ_EXPR:
7327     case NE_EXPR:
7328       if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
7329         warning ("comparing floating point with == or != is unsafe");
7330       /* Result of comparison is always int,
7331          but don't convert the args to int!  */
7332       build_type = integer_type_node;
7333       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
7334            || code0 == COMPLEX_TYPE)
7335           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
7336               || code1 == COMPLEX_TYPE))
7337         short_compare = 1;
7338       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
7339         {
7340           tree tt0 = TREE_TYPE (type0);
7341           tree tt1 = TREE_TYPE (type1);
7342           /* Anything compares with void *.  void * compares with anything.
7343              Otherwise, the targets must be compatible
7344              and both must be object or both incomplete.  */
7345           if (comp_target_types (type0, type1, 1))
7346             result_type = common_pointer_type (type0, type1);
7347           else if (VOID_TYPE_P (tt0))
7348             {
7349               /* op0 != orig_op0 detects the case of something
7350                  whose value is 0 but which isn't a valid null ptr const.  */
7351               if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
7352                   && TREE_CODE (tt1) == FUNCTION_TYPE)
7353                 pedwarn ("ISO C forbids comparison of %<void *%>"
7354                          " with function pointer");
7355             }
7356           else if (VOID_TYPE_P (tt1))
7357             {
7358               if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
7359                   && TREE_CODE (tt0) == FUNCTION_TYPE)
7360                 pedwarn ("ISO C forbids comparison of %<void *%>"
7361                          " with function pointer");
7362             }
7363           else
7364             pedwarn ("comparison of distinct pointer types lacks a cast");
7365
7366           if (result_type == NULL_TREE)
7367             result_type = ptr_type_node;
7368         }
7369       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
7370                && integer_zerop (op1))
7371         result_type = type0;
7372       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
7373                && integer_zerop (op0))
7374         result_type = type1;
7375       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7376         {
7377           result_type = type0;
7378           pedwarn ("comparison between pointer and integer");
7379         }
7380       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
7381         {
7382           result_type = type1;
7383           pedwarn ("comparison between pointer and integer");
7384         }
7385       break;
7386
7387     case MAX_EXPR:
7388     case MIN_EXPR:
7389       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
7390           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
7391         shorten = 1;
7392       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
7393         {
7394           if (comp_target_types (type0, type1, 1))
7395             {
7396               result_type = common_pointer_type (type0, type1);
7397               if (pedantic
7398                   && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
7399                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
7400             }
7401           else
7402             {
7403               result_type = ptr_type_node;
7404               pedwarn ("comparison of distinct pointer types lacks a cast");
7405             }
7406         }
7407       break;
7408
7409     case LE_EXPR:
7410     case GE_EXPR:
7411     case LT_EXPR:
7412     case GT_EXPR:
7413       build_type = integer_type_node;
7414       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
7415           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
7416         short_compare = 1;
7417       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
7418         {
7419           if (comp_target_types (type0, type1, 1))
7420             {
7421               result_type = common_pointer_type (type0, type1);
7422               if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
7423                   != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
7424                 pedwarn ("comparison of complete and incomplete pointers");
7425               else if (pedantic
7426                        && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
7427                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
7428             }
7429           else
7430             {
7431               result_type = ptr_type_node;
7432               pedwarn ("comparison of distinct pointer types lacks a cast");
7433             }
7434         }
7435       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
7436                && integer_zerop (op1))
7437         {
7438           result_type = type0;
7439           if (pedantic || extra_warnings)
7440             pedwarn ("ordered comparison of pointer with integer zero");
7441         }
7442       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
7443                && integer_zerop (op0))
7444         {
7445           result_type = type1;
7446           if (pedantic)
7447             pedwarn ("ordered comparison of pointer with integer zero");
7448         }
7449       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7450         {
7451           result_type = type0;
7452           pedwarn ("comparison between pointer and integer");
7453         }
7454       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
7455         {
7456           result_type = type1;
7457           pedwarn ("comparison between pointer and integer");
7458         }
7459       break;
7460
7461     case UNORDERED_EXPR:
7462     case ORDERED_EXPR:
7463     case UNLT_EXPR:
7464     case UNLE_EXPR:
7465     case UNGT_EXPR:
7466     case UNGE_EXPR:
7467     case UNEQ_EXPR:
7468     case LTGT_EXPR:
7469       build_type = integer_type_node;
7470       if (code0 != REAL_TYPE || code1 != REAL_TYPE)
7471         {
7472           error ("unordered comparison on non-floating point argument");
7473           return error_mark_node;
7474         }
7475       common = 1;
7476       break;
7477
7478     default:
7479       break;
7480     }
7481
7482   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
7483     return error_mark_node;
7484
7485   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
7486        || code0 == VECTOR_TYPE)
7487       &&
7488       (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
7489        || code1 == VECTOR_TYPE))
7490     {
7491       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
7492
7493       if (shorten || common || short_compare)
7494         result_type = common_type (type0, type1);
7495
7496       /* For certain operations (which identify themselves by shorten != 0)
7497          if both args were extended from the same smaller type,
7498          do the arithmetic in that type and then extend.
7499
7500          shorten !=0 and !=1 indicates a bitwise operation.
7501          For them, this optimization is safe only if
7502          both args are zero-extended or both are sign-extended.
7503          Otherwise, we might change the result.
7504          Eg, (short)-1 | (unsigned short)-1 is (int)-1
7505          but calculated in (unsigned short) it would be (unsigned short)-1.  */
7506
7507       if (shorten && none_complex)
7508         {
7509           int unsigned0, unsigned1;
7510           tree arg0 = get_narrower (op0, &unsigned0);
7511           tree arg1 = get_narrower (op1, &unsigned1);
7512           /* UNS is 1 if the operation to be done is an unsigned one.  */
7513           int uns = TYPE_UNSIGNED (result_type);
7514           tree type;
7515
7516           final_type = result_type;
7517
7518           /* Handle the case that OP0 (or OP1) does not *contain* a conversion
7519              but it *requires* conversion to FINAL_TYPE.  */
7520
7521           if ((TYPE_PRECISION (TREE_TYPE (op0))
7522                == TYPE_PRECISION (TREE_TYPE (arg0)))
7523               && TREE_TYPE (op0) != final_type)
7524             unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
7525           if ((TYPE_PRECISION (TREE_TYPE (op1))
7526                == TYPE_PRECISION (TREE_TYPE (arg1)))
7527               && TREE_TYPE (op1) != final_type)
7528             unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
7529
7530           /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
7531
7532           /* For bitwise operations, signedness of nominal type
7533              does not matter.  Consider only how operands were extended.  */
7534           if (shorten == -1)
7535             uns = unsigned0;
7536
7537           /* Note that in all three cases below we refrain from optimizing
7538              an unsigned operation on sign-extended args.
7539              That would not be valid.  */
7540
7541           /* Both args variable: if both extended in same way
7542              from same width, do it in that width.
7543              Do it unsigned if args were zero-extended.  */
7544           if ((TYPE_PRECISION (TREE_TYPE (arg0))
7545                < TYPE_PRECISION (result_type))
7546               && (TYPE_PRECISION (TREE_TYPE (arg1))
7547                   == TYPE_PRECISION (TREE_TYPE (arg0)))
7548               && unsigned0 == unsigned1
7549               && (unsigned0 || !uns))
7550             result_type
7551               = c_common_signed_or_unsigned_type
7552               (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
7553           else if (TREE_CODE (arg0) == INTEGER_CST
7554                    && (unsigned1 || !uns)
7555                    && (TYPE_PRECISION (TREE_TYPE (arg1))
7556                        < TYPE_PRECISION (result_type))
7557                    && (type
7558                        = c_common_signed_or_unsigned_type (unsigned1,
7559                                                            TREE_TYPE (arg1)),
7560                        int_fits_type_p (arg0, type)))
7561             result_type = type;
7562           else if (TREE_CODE (arg1) == INTEGER_CST
7563                    && (unsigned0 || !uns)
7564                    && (TYPE_PRECISION (TREE_TYPE (arg0))
7565                        < TYPE_PRECISION (result_type))
7566                    && (type
7567                        = c_common_signed_or_unsigned_type (unsigned0,
7568                                                            TREE_TYPE (arg0)),
7569                        int_fits_type_p (arg1, type)))
7570             result_type = type;
7571         }
7572
7573       /* Shifts can be shortened if shifting right.  */
7574
7575       if (short_shift)
7576         {
7577           int unsigned_arg;
7578           tree arg0 = get_narrower (op0, &unsigned_arg);
7579
7580           final_type = result_type;
7581
7582           if (arg0 == op0 && final_type == TREE_TYPE (op0))
7583             unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
7584
7585           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
7586               /* We can shorten only if the shift count is less than the
7587                  number of bits in the smaller type size.  */
7588               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
7589               /* We cannot drop an unsigned shift after sign-extension.  */
7590               && (!TYPE_UNSIGNED (final_type) || unsigned_arg))
7591             {
7592               /* Do an unsigned shift if the operand was zero-extended.  */
7593               result_type
7594                 = c_common_signed_or_unsigned_type (unsigned_arg,
7595                                                     TREE_TYPE (arg0));
7596               /* Convert value-to-be-shifted to that type.  */
7597               if (TREE_TYPE (op0) != result_type)
7598                 op0 = convert (result_type, op0);
7599               converted = 1;
7600             }
7601         }
7602
7603       /* Comparison operations are shortened too but differently.
7604          They identify themselves by setting short_compare = 1.  */
7605
7606       if (short_compare)
7607         {
7608           /* Don't write &op0, etc., because that would prevent op0
7609              from being kept in a register.
7610              Instead, make copies of the our local variables and
7611              pass the copies by reference, then copy them back afterward.  */
7612           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
7613           enum tree_code xresultcode = resultcode;
7614           tree val
7615             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
7616
7617           if (val != 0)
7618             return val;
7619
7620           op0 = xop0, op1 = xop1;
7621           converted = 1;
7622           resultcode = xresultcode;
7623
7624           if (warn_sign_compare && skip_evaluation == 0)
7625             {
7626               int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
7627               int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
7628               int unsignedp0, unsignedp1;
7629               tree primop0 = get_narrower (op0, &unsignedp0);
7630               tree primop1 = get_narrower (op1, &unsignedp1);
7631
7632               xop0 = orig_op0;
7633               xop1 = orig_op1;
7634               STRIP_TYPE_NOPS (xop0);
7635               STRIP_TYPE_NOPS (xop1);
7636
7637               /* Give warnings for comparisons between signed and unsigned
7638                  quantities that may fail.
7639
7640                  Do the checking based on the original operand trees, so that
7641                  casts will be considered, but default promotions won't be.
7642
7643                  Do not warn if the comparison is being done in a signed type,
7644                  since the signed type will only be chosen if it can represent
7645                  all the values of the unsigned type.  */
7646               if (!TYPE_UNSIGNED (result_type))
7647                 /* OK */;
7648               /* Do not warn if both operands are the same signedness.  */
7649               else if (op0_signed == op1_signed)
7650                 /* OK */;
7651               else
7652                 {
7653                   tree sop, uop;
7654
7655                   if (op0_signed)
7656                     sop = xop0, uop = xop1;
7657                   else
7658                     sop = xop1, uop = xop0;
7659
7660                   /* Do not warn if the signed quantity is an
7661                      unsuffixed integer literal (or some static
7662                      constant expression involving such literals or a
7663                      conditional expression involving such literals)
7664                      and it is non-negative.  */
7665                   if (tree_expr_nonnegative_p (sop))
7666                     /* OK */;
7667                   /* Do not warn if the comparison is an equality operation,
7668                      the unsigned quantity is an integral constant, and it
7669                      would fit in the result if the result were signed.  */
7670                   else if (TREE_CODE (uop) == INTEGER_CST
7671                            && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
7672                            && int_fits_type_p
7673                            (uop, c_common_signed_type (result_type)))
7674                     /* OK */;
7675                   /* Do not warn if the unsigned quantity is an enumeration
7676                      constant and its maximum value would fit in the result
7677                      if the result were signed.  */
7678                   else if (TREE_CODE (uop) == INTEGER_CST
7679                            && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
7680                            && int_fits_type_p
7681                            (TYPE_MAX_VALUE (TREE_TYPE (uop)),
7682                             c_common_signed_type (result_type)))
7683                     /* OK */;
7684                   else
7685                     warning ("comparison between signed and unsigned");
7686                 }
7687
7688               /* Warn if two unsigned values are being compared in a size
7689                  larger than their original size, and one (and only one) is the
7690                  result of a `~' operator.  This comparison will always fail.
7691
7692                  Also warn if one operand is a constant, and the constant
7693                  does not have all bits set that are set in the ~ operand
7694                  when it is extended.  */
7695
7696               if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
7697                   != (TREE_CODE (primop1) == BIT_NOT_EXPR))
7698                 {
7699                   if (TREE_CODE (primop0) == BIT_NOT_EXPR)
7700                     primop0 = get_narrower (TREE_OPERAND (primop0, 0),
7701                                             &unsignedp0);
7702                   else
7703                     primop1 = get_narrower (TREE_OPERAND (primop1, 0),
7704                                             &unsignedp1);
7705
7706                   if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
7707                     {
7708                       tree primop;
7709                       HOST_WIDE_INT constant, mask;
7710                       int unsignedp, bits;
7711
7712                       if (host_integerp (primop0, 0))
7713                         {
7714                           primop = primop1;
7715                           unsignedp = unsignedp1;
7716                           constant = tree_low_cst (primop0, 0);
7717                         }
7718                       else
7719                         {
7720                           primop = primop0;
7721                           unsignedp = unsignedp0;
7722                           constant = tree_low_cst (primop1, 0);
7723                         }
7724
7725                       bits = TYPE_PRECISION (TREE_TYPE (primop));
7726                       if (bits < TYPE_PRECISION (result_type)
7727                           && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
7728                         {
7729                           mask = (~(HOST_WIDE_INT) 0) << bits;
7730                           if ((mask & constant) != mask)
7731                             warning ("comparison of promoted ~unsigned with constant");
7732                         }
7733                     }
7734                   else if (unsignedp0 && unsignedp1
7735                            && (TYPE_PRECISION (TREE_TYPE (primop0))
7736                                < TYPE_PRECISION (result_type))
7737                            && (TYPE_PRECISION (TREE_TYPE (primop1))
7738                                < TYPE_PRECISION (result_type)))
7739                     warning ("comparison of promoted ~unsigned with unsigned");
7740                 }
7741             }
7742         }
7743     }
7744
7745   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
7746      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
7747      Then the expression will be built.
7748      It will be given type FINAL_TYPE if that is nonzero;
7749      otherwise, it will be given type RESULT_TYPE.  */
7750
7751   if (!result_type)
7752     {
7753       binary_op_error (code);
7754       return error_mark_node;
7755     }
7756
7757   if (!converted)
7758     {
7759       if (TREE_TYPE (op0) != result_type)
7760         op0 = convert (result_type, op0);
7761       if (TREE_TYPE (op1) != result_type)
7762         op1 = convert (result_type, op1);
7763
7764       /* This can happen if one operand has a vector type, and the other
7765          has a different type.  */
7766       if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
7767         return error_mark_node;
7768     }
7769
7770   if (build_type == NULL_TREE)
7771     build_type = result_type;
7772
7773   {
7774     tree result = build2 (resultcode, build_type, op0, op1);
7775
7776     /* Treat expressions in initializers specially as they can't trap.  */
7777     result = require_constant_value ? fold_initializer (result)
7778                                     : fold (result);
7779
7780     if (final_type != 0)
7781       result = convert (final_type, result);
7782     return result;
7783   }
7784 }