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