gcc/c-typeck.c

   1 /* Build expressions with type checking for C compiler.
   2    Copyright (C) 1987, 88, 91, 92, 93, 94, 1995 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20
  21 /* This file is part of the C front end.
  22    It contains routines to build C expressions given their operands,
  23    including computing the types of the result, C-specific error checks,
  24    and some optimization.
  25
  26    There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
  27    and to process initializations in declarations (since they work
  28    like a strange sort of assignment).  */
  29
  30 #include "config.h"
  31 #include <stdio.h>
  32 #include "tree.h"
  33 #include "c-tree.h"
  34 #include "flags.h"
  35 #include "output.h"
  36
  37 /* Nonzero if we've already printed a "missing braces around initializer"
  38    message within this initializer.  */
  39 static int missing_braces_mentioned;
  40
  41 extern char *index ();
  42 extern char *rindex ();
  43
  44 static tree quality_type                PROTO((tree, tree));
  45 static int comp_target_types            PROTO((tree, tree));
  46 static int function_types_compatible_p  PROTO((tree, tree));
  47 static int type_lists_compatible_p      PROTO((tree, tree));
  48 static int self_promoting_type_p        PROTO((tree));
  49 static tree decl_constant_value         PROTO((tree));
  50 static tree lookup_field                PROTO((tree, tree, tree *));
  51 static tree convert_arguments           PROTO((tree, tree, tree, tree));
  52 static tree pointer_int_sum             PROTO((enum tree_code, tree, tree));
  53 static tree pointer_diff                PROTO((tree, tree));
  54 static tree unary_complex_lvalue        PROTO((enum tree_code, tree));
  55 static void pedantic_lvalue_warning     PROTO((enum tree_code));
  56 static tree internal_build_compound_expr PROTO((tree, int));
  57 static tree convert_for_assignment      PROTO((tree, tree, char *, tree,
  58                                                tree, int));
  59 static void warn_for_assignment         PROTO((char *, char *, tree, int));
  60 static tree valid_compound_expr_initializer PROTO((tree, tree));
  61 static void push_string                 PROTO((char *));
  62 static void push_member_name            PROTO((tree));
  63 static void push_array_bounds           PROTO((int));
  64 static int spelling_length              PROTO((void));
  65 static char *print_spelling             PROTO((char *));
  66 static char *get_spelling               PROTO((char *));
  67 static void warning_init                PROTO((char *, char *,
  68                                                char *));
  69 static tree digest_init                 PROTO((tree, tree, int, int));
  70 static void check_init_type_bitfields   PROTO((tree));
  71 static void output_init_element         PROTO((tree, tree, tree, int));
  72 static void output_pending_init_elements PROTO((int));
  73 \f
  74 /* Do `exp = require_complete_type (exp);' to make sure exp
  75    does not have an incomplete type.  (That includes void types.)  */
  76
  77 tree
  78 require_complete_type (value)
  79      tree value;
  80 {
  81   tree type = TREE_TYPE (value);
  82
  83   /* First, detect a valid value with a complete type.  */
  84   if (TYPE_SIZE (type) != 0
  85       && type != void_type_node)
  86     return value;
  87
  88   incomplete_type_error (value, type);
  89   return error_mark_node;
  90 }
  91
  92 /* Print an error message for invalid use of an incomplete type.
  93    VALUE is the expression that was used (or 0 if that isn't known)
  94    and TYPE is the type that was invalid.  */
  95
  96 void
  97 incomplete_type_error (value, type)
  98      tree value;
  99      tree type;
 100 {
 101   char *errmsg;
 102
 103   /* Avoid duplicate error message.  */
 104   if (TREE_CODE (type) == ERROR_MARK)
 105     return;
 106
 107   if (value != 0 && (TREE_CODE (value) == VAR_DECL
 108                      || TREE_CODE (value) == PARM_DECL))
 109     error ("`%s' has an incomplete type",
 110            IDENTIFIER_POINTER (DECL_NAME (value)));
 111   else
 112     {
 113     retry:
 114       /* We must print an error message.  Be clever about what it says.  */
 115
 116       switch (TREE_CODE (type))
 117         {
 118         case RECORD_TYPE:
 119           errmsg = "invalid use of undefined type `struct %s'";
 120           break;
 121
 122         case UNION_TYPE:
 123           errmsg = "invalid use of undefined type `union %s'";
 124           break;
 125
 126         case ENUMERAL_TYPE:
 127           errmsg = "invalid use of undefined type `enum %s'";
 128           break;
 129
 130         case VOID_TYPE:
 131           error ("invalid use of void expression");
 132           return;
 133
 134         case ARRAY_TYPE:
 135           if (TYPE_DOMAIN (type))
 136             {
 137               type = TREE_TYPE (type);
 138               goto retry;
 139             }
 140           error ("invalid use of array with unspecified bounds");
 141           return;
 142
 143         default:
 144           abort ();
 145         }
 146
 147       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
 148         error (errmsg, IDENTIFIER_POINTER (TYPE_NAME (type)));
 149       else
 150         /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL.  */
 151         error ("invalid use of incomplete typedef `%s'",
 152                IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
 153     }
 154 }
 155
 156 /* Return a variant of TYPE which has all the type qualifiers of LIKE
 157    as well as those of TYPE.  */
 158
 159 static tree
 160 qualify_type (type, like)
 161      tree type, like;
 162 {
 163   int constflag = TYPE_READONLY (type) || TYPE_READONLY (like);
 164   int volflag = TYPE_VOLATILE (type) || TYPE_VOLATILE (like);
 165   return c_build_type_variant (type, constflag, volflag);
 166 }
 167 \f
 168 /* Return the common type of two types.
 169    We assume that comptypes has already been done and returned 1;
 170    if that isn't so, this may crash.  In particular, we assume that qualifiers
 171    match.
 172
 173    This is the type for the result of most arithmetic operations
 174    if the operands have the given two types.  */
 175
 176 tree
 177 common_type (t1, t2)
 178      tree t1, t2;
 179 {
 180   register enum tree_code code1;
 181   register enum tree_code code2;
 182   tree attributes;
 183
 184   /* Save time if the two types are the same.  */
 185
 186   if (t1 == t2) return t1;
 187
 188   /* If one type is nonsense, use the other.  */
 189   if (t1 == error_mark_node)
 190     return t2;
 191   if (t2 == error_mark_node)
 192     return t1;
 193
 194   /* Merge the attributes */
 195
 196   { register tree a1, a2;
 197     a1 = TYPE_ATTRIBUTES (t1);
 198     a2 = TYPE_ATTRIBUTES (t2);
 199
 200     /* Either one unset?  Take the set one.  */
 201
 202     if (!(attributes = a1))
 203        attributes = a2;
 204
 205     /* One that completely contains the other?  Take it.  */
 206
 207     else if (a2 && !attribute_list_contained (a1, a2))
 208        if (attribute_list_contained (a2, a1))
 209           attributes = a2;
 210        else
 211         {
 212           /* Pick the longest list, and hang on the other
 213              list.  */
 214
 215           if (list_length (a1) < list_length (a2))
 216              attributes = a2, a2 = a1;
 217
 218           for (; a2; a2 = TREE_CHAIN (a2))
 219              if (!value_member (attributes, a2))
 220               {
 221                 a1 = copy_node (a2);
 222                 TREE_CHAIN (a1) = attributes;
 223                 attributes = a1;
 224               }
 225         }
 226   }
 227
 228   /* Treat an enum type as the unsigned integer type of the same width.  */
 229
 230   if (TREE_CODE (t1) == ENUMERAL_TYPE)
 231     t1 = type_for_size (TYPE_PRECISION (t1), 1);
 232   if (TREE_CODE (t2) == ENUMERAL_TYPE)
 233     t2 = type_for_size (TYPE_PRECISION (t2), 1);
 234
 235   code1 = TREE_CODE (t1);
 236   code2 = TREE_CODE (t2);
 237
 238   /* If one type is complex, form the common type of the non-complex
 239      components, then make that complex.  Use T1 or T2 if it is the
 240      required type.  */
 241   if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
 242     {
 243       tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
 244       tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
 245       tree subtype = common_type (subtype1, subtype2);
 246
 247       if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
 248         return build_type_attribute_variant (t1, attributes);
 249       else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
 250         return build_type_attribute_variant (t2, attributes);
 251       else
 252         return build_type_attribute_variant (build_complex_type (subtype),
 253                                              attributes);
 254     }
 255
 256   switch (code1)
 257     {
 258     case INTEGER_TYPE:
 259     case REAL_TYPE:
 260       /* If only one is real, use it as the result.  */
 261
 262       if (code1 == REAL_TYPE && code2 != REAL_TYPE)
 263         return build_type_attribute_variant (t1, attributes);
 264
 265       if (code2 == REAL_TYPE && code1 != REAL_TYPE)
 266         return build_type_attribute_variant (t2, attributes);
 267
 268       /* Both real or both integers; use the one with greater precision.  */
 269
 270       if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
 271         return build_type_attribute_variant (t1, attributes);
 272       else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
 273         return build_type_attribute_variant (t2, attributes);
 274
 275       /* Same precision.  Prefer longs to ints even when same size.  */
 276
 277       if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
 278           || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
 279         return build_type_attribute_variant (long_unsigned_type_node,
 280                                              attributes);
 281
 282       if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
 283           || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
 284         {
 285           /* But preserve unsignedness from the other type,
 286              since long cannot hold all the values of an unsigned int.  */
 287           if (TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
 288              t1 = long_unsigned_type_node;
 289           else
 290              t1 = long_integer_type_node;
 291           return build_type_attribute_variant (t1, attributes);
 292         }
 293
 294       /* Otherwise prefer the unsigned one.  */
 295
 296       if (TREE_UNSIGNED (t1))
 297         return build_type_attribute_variant (t1, attributes);
 298       else
 299         return build_type_attribute_variant (t2, attributes);
 300
 301     case POINTER_TYPE:
 302       /* For two pointers, do this recursively on the target type,
 303          and combine the qualifiers of the two types' targets.  */
 304       /* This code was turned off; I don't know why.
 305          But ANSI C specifies doing this with the qualifiers.
 306          So I turned it on again.  */
 307       {
 308         tree target = common_type (TYPE_MAIN_VARIANT (TREE_TYPE (t1)),
 309                                    TYPE_MAIN_VARIANT (TREE_TYPE (t2)));
 310         int constp
 311           = TYPE_READONLY (TREE_TYPE (t1)) || TYPE_READONLY (TREE_TYPE (t2));
 312         int volatilep
 313           = TYPE_VOLATILE (TREE_TYPE (t1)) || TYPE_VOLATILE (TREE_TYPE (t2));
 314         t1 = build_pointer_type (c_build_type_variant (target, constp,
 315                                  volatilep));
 316         return build_type_attribute_variant (t1, attributes);
 317       }
 318 #if 0
 319       t1 = build_pointer_type (common_type (TREE_TYPE (t1), TREE_TYPE (t2)));
 320       return build_type_attribute_variant (t1, attributes);
 321 #endif
 322
 323     case ARRAY_TYPE:
 324       {
 325         tree elt = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
 326         /* Save space: see if the result is identical to one of the args.  */
 327         if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
 328           return build_type_attribute_variant (t1, attributes);
 329         if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
 330           return build_type_attribute_variant (t2, attributes);
 331         /* Merge the element types, and have a size if either arg has one.  */
 332         t1 = build_array_type (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
 333         return build_type_attribute_variant (t1, attributes);
 334       }
 335
 336     case FUNCTION_TYPE:
 337       /* Function types: prefer the one that specified arg types.
 338          If both do, merge the arg types.  Also merge the return types.  */
 339       {
 340         tree valtype = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
 341         tree p1 = TYPE_ARG_TYPES (t1);
 342         tree p2 = TYPE_ARG_TYPES (t2);
 343         int len;
 344         tree newargs, n;
 345         int i;
 346
 347         /* Save space: see if the result is identical to one of the args.  */
 348         if (valtype == TREE_TYPE (t1) && ! TYPE_ARG_TYPES (t2))
 349           return build_type_attribute_variant (t1, attributes);
 350         if (valtype == TREE_TYPE (t2) && ! TYPE_ARG_TYPES (t1))
 351           return build_type_attribute_variant (t2, attributes);
 352
 353         /* Simple way if one arg fails to specify argument types.  */
 354         if (TYPE_ARG_TYPES (t1) == 0)
 355          {
 356            t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
 357            return build_type_attribute_variant (t1, attributes);
 358          }
 359         if (TYPE_ARG_TYPES (t2) == 0)
 360          {
 361            t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
 362            return build_type_attribute_variant (t1, attributes);
 363          }
 364
 365         /* If both args specify argument types, we must merge the two
 366            lists, argument by argument.  */
 367
 368         len = list_length (p1);
 369         newargs = 0;
 370
 371         for (i = 0; i < len; i++)
 372           newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
 373
 374         n = newargs;
 375
 376         for (; p1;
 377              p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
 378           {
 379             /* A null type means arg type is not specified.
 380                Take whatever the other function type has.  */
 381             if (TREE_VALUE (p1) == 0)
 382               {
 383                 TREE_VALUE (n) = TREE_VALUE (p2);
 384                 goto parm_done;
 385               }
 386             if (TREE_VALUE (p2) == 0)
 387               {
 388                 TREE_VALUE (n) = TREE_VALUE (p1);
 389                 goto parm_done;
 390               }
 391
 392             /* Given  wait (union {union wait *u; int *i} *)
 393                and  wait (union wait *),
 394                prefer  union wait *  as type of parm.  */
 395             if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
 396                 && TREE_VALUE (p1) != TREE_VALUE (p2))
 397               {
 398                 tree memb;
 399                 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
 400                      memb; memb = TREE_CHAIN (memb))
 401                   if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2)))
 402                     {
 403                       TREE_VALUE (n) = TREE_VALUE (p2);
 404                       if (pedantic)
 405                         pedwarn ("function types not truly compatible in ANSI C");
 406                       goto parm_done;
 407                     }
 408               }
 409             if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
 410                 && TREE_VALUE (p2) != TREE_VALUE (p1))
 411               {
 412                 tree memb;
 413                 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
 414                      memb; memb = TREE_CHAIN (memb))
 415                   if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1)))
 416                     {
 417                       TREE_VALUE (n) = TREE_VALUE (p1);
 418                       if (pedantic)
 419                         pedwarn ("function types not truly compatible in ANSI C");
 420                       goto parm_done;
 421                     }
 422               }
 423             TREE_VALUE (n) = common_type (TREE_VALUE (p1), TREE_VALUE (p2));
 424           parm_done: ;
 425           }
 426
 427         t1 = build_function_type (valtype, newargs);
 428         /* ... falls through ... */
 429       }
 430
 431     default:
 432       return build_type_attribute_variant (t1, attributes);
 433     }
 434
 435 }
 436 \f
 437 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
 438    or various other operations.  Return 2 if they are compatible
 439    but a warning may be needed if you use them together.  */
 440
 441 int
 442 comptypes (type1, type2)
 443      tree type1, type2;
 444 {
 445   register tree t1 = type1;
 446   register tree t2 = type2;
 447   int attrval, val;
 448
 449   /* Suppress errors caused by previously reported errors.  */
 450
 451   if (t1 == t2 || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
 452     return 1;
 453
 454   /* Treat an enum type as the integer type of the same width and
 455      signedness.  */
 456
 457   if (TREE_CODE (t1) == ENUMERAL_TYPE)
 458     t1 = type_for_size (TYPE_PRECISION (t1), TREE_UNSIGNED (t1));
 459   if (TREE_CODE (t2) == ENUMERAL_TYPE)
 460     t2 = type_for_size (TYPE_PRECISION (t2), TREE_UNSIGNED (t2));
 461
 462   if (t1 == t2)
 463     return 1;
 464
 465   /* Different classes of types can't be compatible.  */
 466
 467   if (TREE_CODE (t1) != TREE_CODE (t2)) return 0;
 468
 469   /* Qualifiers must match.  */
 470
 471   if (TYPE_READONLY (t1) != TYPE_READONLY (t2))
 472     return 0;
 473   if (TYPE_VOLATILE (t1) != TYPE_VOLATILE (t2))
 474     return 0;
 475
 476   /* Allow for two different type nodes which have essentially the same
 477      definition.  Note that we already checked for equality of the type
 478      type qualifiers (just above).  */
 479
 480   if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
 481     return 1;
 482
 483 #ifndef COMP_TYPE_ATTRIBUTES
 484 #define COMP_TYPE_ATTRIBUTES(t1,t2)     1
 485 #endif
 486
 487   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 488   if (! (attrval = COMP_TYPE_ATTRIBUTES (t1, t2)))
 489      return 0;
 490
 491   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 492   val = 0;
 493
 494   switch (TREE_CODE (t1))
 495     {
 496     case POINTER_TYPE:
 497       val = (TREE_TYPE (t1) == TREE_TYPE (t2)
 498               ? 1 : comptypes (TREE_TYPE (t1), TREE_TYPE (t2)));
 499       break;
 500
 501     case FUNCTION_TYPE:
 502       val = function_types_compatible_p (t1, t2);
 503       break;
 504
 505     case ARRAY_TYPE:
 506       {
 507         tree d1 = TYPE_DOMAIN (t1);
 508         tree d2 = TYPE_DOMAIN (t2);
 509         val = 1;
 510
 511         /* Target types must match incl. qualifiers.  */
 512         if (TREE_TYPE (t1) != TREE_TYPE (t2)
 513             && 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2))))
 514           return 0;
 515
 516         /* Sizes must match unless one is missing or variable.  */
 517         if (d1 == 0 || d2 == 0 || d1 == d2
 518             || TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
 519             || TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
 520             || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST
 521             || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST)
 522           break;
 523
 524         if (! ((TREE_INT_CST_LOW (TYPE_MIN_VALUE (d1))
 525                   == TREE_INT_CST_LOW (TYPE_MIN_VALUE (d2)))
 526                  && (TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d1))
 527                      == TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d2)))
 528                  && (TREE_INT_CST_LOW (TYPE_MAX_VALUE (d1))
 529                      == TREE_INT_CST_LOW (TYPE_MAX_VALUE (d2)))
 530                  && (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d1))
 531                      == TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d2)))))
 532            val = 0;
 533         break;
 534       }
 535
 536     case RECORD_TYPE:
 537       if (maybe_objc_comptypes (t1, t2, 0) == 1)
 538         val = 1;
 539       break;
 540     }
 541   return attrval == 2 && val == 1 ? 2 : val;
 542 }
 543
 544 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
 545    ignoring their qualifiers.  */
 546
 547 static int
 548 comp_target_types (ttl, ttr)
 549      tree ttl, ttr;
 550 {
 551   int val;
 552
 553   /* Give maybe_objc_comptypes a crack at letting these types through.  */
 554   if (val = maybe_objc_comptypes (ttl, ttr, 1) >= 0)
 555     return val;
 556
 557   val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)),
 558                    TYPE_MAIN_VARIANT (TREE_TYPE (ttr)));
 559
 560   if (val == 2 && pedantic)
 561     pedwarn ("types are not quite compatible");
 562   return val;
 563 }
 564 \f
 565 /* Subroutines of `comptypes'.  */
 566
 567 /* Return 1 if two function types F1 and F2 are compatible.
 568    If either type specifies no argument types,
 569    the other must specify a fixed number of self-promoting arg types.
 570    Otherwise, if one type specifies only the number of arguments,
 571    the other must specify that number of self-promoting arg types.
 572    Otherwise, the argument types must match.  */
 573
 574 static int
 575 function_types_compatible_p (f1, f2)
 576      tree f1, f2;
 577 {
 578   tree args1, args2;
 579   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 580   int val = 1;
 581   int val1;
 582
 583   if (!(TREE_TYPE (f1) == TREE_TYPE (f2)
 584         || (val = comptypes (TREE_TYPE (f1), TREE_TYPE (f2)))))
 585     return 0;
 586
 587   args1 = TYPE_ARG_TYPES (f1);
 588   args2 = TYPE_ARG_TYPES (f2);
 589
 590   /* An unspecified parmlist matches any specified parmlist
 591      whose argument types don't need default promotions.  */
 592
 593   if (args1 == 0)
 594     {
 595       if (!self_promoting_args_p (args2))
 596         return 0;
 597       /* If one of these types comes from a non-prototype fn definition,
 598          compare that with the other type's arglist.
 599          If they don't match, ask for a warning (but no error).  */
 600       if (TYPE_ACTUAL_ARG_TYPES (f1)
 601           && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
 602         val = 2;
 603       return val;
 604     }
 605   if (args2 == 0)
 606     {
 607       if (!self_promoting_args_p (args1))
 608         return 0;
 609       if (TYPE_ACTUAL_ARG_TYPES (f2)
 610           && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
 611         val = 2;
 612       return val;
 613     }
 614
 615   /* Both types have argument lists: compare them and propagate results.  */
 616   val1 = type_lists_compatible_p (args1, args2);
 617   return val1 != 1 ? val1 : val;
 618 }
 619
 620 /* Check two lists of types for compatibility,
 621    returning 0 for incompatible, 1 for compatible,
 622    or 2 for compatible with warning.  */
 623
 624 static int
 625 type_lists_compatible_p (args1, args2)
 626      tree args1, args2;
 627 {
 628   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 629   int val = 1;
 630   int newval = 0;
 631
 632   while (1)
 633     {
 634       if (args1 == 0 && args2 == 0)
 635         return val;
 636       /* If one list is shorter than the other,
 637          they fail to match.  */
 638       if (args1 == 0 || args2 == 0)
 639         return 0;
 640       /* A null pointer instead of a type
 641          means there is supposed to be an argument
 642          but nothing is specified about what type it has.
 643          So match anything that self-promotes.  */
 644       if (TREE_VALUE (args1) == 0)
 645         {
 646           if (! self_promoting_type_p (TREE_VALUE (args2)))
 647             return 0;
 648         }
 649       else if (TREE_VALUE (args2) == 0)
 650         {
 651           if (! self_promoting_type_p (TREE_VALUE (args1)))
 652             return 0;
 653         }
 654       else if (! (newval = comptypes (TREE_VALUE (args1), TREE_VALUE (args2))))
 655         {
 656           /* Allow  wait (union {union wait *u; int *i} *)
 657              and  wait (union wait *)  to be compatible.  */
 658           if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE
 659               && (TYPE_NAME (TREE_VALUE (args1)) == 0
 660                   || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1)))
 661               && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST
 662               && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)),
 663                                      TYPE_SIZE (TREE_VALUE (args2))))
 664             {
 665               tree memb;
 666               for (memb = TYPE_FIELDS (TREE_VALUE (args1));
 667                    memb; memb = TREE_CHAIN (memb))
 668                 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2)))
 669                   break;
 670               if (memb == 0)
 671                 return 0;
 672             }
 673           else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE
 674                    && (TYPE_NAME (TREE_VALUE (args2)) == 0
 675                        || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2)))
 676                    && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST
 677                    && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)),
 678                                           TYPE_SIZE (TREE_VALUE (args1))))
 679             {
 680               tree memb;
 681               for (memb = TYPE_FIELDS (TREE_VALUE (args2));
 682                    memb; memb = TREE_CHAIN (memb))
 683                 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1)))
 684                   break;
 685               if (memb == 0)
 686                 return 0;
 687             }
 688           else
 689             return 0;
 690         }
 691
 692       /* comptypes said ok, but record if it said to warn.  */
 693       if (newval > val)
 694         val = newval;
 695
 696       args1 = TREE_CHAIN (args1);
 697       args2 = TREE_CHAIN (args2);
 698     }
 699 }
 700
 701 /* Return 1 if PARMS specifies a fixed number of parameters
 702    and none of their types is affected by default promotions.  */
 703
 704 int
 705 self_promoting_args_p (parms)
 706      tree parms;
 707 {
 708   register tree t;
 709   for (t = parms; t; t = TREE_CHAIN (t))
 710     {
 711       register tree type = TREE_VALUE (t);
 712
 713       if (TREE_CHAIN (t) == 0 && type != void_type_node)
 714         return 0;
 715
 716       if (type == 0)
 717         return 0;
 718
 719       if (TYPE_MAIN_VARIANT (type) == float_type_node)
 720         return 0;
 721
 722       if (C_PROMOTING_INTEGER_TYPE_P (type))
 723         return 0;
 724     }
 725   return 1;
 726 }
 727
 728 /* Return 1 if TYPE is not affected by default promotions.  */
 729
 730 static int
 731 self_promoting_type_p (type)
 732      tree type;
 733 {
 734   if (TYPE_MAIN_VARIANT (type) == float_type_node)
 735     return 0;
 736
 737   if (C_PROMOTING_INTEGER_TYPE_P (type))
 738     return 0;
 739
 740   return 1;
 741 }
 742 \f
 743 /* Return an unsigned type the same as TYPE in other respects.  */
 744
 745 tree
 746 unsigned_type (type)
 747      tree type;
 748 {
 749   tree type1 = TYPE_MAIN_VARIANT (type);
 750   if (type1 == signed_char_type_node || type1 == char_type_node)
 751     return unsigned_char_type_node;
 752   if (type1 == integer_type_node)
 753     return unsigned_type_node;
 754   if (type1 == short_integer_type_node)
 755     return short_unsigned_type_node;
 756   if (type1 == long_integer_type_node)
 757     return long_unsigned_type_node;
 758   if (type1 == long_long_integer_type_node)
 759     return long_long_unsigned_type_node;
 760   return type;
 761 }
 762
 763 /* Return a signed type the same as TYPE in other respects.  */
 764
 765 tree
 766 signed_type (type)
 767      tree type;
 768 {
 769   tree type1 = TYPE_MAIN_VARIANT (type);
 770   if (type1 == unsigned_char_type_node || type1 == char_type_node)
 771     return signed_char_type_node;
 772   if (type1 == unsigned_type_node)
 773     return integer_type_node;
 774   if (type1 == short_unsigned_type_node)
 775     return short_integer_type_node;
 776   if (type1 == long_unsigned_type_node)
 777     return long_integer_type_node;
 778   if (type1 == long_long_unsigned_type_node)
 779     return long_long_integer_type_node;
 780   return type;
 781 }
 782
 783 /* Return a type the same as TYPE except unsigned or
 784    signed according to UNSIGNEDP.  */
 785
 786 tree
 787 signed_or_unsigned_type (unsignedp, type)
 788      int unsignedp;
 789      tree type;
 790 {
 791   if (! INTEGRAL_TYPE_P (type))
 792     return type;
 793   if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
 794     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
 795   if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
 796     return unsignedp ? unsigned_type_node : integer_type_node;
 797   if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
 798     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
 799   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
 800     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
 801   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
 802     return (unsignedp ? long_long_unsigned_type_node
 803             : long_long_integer_type_node);
 804   return type;
 805 }
 806
 807 /* Compute the value of the `sizeof' operator.  */
 808
 809 tree
 810 c_sizeof (type)
 811      tree type;
 812 {
 813   enum tree_code code = TREE_CODE (type);
 814   tree t;
 815
 816   if (code == FUNCTION_TYPE)
 817     {
 818       if (pedantic || warn_pointer_arith)
 819         pedwarn ("sizeof applied to a function type");
 820       return size_int (1);
 821     }
 822   if (code == VOID_TYPE)
 823     {
 824       if (pedantic || warn_pointer_arith)
 825         pedwarn ("sizeof applied to a void type");
 826       return size_int (1);
 827     }
 828   if (code == ERROR_MARK)
 829     return size_int (1);
 830   if (TYPE_SIZE (type) == 0)
 831     {
 832       error ("sizeof applied to an incomplete type");
 833       return size_int (0);
 834     }
 835
 836   /* Convert in case a char is more than one unit.  */
 837   t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
 838                   size_int (TYPE_PRECISION (char_type_node)));
 839   /* size_binop does not put the constant in range, so do it now.  */
 840   if (TREE_CODE (t) == INTEGER_CST && force_fit_type (t, 0))
 841     TREE_CONSTANT_OVERFLOW (t) = TREE_OVERFLOW (t) = 1;
 842   return t;
 843 }
 844
 845 tree
 846 c_sizeof_nowarn (type)
 847      tree type;
 848 {
 849   enum tree_code code = TREE_CODE (type);
 850   tree t;
 851
 852   if (code == FUNCTION_TYPE
 853       || code == VOID_TYPE
 854       || code == ERROR_MARK)
 855     return size_int (1);
 856   if (TYPE_SIZE (type) == 0)
 857     return size_int (0);
 858
 859   /* Convert in case a char is more than one unit.  */
 860   t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
 861                   size_int (TYPE_PRECISION (char_type_node)));
 862   force_fit_type (t, 0);
 863   return t;
 864 }
 865
 866 /* Compute the size to increment a pointer by.  */
 867
 868 tree
 869 c_size_in_bytes (type)
 870      tree type;
 871 {
 872   enum tree_code code = TREE_CODE (type);
 873   tree t;
 874
 875   if (code == FUNCTION_TYPE)
 876     return size_int (1);
 877   if (code == VOID_TYPE)
 878     return size_int (1);
 879   if (code == ERROR_MARK)
 880     return size_int (1);
 881   if (TYPE_SIZE (type) == 0)
 882     {
 883       error ("arithmetic on pointer to an incomplete type");
 884       return size_int (1);
 885     }
 886
 887   /* Convert in case a char is more than one unit.  */
 888   t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
 889                      size_int (BITS_PER_UNIT));
 890   force_fit_type (t, 0);
 891   return t;
 892 }
 893
 894 /* Implement the __alignof keyword: Return the minimum required
 895    alignment of TYPE, measured in bytes.  */
 896
 897 tree
 898 c_alignof (type)
 899      tree type;
 900 {
 901   enum tree_code code = TREE_CODE (type);
 902
 903   if (code == FUNCTION_TYPE)
 904     return size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
 905
 906   if (code == VOID_TYPE || code == ERROR_MARK)
 907     return size_int (1);
 908
 909   return size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
 910 }
 911 \f
 912 /* Implement the __alignof keyword: Return the minimum required
 913    alignment of EXPR, measured in bytes.  For VAR_DECL's and
 914    FIELD_DECL's return DECL_ALIGN (which can be set from an
 915    "aligned" __attribute__ specification).  */
 916
 917 tree
 918 c_alignof_expr (expr)
 919      tree expr;
 920 {
 921   if (TREE_CODE (expr) == VAR_DECL)
 922     return size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
 923
 924   if (TREE_CODE (expr) == COMPONENT_REF
 925       && DECL_BIT_FIELD (TREE_OPERAND (expr, 1)))
 926     {
 927       error ("`__alignof' applied to a bit-field");
 928       return size_int (1);
 929     }
 930   else if (TREE_CODE (expr) == COMPONENT_REF
 931       && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
 932     return size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
 933
 934   if (TREE_CODE (expr) == INDIRECT_REF)
 935     {
 936       tree t = TREE_OPERAND (expr, 0);
 937       tree best = t;
 938       int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
 939
 940       while (TREE_CODE (t) == NOP_EXPR
 941               && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
 942         {
 943           int thisalign;
 944
 945           t = TREE_OPERAND (t, 0);
 946           thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
 947           if (thisalign > bestalign)
 948             best = t, bestalign = thisalign;
 949         }
 950       return c_alignof (TREE_TYPE (TREE_TYPE (best)));
 951     }
 952   else
 953     return c_alignof (TREE_TYPE (expr));
 954 }
 955 /* Return either DECL or its known constant value (if it has one).  */
 956
 957 static tree
 958 decl_constant_value (decl)
 959      tree decl;
 960 {
 961   if (! TREE_PUBLIC (decl)
 962       /* Don't change a variable array bound or initial value to a constant
 963          in a place where a variable is invalid.  */
 964       && current_function_decl != 0
 965       && ! pedantic
 966       && ! TREE_THIS_VOLATILE (decl)
 967       && TREE_READONLY (decl) && ! ITERATOR_P (decl)
 968       && DECL_INITIAL (decl) != 0
 969       && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
 970       /* This is invalid if initial value is not constant.
 971          If it has either a function call, a memory reference,
 972          or a variable, then re-evaluating it could give different results.  */
 973       && TREE_CONSTANT (DECL_INITIAL (decl))
 974       /* Check for cases where this is sub-optimal, even though valid.  */
 975       && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR
 976       && DECL_MODE (decl) != BLKmode)
 977     return DECL_INITIAL (decl);
 978   return decl;
 979 }
 980
 981 /* Perform default promotions for C data used in expressions.
 982    Arrays and functions are converted to pointers;
 983    enumeral types or short or char, to int.
 984    In addition, manifest constants symbols are replaced by their values.  */
 985
 986 tree
 987 default_conversion (exp)
 988      tree exp;
 989 {
 990   register tree type = TREE_TYPE (exp);
 991   register enum tree_code code = TREE_CODE (type);
 992
 993   /* Constants can be used directly unless they're not loadable.  */
 994   if (TREE_CODE (exp) == CONST_DECL)
 995     exp = DECL_INITIAL (exp);
 996
 997   /* Replace a nonvolatile const static variable with its value unless
 998      it is an array, in which case we must be sure that taking the
 999      address of the array produces consistent results.  */
1000   else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
1001     {
1002       exp = decl_constant_value (exp);
1003       type = TREE_TYPE (exp);
1004     }
1005
1006   /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1007      an lvalue.  */
1008   /* Do not use STRIP_NOPS here!  It will remove conversions from pointer
1009      to integer and cause infinite recursion.  */
1010   while (TREE_CODE (exp) == NON_LVALUE_EXPR
1011          || (TREE_CODE (exp) == NOP_EXPR
1012              && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
1013     exp = TREE_OPERAND (exp, 0);
1014
1015   /* Normally convert enums to int,
1016      but convert wide enums to something wider.  */
1017   if (code == ENUMERAL_TYPE)
1018     {
1019       type = type_for_size (MAX (TYPE_PRECISION (type),
1020                                  TYPE_PRECISION (integer_type_node)),
1021                             ((flag_traditional
1022                               || TYPE_PRECISION (type) >= TYPE_PRECISION (integer_type_node))
1023                              && TREE_UNSIGNED (type)));
1024       return convert (type, exp);
1025     }
1026
1027   if (C_PROMOTING_INTEGER_TYPE_P (type))
1028     {
1029       /* Traditionally, unsignedness is preserved in default promotions.
1030          Also preserve unsignedness if not really getting any wider.  */
1031       if (TREE_UNSIGNED (type)
1032           && (flag_traditional
1033               || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
1034         return convert (unsigned_type_node, exp);
1035       return convert (integer_type_node, exp);
1036     }
1037   if (flag_traditional && !flag_allow_single_precision
1038       && TYPE_MAIN_VARIANT (type) == float_type_node)
1039     return convert (double_type_node, exp);
1040   if (code == VOID_TYPE)
1041     {
1042       error ("void value not ignored as it ought to be");
1043       return error_mark_node;
1044     }
1045   if (code == FUNCTION_TYPE)
1046     {
1047       return build_unary_op (ADDR_EXPR, exp, 0);
1048     }
1049   if (code == ARRAY_TYPE)
1050     {
1051       register tree adr;
1052       tree restype = TREE_TYPE (type);
1053       tree ptrtype;
1054       int constp = 0;
1055       int volatilep = 0;
1056
1057       if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'r'
1058           || TREE_CODE_CLASS (TREE_CODE (exp)) == 'd')
1059         {
1060           constp = TREE_READONLY (exp);
1061           volatilep = TREE_THIS_VOLATILE (exp);
1062         }
1063
1064       if (TYPE_READONLY (type) || TYPE_VOLATILE (type)
1065           || constp || volatilep)
1066         restype = c_build_type_variant (restype,
1067                                         TYPE_READONLY (type) || constp,
1068                                         TYPE_VOLATILE (type) || volatilep);
1069
1070       if (TREE_CODE (exp) == INDIRECT_REF)
1071         return convert (TYPE_POINTER_TO (restype),
1072                         TREE_OPERAND (exp, 0));
1073
1074       if (TREE_CODE (exp) == COMPOUND_EXPR)
1075         {
1076           tree op1 = default_conversion (TREE_OPERAND (exp, 1));
1077           return build (COMPOUND_EXPR, TREE_TYPE (op1),
1078                         TREE_OPERAND (exp, 0), op1);
1079         }
1080
1081       if (!lvalue_p (exp)
1082           && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
1083         {
1084           error ("invalid use of non-lvalue array");
1085           return error_mark_node;
1086         }
1087
1088       ptrtype = build_pointer_type (restype);
1089
1090       if (TREE_CODE (exp) == VAR_DECL)
1091         {
1092           /* ??? This is not really quite correct
1093              in that the type of the operand of ADDR_EXPR
1094              is not the target type of the type of the ADDR_EXPR itself.
1095              Question is, can this lossage be avoided?  */
1096           adr = build1 (ADDR_EXPR, ptrtype, exp);
1097           if (mark_addressable (exp) == 0)
1098             return error_mark_node;
1099           TREE_CONSTANT (adr) = staticp (exp);
1100           TREE_SIDE_EFFECTS (adr) = 0;   /* Default would be, same as EXP.  */
1101           return adr;
1102         }
1103       /* This way is better for a COMPONENT_REF since it can
1104          simplify the offset for a component.  */
1105       adr = build_unary_op (ADDR_EXPR, exp, 1);
1106       return convert (ptrtype, adr);
1107     }
1108   return exp;
1109 }
1110 \f
1111 /* Look up component name in the structure type definition.
1112
1113    If this component name is found indirectly within an anonymous union,
1114    store in *INDIRECT the component which directly contains
1115    that anonymous union.  Otherwise, set *INDIRECT to 0.  */
1116
1117 static tree
1118 lookup_field (type, component, indirect)
1119      tree type, component;
1120      tree *indirect;
1121 {
1122   tree field;
1123
1124   /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1125      to the field elements.  Use a binary search on this array to quickly
1126      find the element.  Otherwise, do a linear search.  TYPE_LANG_SPECIFIC
1127      will always be set for structures which have many elements.  */
1128
1129   if (TYPE_LANG_SPECIFIC (type))
1130     {
1131       int bot, top, half;
1132       tree *field_array = &TYPE_LANG_SPECIFIC (type)->elts[0];
1133
1134       field = TYPE_FIELDS (type);
1135       bot = 0;
1136       top = TYPE_LANG_SPECIFIC (type)->len;
1137       while (top - bot > 1)
1138         {
1139           HOST_WIDE_INT cmp;
1140
1141           half = (top - bot + 1) >> 1;
1142           field = field_array[bot+half];
1143
1144           if (DECL_NAME (field) == NULL_TREE)
1145             {
1146               /* Step through all anon unions in linear fashion.  */
1147               while (DECL_NAME (field_array[bot]) == NULL_TREE)
1148                 {
1149                   tree anon, junk;
1150
1151                   field = field_array[bot++];
1152                   anon = lookup_field (TREE_TYPE (field), component, &junk);
1153                   if (anon != NULL_TREE)
1154                     {
1155                       *indirect = field;
1156                       return anon;
1157                     }
1158                 }
1159
1160               /* Entire record is only anon unions.  */
1161               if (bot > top)
1162                 return NULL_TREE;
1163
1164               /* Restart the binary search, with new lower bound.  */
1165               continue;
1166             }
1167
1168           cmp = (HOST_WIDE_INT) DECL_NAME (field) - (HOST_WIDE_INT) component;
1169           if (cmp == 0)
1170             break;
1171           if (cmp < 0)
1172             bot += half;
1173           else
1174             top = bot + half;
1175         }
1176
1177       if (DECL_NAME (field_array[bot]) == component)
1178         field = field_array[bot];
1179       else if (DECL_NAME (field) != component)
1180         field = 0;
1181     }
1182   else
1183     {
1184       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1185         {
1186           if (DECL_NAME (field) == NULL_TREE)
1187             {
1188               tree junk;
1189               tree anon = lookup_field (TREE_TYPE (field), component, &junk);
1190               if (anon != NULL_TREE)
1191                 {
1192                   *indirect = field;
1193                   return anon;
1194                 }
1195             }
1196
1197           if (DECL_NAME (field) == component)
1198             break;
1199         }
1200     }
1201
1202   *indirect = NULL_TREE;
1203   return field;
1204 }
1205
1206 /* Make an expression to refer to the COMPONENT field of
1207    structure or union value DATUM.  COMPONENT is an IDENTIFIER_NODE.  */
1208
1209 tree
1210 build_component_ref (datum, component)
1211      tree datum, component;
1212 {
1213   register tree type = TREE_TYPE (datum);
1214   register enum tree_code code = TREE_CODE (type);
1215   register tree field = NULL;
1216   register tree ref;
1217
1218   /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference inside it
1219      unless we are not to support things not strictly ANSI.  */
1220   switch (TREE_CODE (datum))
1221     {
1222     case COMPOUND_EXPR:
1223       {
1224         tree value = build_component_ref (TREE_OPERAND (datum, 1), component);
1225         return build (COMPOUND_EXPR, TREE_TYPE (value),
1226                       TREE_OPERAND (datum, 0), value);
1227       }
1228     case COND_EXPR:
1229       return build_conditional_expr
1230         (TREE_OPERAND (datum, 0),
1231          build_component_ref (TREE_OPERAND (datum, 1), component),
1232          build_component_ref (TREE_OPERAND (datum, 2), component));
1233     }
1234
1235   /* See if there is a field or component with name COMPONENT.  */
1236
1237   if (code == RECORD_TYPE || code == UNION_TYPE)
1238     {
1239       tree indirect = 0;
1240
1241       if (TYPE_SIZE (type) == 0)
1242         {
1243           incomplete_type_error (NULL_TREE, type);
1244           return error_mark_node;
1245         }
1246
1247       field = lookup_field (type, component, &indirect);
1248
1249       if (!field)
1250         {
1251           error (code == RECORD_TYPE
1252                  ? "structure has no member named `%s'"
1253                  : "union has no member named `%s'",
1254                  IDENTIFIER_POINTER (component));
1255           return error_mark_node;
1256         }
1257       if (TREE_TYPE (field) == error_mark_node)
1258         return error_mark_node;
1259
1260       /* If FIELD was found buried within an anonymous union,
1261          make one COMPONENT_REF to get that anonymous union,
1262          then fall thru to make a second COMPONENT_REF to get FIELD.  */
1263       if (indirect != 0)
1264         {
1265           ref = build (COMPONENT_REF, TREE_TYPE (indirect), datum, indirect);
1266           if (TREE_READONLY (datum) || TREE_READONLY (indirect))
1267             TREE_READONLY (ref) = 1;
1268           if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (indirect))
1269             TREE_THIS_VOLATILE (ref) = 1;
1270           datum = ref;
1271         }
1272
1273       ref = build (COMPONENT_REF, TREE_TYPE (field), datum, field);
1274
1275       if (TREE_READONLY (datum) || TREE_READONLY (field))
1276         TREE_READONLY (ref) = 1;
1277       if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (field))
1278         TREE_THIS_VOLATILE (ref) = 1;
1279
1280       return ref;
1281     }
1282   else if (code != ERROR_MARK)
1283     error ("request for member `%s' in something not a structure or union",
1284             IDENTIFIER_POINTER (component));
1285
1286   return error_mark_node;
1287 }
1288 \f
1289 /* Given an expression PTR for a pointer, return an expression
1290    for the value pointed to.
1291    ERRORSTRING is the name of the operator to appear in error messages.  */
1292
1293 tree
1294 build_indirect_ref (ptr, errorstring)
1295      tree ptr;
1296      char *errorstring;
1297 {
1298   register tree pointer = default_conversion (ptr);
1299   register tree type = TREE_TYPE (pointer);
1300
1301   if (TREE_CODE (type) == POINTER_TYPE)
1302     {
1303       if (TREE_CODE (pointer) == ADDR_EXPR
1304           && !flag_volatile
1305           && (TREE_TYPE (TREE_OPERAND (pointer, 0))
1306               == TREE_TYPE (type)))
1307         return TREE_OPERAND (pointer, 0);
1308       else
1309         {
1310           tree t = TREE_TYPE (type);
1311           register tree ref = build1 (INDIRECT_REF,
1312                                       TYPE_MAIN_VARIANT (t), pointer);
1313
1314           if (TYPE_SIZE (t) == 0 && TREE_CODE (t) != ARRAY_TYPE)
1315             {
1316               error ("dereferencing pointer to incomplete type");
1317               return error_mark_node;
1318             }
1319           if (TREE_CODE (t) == VOID_TYPE)
1320             warning ("dereferencing `void *' pointer");
1321
1322           /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1323              so that we get the proper error message if the result is used
1324              to assign to.  Also, &* is supposed to be a no-op.
1325              And ANSI C seems to specify that the type of the result
1326              should be the const type.  */
1327           /* A de-reference of a pointer to const is not a const.  It is valid
1328              to change it via some other pointer.  */
1329           TREE_READONLY (ref) = TYPE_READONLY (t);
1330           TREE_SIDE_EFFECTS (ref)
1331             = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer) || flag_volatile;
1332           TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
1333           return ref;
1334         }
1335     }
1336   else if (TREE_CODE (pointer) != ERROR_MARK)
1337     error ("invalid type argument of `%s'", errorstring);
1338   return error_mark_node;
1339 }
1340
1341 /* This handles expressions of the form "a[i]", which denotes
1342    an array reference.
1343
1344    This is logically equivalent in C to *(a+i), but we may do it differently.
1345    If A is a variable or a member, we generate a primitive ARRAY_REF.
1346    This avoids forcing the array out of registers, and can work on
1347    arrays that are not lvalues (for example, members of structures returned
1348    by functions).  */
1349
1350 tree
1351 build_array_ref (array, index)
1352      tree array, index;
1353 {
1354   if (index == 0)
1355     {
1356       error ("subscript missing in array reference");
1357       return error_mark_node;
1358     }
1359
1360   if (TREE_TYPE (array) == error_mark_node
1361       || TREE_TYPE (index) == error_mark_node)
1362     return error_mark_node;
1363
1364   if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
1365       && TREE_CODE (array) != INDIRECT_REF)
1366     {
1367       tree rval, type;
1368
1369       /* Subscripting with type char is likely to lose
1370          on a machine where chars are signed.
1371          So warn on any machine, but optionally.
1372          Don't warn for unsigned char since that type is safe.
1373          Don't warn for signed char because anyone who uses that
1374          must have done so deliberately.  */
1375       if (warn_char_subscripts
1376           && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1377         warning ("array subscript has type `char'");
1378
1379       /* Apply default promotions *after* noticing character types.  */
1380       index = default_conversion (index);
1381
1382       /* Require integer *after* promotion, for sake of enums.  */
1383       if (TREE_CODE (TREE_TYPE (index)) != INTEGER_TYPE)
1384         {
1385           error ("array subscript is not an integer");
1386           return error_mark_node;
1387         }
1388
1389       /* An array that is indexed by a non-constant
1390          cannot be stored in a register; we must be able to do
1391          address arithmetic on its address.
1392          Likewise an array of elements of variable size.  */
1393       if (TREE_CODE (index) != INTEGER_CST
1394           || (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))) != 0
1395               && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
1396         {
1397           if (mark_addressable (array) == 0)
1398             return error_mark_node;
1399         }
1400       /* An array that is indexed by a constant value which is not within
1401          the array bounds cannot be stored in a register either; because we
1402          would get a crash in store_bit_field/extract_bit_field when trying
1403          to access a non-existent part of the register.  */
1404       if (TREE_CODE (index) == INTEGER_CST
1405           && TYPE_VALUES (TREE_TYPE (array))
1406           && ! int_fits_type_p (index, TYPE_VALUES (TREE_TYPE (array))))
1407         {
1408           if (mark_addressable (array) == 0)
1409             return error_mark_node;
1410         }
1411
1412       if (pedantic && !lvalue_p (array))
1413         {
1414           if (DECL_REGISTER (array))
1415             pedwarn ("ANSI C forbids subscripting `register' array");
1416           else
1417             pedwarn ("ANSI C forbids subscripting non-lvalue array");
1418         }
1419
1420       if (pedantic)
1421         {
1422           tree foo = array;
1423           while (TREE_CODE (foo) == COMPONENT_REF)
1424             foo = TREE_OPERAND (foo, 0);
1425           if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
1426             pedwarn ("ANSI C forbids subscripting non-lvalue array");
1427         }
1428
1429       type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
1430       rval = build (ARRAY_REF, type, array, index);
1431       /* Array ref is const/volatile if the array elements are
1432          or if the array is.  */
1433       TREE_READONLY (rval)
1434         |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
1435             | TREE_READONLY (array));
1436       TREE_SIDE_EFFECTS (rval)
1437         |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1438             | TREE_SIDE_EFFECTS (array));
1439       TREE_THIS_VOLATILE (rval)
1440         |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1441             /* This was added by rms on 16 Nov 91.
1442                It fixes  vol struct foo *a;  a->elts[1]
1443                in an inline function.
1444                Hope it doesn't break something else.  */
1445             | TREE_THIS_VOLATILE (array));
1446       return require_complete_type (fold (rval));
1447     }
1448
1449   {
1450     tree ar = default_conversion (array);
1451     tree ind = default_conversion (index);
1452
1453     /* Put the integer in IND to simplify error checking.  */
1454     if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
1455       {
1456         tree temp = ar;
1457         ar = ind;
1458         ind = temp;
1459       }
1460
1461     if (ar == error_mark_node)
1462       return ar;
1463
1464     if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE)
1465       {
1466         error ("subscripted value is neither array nor pointer");
1467         return error_mark_node;
1468       }
1469     if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
1470       {
1471         error ("array subscript is not an integer");
1472         return error_mark_node;
1473       }
1474
1475     return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, ind, 0),
1476                                "array indexing");
1477   }
1478 }
1479 \f
1480 /* Build a function call to function FUNCTION with parameters PARAMS.
1481    PARAMS is a list--a chain of TREE_LIST nodes--in which the
1482    TREE_VALUE of each node is a parameter-expression.
1483    FUNCTION's data type may be a function type or a pointer-to-function.  */
1484
1485 tree
1486 build_function_call (function, params)
1487      tree function, params;
1488 {
1489   register tree fntype, fundecl = 0;
1490   register tree coerced_params;
1491   tree name = NULL_TREE, assembler_name = NULL_TREE;
1492
1493   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
1494   STRIP_TYPE_NOPS (function);
1495
1496   /* Convert anything with function type to a pointer-to-function.  */
1497   if (TREE_CODE (function) == FUNCTION_DECL)
1498     {
1499       name = DECL_NAME (function);
1500       assembler_name = DECL_ASSEMBLER_NAME (function);
1501
1502       /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1503          (because calling an inline function does not mean the function
1504          needs to be separately compiled).  */
1505       fntype = build_type_variant (TREE_TYPE (function),
1506                                    TREE_READONLY (function),
1507                                    TREE_THIS_VOLATILE (function));
1508       fundecl = function;
1509       function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
1510     }
1511   else
1512     function = default_conversion (function);
1513
1514   fntype = TREE_TYPE (function);
1515
1516   if (TREE_CODE (fntype) == ERROR_MARK)
1517     return error_mark_node;
1518
1519   if (!(TREE_CODE (fntype) == POINTER_TYPE
1520         && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
1521     {
1522       error ("called object is not a function");
1523       return error_mark_node;
1524     }
1525
1526   /* fntype now gets the type of function pointed to.  */
1527   fntype = TREE_TYPE (fntype);
1528
1529   /* Convert the parameters to the types declared in the
1530      function prototype, or apply default promotions.  */
1531
1532   coerced_params
1533     = convert_arguments (TYPE_ARG_TYPES (fntype), params, name, fundecl);
1534
1535   /* Check for errors in format strings.  */
1536
1537   if (warn_format && (name || assembler_name))
1538     check_function_format (name, assembler_name, coerced_params);
1539
1540   /* Recognize certain built-in functions so we can make tree-codes
1541      other than CALL_EXPR.  We do this when it enables fold-const.c
1542      to do something useful.  */
1543
1544   if (TREE_CODE (function) == ADDR_EXPR
1545       && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
1546       && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
1547     switch (DECL_FUNCTION_CODE (TREE_OPERAND (function, 0)))
1548       {
1549       case BUILT_IN_ABS:
1550       case BUILT_IN_LABS:
1551       case BUILT_IN_FABS:
1552         if (coerced_params == 0)
1553           return integer_zero_node;
1554         return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
1555       }
1556
1557   {
1558     register tree result
1559       = build (CALL_EXPR, TREE_TYPE (fntype),
1560                function, coerced_params, NULL_TREE);
1561
1562     TREE_SIDE_EFFECTS (result) = 1;
1563     if (TREE_TYPE (result) == void_type_node)
1564       return result;
1565     return require_complete_type (result);
1566   }
1567 }
1568 \f
1569 /* Convert the argument expressions in the list VALUES
1570    to the types in the list TYPELIST.  The result is a list of converted
1571    argument expressions.
1572
1573    If TYPELIST is exhausted, or when an element has NULL as its type,
1574    perform the default conversions.
1575
1576    PARMLIST is the chain of parm decls for the function being called.
1577    It may be 0, if that info is not available.
1578    It is used only for generating error messages.
1579
1580    NAME is an IDENTIFIER_NODE or 0.  It is used only for error messages.
1581
1582    This is also where warnings about wrong number of args are generated.
1583
1584    Both VALUES and the returned value are chains of TREE_LIST nodes
1585    with the elements of the list in the TREE_VALUE slots of those nodes.  */
1586
1587 static tree
1588 convert_arguments (typelist, values, name, fundecl)
1589      tree typelist, values, name, fundecl;
1590 {
1591   register tree typetail, valtail;
1592   register tree result = NULL;
1593   int parmnum;
1594
1595   /* Scan the given expressions and types, producing individual
1596      converted arguments and pushing them on RESULT in reverse order.  */
1597
1598   for (valtail = values, typetail = typelist, parmnum = 0;
1599        valtail;
1600        valtail = TREE_CHAIN (valtail), parmnum++)
1601     {
1602       register tree type = typetail ? TREE_VALUE (typetail) : 0;
1603       register tree val = TREE_VALUE (valtail);
1604
1605       if (type == void_type_node)
1606         {
1607           if (name)
1608             error ("too many arguments to function `%s'",
1609                    IDENTIFIER_POINTER (name));
1610           else
1611             error ("too many arguments to function");
1612           break;
1613         }
1614
1615       /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
1616       /* Do not use STRIP_NOPS here!  We do not want an enumerator with value 0
1617          to convert automatically to a pointer.  */
1618       if (TREE_CODE (val) == NON_LVALUE_EXPR)
1619         val = TREE_OPERAND (val, 0);
1620
1621       if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
1622           || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE)
1623         val = default_conversion (val);
1624
1625       val = require_complete_type (val);
1626
1627       if (type != 0)
1628         {
1629           /* Formal parm type is specified by a function prototype.  */
1630           tree parmval;
1631
1632           if (TYPE_SIZE (type) == 0)
1633             {
1634               error ("type of formal parameter %d is incomplete", parmnum + 1);
1635               parmval = val;
1636             }
1637           else
1638             {
1639               /* Optionally warn about conversions that
1640                  differ from the default conversions.  */
1641               if (warn_conversion)
1642                 {
1643                   int formal_prec = TYPE_PRECISION (type);
1644
1645                   if (INTEGRAL_TYPE_P (type)
1646                       && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1647                     warn_for_assignment ("%s as integer rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1648                   else if (TREE_CODE (type) == COMPLEX_TYPE
1649                            && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1650                     warn_for_assignment ("%s as complex rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1651                   else if (TREE_CODE (type) == REAL_TYPE
1652                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1653                     warn_for_assignment ("%s as floating rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1654                   else if (TREE_CODE (type) == REAL_TYPE
1655                            && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1656                     warn_for_assignment ("%s as floating rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1657                   /* ??? At some point, messages should be written about
1658                      conversions between complex types, but that's too messy
1659                      to do now.  */
1660                   else if (TREE_CODE (type) == REAL_TYPE
1661                            && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1662                     {
1663                       /* Warn if any argument is passed as `float',
1664                          since without a prototype it would be `double'.  */
1665                       if (formal_prec == TYPE_PRECISION (float_type_node))
1666                         warn_for_assignment ("%s as `float' rather than `double' due to prototype", (char *) 0, name, parmnum + 1);
1667                     }
1668                   /* Detect integer changing in width or signedness.  */
1669                   else if (INTEGRAL_TYPE_P (type)
1670                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1671                     {
1672                       tree would_have_been = default_conversion (val);
1673                       tree type1 = TREE_TYPE (would_have_been);
1674
1675                       if (TREE_CODE (type) == ENUMERAL_TYPE
1676                           && type == TREE_TYPE (val))
1677                         /* No warning if function asks for enum
1678                            and the actual arg is that enum type.  */
1679                         ;
1680                       else if (formal_prec != TYPE_PRECISION (type1))
1681                         warn_for_assignment ("%s with different width due to prototype", (char *) 0, name, parmnum + 1);
1682                       else if (TREE_UNSIGNED (type) == TREE_UNSIGNED (type1))
1683                         ;
1684                       /* Don't complain if the formal parameter type
1685                          is an enum, because we can't tell now whether
1686                          the value was an enum--even the same enum.  */
1687                       else if (TREE_CODE (type) == ENUMERAL_TYPE)
1688                         ;
1689                       else if (TREE_CODE (val) == INTEGER_CST
1690                                && int_fits_type_p (val, type))
1691                         /* Change in signedness doesn't matter
1692                            if a constant value is unaffected.  */
1693                         ;
1694                       /* Likewise for a constant in a NOP_EXPR.  */
1695                       else if (TREE_CODE (val) == NOP_EXPR
1696                                && TREE_CODE (TREE_OPERAND (val, 0)) == INTEGER_CST
1697                                && int_fits_type_p (TREE_OPERAND (val, 0), type))
1698                         ;
1699 #if 0 /* We never get such tree structure here.  */
1700                       else if (TREE_CODE (TREE_TYPE (val)) == ENUMERAL_TYPE
1701                                && int_fits_type_p (TYPE_MIN_VALUE (TREE_TYPE (val)), type)
1702                                && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (val)), type))
1703                         /* Change in signedness doesn't matter
1704                            if an enum value is unaffected.  */
1705                         ;
1706 #endif
1707                       /* If the value is extended from a narrower
1708                          unsigned type, it doesn't matter whether we
1709                          pass it as signed or unsigned; the value
1710                          certainly is the same either way.  */
1711                       else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
1712                                && TREE_UNSIGNED (TREE_TYPE (val)))
1713                         ;
1714                       else if (TREE_UNSIGNED (type))
1715                         warn_for_assignment ("%s as unsigned due to prototype", (char *) 0, name, parmnum + 1);
1716                       else
1717                         warn_for_assignment ("%s as signed due to prototype", (char *) 0, name, parmnum + 1);
1718                     }
1719                 }
1720
1721               parmval = convert_for_assignment (type, val,
1722                                                 (char *)0, /* arg passing  */
1723                                                 fundecl, name, parmnum + 1);
1724
1725 #ifdef PROMOTE_PROTOTYPES
1726               if ((TREE_CODE (type) == INTEGER_TYPE
1727                    || TREE_CODE (type) == ENUMERAL_TYPE)
1728                   && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
1729                 parmval = default_conversion (parmval);
1730 #endif
1731             }
1732           result = tree_cons (NULL_TREE, parmval, result);
1733         }
1734       else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
1735                && (TYPE_PRECISION (TREE_TYPE (val))
1736                    < TYPE_PRECISION (double_type_node)))
1737         /* Convert `float' to `double'.  */
1738         result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
1739       else
1740         /* Convert `short' and `char' to full-size `int'.  */
1741         result = tree_cons (NULL_TREE, default_conversion (val), result);
1742
1743       if (typetail)
1744         typetail = TREE_CHAIN (typetail);
1745     }
1746
1747   if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
1748     {
1749       if (name)
1750         error ("too few arguments to function `%s'",
1751                IDENTIFIER_POINTER (name));
1752       else
1753         error ("too few arguments to function");
1754     }
1755
1756   return nreverse (result);
1757 }
1758 \f
1759 /* This is the entry point used by the parser
1760    for binary operators in the input.
1761    In addition to constructing the expression,
1762    we check for operands that were written with other binary operators
1763    in a way that is likely to confuse the user.  */
1764
1765 tree
1766 parser_build_binary_op (code, arg1, arg2)
1767      enum tree_code code;
1768      tree arg1, arg2;
1769 {
1770   tree result = build_binary_op (code, arg1, arg2, 1);
1771
1772   char class;
1773   char class1 = TREE_CODE_CLASS (TREE_CODE (arg1));
1774   char class2 = TREE_CODE_CLASS (TREE_CODE (arg2));
1775   enum tree_code code1 = ERROR_MARK;
1776   enum tree_code code2 = ERROR_MARK;
1777
1778   if (class1 == 'e' || class1 == '1'
1779       || class1 == '2' || class1 == '<')
1780     code1 = C_EXP_ORIGINAL_CODE (arg1);
1781   if (class2 == 'e' || class2 == '1'
1782       || class2 == '2' || class2 == '<')
1783     code2 = C_EXP_ORIGINAL_CODE (arg2);
1784
1785   /* Check for cases such as x+y<<z which users are likely
1786      to misinterpret.  If parens are used, C_EXP_ORIGINAL_CODE
1787      is cleared to prevent these warnings.  */
1788   if (warn_parentheses)
1789     {
1790       if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
1791         {
1792           if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1793               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1794             warning ("suggest parentheses around + or - inside shift");
1795         }
1796
1797       if (code == TRUTH_ORIF_EXPR)
1798         {
1799           if (code1 == TRUTH_ANDIF_EXPR
1800               || code2 == TRUTH_ANDIF_EXPR)
1801             warning ("suggest parentheses around && within ||");
1802         }
1803
1804       if (code == BIT_IOR_EXPR)
1805         {
1806           if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
1807               || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1808               || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
1809               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1810             warning ("suggest parentheses around arithmetic in operand of |");
1811         }
1812
1813       if (code == BIT_XOR_EXPR)
1814         {
1815           if (code1 == BIT_AND_EXPR
1816               || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1817               || code2 == BIT_AND_EXPR
1818               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1819             warning ("suggest parentheses around arithmetic in operand of ^");
1820         }
1821
1822       if (code == BIT_AND_EXPR)
1823         {
1824           if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1825               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1826             warning ("suggest parentheses around + or - in operand of &");
1827         }
1828     }
1829
1830   /* Similarly, check for cases like 1<=i<=10 that are probably errors.  */
1831   if (TREE_CODE_CLASS (code) == '<' && extra_warnings
1832       && (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<'))
1833     warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
1834
1835   unsigned_conversion_warning (result, arg1);
1836   unsigned_conversion_warning (result, arg2);
1837   overflow_warning (result);
1838
1839   class = TREE_CODE_CLASS (TREE_CODE (result));
1840
1841   /* Record the code that was specified in the source,
1842      for the sake of warnings about confusing nesting.  */
1843   if (class == 'e' || class == '1'
1844       || class == '2' || class == '<')
1845     C_SET_EXP_ORIGINAL_CODE (result, code);
1846   else
1847     {
1848       int flag = TREE_CONSTANT (result);
1849       /* We used to use NOP_EXPR rather than NON_LVALUE_EXPR
1850          so that convert_for_assignment wouldn't strip it.
1851          That way, we got warnings for things like p = (1 - 1).
1852          But it turns out we should not get those warnings.  */
1853       result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
1854       C_SET_EXP_ORIGINAL_CODE (result, code);
1855       TREE_CONSTANT (result) = flag;
1856     }
1857
1858   return result;
1859 }
1860
1861 /* Build a binary-operation expression without default conversions.
1862    CODE is the kind of expression to build.
1863    This function differs from `build' in several ways:
1864    the data type of the result is computed and recorded in it,
1865    warnings are generated if arg data types are invalid,
1866    special handling for addition and subtraction of pointers is known,
1867    and some optimization is done (operations on narrow ints
1868    are done in the narrower type when that gives the same result).
1869    Constant folding is also done before the result is returned.
1870
1871    Note that the operands will never have enumeral types, or function
1872    or array types, because either they will have the default conversions
1873    performed or they have both just been converted to some other type in which
1874    the arithmetic is to be done.  */
1875
1876 tree
1877 build_binary_op (code, orig_op0, orig_op1, convert_p)
1878      enum tree_code code;
1879      tree orig_op0, orig_op1;
1880      int convert_p;
1881 {
1882   tree type0, type1;
1883   register enum tree_code code0, code1;
1884   tree op0, op1;
1885
1886   /* Expression code to give to the expression when it is built.
1887      Normally this is CODE, which is what the caller asked for,
1888      but in some special cases we change it.  */
1889   register enum tree_code resultcode = code;
1890
1891   /* Data type in which the computation is to be performed.
1892      In the simplest cases this is the common type of the arguments.  */
1893   register tree result_type = NULL;
1894
1895   /* Nonzero means operands have already been type-converted
1896      in whatever way is necessary.
1897      Zero means they need to be converted to RESULT_TYPE.  */
1898   int converted = 0;
1899
1900   /* Nonzero means after finally constructing the expression
1901      give it this type.  Otherwise, give it type RESULT_TYPE.  */
1902   tree final_type = 0;
1903
1904   /* Nonzero if this is an operation like MIN or MAX which can
1905      safely be computed in short if both args are promoted shorts.
1906      Also implies COMMON.
1907      -1 indicates a bitwise operation; this makes a difference
1908      in the exact conditions for when it is safe to do the operation
1909      in a narrower mode.  */
1910   int shorten = 0;
1911
1912   /* Nonzero if this is a comparison operation;
1913      if both args are promoted shorts, compare the original shorts.
1914      Also implies COMMON.  */
1915   int short_compare = 0;
1916
1917   /* Nonzero if this is a right-shift operation, which can be computed on the
1918      original short and then promoted if the operand is a promoted short.  */
1919   int short_shift = 0;
1920
1921   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
1922   int common = 0;
1923
1924   if (convert_p)
1925     {
1926       op0 = default_conversion (orig_op0);
1927       op1 = default_conversion (orig_op1);
1928     }
1929   else
1930     {
1931       op0 = orig_op0;
1932       op1 = orig_op1;
1933     }
1934
1935   type0 = TREE_TYPE (op0);
1936   type1 = TREE_TYPE (op1);
1937
1938   /* The expression codes of the data types of the arguments tell us
1939      whether the arguments are integers, floating, pointers, etc.  */
1940   code0 = TREE_CODE (type0);
1941   code1 = TREE_CODE (type1);
1942
1943   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
1944   STRIP_TYPE_NOPS (op0);
1945   STRIP_TYPE_NOPS (op1);
1946
1947   /* If an error was already reported for one of the arguments,
1948      avoid reporting another error.  */
1949
1950   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
1951     return error_mark_node;
1952
1953   switch (code)
1954     {
1955     case PLUS_EXPR:
1956       /* Handle the pointer + int case.  */
1957       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
1958         return pointer_int_sum (PLUS_EXPR, op0, op1);
1959       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
1960         return pointer_int_sum (PLUS_EXPR, op1, op0);
1961       else
1962         common = 1;
1963       break;
1964
1965     case MINUS_EXPR:
1966       /* Subtraction of two similar pointers.
1967          We must subtract them as integers, then divide by object size.  */
1968       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
1969           && comp_target_types (type0, type1))
1970         return pointer_diff (op0, op1);
1971       /* Handle pointer minus int.  Just like pointer plus int.  */
1972       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
1973         return pointer_int_sum (MINUS_EXPR, op0, op1);
1974       else
1975         common = 1;
1976       break;
1977
1978     case MULT_EXPR:
1979       common = 1;
1980       break;
1981
1982     case TRUNC_DIV_EXPR:
1983     case CEIL_DIV_EXPR:
1984     case FLOOR_DIV_EXPR:
1985     case ROUND_DIV_EXPR:
1986     case EXACT_DIV_EXPR:
1987       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
1988            || code0 == COMPLEX_TYPE)
1989           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
1990               || code1 == COMPLEX_TYPE))
1991         {
1992           if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
1993             resultcode = RDIV_EXPR;
1994           else
1995             {
1996               /* Although it would be tempting to shorten always here, that
1997                  loses on some targets, since the modulo instruction is
1998                  undefined if the quotient can't be represented in the
1999                  computation mode.  We shorten only if unsigned or if
2000                  dividing by something we know != -1.  */
2001               shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2002                          || (TREE_CODE (op1) == INTEGER_CST
2003                              && (TREE_INT_CST_LOW (op1) != -1
2004                                  || TREE_INT_CST_HIGH (op1) != -1)));
2005             }
2006           common = 1;
2007         }
2008       break;
2009
2010     case BIT_AND_EXPR:
2011     case BIT_ANDTC_EXPR:
2012     case BIT_IOR_EXPR:
2013     case BIT_XOR_EXPR:
2014       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2015         shorten = -1;
2016       /* If one operand is a constant, and the other is a short type
2017          that has been converted to an int,
2018          really do the work in the short type and then convert the
2019          result to int.  If we are lucky, the constant will be 0 or 1
2020          in the short type, making the entire operation go away.  */
2021       if (TREE_CODE (op0) == INTEGER_CST
2022           && TREE_CODE (op1) == NOP_EXPR
2023           && TYPE_PRECISION (type1) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))
2024           && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1, 0))))
2025         {
2026           final_type = result_type;
2027           op1 = TREE_OPERAND (op1, 0);
2028           result_type = TREE_TYPE (op1);
2029         }
2030       if (TREE_CODE (op1) == INTEGER_CST
2031           && TREE_CODE (op0) == NOP_EXPR
2032           && TYPE_PRECISION (type0) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))
2033           && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2034         {
2035           final_type = result_type;
2036           op0 = TREE_OPERAND (op0, 0);
2037           result_type = TREE_TYPE (op0);
2038         }
2039       break;
2040
2041     case TRUNC_MOD_EXPR:
2042     case FLOOR_MOD_EXPR:
2043       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2044         {
2045           /* Although it would be tempting to shorten always here, that loses
2046              on some targets, since the modulo instruction is undefined if the
2047              quotient can't be represented in the computation mode.  We shorten
2048              only if unsigned or if dividing by something we know != -1.  */
2049           shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2050                      || (TREE_CODE (op1) == INTEGER_CST
2051                          && (TREE_INT_CST_LOW (op1) != -1
2052                              || TREE_INT_CST_HIGH (op1) != -1)));
2053           common = 1;
2054         }
2055       break;
2056
2057     case TRUTH_ANDIF_EXPR:
2058     case TRUTH_ORIF_EXPR:
2059     case TRUTH_AND_EXPR:
2060     case TRUTH_OR_EXPR:
2061     case TRUTH_XOR_EXPR:
2062       if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
2063            || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2064           && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
2065               || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2066         {
2067           /* Result of these operations is always an int,
2068              but that does not mean the operands should be
2069              converted to ints!  */
2070           result_type = integer_type_node;
2071           op0 = truthvalue_conversion (op0);
2072           op1 = truthvalue_conversion (op1);
2073           converted = 1;
2074         }
2075       break;
2076
2077       /* Shift operations: result has same type as first operand;
2078          always convert second operand to int.
2079          Also set SHORT_SHIFT if shifting rightward.  */
2080
2081     case RSHIFT_EXPR:
2082       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2083         {
2084           if (TREE_CODE (op1) == INTEGER_CST)
2085             {
2086               if (tree_int_cst_sgn (op1) < 0)
2087                 warning ("right shift count is negative");
2088               else
2089                 {
2090                   if (TREE_INT_CST_LOW (op1) | TREE_INT_CST_HIGH (op1))
2091                     short_shift = 1;
2092                   if (TREE_INT_CST_HIGH (op1) != 0
2093                       || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
2094                           >= TYPE_PRECISION (type0)))
2095                     warning ("right shift count >= width of type");
2096                 }
2097             }
2098           /* Use the type of the value to be shifted.
2099              This is what most traditional C compilers do.  */
2100           result_type = type0;
2101           /* Unless traditional, convert the shift-count to an integer,
2102              regardless of size of value being shifted.  */
2103           if (! flag_traditional)
2104             {
2105               if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2106                 op1 = convert (integer_type_node, op1);
2107               /* Avoid converting op1 to result_type later.  */
2108               converted = 1;
2109             }
2110         }
2111       break;
2112
2113     case LSHIFT_EXPR:
2114       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2115         {
2116           if (TREE_CODE (op1) == INTEGER_CST)
2117             {
2118               if (tree_int_cst_sgn (op1) < 0)
2119                 warning ("left shift count is negative");
2120               else if (TREE_INT_CST_HIGH (op1) != 0
2121                        || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
2122                            >= TYPE_PRECISION (type0)))
2123                 warning ("left shift count >= width of type");
2124             }
2125           /* Use the type of the value to be shifted.
2126              This is what most traditional C compilers do.  */
2127           result_type = type0;
2128           /* Unless traditional, convert the shift-count to an integer,
2129              regardless of size of value being shifted.  */
2130           if (! flag_traditional)
2131             {
2132               if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2133                 op1 = convert (integer_type_node, op1);
2134               /* Avoid converting op1 to result_type later.  */
2135               converted = 1;
2136             }
2137         }
2138       break;
2139
2140     case RROTATE_EXPR:
2141     case LROTATE_EXPR:
2142       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2143         {
2144           if (TREE_CODE (op1) == INTEGER_CST)
2145             {
2146               if (tree_int_cst_sgn (op1) < 0)
2147                 warning ("shift count is negative");
2148               else if (TREE_INT_CST_HIGH (op1) != 0
2149                        || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
2150                            >= TYPE_PRECISION (type0)))
2151                 warning ("shift count >= width of type");
2152             }
2153           /* Use the type of the value to be shifted.
2154              This is what most traditional C compilers do.  */
2155           result_type = type0;
2156           /* Unless traditional, convert the shift-count to an integer,
2157              regardless of size of value being shifted.  */
2158           if (! flag_traditional)
2159             {
2160               if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2161                 op1 = convert (integer_type_node, op1);
2162               /* Avoid converting op1 to result_type later.  */
2163               converted = 1;
2164             }
2165         }
2166       break;
2167
2168     case EQ_EXPR:
2169     case NE_EXPR:
2170       /* Result of comparison is always int,
2171          but don't convert the args to int!  */
2172       result_type = integer_type_node;
2173       converted = 1;
2174       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2175            || code0 == COMPLEX_TYPE)
2176           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2177               || code1 == COMPLEX_TYPE))
2178         short_compare = 1;
2179       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2180         {
2181           register tree tt0 = TREE_TYPE (type0);
2182           register tree tt1 = TREE_TYPE (type1);
2183           /* Anything compares with void *.  void * compares with anything.
2184              Otherwise, the targets must be compatible
2185              and both must be object or both incomplete.  */
2186           if (comp_target_types (type0, type1))
2187             ;
2188           else if (TYPE_MAIN_VARIANT (tt0) == void_type_node)
2189             {
2190               /* op0 != orig_op0 detects the case of something
2191                  whose value is 0 but which isn't a valid null ptr const.  */
2192               if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
2193                   && TREE_CODE (tt1) == FUNCTION_TYPE)
2194                 pedwarn ("ANSI C forbids comparison of `void *' with function pointer");
2195             }
2196           else if (TYPE_MAIN_VARIANT (tt1) == void_type_node)
2197             {
2198               if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
2199                   && TREE_CODE (tt0) == FUNCTION_TYPE)
2200                 pedwarn ("ANSI C forbids comparison of `void *' with function pointer");
2201             }
2202           else
2203             pedwarn ("comparison of distinct pointer types lacks a cast");
2204         }
2205       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2206                && integer_zerop (op1))
2207         op1 = null_pointer_node;
2208       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2209                && integer_zerop (op0))
2210         op0 = null_pointer_node;
2211       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2212         {
2213           if (! flag_traditional)
2214             pedwarn ("comparison between pointer and integer");
2215           op1 = convert (TREE_TYPE (op0), op1);
2216         }
2217       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2218         {
2219           if (! flag_traditional)
2220             pedwarn ("comparison between pointer and integer");
2221           op0 = convert (TREE_TYPE (op1), op0);
2222         }
2223       else
2224         /* If args are not valid, clear out RESULT_TYPE
2225            to cause an error message later.  */
2226         result_type = 0;
2227       break;
2228
2229     case MAX_EXPR:
2230     case MIN_EXPR:
2231       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2232           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2233         shorten = 1;
2234       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2235         {
2236           if (! comp_target_types (type0, type1))
2237             pedwarn ("comparison of distinct pointer types lacks a cast");
2238           else if (pedantic
2239                    && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2240             pedwarn ("ANSI C forbids ordered comparisons of pointers to functions");
2241           result_type = common_type (type0, type1);
2242         }
2243       break;
2244
2245     case LE_EXPR:
2246     case GE_EXPR:
2247     case LT_EXPR:
2248     case GT_EXPR:
2249       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2250           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2251         short_compare = 1;
2252       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2253         {
2254           if (! comp_target_types (type0, type1))
2255             pedwarn ("comparison of distinct pointer types lacks a cast");
2256           else if ((TYPE_SIZE (TREE_TYPE (type0)) != 0)
2257                    != (TYPE_SIZE (TREE_TYPE (type1)) != 0))
2258             pedwarn ("comparison of complete and incomplete pointers");
2259           else if (pedantic
2260                    && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2261             pedwarn ("ANSI C forbids ordered comparisons of pointers to functions");
2262           result_type = integer_type_node;
2263         }
2264       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2265                && integer_zerop (op1))
2266         {
2267           result_type = integer_type_node;
2268           op1 = null_pointer_node;
2269           if (pedantic)
2270             pedwarn ("ordered comparison of pointer with integer zero");
2271         }
2272       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2273                && integer_zerop (op0))
2274         {
2275           result_type = integer_type_node;
2276           op0 = null_pointer_node;
2277           if (pedantic)
2278             pedwarn ("ordered comparison of pointer with integer zero");
2279         }
2280       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2281         {
2282           result_type = integer_type_node;
2283           if (! flag_traditional)
2284             pedwarn ("comparison between pointer and integer");
2285           op1 = convert (TREE_TYPE (op0), op1);
2286         }
2287       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2288         {
2289           result_type = integer_type_node;
2290           if (! flag_traditional)
2291             pedwarn ("comparison between pointer and integer");
2292           op0 = convert (TREE_TYPE (op1), op0);
2293         }
2294       converted = 1;
2295       break;
2296     }
2297
2298   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2299       &&
2300       (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2301     {
2302       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
2303
2304       if (shorten || common || short_compare)
2305         result_type = common_type (type0, type1);
2306
2307       /* For certain operations (which identify themselves by shorten != 0)
2308          if both args were extended from the same smaller type,
2309          do the arithmetic in that type and then extend.
2310
2311          shorten !=0 and !=1 indicates a bitwise operation.
2312          For them, this optimization is safe only if
2313          both args are zero-extended or both are sign-extended.
2314          Otherwise, we might change the result.
2315          Eg, (short)-1 | (unsigned short)-1 is (int)-1
2316          but calculated in (unsigned short) it would be (unsigned short)-1.  */
2317
2318       if (shorten && none_complex)
2319         {
2320           int unsigned0, unsigned1;
2321           tree arg0 = get_narrower (op0, &unsigned0);
2322           tree arg1 = get_narrower (op1, &unsigned1);
2323           /* UNS is 1 if the operation to be done is an unsigned one.  */
2324           int uns = TREE_UNSIGNED (result_type);
2325           tree type;
2326
2327           final_type = result_type;
2328
2329           /* Handle the case that OP0 (or OP1) does not *contain* a conversion
2330              but it *requires* conversion to FINAL_TYPE.  */
2331
2332           if ((TYPE_PRECISION (TREE_TYPE (op0))
2333                == TYPE_PRECISION (TREE_TYPE (arg0)))
2334               && TREE_TYPE (op0) != final_type)
2335             unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
2336           if ((TYPE_PRECISION (TREE_TYPE (op1))
2337                == TYPE_PRECISION (TREE_TYPE (arg1)))
2338               && TREE_TYPE (op1) != final_type)
2339             unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
2340
2341           /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
2342
2343           /* For bitwise operations, signedness of nominal type
2344              does not matter.  Consider only how operands were extended.  */
2345           if (shorten == -1)
2346             uns = unsigned0;
2347
2348           /* Note that in all three cases below we refrain from optimizing
2349              an unsigned operation on sign-extended args.
2350              That would not be valid.  */
2351
2352           /* Both args variable: if both extended in same way
2353              from same width, do it in that width.
2354              Do it unsigned if args were zero-extended.  */
2355           if ((TYPE_PRECISION (TREE_TYPE (arg0))
2356                < TYPE_PRECISION (result_type))
2357               && (TYPE_PRECISION (TREE_TYPE (arg1))
2358                   == TYPE_PRECISION (TREE_TYPE (arg0)))
2359               && unsigned0 == unsigned1
2360               && (unsigned0 || !uns))
2361             result_type
2362               = signed_or_unsigned_type (unsigned0,
2363                                          common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
2364           else if (TREE_CODE (arg0) == INTEGER_CST
2365                    && (unsigned1 || !uns)
2366                    && (TYPE_PRECISION (TREE_TYPE (arg1))
2367                        < TYPE_PRECISION (result_type))
2368                    && (type = signed_or_unsigned_type (unsigned1,
2369                                                        TREE_TYPE (arg1)),
2370                        int_fits_type_p (arg0, type)))
2371             result_type = type;
2372           else if (TREE_CODE (arg1) == INTEGER_CST
2373                    && (unsigned0 || !uns)
2374                    && (TYPE_PRECISION (TREE_TYPE (arg0))
2375                        < TYPE_PRECISION (result_type))
2376                    && (type = signed_or_unsigned_type (unsigned0,
2377                                                        TREE_TYPE (arg0)),
2378                        int_fits_type_p (arg1, type)))
2379             result_type = type;
2380         }
2381
2382       /* Shifts can be shortened if shifting right.  */
2383
2384       if (short_shift)
2385         {
2386           int unsigned_arg;
2387           tree arg0 = get_narrower (op0, &unsigned_arg);
2388
2389           final_type = result_type;
2390
2391           if (arg0 == op0 && final_type == TREE_TYPE (op0))
2392             unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
2393
2394           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
2395               /* We can shorten only if the shift count is less than the
2396                  number of bits in the smaller type size.  */
2397               && TREE_INT_CST_HIGH (op1) == 0
2398               && TYPE_PRECISION (TREE_TYPE (arg0)) > TREE_INT_CST_LOW (op1)
2399               /* If arg is sign-extended and then unsigned-shifted,
2400                  we can simulate this with a signed shift in arg's type
2401                  only if the extended result is at least twice as wide
2402                  as the arg.  Otherwise, the shift could use up all the
2403                  ones made by sign-extension and bring in zeros.
2404                  We can't optimize that case at all, but in most machines
2405                  it never happens because available widths are 2**N.  */
2406               && (!TREE_UNSIGNED (final_type)
2407                   || unsigned_arg
2408                   || 2 * TYPE_PRECISION (TREE_TYPE (arg0)) <= TYPE_PRECISION (result_type)))
2409             {
2410               /* Do an unsigned shift if the operand was zero-extended.  */
2411               result_type
2412                 = signed_or_unsigned_type (unsigned_arg,
2413                                            TREE_TYPE (arg0));
2414               /* Convert value-to-be-shifted to that type.  */
2415               if (TREE_TYPE (op0) != result_type)
2416                 op0 = convert (result_type, op0);
2417               converted = 1;
2418             }
2419         }
2420
2421       /* Comparison operations are shortened too but differently.
2422          They identify themselves by setting short_compare = 1.  */
2423
2424       if (short_compare)
2425         {
2426           /* Don't write &op0, etc., because that would prevent op0
2427              from being kept in a register.
2428              Instead, make copies of the our local variables and
2429              pass the copies by reference, then copy them back afterward.  */
2430           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
2431           enum tree_code xresultcode = resultcode;
2432           tree val
2433             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
2434           if (val != 0)
2435             return val;
2436           op0 = xop0, op1 = xop1, result_type = xresult_type;
2437           resultcode = xresultcode;
2438
2439           if (extra_warnings)
2440             {
2441               int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
2442               int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
2443
2444               tree comp_type = TREE_TYPE (op0);
2445
2446               /* Avoid spurious warnings for comparison with enumerators.  */
2447
2448               xop0 = orig_op0;
2449               xop1 = orig_op1;
2450               STRIP_TYPE_NOPS (xop0);
2451               STRIP_TYPE_NOPS (xop1);
2452
2453               /* Give warnings for comparisons between signed and unsigned
2454                  quantities that may fail.  Do not warn if the signed quantity
2455                  is an unsuffixed integer literal (or some static constant
2456                  expression involving such literals) and it is positive.
2457                  Do not warn if the comparison is being done in a signed type,
2458                  since the signed type will only be chosen if it can represent
2459                  all the values of the unsigned type.  */
2460               /* Do the checking based on the original operand trees, so that
2461                  casts will be considered, but default promotions won't be.  */
2462               if (TREE_UNSIGNED (comp_type)
2463                   && ((op0_signed && (TREE_CODE (xop0) != INTEGER_CST
2464                                       || tree_int_cst_sgn (xop0) == -1))
2465                       || (op1_signed && (TREE_CODE (xop1) != INTEGER_CST
2466                                        || tree_int_cst_sgn (xop1) == -1))))
2467                 warning ("comparison between signed and unsigned");
2468             }
2469         }
2470     }
2471
2472   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
2473      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
2474      Then the expression will be built.
2475      It will be given type FINAL_TYPE if that is nonzero;
2476      otherwise, it will be given type RESULT_TYPE.  */
2477
2478   if (!result_type)
2479     {
2480       binary_op_error (code);
2481       return error_mark_node;
2482     }
2483
2484   if (! converted)
2485     {
2486       if (TREE_TYPE (op0) != result_type)
2487         op0 = convert (result_type, op0);
2488       if (TREE_TYPE (op1) != result_type)
2489         op1 = convert (result_type, op1);
2490     }
2491
2492   {
2493     register tree result = build (resultcode, result_type, op0, op1);
2494     register tree folded;
2495
2496     folded = fold (result);
2497     if (folded == result)
2498       TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2499     if (final_type != 0)
2500       return convert (final_type, folded);
2501     return folded;
2502   }
2503 }
2504 \f
2505 /* Return a tree for the sum or difference (RESULTCODE says which)
2506    of pointer PTROP and integer INTOP.  */
2507
2508 static tree
2509 pointer_int_sum (resultcode, ptrop, intop)
2510      enum tree_code resultcode;
2511      register tree ptrop, intop;
2512 {
2513   tree size_exp;
2514
2515   register tree result;
2516   register tree folded;
2517
2518   /* The result is a pointer of the same type that is being added.  */
2519
2520   register tree result_type = TREE_TYPE (ptrop);
2521
2522   if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2523     {
2524       if (pedantic || warn_pointer_arith)
2525         pedwarn ("pointer of type `void *' used in arithmetic");
2526       size_exp = integer_one_node;
2527     }
2528   else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2529     {
2530       if (pedantic || warn_pointer_arith)
2531         pedwarn ("pointer to a function used in arithmetic");
2532       size_exp = integer_one_node;
2533     }
2534   else
2535     size_exp = c_size_in_bytes (TREE_TYPE (result_type));
2536
2537   /* If what we are about to multiply by the size of the elements
2538      contains a constant term, apply distributive law
2539      and multiply that constant term separately.
2540      This helps produce common subexpressions.  */
2541
2542   if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2543       && ! TREE_CONSTANT (intop)
2544       && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2545       && TREE_CONSTANT (size_exp)
2546       /* If the constant comes from pointer subtraction,
2547          skip this optimization--it would cause an error.  */
2548       && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE)
2549     {
2550       enum tree_code subcode = resultcode;
2551       tree int_type = TREE_TYPE (intop);
2552       if (TREE_CODE (intop) == MINUS_EXPR)
2553         subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2554       /* Convert both subexpression types to the type of intop,
2555          because weird cases involving pointer arithmetic
2556          can result in a sum or difference with different type args.  */
2557       ptrop = build_binary_op (subcode, ptrop,
2558                                convert (int_type, TREE_OPERAND (intop, 1)), 1);
2559       intop = convert (int_type, TREE_OPERAND (intop, 0));
2560     }
2561
2562   /* Convert the integer argument to a type the same size as a pointer
2563      so the multiply won't overflow spuriously.  */
2564
2565   if (TYPE_PRECISION (TREE_TYPE (intop)) != POINTER_SIZE)
2566     intop = convert (type_for_size (POINTER_SIZE, 0), intop);
2567
2568   /* Replace the integer argument with a suitable product by the object size.
2569      Do this multiplication as signed, then convert to the appropriate
2570      pointer type (actually unsigned integral).  */
2571
2572   intop = convert (result_type,
2573                    build_binary_op (MULT_EXPR, intop,
2574                                     convert (TREE_TYPE (intop), size_exp), 1));
2575
2576   /* Create the sum or difference.  */
2577
2578   result = build (resultcode, result_type, ptrop, intop);
2579
2580   folded = fold (result);
2581   if (folded == result)
2582     TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2583   return folded;
2584 }
2585
2586 /* Return a tree for the difference of pointers OP0 and OP1.
2587    The resulting tree has type int.  */
2588
2589 static tree
2590 pointer_diff (op0, op1)
2591      register tree op0, op1;
2592 {
2593   register tree result, folded;
2594   tree restype = ptrdiff_type_node;
2595
2596   tree target_type = TREE_TYPE (TREE_TYPE (op0));
2597
2598   if (pedantic || warn_pointer_arith)
2599     {
2600       if (TREE_CODE (target_type) == VOID_TYPE)
2601         pedwarn ("pointer of type `void *' used in subtraction");
2602       if (TREE_CODE (target_type) == FUNCTION_TYPE)
2603         pedwarn ("pointer to a function used in subtraction");
2604     }
2605
2606   /* First do the subtraction as integers;
2607      then drop through to build the divide operator.  */
2608
2609   op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2610                          convert (restype, op1), 1);
2611   /* This generates an error if op1 is pointer to incomplete type.  */
2612   if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1))) == 0)
2613     error ("arithmetic on pointer to an incomplete type");
2614
2615   /* This generates an error if op0 is pointer to incomplete type.  */
2616   op1 = c_size_in_bytes (target_type);
2617
2618   /* Divide by the size, in easiest possible way.  */
2619
2620   result = build (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
2621
2622   folded = fold (result);
2623   if (folded == result)
2624     TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2625   return folded;
2626 }
2627 \f
2628 /* Construct and perhaps optimize a tree representation
2629    for a unary operation.  CODE, a tree_code, specifies the operation
2630    and XARG is the operand.  NOCONVERT nonzero suppresses
2631    the default promotions (such as from short to int).  */
2632
2633 tree
2634 build_unary_op (code, xarg, noconvert)
2635      enum tree_code code;
2636      tree xarg;
2637      int noconvert;
2638 {
2639   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
2640   register tree arg = xarg;
2641   register tree argtype = 0;
2642   register enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
2643   char *errstring = NULL;
2644   tree val;
2645
2646   if (typecode == ERROR_MARK)
2647     return error_mark_node;
2648   if (typecode == ENUMERAL_TYPE)
2649     typecode = INTEGER_TYPE;
2650
2651   switch (code)
2652     {
2653     case CONVERT_EXPR:
2654       /* This is used for unary plus, because a CONVERT_EXPR
2655          is enough to prevent anybody from looking inside for
2656          associativity, but won't generate any code.  */
2657       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2658             || typecode == COMPLEX_TYPE))
2659         errstring = "wrong type argument to unary plus";
2660       else if (!noconvert)
2661         arg = default_conversion (arg);
2662       break;
2663
2664     case NEGATE_EXPR:
2665       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2666             || typecode == COMPLEX_TYPE))
2667         errstring = "wrong type argument to unary minus";
2668       else if (!noconvert)
2669         arg = default_conversion (arg);
2670       break;
2671
2672     case BIT_NOT_EXPR:
2673       if (typecode == COMPLEX_TYPE)
2674         {
2675           code = CONJ_EXPR;
2676           if (!noconvert)
2677             arg = default_conversion (arg);
2678         }
2679       else if (typecode != INTEGER_TYPE)
2680         errstring = "wrong type argument to bit-complement";
2681       else if (!noconvert)
2682         arg = default_conversion (arg);
2683       break;
2684
2685     case ABS_EXPR:
2686       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2687             || typecode == COMPLEX_TYPE))
2688         errstring = "wrong type argument to abs";
2689       else if (!noconvert)
2690         arg = default_conversion (arg);
2691       break;
2692
2693     case CONJ_EXPR:
2694       /* Conjugating a real value is a no-op, but allow it anyway.  */
2695       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2696             || typecode == COMPLEX_TYPE))
2697         errstring = "wrong type argument to conjugation";
2698       else if (!noconvert)
2699         arg = default_conversion (arg);
2700       break;
2701
2702     case TRUTH_NOT_EXPR:
2703       if (typecode != INTEGER_TYPE
2704           && typecode != REAL_TYPE && typecode != POINTER_TYPE
2705           && typecode != COMPLEX_TYPE
2706           /* These will convert to a pointer.  */
2707           && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2708         {
2709           errstring = "wrong type argument to unary exclamation mark";
2710           break;
2711         }
2712       arg = truthvalue_conversion (arg);
2713       return invert_truthvalue (arg);
2714
2715     case NOP_EXPR:
2716       break;
2717
2718     case REALPART_EXPR:
2719       if (TREE_CODE (arg) == COMPLEX_CST)
2720         return TREE_REALPART (arg);
2721       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2722         return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2723       else
2724         return arg;
2725
2726     case IMAGPART_EXPR:
2727       if (TREE_CODE (arg) == COMPLEX_CST)
2728         return TREE_IMAGPART (arg);
2729       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2730         return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2731       else
2732         return convert (TREE_TYPE (arg), integer_zero_node);
2733
2734     case PREINCREMENT_EXPR:
2735     case POSTINCREMENT_EXPR:
2736     case PREDECREMENT_EXPR:
2737     case POSTDECREMENT_EXPR:
2738       /* Handle complex lvalues (when permitted)
2739          by reduction to simpler cases.  */
2740
2741       val = unary_complex_lvalue (code, arg);
2742       if (val != 0)
2743         return val;
2744
2745       /* Increment or decrement the real part of the value,
2746          and don't change the imaginary part.  */
2747       if (typecode == COMPLEX_TYPE)
2748         {
2749           tree real, imag;
2750
2751           arg = stabilize_reference (arg);
2752           real = build_unary_op (REALPART_EXPR, arg, 1);
2753           imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2754           return build (COMPLEX_EXPR, TREE_TYPE (arg),
2755                         build_unary_op (code, real, 1), imag);
2756         }
2757
2758       /* Report invalid types.  */
2759
2760       if (typecode != POINTER_TYPE
2761           && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2762         {
2763           if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2764             errstring ="wrong type argument to increment";
2765           else
2766             errstring ="wrong type argument to decrement";
2767           break;
2768         }
2769
2770       {
2771         register tree inc;
2772         tree result_type = TREE_TYPE (arg);
2773
2774         arg = get_unwidened (arg, 0);
2775         argtype = TREE_TYPE (arg);
2776
2777         /* Compute the increment.  */
2778
2779         if (typecode == POINTER_TYPE)
2780           {
2781             /* If pointer target is an undefined struct,
2782                we just cannot know how to do the arithmetic.  */
2783             if (TYPE_SIZE (TREE_TYPE (result_type)) == 0)
2784               error ("%s of pointer to unknown structure",
2785                        ((code == PREINCREMENT_EXPR
2786                          || code == POSTINCREMENT_EXPR)
2787                         ? "increment" : "decrement"));
2788             else if ((pedantic || warn_pointer_arith)
2789                      && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2790                          || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
2791               pedwarn ("wrong type argument to %s",
2792                        ((code == PREINCREMENT_EXPR
2793                          || code == POSTINCREMENT_EXPR)
2794                         ? "increment" : "decrement"));
2795             inc = c_size_in_bytes (TREE_TYPE (result_type));
2796           }
2797         else
2798           inc = integer_one_node;
2799
2800         inc = convert (argtype, inc);
2801
2802         /* Handle incrementing a cast-expression.  */
2803
2804         while (1)
2805           switch (TREE_CODE (arg))
2806             {
2807             case NOP_EXPR:
2808             case CONVERT_EXPR:
2809             case FLOAT_EXPR:
2810             case FIX_TRUNC_EXPR:
2811             case FIX_FLOOR_EXPR:
2812             case FIX_ROUND_EXPR:
2813             case FIX_CEIL_EXPR:
2814               pedantic_lvalue_warning (CONVERT_EXPR);
2815               /* If the real type has the same machine representation
2816                  as the type it is cast to, we can make better output
2817                  by adding directly to the inside of the cast.  */
2818               if ((TREE_CODE (TREE_TYPE (arg))
2819                    == TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))))
2820                   && (TYPE_MODE (TREE_TYPE (arg))
2821                       == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg, 0)))))
2822                 arg = TREE_OPERAND (arg, 0);
2823               else
2824                 {
2825                   tree incremented, modify, value;
2826                   arg = stabilize_reference (arg);
2827                   if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
2828                     value = arg;
2829                   else
2830                     value = save_expr (arg);
2831                   incremented = build (((code == PREINCREMENT_EXPR
2832                                          || code == POSTINCREMENT_EXPR)
2833                                         ? PLUS_EXPR : MINUS_EXPR),
2834                                        argtype, value, inc);
2835                   TREE_SIDE_EFFECTS (incremented) = 1;
2836                   modify = build_modify_expr (arg, NOP_EXPR, incremented);
2837                   value = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
2838                   TREE_USED (value) = 1;
2839                   return value;
2840                 }
2841               break;
2842
2843             default:
2844               goto give_up;
2845             }
2846       give_up:
2847
2848         /* Complain about anything else that is not a true lvalue.  */
2849         if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
2850                                     || code == POSTINCREMENT_EXPR)
2851                                    ? "increment" : "decrement")))
2852           return error_mark_node;
2853
2854         /* Report a read-only lvalue.  */
2855         if (TREE_READONLY (arg))
2856           readonly_warning (arg,
2857                             ((code == PREINCREMENT_EXPR
2858                               || code == POSTINCREMENT_EXPR)
2859                              ? "increment" : "decrement"));
2860
2861         val = build (code, TREE_TYPE (arg), arg, inc);
2862         TREE_SIDE_EFFECTS (val) = 1;
2863         val = convert (result_type, val);
2864         if (TREE_CODE (val) != code)
2865           TREE_NO_UNUSED_WARNING (val) = 1;
2866         return val;
2867       }
2868
2869     case ADDR_EXPR:
2870       /* Note that this operation never does default_conversion
2871          regardless of NOCONVERT.  */
2872
2873       /* Let &* cancel out to simplify resulting code.  */
2874       if (TREE_CODE (arg) == INDIRECT_REF)
2875         {
2876           /* Don't let this be an lvalue.  */
2877           if (lvalue_p (TREE_OPERAND (arg, 0)))
2878             return non_lvalue (TREE_OPERAND (arg, 0));
2879           return TREE_OPERAND (arg, 0);
2880         }
2881
2882       /* For &x[y], return x+y */
2883       if (TREE_CODE (arg) == ARRAY_REF)
2884         {
2885           if (mark_addressable (TREE_OPERAND (arg, 0)) == 0)
2886             return error_mark_node;
2887           return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
2888                                   TREE_OPERAND (arg, 1), 1);
2889         }
2890
2891       /* Handle complex lvalues (when permitted)
2892          by reduction to simpler cases.  */
2893       val = unary_complex_lvalue (code, arg);
2894       if (val != 0)
2895         return val;
2896
2897 #if 0 /* Turned off because inconsistent;
2898          float f; *&(int)f = 3.4 stores in int format
2899          whereas (int)f = 3.4 stores in float format.  */
2900       /* Address of a cast is just a cast of the address
2901          of the operand of the cast.  */
2902       switch (TREE_CODE (arg))
2903         {
2904         case NOP_EXPR:
2905         case CONVERT_EXPR:
2906         case FLOAT_EXPR:
2907         case FIX_TRUNC_EXPR:
2908         case FIX_FLOOR_EXPR:
2909         case FIX_ROUND_EXPR:
2910         case FIX_CEIL_EXPR:
2911           if (pedantic)
2912             pedwarn ("ANSI C forbids the address of a cast expression");
2913           return convert (build_pointer_type (TREE_TYPE (arg)),
2914                           build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0),
2915                                           0));
2916         }
2917 #endif
2918
2919       /* Allow the address of a constructor if all the elements
2920          are constant.  */
2921       if (TREE_CODE (arg) == CONSTRUCTOR && TREE_CONSTANT (arg))
2922         ;
2923       /* Anything not already handled and not a true memory reference
2924          is an error.  */
2925       else if (typecode != FUNCTION_TYPE && !lvalue_or_else (arg, "unary `&'"))
2926         return error_mark_node;
2927
2928       /* Ordinary case; arg is a COMPONENT_REF or a decl.  */
2929       argtype = TREE_TYPE (arg);
2930       /* If the lvalue is const or volatile,
2931          merge that into the type that the address will point to.  */
2932       if (TREE_CODE_CLASS (TREE_CODE (arg)) == 'd'
2933           || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
2934         {
2935           if (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg))
2936             argtype = c_build_type_variant (argtype,
2937                                             TREE_READONLY (arg),
2938                                             TREE_THIS_VOLATILE (arg));
2939         }
2940
2941       argtype = build_pointer_type (argtype);
2942
2943       if (mark_addressable (arg) == 0)
2944         return error_mark_node;
2945
2946       {
2947         tree addr;
2948
2949         if (TREE_CODE (arg) == COMPONENT_REF)
2950           {
2951             tree field = TREE_OPERAND (arg, 1);
2952
2953             addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
2954
2955             if (DECL_BIT_FIELD (field))
2956               {
2957                 error ("attempt to take address of bit-field structure member `%s'",
2958                        IDENTIFIER_POINTER (DECL_NAME (field)));
2959                 return error_mark_node;
2960               }
2961
2962             addr = convert (argtype, addr);
2963
2964             if (! integer_zerop (DECL_FIELD_BITPOS (field)))
2965               {
2966                 tree offset
2967                   = size_binop (EASY_DIV_EXPR, DECL_FIELD_BITPOS (field),
2968                                 size_int (BITS_PER_UNIT));
2969                 int flag = TREE_CONSTANT (addr);
2970                 addr = fold (build (PLUS_EXPR, argtype,
2971                                     addr, convert (argtype, offset)));
2972                 TREE_CONSTANT (addr) = flag;
2973               }
2974           }
2975         else
2976           addr = build1 (code, argtype, arg);
2977
2978         /* Address of a static or external variable or
2979            file-scope function counts as a constant.  */
2980         if (staticp (arg)
2981             && ! (TREE_CODE (arg) == FUNCTION_DECL
2982                   && DECL_CONTEXT (arg) != 0))
2983           TREE_CONSTANT (addr) = 1;
2984         return addr;
2985       }
2986     }
2987
2988   if (!errstring)
2989     {
2990       if (argtype == 0)
2991         argtype = TREE_TYPE (arg);
2992       return fold (build1 (code, argtype, arg));
2993     }
2994
2995   error (errstring);
2996   return error_mark_node;
2997 }
2998
2999 #if 0
3000 /* If CONVERSIONS is a conversion expression or a nested sequence of such,
3001    convert ARG with the same conversions in the same order
3002    and return the result.  */
3003
3004 static tree
3005 convert_sequence (conversions, arg)
3006      tree conversions;
3007      tree arg;
3008 {
3009   switch (TREE_CODE (conversions))
3010     {
3011     case NOP_EXPR:
3012     case CONVERT_EXPR:
3013     case FLOAT_EXPR:
3014     case FIX_TRUNC_EXPR:
3015     case FIX_FLOOR_EXPR:
3016     case FIX_ROUND_EXPR:
3017     case FIX_CEIL_EXPR:
3018       return convert (TREE_TYPE (conversions),
3019                       convert_sequence (TREE_OPERAND (conversions, 0),
3020                                         arg));
3021
3022     default:
3023       return arg;
3024     }
3025 }
3026 #endif /* 0 */
3027
3028 /* Return nonzero if REF is an lvalue valid for this language.
3029    Lvalues can be assigned, unless their type has TYPE_READONLY.
3030    Lvalues can have their address taken, unless they have DECL_REGISTER.  */
3031
3032 int
3033 lvalue_p (ref)
3034      tree ref;
3035 {
3036   register enum tree_code code = TREE_CODE (ref);
3037
3038   switch (code)
3039     {
3040     case REALPART_EXPR:
3041     case IMAGPART_EXPR:
3042     case COMPONENT_REF:
3043       return lvalue_p (TREE_OPERAND (ref, 0));
3044
3045     case STRING_CST:
3046       return 1;
3047
3048     case INDIRECT_REF:
3049     case ARRAY_REF:
3050     case VAR_DECL:
3051     case PARM_DECL:
3052     case RESULT_DECL:
3053     case ERROR_MARK:
3054       if (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
3055           && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
3056         return 1;
3057       break;
3058     }
3059   return 0;
3060 }
3061
3062 /* Return nonzero if REF is an lvalue valid for this language;
3063    otherwise, print an error message and return zero.  */
3064
3065 int
3066 lvalue_or_else (ref, string)
3067      tree ref;
3068      char *string;
3069 {
3070   int win = lvalue_p (ref);
3071   if (! win)
3072     error ("invalid lvalue in %s", string);
3073   return win;
3074 }
3075
3076 /* Apply unary lvalue-demanding operator CODE to the expression ARG
3077    for certain kinds of expressions which are not really lvalues
3078    but which we can accept as lvalues.
3079
3080    If ARG is not a kind of expression we can handle, return zero.  */
3081
3082 static tree
3083 unary_complex_lvalue (code, arg)
3084      enum tree_code code;
3085      tree arg;
3086 {
3087   /* Handle (a, b) used as an "lvalue".  */
3088   if (TREE_CODE (arg) == COMPOUND_EXPR)
3089     {
3090       tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
3091       pedantic_lvalue_warning (COMPOUND_EXPR);
3092       return build (COMPOUND_EXPR, TREE_TYPE (real_result),
3093                     TREE_OPERAND (arg, 0), real_result);
3094     }
3095
3096   /* Handle (a ? b : c) used as an "lvalue".  */
3097   if (TREE_CODE (arg) == COND_EXPR)
3098     {
3099       pedantic_lvalue_warning (COND_EXPR);
3100       return (build_conditional_expr
3101               (TREE_OPERAND (arg, 0),
3102                build_unary_op (code, TREE_OPERAND (arg, 1), 0),
3103                build_unary_op (code, TREE_OPERAND (arg, 2), 0)));
3104     }
3105
3106   return 0;
3107 }
3108
3109 /* If pedantic, warn about improper lvalue.   CODE is either COND_EXPR
3110    COMPOUND_EXPR, or CONVERT_EXPR (for casts).  */
3111
3112 static void
3113 pedantic_lvalue_warning (code)
3114      enum tree_code code;
3115 {
3116   if (pedantic)
3117     pedwarn ("ANSI C forbids use of %s expressions as lvalues",
3118              code == COND_EXPR ? "conditional"
3119              : code == COMPOUND_EXPR ? "compound" : "cast");
3120 }
3121 \f
3122 /* Warn about storing in something that is `const'.  */
3123
3124 void
3125 readonly_warning (arg, string)
3126      tree arg;
3127      char *string;
3128 {
3129   char buf[80];
3130   strcpy (buf, string);
3131
3132   /* Forbid assignments to iterators.  */
3133   if (TREE_CODE (arg) == VAR_DECL && ITERATOR_P (arg))
3134     {
3135       strcat (buf, " of iterator `%s'");
3136       pedwarn (buf, IDENTIFIER_POINTER (DECL_NAME (arg)));
3137     }
3138
3139   if (TREE_CODE (arg) == COMPONENT_REF)
3140     {
3141       if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
3142         readonly_warning (TREE_OPERAND (arg, 0), string);
3143       else
3144         {
3145           strcat (buf, " of read-only member `%s'");
3146           pedwarn (buf, IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
3147         }
3148     }
3149   else if (TREE_CODE (arg) == VAR_DECL)
3150     {
3151       strcat (buf, " of read-only variable `%s'");
3152       pedwarn (buf, IDENTIFIER_POINTER (DECL_NAME (arg)));
3153     }
3154   else
3155     {
3156       pedwarn ("%s of read-only location", buf);
3157     }
3158 }
3159 \f
3160 /* Mark EXP saying that we need to be able to take the
3161    address of it; it should not be allocated in a register.
3162    Value is 1 if successful.  */
3163
3164 int
3165 mark_addressable (exp)
3166      tree exp;
3167 {
3168   register tree x = exp;
3169   while (1)
3170     switch (TREE_CODE (x))
3171       {
3172       case ADDR_EXPR:
3173       case COMPONENT_REF:
3174       case ARRAY_REF:
3175       case REALPART_EXPR:
3176       case IMAGPART_EXPR:
3177         x = TREE_OPERAND (x, 0);
3178         break;
3179
3180       case CONSTRUCTOR:
3181         TREE_ADDRESSABLE (x) = 1;
3182         return 1;
3183
3184       case VAR_DECL:
3185       case CONST_DECL:
3186       case PARM_DECL:
3187       case RESULT_DECL:
3188         if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
3189             && DECL_NONLOCAL (x))
3190           {
3191             if (TREE_PUBLIC (x))
3192               {
3193                 error ("global register variable `%s' used in nested function",
3194                        IDENTIFIER_POINTER (DECL_NAME (x)));
3195                 return 0;
3196               }
3197             pedwarn ("register variable `%s' used in nested function",
3198                      IDENTIFIER_POINTER (DECL_NAME (x)));
3199           }
3200         else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
3201           {
3202             if (TREE_PUBLIC (x))
3203               {
3204                 error ("address of global register variable `%s' requested",
3205                        IDENTIFIER_POINTER (DECL_NAME (x)));
3206                 return 0;
3207               }
3208
3209             /* If we are making this addressable due to its having
3210                volatile components, give a different error message.  Also
3211                handle the case of an unnamed parameter by not trying
3212                to give the name.  */
3213
3214             else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x)))
3215               {
3216                 error ("cannot put object with volatile field into register");
3217                 return 0;
3218               }
3219
3220             pedwarn ("address of register variable `%s' requested",
3221                      IDENTIFIER_POINTER (DECL_NAME (x)));
3222           }
3223         put_var_into_stack (x);
3224
3225         /* drops in */
3226       case FUNCTION_DECL:
3227         TREE_ADDRESSABLE (x) = 1;
3228 #if 0  /* poplevel deals with this now.  */
3229         if (DECL_CONTEXT (x) == 0)
3230           TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
3231 #endif
3232
3233       default:
3234         return 1;
3235     }
3236 }
3237 \f
3238 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
3239
3240 tree
3241 build_conditional_expr (ifexp, op1, op2)
3242      tree ifexp, op1, op2;
3243 {
3244   register tree type1;
3245   register tree type2;
3246   register enum tree_code code1;
3247   register enum tree_code code2;
3248   register tree result_type = NULL;
3249   tree orig_op1 = op1, orig_op2 = op2;
3250
3251   /* If second operand is omitted, it is the same as the first one;
3252      make sure it is calculated only once.  */
3253   if (op1 == 0)
3254     {
3255       if (pedantic)
3256         pedwarn ("ANSI C forbids omitting the middle term of a ?: expression");
3257       ifexp = op1 = save_expr (ifexp);
3258     }
3259
3260   ifexp = truthvalue_conversion (default_conversion (ifexp));
3261
3262 #if 0 /* Produces wrong result if within sizeof.  */
3263   /* Don't promote the operands separately if they promote
3264      the same way.  Return the unpromoted type and let the combined
3265      value get promoted if necessary.  */
3266
3267   if (TREE_TYPE (op1) == TREE_TYPE (op2)
3268       && TREE_CODE (TREE_TYPE (op1)) != ARRAY_TYPE
3269       && TREE_CODE (TREE_TYPE (op1)) != ENUMERAL_TYPE
3270       && TREE_CODE (TREE_TYPE (op1)) != FUNCTION_TYPE)
3271     {
3272       if (TREE_CODE (ifexp) == INTEGER_CST)
3273         return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3274
3275       return fold (build (COND_EXPR, TREE_TYPE (op1), ifexp, op1, op2));
3276     }
3277 #endif
3278
3279   /* Promote both alternatives.  */
3280
3281   if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
3282     op1 = default_conversion (op1);
3283   if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
3284     op2 = default_conversion (op2);
3285
3286   if (TREE_CODE (ifexp) == ERROR_MARK
3287       || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
3288       || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
3289     return error_mark_node;
3290
3291   type1 = TREE_TYPE (op1);
3292   code1 = TREE_CODE (type1);
3293   type2 = TREE_TYPE (op2);
3294   code2 = TREE_CODE (type2);
3295
3296   /* Quickly detect the usual case where op1 and op2 have the same type
3297      after promotion.  */
3298   if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
3299     {
3300       if (type1 == type2)
3301         result_type = type1;
3302       else
3303         result_type = TYPE_MAIN_VARIANT (type1);
3304     }
3305   else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE)
3306            && (code2 == INTEGER_TYPE || code2 == REAL_TYPE))
3307     {
3308       result_type = common_type (type1, type2);
3309     }
3310   else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
3311     {
3312       if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
3313         pedwarn ("ANSI C forbids conditional expr with only one void side");
3314       result_type = void_type_node;
3315     }
3316   else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
3317     {
3318       if (comp_target_types (type1, type2))
3319         result_type = common_type (type1, type2);
3320       else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
3321                && TREE_CODE (orig_op1) != NOP_EXPR)
3322         result_type = qualify_type (type2, type1);
3323       else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
3324                && TREE_CODE (orig_op2) != NOP_EXPR)
3325         result_type = qualify_type (type1, type2);
3326       else if (TYPE_MAIN_VARIANT (TREE_TYPE (type1)) == void_type_node)
3327         {
3328           if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
3329             pedwarn ("ANSI C forbids conditional expr between `void *' and function pointer");
3330           result_type = qualify_type (type1, type2);
3331         }
3332       else if (TYPE_MAIN_VARIANT (TREE_TYPE (type2)) == void_type_node)
3333         {
3334           if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
3335             pedwarn ("ANSI C forbids conditional expr between `void *' and function pointer");
3336           result_type = qualify_type (type2, type1);
3337         }
3338       else
3339         {
3340           pedwarn ("pointer type mismatch in conditional expression");
3341           result_type = build_pointer_type (void_type_node);
3342         }
3343     }
3344   else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
3345     {
3346       if (! integer_zerop (op2))
3347         pedwarn ("pointer/integer type mismatch in conditional expression");
3348       else
3349         {
3350           op2 = null_pointer_node;
3351 #if 0  /* The spec seems to say this is permitted.  */
3352           if (pedantic && TREE_CODE (type1) == FUNCTION_TYPE)
3353             pedwarn ("ANSI C forbids conditional expr between 0 and function pointer");
3354 #endif
3355         }
3356       result_type = type1;
3357     }
3358   else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
3359     {
3360       if (!integer_zerop (op1))
3361         pedwarn ("pointer/integer type mismatch in conditional expression");
3362       else
3363         {
3364           op1 = null_pointer_node;
3365 #if 0  /* The spec seems to say this is permitted.  */
3366           if (pedantic && TREE_CODE (type2) == FUNCTION_TYPE)
3367             pedwarn ("ANSI C forbids conditional expr between 0 and function pointer");
3368 #endif
3369         }
3370       result_type = type2;
3371     }
3372
3373   if (!result_type)
3374     {
3375       if (flag_cond_mismatch)
3376         result_type = void_type_node;
3377       else
3378         {
3379           error ("type mismatch in conditional expression");
3380           return error_mark_node;
3381         }
3382     }
3383
3384   /* Merge const and volatile flags of the incoming types.  */
3385   result_type
3386     = build_type_variant (result_type,
3387                           TREE_READONLY (op1) || TREE_READONLY (op2),
3388                           TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
3389
3390   if (result_type != TREE_TYPE (op1))
3391     op1 = convert_and_check (result_type, op1);
3392   if (result_type != TREE_TYPE (op2))
3393     op2 = convert_and_check (result_type, op2);
3394
3395 #if 0
3396   if (code1 == RECORD_TYPE || code1 == UNION_TYPE)
3397     {
3398       result_type = TREE_TYPE (op1);
3399       if (TREE_CONSTANT (ifexp))
3400         return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3401
3402       if (TYPE_MODE (result_type) == BLKmode)
3403         {
3404           register tree tempvar
3405             = build_decl (VAR_DECL, NULL_TREE, result_type);
3406           register tree xop1 = build_modify_expr (tempvar, op1);
3407           register tree xop2 = build_modify_expr (tempvar, op2);
3408           register tree result = fold (build (COND_EXPR, result_type,
3409                                               ifexp, xop1, xop2));
3410
3411           layout_decl (tempvar, TYPE_ALIGN (result_type));
3412           /* No way to handle variable-sized objects here.
3413              I fear that the entire handling of BLKmode conditional exprs
3414              needs to be redone.  */
3415           if (TREE_CODE (DECL_SIZE (tempvar)) != INTEGER_CST)
3416             abort ();
3417           DECL_RTL (tempvar)
3418             = assign_stack_local (DECL_MODE (tempvar),
3419                                   (TREE_INT_CST_LOW (DECL_SIZE (tempvar))
3420                                    + BITS_PER_UNIT - 1)
3421                                   / BITS_PER_UNIT,
3422                                   0);
3423
3424           TREE_SIDE_EFFECTS (result)
3425             = TREE_SIDE_EFFECTS (ifexp) | TREE_SIDE_EFFECTS (op1)
3426               | TREE_SIDE_EFFECTS (op2);
3427           return build (COMPOUND_EXPR, result_type, result, tempvar);
3428         }
3429     }
3430 #endif /* 0 */
3431
3432   if (TREE_CODE (ifexp) == INTEGER_CST)
3433     return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3434
3435   return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
3436 }
3437 \f
3438 /* Given a list of expressions, return a compound expression
3439    that performs them all and returns the value of the last of them.  */
3440
3441 tree
3442 build_compound_expr (list)
3443      tree list;
3444 {
3445   return internal_build_compound_expr (list, TRUE);
3446 }
3447
3448 static tree
3449 internal_build_compound_expr (list, first_p)
3450      tree list;
3451      int first_p;
3452 {
3453   register tree rest;
3454
3455   if (TREE_CHAIN (list) == 0)
3456     {
3457 #if 0 /* If something inside inhibited lvalueness, we should not override.  */
3458       /* Consider (x, y+0), which is not an lvalue since y+0 is not.  */
3459
3460       /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3461       if (TREE_CODE (list) == NON_LVALUE_EXPR)
3462         list = TREE_OPERAND (list, 0);
3463 #endif
3464
3465       /* Don't let (0, 0) be null pointer constant.  */
3466       if (!first_p && integer_zerop (TREE_VALUE (list)))
3467         return non_lvalue (TREE_VALUE (list));
3468       return TREE_VALUE (list);
3469     }
3470
3471   if (TREE_CHAIN (list) != 0 && TREE_CHAIN (TREE_CHAIN (list)) == 0)
3472     {
3473       /* Convert arrays to pointers when there really is a comma operator.  */
3474       if (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (list)))) == ARRAY_TYPE)
3475         TREE_VALUE (TREE_CHAIN (list))
3476           = default_conversion (TREE_VALUE (TREE_CHAIN (list)));
3477     }
3478
3479   rest = internal_build_compound_expr (TREE_CHAIN (list), FALSE);
3480
3481   /* When pedantic, a compound expression can be neither an lvalue
3482      nor an integer constant expression.  */
3483   if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)) && ! pedantic)
3484     return rest;
3485
3486   return build (COMPOUND_EXPR, TREE_TYPE (rest), TREE_VALUE (list), rest);
3487 }
3488
3489 /* Build an expression representing a cast to type TYPE of expression EXPR.  */
3490
3491 tree
3492 build_c_cast (type, expr)
3493      register tree type;
3494      tree expr;
3495 {
3496   register tree value = expr;
3497
3498   if (type == error_mark_node || expr == error_mark_node)
3499     return error_mark_node;
3500   type = TYPE_MAIN_VARIANT (type);
3501
3502 #if 0
3503   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3504   if (TREE_CODE (value) == NON_LVALUE_EXPR)
3505     value = TREE_OPERAND (value, 0);
3506 #endif
3507
3508   if (TREE_CODE (type) == ARRAY_TYPE)
3509     {
3510       error ("cast specifies array type");
3511       return error_mark_node;
3512     }
3513
3514   if (TREE_CODE (type) == FUNCTION_TYPE)
3515     {
3516       error ("cast specifies function type");
3517       return error_mark_node;
3518     }
3519
3520   if (type == TREE_TYPE (value))
3521     {
3522       if (pedantic)
3523         {
3524           if (TREE_CODE (type) == RECORD_TYPE
3525               || TREE_CODE (type) == UNION_TYPE)
3526             pedwarn ("ANSI C forbids casting nonscalar to the same type");
3527         }
3528     }
3529   else if (TREE_CODE (type) == UNION_TYPE)
3530     {
3531       tree field;
3532       if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
3533           || TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE)
3534         value = default_conversion (value);
3535
3536       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3537         if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3538                        TYPE_MAIN_VARIANT (TREE_TYPE (value))))
3539           break;
3540
3541       if (field)
3542         {
3543           char *name;
3544           tree t;
3545
3546           if (pedantic)
3547             pedwarn ("ANSI C forbids casts to union type");
3548           if (TYPE_NAME (type) != 0)
3549             {
3550               if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
3551                 name = IDENTIFIER_POINTER (TYPE_NAME (type));
3552               else
3553                 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
3554             }
3555           else
3556             name = "";
3557           t = digest_init (type, build (CONSTRUCTOR, type, NULL_TREE,
3558                                         build_tree_list (field, value)),
3559                            0, 0);
3560           TREE_CONSTANT (t) = TREE_CONSTANT (value);
3561           return t;
3562         }
3563       error ("cast to union type from type not present in union");
3564       return error_mark_node;
3565     }
3566   else
3567     {
3568       tree otype, ovalue;
3569
3570       /* If casting to void, avoid the error that would come
3571          from default_conversion in the case of a non-lvalue array.  */
3572       if (type == void_type_node)
3573         return build1 (CONVERT_EXPR, type, value);
3574
3575       /* Convert functions and arrays to pointers,
3576          but don't convert any other types.  */
3577       if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
3578           || TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE)
3579         value = default_conversion (value);
3580       otype = TREE_TYPE (value);
3581
3582       /* Optionally warn about potentially worrisome casts.  */
3583
3584       if (warn_cast_qual
3585           && TREE_CODE (type) == POINTER_TYPE
3586           && TREE_CODE (otype) == POINTER_TYPE)
3587         {
3588           if (TYPE_VOLATILE (TREE_TYPE (otype))
3589               && ! TYPE_VOLATILE (TREE_TYPE (type)))
3590             pedwarn ("cast discards `volatile' from pointer target type");
3591           if (TYPE_READONLY (TREE_TYPE (otype))
3592               && ! TYPE_READONLY (TREE_TYPE (type)))
3593             pedwarn ("cast discards `const' from pointer target type");
3594         }
3595
3596       /* Warn about possible alignment problems.  */
3597       if (STRICT_ALIGNMENT && warn_cast_align
3598           && TREE_CODE (type) == POINTER_TYPE
3599           && TREE_CODE (otype) == POINTER_TYPE
3600           && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3601           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3602           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3603         warning ("cast increases required alignment of target type");
3604
3605       if (TREE_CODE (type) == INTEGER_TYPE
3606           && TREE_CODE (otype) == POINTER_TYPE
3607           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3608           && !TREE_CONSTANT (value))
3609         warning ("cast from pointer to integer of different size");
3610
3611       if (warn_bad_function_cast
3612           && TREE_CODE (value) == CALL_EXPR
3613           && TREE_CODE (type) != TREE_CODE (otype))
3614         warning ("cast does not match function type");
3615
3616       if (TREE_CODE (type) == POINTER_TYPE
3617           && TREE_CODE (otype) == INTEGER_TYPE
3618           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3619 #if 0
3620           /* Don't warn about converting 0 to pointer,
3621              provided the 0 was explicit--not cast or made by folding.  */
3622           && !(TREE_CODE (value) == INTEGER_CST && integer_zerop (value))
3623 #endif
3624           /* Don't warn about converting any constant.  */
3625           && !TREE_CONSTANT (value))
3626         warning ("cast to pointer from integer of different size");
3627
3628       ovalue = value;
3629       value = convert (type, value);
3630
3631       /* Ignore any integer overflow caused by the cast.  */
3632       if (TREE_CODE (value) == INTEGER_CST)
3633         {
3634           TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3635           TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3636         }
3637     }
3638
3639   /* Pedantically, don't ley (void *) (FOO *) 0 be a null pointer constant.  */
3640   if (pedantic && TREE_CODE (value) == INTEGER_CST
3641       && TREE_CODE (expr) == INTEGER_CST
3642       && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3643     value = non_lvalue (value);
3644
3645   /* If pedantic, don't let a cast be an lvalue.  */
3646   if (value == expr && pedantic)
3647     value = non_lvalue (value);
3648
3649   return value;
3650 }
3651 \f
3652 /* Build an assignment expression of lvalue LHS from value RHS.
3653    MODIFYCODE is the code for a binary operator that we use
3654    to combine the old value of LHS with RHS to get the new value.
3655    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.  */
3656
3657 tree
3658 build_modify_expr (lhs, modifycode, rhs)
3659      tree lhs, rhs;
3660      enum tree_code modifycode;
3661 {
3662   register tree result;
3663   tree newrhs;
3664   tree lhstype = TREE_TYPE (lhs);
3665   tree olhstype = lhstype;
3666
3667   /* Types that aren't fully specified cannot be used in assignments.  */
3668   lhs = require_complete_type (lhs);
3669
3670   /* Avoid duplicate error messages from operands that had errors.  */
3671   if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3672     return error_mark_node;
3673
3674   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3675   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3676      whose value is 0 to count as a null pointer constant.  */
3677   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3678     rhs = TREE_OPERAND (rhs, 0);
3679
3680   newrhs = rhs;
3681
3682   /* Handle control structure constructs used as "lvalues".  */
3683
3684   switch (TREE_CODE (lhs))
3685     {
3686       /* Handle (a, b) used as an "lvalue".  */
3687     case COMPOUND_EXPR:
3688       pedantic_lvalue_warning (COMPOUND_EXPR);
3689       newrhs = build_modify_expr (TREE_OPERAND (lhs, 1),
3690                                   modifycode, rhs);
3691       if (TREE_CODE (newrhs) == ERROR_MARK)
3692         return error_mark_node;
3693       return build (COMPOUND_EXPR, lhstype,
3694                     TREE_OPERAND (lhs, 0), newrhs);
3695
3696       /* Handle (a ? b : c) used as an "lvalue".  */
3697     case COND_EXPR:
3698       pedantic_lvalue_warning (COND_EXPR);
3699       rhs = save_expr (rhs);
3700       {
3701         /* Produce (a ? (b = rhs) : (c = rhs))
3702            except that the RHS goes through a save-expr
3703            so the code to compute it is only emitted once.  */
3704         tree cond
3705           = build_conditional_expr (TREE_OPERAND (lhs, 0),
3706                                     build_modify_expr (TREE_OPERAND (lhs, 1),
3707                                                        modifycode, rhs),
3708                                     build_modify_expr (TREE_OPERAND (lhs, 2),
3709                                                        modifycode, rhs));
3710         if (TREE_CODE (cond) == ERROR_MARK)
3711           return cond;
3712         /* Make sure the code to compute the rhs comes out
3713            before the split.  */
3714         return build (COMPOUND_EXPR, TREE_TYPE (lhs),
3715                       /* But cast it to void to avoid an "unused" error.  */
3716                       convert (void_type_node, rhs), cond);
3717       }
3718     }
3719
3720   /* If a binary op has been requested, combine the old LHS value with the RHS
3721      producing the value we should actually store into the LHS.  */
3722
3723   if (modifycode != NOP_EXPR)
3724     {
3725       lhs = stabilize_reference (lhs);
3726       newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3727     }
3728
3729   /* Handle a cast used as an "lvalue".
3730      We have already performed any binary operator using the value as cast.
3731      Now convert the result to the cast type of the lhs,
3732      and then true type of the lhs and store it there;
3733      then convert result back to the cast type to be the value
3734      of the assignment.  */
3735
3736   switch (TREE_CODE (lhs))
3737     {
3738     case NOP_EXPR:
3739     case CONVERT_EXPR:
3740     case FLOAT_EXPR:
3741     case FIX_TRUNC_EXPR:
3742     case FIX_FLOOR_EXPR:
3743     case FIX_ROUND_EXPR:
3744     case FIX_CEIL_EXPR:
3745       if (TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
3746           || TREE_CODE (TREE_TYPE (newrhs)) == FUNCTION_TYPE)
3747         newrhs = default_conversion (newrhs);
3748       {
3749         tree inner_lhs = TREE_OPERAND (lhs, 0);
3750         tree result;
3751         result = build_modify_expr (inner_lhs, NOP_EXPR,
3752                                     convert (TREE_TYPE (inner_lhs),
3753                                              convert (lhstype, newrhs)));
3754         if (TREE_CODE (result) == ERROR_MARK)
3755           return result;
3756         pedantic_lvalue_warning (CONVERT_EXPR);
3757         return convert (TREE_TYPE (lhs), result);
3758       }
3759     }
3760
3761   /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
3762      Reject anything strange now.  */
3763
3764   if (!lvalue_or_else (lhs, "assignment"))
3765     return error_mark_node;
3766
3767   /* Warn about storing in something that is `const'.  */
3768
3769   if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3770       || ((TREE_CODE (lhstype) == RECORD_TYPE
3771            || TREE_CODE (lhstype) == UNION_TYPE)
3772           && C_TYPE_FIELDS_READONLY (lhstype)))
3773     readonly_warning (lhs, "assignment");
3774
3775   /* If storing into a structure or union member,
3776      it has probably been given type `int'.
3777      Compute the type that would go with
3778      the actual amount of storage the member occupies.  */
3779
3780   if (TREE_CODE (lhs) == COMPONENT_REF
3781       && (TREE_CODE (lhstype) == INTEGER_TYPE
3782           || TREE_CODE (lhstype) == REAL_TYPE
3783           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3784     lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3785
3786   /* If storing in a field that is in actuality a short or narrower than one,
3787      we must store in the field in its actual type.  */
3788
3789   if (lhstype != TREE_TYPE (lhs))
3790     {
3791       lhs = copy_node (lhs);
3792       TREE_TYPE (lhs) = lhstype;
3793     }
3794
3795   /* Convert new value to destination type.  */
3796
3797   newrhs = convert_for_assignment (lhstype, newrhs, "assignment",
3798                                    NULL_TREE, NULL_TREE, 0);
3799   if (TREE_CODE (newrhs) == ERROR_MARK)
3800     return error_mark_node;
3801
3802   result = build (MODIFY_EXPR, lhstype, lhs, newrhs);
3803   TREE_SIDE_EFFECTS (result) = 1;
3804
3805   /* If we got the LHS in a different type for storing in,
3806      convert the result back to the nominal type of LHS
3807      so that the value we return always has the same type
3808      as the LHS argument.  */
3809
3810   if (olhstype == TREE_TYPE (result))
3811     return result;
3812   return convert_for_assignment (olhstype, result, "assignment",
3813                                  NULL_TREE, NULL_TREE, 0);
3814 }
3815 \f
3816 /* Convert value RHS to type TYPE as preparation for an assignment
3817    to an lvalue of type TYPE.
3818    The real work of conversion is done by `convert'.
3819    The purpose of this function is to generate error messages
3820    for assignments that are not allowed in C.
3821    ERRTYPE is a string to use in error messages:
3822    "assignment", "return", etc.  If it is null, this is parameter passing
3823    for a function call (and different error messages are output).  Otherwise,
3824    it may be a name stored in the spelling stack and interpreted by
3825    get_spelling.
3826
3827    FUNNAME is the name of the function being called,
3828    as an IDENTIFIER_NODE, or null.
3829    PARMNUM is the number of the argument, for printing in error messages.  */
3830
3831 static tree
3832 convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
3833      tree type, rhs;
3834      char *errtype;
3835      tree fundecl, funname;
3836      int parmnum;
3837 {
3838   register enum tree_code codel = TREE_CODE (type);
3839   register tree rhstype;
3840   register enum tree_code coder;
3841
3842   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3843   /* Do not use STRIP_NOPS here.  We do not want an enumerator
3844      whose value is 0 to count as a null pointer constant.  */
3845   if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3846     rhs = TREE_OPERAND (rhs, 0);
3847
3848   if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
3849       || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
3850     rhs = default_conversion (rhs);
3851   else if (optimize && TREE_CODE (rhs) == VAR_DECL)
3852     rhs = decl_constant_value (rhs);
3853
3854   rhstype = TREE_TYPE (rhs);
3855   coder = TREE_CODE (rhstype);
3856
3857   if (coder == ERROR_MARK)
3858     return error_mark_node;
3859
3860   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
3861     {
3862       overflow_warning (rhs);
3863       /* Check for Objective-C protocols.  This will issue a warning if
3864          there are protocol violations.  No need to use the return value.  */
3865       maybe_objc_comptypes (type, rhstype, 0);
3866       return rhs;
3867     }
3868
3869   if (coder == VOID_TYPE)
3870     {
3871       error ("void value not ignored as it ought to be");
3872       return error_mark_node;
3873     }
3874   /* Arithmetic types all interconvert, and enum is treated like int.  */
3875   if ((codel == INTEGER_TYPE || codel == REAL_TYPE || codel == ENUMERAL_TYPE
3876        || codel == COMPLEX_TYPE)
3877       && (coder == INTEGER_TYPE || coder == REAL_TYPE || coder == ENUMERAL_TYPE
3878           || coder == COMPLEX_TYPE))
3879     return convert_and_check (type, rhs);
3880
3881   /* Conversion to a union from its member types.  */
3882   else if (codel == UNION_TYPE)
3883     {
3884       tree memb_types;
3885
3886       for (memb_types = TYPE_FIELDS (type); memb_types;
3887            memb_types = TREE_CHAIN (memb_types))
3888         {
3889           if (comptypes (TREE_TYPE (memb_types), TREE_TYPE (rhs)))
3890             {
3891               if (pedantic
3892                   && !(fundecl != 0 && DECL_IN_SYSTEM_HEADER (fundecl)))
3893                 pedwarn ("ANSI C prohibits argument conversion to union type");
3894               return build1 (NOP_EXPR, type, rhs);
3895             }
3896
3897           else if (coder == POINTER_TYPE
3898                    && TREE_CODE (TREE_TYPE (memb_types)) == POINTER_TYPE)
3899             {
3900               tree memb_type = TREE_TYPE (memb_types);
3901               register tree ttl = TREE_TYPE (memb_type);
3902               register tree ttr = TREE_TYPE (rhstype);
3903
3904               /* Any non-function converts to a [const][volatile] void *
3905                  and vice versa; otherwise, targets must be the same.
3906                  Meanwhile, the lhs target must have all the qualifiers of
3907                  the rhs.  */
3908               if (TYPE_MAIN_VARIANT (ttl) == void_type_node
3909                   || TYPE_MAIN_VARIANT (ttr) == void_type_node
3910                   || comp_target_types (memb_type, rhstype))
3911                 {
3912                   /* Const and volatile mean something different for function
3913                      types, so the usual warnings are not appropriate.  */
3914                   if (TREE_CODE (ttr) != FUNCTION_TYPE
3915                       || TREE_CODE (ttl) != FUNCTION_TYPE)
3916                     {
3917                       if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr))
3918                         warn_for_assignment ("%s discards `const' from pointer target type",
3919                                              get_spelling (errtype), funname,
3920                                              parmnum);
3921                       if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
3922                         warn_for_assignment ("%s discards `volatile' from pointer target type",
3923                                              get_spelling (errtype), funname,
3924                                              parmnum);
3925                     }
3926                   else
3927                     {
3928                       /* Because const and volatile on functions are
3929                          restrictions that say the function will not do
3930                          certain things, it is okay to use a const or volatile
3931                          function where an ordinary one is wanted, but not
3932                          vice-versa.  */
3933                       if (TYPE_READONLY (ttl) && ! TYPE_READONLY (ttr))
3934                         warn_for_assignment ("%s makes `const *' function pointer from non-const",
3935                                              get_spelling (errtype), funname,
3936                                              parmnum);
3937                       if (TYPE_VOLATILE (ttl) && ! TYPE_VOLATILE (ttr))
3938                         warn_for_assignment ("%s makes `volatile *' function pointer from non-volatile",
3939                                              get_spelling (errtype), funname,
3940                                              parmnum);
3941                     }
3942
3943                   if (pedantic
3944                       && !(fundecl != 0 && DECL_IN_SYSTEM_HEADER (fundecl)))
3945                     pedwarn ("ANSI C prohibits argument conversion to union type");
3946                   return build1 (NOP_EXPR, type, rhs);
3947                 }
3948             }
3949
3950           /* Can convert integer zero to any pointer type.  */
3951           else if (TREE_CODE (TREE_TYPE (memb_types)) == POINTER_TYPE
3952                    && (integer_zerop (rhs)
3953                        || (TREE_CODE (rhs) == NOP_EXPR
3954                            && integer_zerop (TREE_OPERAND (rhs, 0)))))
3955             return build1 (NOP_EXPR, type, null_pointer_node);
3956         }
3957     }
3958
3959   /* Conversions among pointers */
3960   else if (codel == POINTER_TYPE && coder == POINTER_TYPE)
3961     {
3962       register tree ttl = TREE_TYPE (type);
3963       register tree ttr = TREE_TYPE (rhstype);
3964
3965       /* Any non-function converts to a [const][volatile] void *
3966          and vice versa; otherwise, targets must be the same.
3967          Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
3968       if (TYPE_MAIN_VARIANT (ttl) == void_type_node
3969           || TYPE_MAIN_VARIANT (ttr) == void_type_node
3970           || comp_target_types (type, rhstype)
3971           || (unsigned_type (TYPE_MAIN_VARIANT (ttl))
3972               == unsigned_type (TYPE_MAIN_VARIANT (ttr))))
3973         {
3974           if (pedantic
3975               && ((TYPE_MAIN_VARIANT (ttl) == void_type_node
3976                    && TREE_CODE (ttr) == FUNCTION_TYPE)
3977                   ||
3978                   (TYPE_MAIN_VARIANT (ttr) == void_type_node
3979                    /* Check TREE_CODE to catch cases like (void *) (char *) 0
3980                       which are not ANSI null ptr constants.  */
3981                    && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
3982                    && TREE_CODE (ttl) == FUNCTION_TYPE)))
3983             warn_for_assignment ("ANSI forbids %s between function pointer and `void *'",
3984                                  get_spelling (errtype), funname, parmnum);
3985           /* Const and volatile mean something different for function types,
3986              so the usual warnings are not appropriate.  */
3987           else if (TREE_CODE (ttr) != FUNCTION_TYPE
3988                    || TREE_CODE (ttl) != FUNCTION_TYPE)
3989             {
3990               if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr))
3991                 warn_for_assignment ("%s discards `const' from pointer target type",
3992                                      get_spelling (errtype), funname, parmnum);
3993               else if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
3994                 warn_for_assignment ("%s discards `volatile' from pointer target type",
3995                                      get_spelling (errtype), funname, parmnum);
3996               /* If this is not a case of ignoring a mismatch in signedness,
3997                  no warning.  */
3998               else if (TYPE_MAIN_VARIANT (ttl) == void_type_node
3999                        || TYPE_MAIN_VARIANT (ttr) == void_type_node
4000                        || comp_target_types (type, rhstype))
4001                 ;
4002               /* If there is a mismatch, do warn.  */
4003               else if (pedantic)
4004                 warn_for_assignment ("pointer targets in %s differ in signedness",
4005                                      get_spelling (errtype), funname, parmnum);
4006             }
4007           else
4008             {
4009               /* Because const and volatile on functions are restrictions
4010                  that say the function will not do certain things,
4011                  it is okay to use a const or volatile function
4012                  where an ordinary one is wanted, but not vice-versa.  */
4013               if (TYPE_READONLY (ttl) && ! TYPE_READONLY (ttr))
4014                 warn_for_assignment ("%s makes `const *' function pointer from non-const",
4015                                      get_spelling (errtype), funname, parmnum);
4016               if (TYPE_VOLATILE (ttl) && ! TYPE_VOLATILE (ttr))
4017                 warn_for_assignment ("%s makes `volatile *' function pointer from non-volatile",
4018                                      get_spelling (errtype), funname, parmnum);
4019             }
4020         }
4021       else
4022         warn_for_assignment ("%s from incompatible pointer type",
4023                              get_spelling (errtype), funname, parmnum);
4024       return convert (type, rhs);
4025     }
4026   else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
4027     {
4028       /* An explicit constant 0 can convert to a pointer,
4029          or one that results from arithmetic, even including
4030          a cast to integer type.  */
4031       if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
4032           &&
4033           ! (TREE_CODE (rhs) == NOP_EXPR
4034              && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
4035              && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
4036              && integer_zerop (TREE_OPERAND (rhs, 0))))
4037         {
4038           warn_for_assignment ("%s makes pointer from integer without a cast",
4039                                get_spelling (errtype), funname, parmnum);
4040           return convert (type, rhs);
4041         }
4042       return null_pointer_node;
4043     }
4044   else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
4045     {
4046       warn_for_assignment ("%s makes integer from pointer without a cast",
4047                            get_spelling (errtype), funname, parmnum);
4048       return convert (type, rhs);
4049     }
4050
4051   if (!errtype)
4052     {
4053       if (funname)
4054         {
4055           tree selector = maybe_building_objc_message_expr ();
4056
4057           if (selector && parmnum > 2)
4058             error ("incompatible type for argument %d of `%s'",
4059                    parmnum - 2, IDENTIFIER_POINTER (selector));
4060           else
4061             error ("incompatible type for argument %d of `%s'",
4062                    parmnum, IDENTIFIER_POINTER (funname));
4063         }
4064       else
4065         error ("incompatible type for argument %d of indirect function call",
4066                parmnum);
4067     }
4068   else
4069     error ("incompatible types in %s", get_spelling (errtype));
4070
4071   return error_mark_node;
4072 }
4073
4074 /* Print a warning using MSG.
4075    It gets OPNAME as its one parameter.
4076    If OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
4077    FUNCTION and ARGNUM are handled specially if we are building an
4078    Objective-C selector.  */
4079
4080 static void
4081 warn_for_assignment (msg, opname, function, argnum)
4082      char *msg;
4083      char *opname;
4084      tree function;
4085      int argnum;
4086 {
4087   static char argstring[] = "passing arg %d of `%s'";
4088   static char argnofun[] =  "passing arg %d";
4089
4090   if (opname == 0)
4091     {
4092       tree selector = maybe_building_objc_message_expr ();
4093
4094       if (selector && argnum > 2)
4095         {
4096           function = selector;
4097           argnum -= 2;
4098         }
4099       if (function)
4100         {
4101           /* Function name is known; supply it.  */
4102           opname = (char *) alloca (IDENTIFIER_LENGTH (function)
4103                                     + sizeof (argstring) + 25 /*%d*/ + 1);
4104           sprintf (opname, argstring, argnum, IDENTIFIER_POINTER (function));
4105         }
4106       else
4107         {
4108           /* Function name unknown (call through ptr); just give arg number.  */
4109           opname = (char *) alloca (sizeof (argnofun) + 25 /*%d*/ + 1);
4110           sprintf (opname, argnofun, argnum);
4111         }
4112     }
4113   pedwarn (msg, opname);
4114 }
4115 \f
4116 /* Return nonzero if VALUE is a valid constant-valued expression
4117    for use in initializing a static variable; one that can be an
4118    element of a "constant" initializer.
4119
4120    Return null_pointer_node if the value is absolute;
4121    if it is relocatable, return the variable that determines the relocation.
4122    We assume that VALUE has been folded as much as possible;
4123    therefore, we do not need to check for such things as
4124    arithmetic-combinations of integers.  */
4125
4126 tree
4127 initializer_constant_valid_p (value, endtype)
4128      tree value;
4129      tree endtype;
4130 {
4131   switch (TREE_CODE (value))
4132     {
4133     case CONSTRUCTOR:
4134       if (TREE_CODE (TREE_TYPE (value)) == UNION_TYPE
4135           && TREE_CONSTANT (value))
4136         return
4137           initializer_constant_valid_p (TREE_VALUE (CONSTRUCTOR_ELTS (value)),
4138                                         endtype);
4139
4140       return TREE_STATIC (value) ? null_pointer_node : 0;
4141
4142     case INTEGER_CST:
4143     case REAL_CST:
4144     case STRING_CST:
4145     case COMPLEX_CST:
4146       return null_pointer_node;
4147
4148     case ADDR_EXPR:
4149       return TREE_OPERAND (value, 0);
4150
4151     case NON_LVALUE_EXPR:
4152       return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4153
4154     case CONVERT_EXPR:
4155     case NOP_EXPR:
4156       /* Allow conversions between pointer types.  */
4157       if (TREE_CODE (TREE_TYPE (value)) == POINTER_TYPE
4158           && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == POINTER_TYPE)
4159         return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4160
4161       /* Allow conversions between real types.  */
4162       if (TREE_CODE (TREE_TYPE (value)) == REAL_TYPE
4163           && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == REAL_TYPE)
4164         return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4165
4166       /* Allow length-preserving conversions between integer types.  */
4167       if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
4168           && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE
4169           && (TYPE_PRECISION (TREE_TYPE (value))
4170               == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4171         return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4172
4173       /* Allow conversions between other integer types only if
4174          explicit value.  */
4175       if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
4176           && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE)
4177         {
4178           tree inner = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4179                                                      endtype);
4180           if (inner == null_pointer_node)
4181             return null_pointer_node;
4182           return 0;
4183         }
4184
4185       /* Allow (int) &foo provided int is as wide as a pointer.  */
4186       if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
4187           && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == POINTER_TYPE
4188           && (TYPE_PRECISION (TREE_TYPE (value))
4189               >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4190         return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4191                                              endtype);
4192
4193       /* Likewise conversions from int to pointers.  */
4194       if (TREE_CODE (TREE_TYPE (value)) == POINTER_TYPE
4195           && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE
4196           && (TYPE_PRECISION (TREE_TYPE (value))
4197               <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4198         return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4199                                              endtype);
4200
4201       /* Allow conversions to union types if the value inside is okay.  */
4202       if (TREE_CODE (TREE_TYPE (value)) == UNION_TYPE)
4203         return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4204                                              endtype);
4205       return 0;
4206
4207     case PLUS_EXPR:
4208       if (TREE_CODE (endtype) == INTEGER_TYPE
4209           && TYPE_PRECISION (endtype) < POINTER_SIZE)
4210         return 0;
4211       {
4212         tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4213                                                     endtype);
4214         tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
4215                                                     endtype);
4216         /* If either term is absolute, use the other terms relocation.  */
4217         if (valid0 == null_pointer_node)
4218           return valid1;
4219         if (valid1 == null_pointer_node)
4220           return valid0;
4221         return 0;
4222       }
4223
4224     case MINUS_EXPR:
4225       if (TREE_CODE (endtype) == INTEGER_TYPE
4226           && TYPE_PRECISION (endtype) < POINTER_SIZE)
4227         return 0;
4228       {
4229         tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4230                                                     endtype);
4231         tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
4232                                                     endtype);
4233         /* Win if second argument is absolute.  */
4234         if (valid1 == null_pointer_node)
4235           return valid0;
4236         /* Win if both arguments have the same relocation.
4237            Then the value is absolute.  */
4238         if (valid0 == valid1)
4239           return null_pointer_node;
4240         return 0;
4241       }
4242     }
4243
4244   return 0;
4245 }
4246
4247 /* If VALUE is a compound expr all of whose expressions are constant, then
4248    return its value.  Otherwise, return error_mark_node.
4249
4250    This is for handling COMPOUND_EXPRs as initializer elements
4251    which is allowed with a warning when -pedantic is specified.  */
4252
4253 static tree
4254 valid_compound_expr_initializer (value, endtype)
4255      tree value;
4256      tree endtype;
4257 {
4258   if (TREE_CODE (value) == COMPOUND_EXPR)
4259     {
4260       if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
4261           == error_mark_node)
4262         return error_mark_node;
4263       return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
4264                                               endtype);
4265     }
4266   else if (! TREE_CONSTANT (value)
4267            && ! initializer_constant_valid_p (value, endtype))
4268     return error_mark_node;
4269   else
4270     return value;
4271 }
4272 \f
4273 /* Perform appropriate conversions on the initial value of a variable,
4274    store it in the declaration DECL,
4275    and print any error messages that are appropriate.
4276    If the init is invalid, store an ERROR_MARK.  */
4277
4278 void
4279 store_init_value (decl, init)
4280      tree decl, init;
4281 {
4282   register tree value, type;
4283
4284   /* If variable's type was invalidly declared, just ignore it.  */
4285
4286   type = TREE_TYPE (decl);
4287   if (TREE_CODE (type) == ERROR_MARK)
4288     return;
4289
4290   /* Digest the specified initializer into an expression.  */
4291
4292   value = digest_init (type, init, TREE_STATIC (decl),
4293                        TREE_STATIC (decl) || pedantic);
4294
4295   /* Store the expression if valid; else report error.  */
4296
4297 #if 0
4298   /* Note that this is the only place we can detect the error
4299      in a case such as   struct foo bar = (struct foo) { x, y };
4300      where there is one initial value which is a constructor expression.  */
4301   if (value == error_mark_node)
4302     ;
4303   else if (TREE_STATIC (decl) && ! TREE_CONSTANT (value))
4304     {
4305       error ("initializer for static variable is not constant");
4306       value = error_mark_node;
4307     }
4308   else if (TREE_STATIC (decl)
4309            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
4310     {
4311       error ("initializer for static variable uses complicated arithmetic");
4312       value = error_mark_node;
4313     }
4314   else
4315     {
4316       if (pedantic && TREE_CODE (value) == CONSTRUCTOR)
4317         {
4318           if (! TREE_CONSTANT (value))
4319             pedwarn ("aggregate initializer is not constant");
4320           else if (! TREE_STATIC (value))
4321             pedwarn ("aggregate initializer uses complicated arithmetic");
4322         }
4323     }
4324 #endif
4325
4326   DECL_INITIAL (decl) = value;
4327
4328   /* ANSI wants warnings about out-of-range constant initializers.  */
4329   STRIP_TYPE_NOPS (value);
4330   constant_expression_warning (value);
4331 }
4332 \f
4333 /* Methods for storing and printing names for error messages.  */
4334
4335 /* Implement a spelling stack that allows components of a name to be pushed
4336    and popped.  Each element on the stack is this structure.  */
4337
4338 struct spelling
4339 {
4340   int kind;
4341   union
4342     {
4343       int i;
4344       char *s;
4345     } u;
4346 };
4347
4348 #define SPELLING_STRING 1
4349 #define SPELLING_MEMBER 2
4350 #define SPELLING_BOUNDS 3
4351
4352 static struct spelling *spelling;       /* Next stack element (unused).  */
4353 static struct spelling *spelling_base;  /* Spelling stack base.  */
4354 static int spelling_size;               /* Size of the spelling stack.  */
4355
4356 /* Macros to save and restore the spelling stack around push_... functions.
4357    Alternative to SAVE_SPELLING_STACK.  */
4358
4359 #define SPELLING_DEPTH() (spelling - spelling_base)
4360 #define RESTORE_SPELLING_DEPTH(depth) (spelling = spelling_base + depth)
4361
4362 /* Save and restore the spelling stack around arbitrary C code.  */
4363
4364 #define SAVE_SPELLING_DEPTH(code)               \
4365 {                                               \
4366   int __depth = SPELLING_DEPTH ();              \
4367   code;                                         \
4368   RESTORE_SPELLING_DEPTH (__depth);             \
4369 }
4370
4371 /* Push an element on the spelling stack with type KIND and assign VALUE
4372    to MEMBER.  */
4373
4374 #define PUSH_SPELLING(KIND, VALUE, MEMBER)                              \
4375 {                                                                       \
4376   int depth = SPELLING_DEPTH ();                                        \
4377                                                                         \
4378   if (depth >= spelling_size)                                           \
4379     {                                                                   \
4380       spelling_size += 10;                                              \
4381       if (spelling_base == 0)                                           \
4382         spelling_base                                                   \
4383           = (struct spelling *) xmalloc (spelling_size * sizeof (struct spelling));     \
4384       else                                                              \
4385         spelling_base                                                   \
4386           = (struct spelling *) xrealloc (spelling_base,                \
4387                                           spelling_size * sizeof (struct spelling));    \
4388       RESTORE_SPELLING_DEPTH (depth);                                   \
4389     }                                                                   \
4390                                                                         \
4391   spelling->kind = (KIND);                                              \
4392   spelling->MEMBER = (VALUE);                                           \
4393   spelling++;                                                           \
4394 }
4395
4396 /* Push STRING on the stack.  Printed literally.  */
4397
4398 static void
4399 push_string (string)
4400      char *string;
4401 {
4402   PUSH_SPELLING (SPELLING_STRING, string, u.s);
4403 }
4404
4405 /* Push a member name on the stack.  Printed as '.' STRING.  */
4406
4407 static void
4408 push_member_name (decl)
4409      tree decl;
4410
4411 {
4412   char *string
4413     = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
4414   PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
4415 }
4416
4417 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
4418
4419 static void
4420 push_array_bounds (bounds)
4421      int bounds;
4422 {
4423   PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
4424 }
4425
4426 /* Compute the maximum size in bytes of the printed spelling.  */
4427
4428 static int
4429 spelling_length ()
4430 {
4431   register int size = 0;
4432   register struct spelling *p;
4433
4434   for (p = spelling_base; p < spelling; p++)
4435     {
4436       if (p->kind == SPELLING_BOUNDS)
4437         size += 25;
4438       else
4439         size += strlen (p->u.s) + 1;
4440     }
4441
4442   return size;
4443 }
4444
4445 /* Print the spelling to BUFFER and return it.  */
4446
4447 static char *
4448 print_spelling (buffer)
4449      register char *buffer;
4450 {
4451   register char *d = buffer;
4452   register char *s;
4453   register struct spelling *p;
4454
4455   for (p = spelling_base; p < spelling; p++)
4456     if (p->kind == SPELLING_BOUNDS)
4457       {
4458         sprintf (d, "[%d]", p->u.i);
4459         d += strlen (d);
4460       }
4461     else
4462       {
4463         if (p->kind == SPELLING_MEMBER)
4464           *d++ = '.';
4465         for (s = p->u.s; *d = *s++; d++)
4466           ;
4467       }
4468   *d++ = '\0';
4469   return buffer;
4470 }
4471
4472 /* Provide a means to pass component names derived from the spelling stack.  */
4473
4474 char initialization_message;
4475
4476 /* Interpret the spelling of the given ERRTYPE message.  */
4477
4478 static char *
4479 get_spelling (errtype)
4480      char *errtype;
4481 {
4482   static char *buffer;
4483   static int size = -1;
4484
4485   if (errtype == &initialization_message)
4486     {
4487       /* Avoid counting chars */
4488       static char message[] = "initialization of `%s'";
4489       register int needed = sizeof (message) + spelling_length () + 1;
4490       char *temp;
4491
4492       if (size < 0)
4493         buffer = (char *) xmalloc (size = needed);
4494       if (needed > size)
4495         buffer = (char *) xrealloc (buffer, size = needed);
4496
4497       temp = (char *) alloca (needed);
4498       sprintf (buffer, message, print_spelling (temp));
4499       return buffer;
4500     }
4501
4502   return errtype;
4503 }
4504
4505 /* Issue an error message for a bad initializer component.
4506    FORMAT describes the message.  OFWHAT is the name for the component.
4507    LOCAL is a format string for formatting the insertion of the name
4508    into the message.
4509
4510    If OFWHAT is null, the component name is stored on the spelling stack.
4511    If the component name is a null string, then LOCAL is omitted entirely.  */
4512
4513 void
4514 error_init (format, local, ofwhat)
4515      char *format, *local, *ofwhat;
4516 {
4517   char *buffer;
4518
4519   if (ofwhat == 0)
4520     ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4521   buffer = (char *) alloca (strlen (local) + strlen (ofwhat) + 2);
4522
4523   if (*ofwhat)
4524     sprintf (buffer, local, ofwhat);
4525   else
4526     buffer[0] = 0;
4527
4528   error (format, buffer);
4529 }
4530
4531 /* Issue a pedantic warning for a bad initializer component.
4532    FORMAT describes the message.  OFWHAT is the name for the component.
4533    LOCAL is a format string for formatting the insertion of the name
4534    into the message.
4535
4536    If OFWHAT is null, the component name is stored on the spelling stack.
4537    If the component name is a null string, then LOCAL is omitted entirely.  */
4538
4539 void
4540 pedwarn_init (format, local, ofwhat)
4541      char *format, *local, *ofwhat;
4542 {
4543   char *buffer;
4544
4545   if (ofwhat == 0)
4546     ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4547   buffer = (char *) alloca (strlen (local) + strlen (ofwhat) + 2);
4548
4549   if (*ofwhat)
4550     sprintf (buffer, local, ofwhat);
4551   else
4552     buffer[0] = 0;
4553
4554   pedwarn (format, buffer);
4555 }
4556
4557 /* Issue a warning for a bad initializer component.
4558    FORMAT describes the message.  OFWHAT is the name for the component.
4559    LOCAL is a format string for formatting the insertion of the name
4560    into the message.
4561
4562    If OFWHAT is null, the component name is stored on the spelling stack.
4563    If the component name is a null string, then LOCAL is omitted entirely.  */
4564
4565 static void
4566 warning_init (format, local, ofwhat)
4567      char *format, *local, *ofwhat;
4568 {
4569   char *buffer;
4570
4571   if (ofwhat == 0)
4572     ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4573   buffer = (char *) alloca (strlen (local) + strlen (ofwhat) + 2);
4574
4575   if (*ofwhat)
4576     sprintf (buffer, local, ofwhat);
4577   else
4578     buffer[0] = 0;
4579
4580   warning (format, buffer);
4581 }
4582 \f
4583 /* Digest the parser output INIT as an initializer for type TYPE.
4584    Return a C expression of type TYPE to represent the initial value.
4585
4586    The arguments REQUIRE_CONSTANT and CONSTRUCTOR_CONSTANT request errors
4587    if non-constant initializers or elements are seen.  CONSTRUCTOR_CONSTANT
4588    applies only to elements of constructors.  */
4589
4590 static tree
4591 digest_init (type, init, require_constant, constructor_constant)
4592      tree type, init;
4593      int require_constant, constructor_constant;
4594 {
4595   enum tree_code code = TREE_CODE (type);
4596   tree inside_init = init;
4597
4598   if (init == error_mark_node)
4599     return init;
4600
4601   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
4602   /* Do not use STRIP_NOPS here.  We do not want an enumerator
4603      whose value is 0 to count as a null pointer constant.  */
4604   if (TREE_CODE (init) == NON_LVALUE_EXPR)
4605     inside_init = TREE_OPERAND (init, 0);
4606
4607   /* Initialization of an array of chars from a string constant
4608      optionally enclosed in braces.  */
4609
4610   if (code == ARRAY_TYPE)
4611     {
4612       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4613       if ((typ1 == char_type_node
4614            || typ1 == signed_char_type_node
4615            || typ1 == unsigned_char_type_node
4616            || typ1 == unsigned_wchar_type_node
4617            || typ1 == signed_wchar_type_node)
4618           && ((inside_init && TREE_CODE (inside_init) == STRING_CST)))
4619         {
4620           if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4621                          TYPE_MAIN_VARIANT (type)))
4622             return inside_init;
4623
4624           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4625                != char_type_node)
4626               && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node))
4627             {
4628               error_init ("char-array%s initialized from wide string",
4629                           " `%s'", NULL);
4630               return error_mark_node;
4631             }
4632           if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4633                == char_type_node)
4634               && TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node))
4635             {
4636               error_init ("int-array%s initialized from non-wide string",
4637                           " `%s'", NULL);
4638               return error_mark_node;
4639             }
4640
4641           TREE_TYPE (inside_init) = type;
4642           if (TYPE_DOMAIN (type) != 0
4643               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
4644             {
4645               register int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
4646               size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
4647               /* Subtract 1 (or sizeof (wchar_t))
4648                  because it's ok to ignore the terminating null char
4649                  that is counted in the length of the constant.  */
4650               if (size < TREE_STRING_LENGTH (inside_init)
4651                   - (TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node)
4652                      ? TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT
4653                      : 1))
4654                 pedwarn_init (
4655                   "initializer-string for array of chars%s is too long",
4656                   " `%s'", NULL);
4657             }
4658           return inside_init;
4659         }
4660     }
4661
4662   /* Any type can be initialized
4663      from an expression of the same type, optionally with braces.  */
4664
4665   if (inside_init && TREE_TYPE (inside_init) != 0
4666       && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4667                      TYPE_MAIN_VARIANT (type))
4668           || (code == ARRAY_TYPE
4669               && comptypes (TREE_TYPE (inside_init), type))
4670           || (code == POINTER_TYPE
4671               && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4672                   || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE)
4673               && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4674                             TREE_TYPE (type)))))
4675     {
4676       if (code == POINTER_TYPE
4677           && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4678               || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE))
4679         inside_init = default_conversion (inside_init);
4680       else if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4681                && TREE_CODE (inside_init) != CONSTRUCTOR)
4682         {
4683           error_init ("array%s initialized from non-constant array expression",
4684                       " `%s'", NULL);
4685           return error_mark_node;
4686         }
4687
4688       if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4689         inside_init = decl_constant_value (inside_init);
4690
4691       /* Compound expressions can only occur here if -pedantic or
4692          -pedantic-errors is specified.  In the later case, we always want
4693          an error.  In the former case, we simply want a warning.  */
4694       if (require_constant && pedantic
4695           && TREE_CODE (inside_init) == COMPOUND_EXPR)
4696         {
4697           inside_init
4698             = valid_compound_expr_initializer (inside_init,
4699                                                TREE_TYPE (inside_init));
4700           if (inside_init == error_mark_node)
4701             error_init ("initializer element%s is not constant",
4702                         " for `%s'", NULL);
4703           else
4704             pedwarn_init ("initializer element%s is not constant",
4705                           " for `%s'", NULL);
4706           if (flag_pedantic_errors)
4707             inside_init = error_mark_node;
4708         }
4709       else if (require_constant && ! TREE_CONSTANT (inside_init))
4710         {
4711           error_init ("initializer element%s is not constant",
4712                       " for `%s'", NULL);
4713           inside_init = error_mark_node;
4714         }
4715       else if (require_constant
4716                && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4717         {
4718           error_init ("initializer element%s is not computable at load time",
4719                       " for `%s'", NULL);
4720           inside_init = error_mark_node;
4721         }
4722
4723       return inside_init;
4724     }
4725
4726   /* Handle scalar types, including conversions.  */
4727
4728   if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4729       || code == ENUMERAL_TYPE || code == COMPLEX_TYPE)
4730     {
4731       /* Note that convert_for_assignment calls default_conversion
4732          for arrays and functions.  We must not call it in the
4733          case where inside_init is a null pointer constant.  */
4734       inside_init
4735         = convert_for_assignment (type, init, "initialization",
4736                                   NULL_TREE, NULL_TREE, 0);
4737
4738       if (require_constant && ! TREE_CONSTANT (inside_init))
4739         {
4740           error_init ("initializer element%s is not constant",
4741                       " for `%s'", NULL);
4742           inside_init = error_mark_node;
4743         }
4744       else if (require_constant
4745                && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4746         {
4747           error_init ("initializer element%s is not computable at load time",
4748                       " for `%s'", NULL);
4749           inside_init = error_mark_node;
4750         }
4751
4752       return inside_init;
4753     }
4754
4755   /* Come here only for records and arrays.  */
4756
4757   if (TYPE_SIZE (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4758     {
4759       error_init ("variable-sized object%s may not be initialized",
4760                   " `%s'", NULL);
4761       return error_mark_node;
4762     }
4763
4764   /* Traditionally, you can write  struct foo x = 0;
4765      and it initializes the first element of x to 0.  */
4766   if (flag_traditional)
4767     {
4768       tree top = 0, prev = 0;
4769       while (TREE_CODE (type) == RECORD_TYPE
4770              || TREE_CODE (type) == ARRAY_TYPE
4771              || TREE_CODE (type) == QUAL_UNION_TYPE
4772              || TREE_CODE (type) == UNION_TYPE)
4773         {
4774           tree temp = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
4775           if (prev == 0)
4776             top = temp;
4777           else
4778             TREE_OPERAND (prev, 1) = build_tree_list (NULL_TREE, temp);
4779           prev = temp;
4780           if (TREE_CODE (type) == ARRAY_TYPE)
4781             type = TREE_TYPE (type);
4782           else if (TYPE_FIELDS (type))
4783             type = TREE_TYPE (TYPE_FIELDS (type));
4784           else
4785             {
4786               error_init ("invalid initializer%s", " for `%s'", NULL);
4787               return error_mark_node;
4788             }
4789         }
4790       TREE_OPERAND (prev, 1)
4791         = build_tree_list (NULL_TREE,
4792                            digest_init (type, init, require_constant,
4793                                         constructor_constant));
4794       return top;
4795     }
4796   error_init ("invalid initializer%s", " for `%s'", NULL);
4797   return error_mark_node;
4798 }
4799 \f
4800 /* Handle initializers that use braces.  */
4801
4802 /* Type of object we are accumulating a constructor for.
4803    This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE.  */
4804 static tree constructor_type;
4805
4806 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4807    left to fill.  */
4808 static tree constructor_fields;
4809
4810 /* For an ARRAY_TYPE, this is the specified index
4811    at which to store the next element we get.
4812    This is a special INTEGER_CST node that we modify in place.  */
4813 static tree constructor_index;
4814
4815 /* For an ARRAY_TYPE, this is the end index of the range
4816    to intitialize with the next element, or NULL in the ordinary case
4817    where the element is used just once.  */
4818 static tree constructor_range_end;
4819
4820 /* For an ARRAY_TYPE, this is the maximum index.  */
4821 static tree constructor_max_index;
4822
4823 /* For a RECORD_TYPE, this is the first field not yet written out.  */
4824 static tree constructor_unfilled_fields;
4825
4826 /* For an ARRAY_TYPE, this is the index of the first element
4827    not yet written out.
4828    This is a special INTEGER_CST node that we modify in place.  */
4829 static tree constructor_unfilled_index;
4830
4831 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4832    This is so we can generate gaps between fields, when appropriate.
4833    This is a special INTEGER_CST node that we modify in place.  */
4834 static tree constructor_bit_index;
4835
4836 /* If we are saving up the elements rather than allocating them,
4837    this is the list of elements so far (in reverse order,
4838    most recent first).  */
4839 static tree constructor_elements;
4840
4841 /* 1 if so far this constructor's elements are all compile-time constants.  */
4842 static int constructor_constant;
4843
4844 /* 1 if so far this constructor's elements are all valid address constants.  */
4845 static int constructor_simple;
4846
4847 /* 1 if this constructor is erroneous so far.  */
4848 static int constructor_erroneous;
4849
4850 /* 1 if have called defer_addressed_constants.  */
4851 static int constructor_subconstants_deferred;
4852
4853 /* List of pending elements at this constructor level.
4854    These are elements encountered out of order
4855    which belong at places we haven't reached yet in actually
4856    writing the output.  */
4857 static tree constructor_pending_elts;
4858
4859 /* The SPELLING_DEPTH of this constructor.  */
4860 static int constructor_depth;
4861
4862 /* 0 if implicitly pushing constructor levels is allowed.  */
4863 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages. */
4864
4865 /* 1 if this constructor level was entered implicitly.  */
4866 static int constructor_implicit;
4867
4868 static int require_constant_value;
4869 static int require_constant_elements;
4870
4871 /* 1 if it is ok to output this constructor as we read it.
4872    0 means must accumulate a CONSTRUCTOR expression.  */
4873 static int constructor_incremental;
4874
4875 /* DECL node for which an initializer is being read.
4876    0 means we are reading a constructor expression
4877    such as (struct foo) {...}.  */
4878 static tree constructor_decl;
4879
4880 /* start_init saves the ASMSPEC arg here for really_start_incremental_init.  */
4881 static char *constructor_asmspec;
4882
4883 /* Nonzero if this is an initializer for a top-level decl.  */
4884 static int constructor_top_level;
4885
4886 /* When we finish reading a constructor expression
4887    (constructor_decl is 0), the CONSTRUCTOR goes here.  */
4888 static tree constructor_result;
4889 \f
4890 /* This stack has a level for each implicit or explicit level of
4891    structuring in the initializer, including the outermost one.  It
4892    saves the values of most of the variables above.  */
4893
4894 struct constructor_stack
4895 {
4896   struct constructor_stack *next;
4897   tree type;
4898   tree fields;
4899   tree index;
4900   tree range_end;
4901   tree max_index;
4902   tree unfilled_index;
4903   tree unfilled_fields;
4904   tree bit_index;
4905   tree elements;
4906   int offset;
4907   tree pending_elts;
4908   int depth;
4909   /* If nonzero, this value should replace the entire
4910      constructor at this level.  */
4911   tree replacement_value;
4912   char constant;
4913   char simple;
4914   char implicit;
4915   char incremental;
4916   char erroneous;
4917   char outer;
4918 };
4919
4920 struct constructor_stack *constructor_stack;
4921
4922 /* This stack records separate initializers that are nested.
4923    Nested initializers can't happen in ANSI C, but GNU C allows them
4924    in cases like { ... (struct foo) { ... } ... }.  */
4925
4926 struct initializer_stack
4927 {
4928   struct initializer_stack *next;
4929   tree decl;
4930   char *asmspec;
4931   struct constructor_stack *constructor_stack;
4932   tree elements;
4933   struct spelling *spelling;
4934   struct spelling *spelling_base;
4935   int spelling_size;
4936   char top_level;
4937   char incremental;
4938   char require_constant_value;
4939   char require_constant_elements;
4940   char deferred;
4941 };
4942
4943 struct initializer_stack *initializer_stack;
4944 \f
4945 /* Prepare to parse and output the initializer for variable DECL.  */
4946
4947 void
4948 start_init (decl, asmspec_tree, top_level)
4949      tree decl;
4950      tree asmspec_tree;
4951      int top_level;
4952 {
4953   char *locus;
4954   struct initializer_stack *p
4955     = (struct initializer_stack *) xmalloc (sizeof (struct initializer_stack));
4956   char *asmspec = 0;
4957
4958   if (asmspec_tree)
4959     asmspec = TREE_STRING_POINTER (asmspec_tree);
4960
4961   p->decl = constructor_decl;
4962   p->asmspec = constructor_asmspec;
4963   p->incremental = constructor_incremental;
4964   p->require_constant_value = require_constant_value;
4965   p->require_constant_elements = require_constant_elements;
4966   p->constructor_stack = constructor_stack;
4967   p->elements = constructor_elements;
4968   p->spelling = spelling;
4969   p->spelling_base = spelling_base;
4970   p->spelling_size = spelling_size;
4971   p->deferred = constructor_subconstants_deferred;
4972   p->top_level = constructor_top_level;
4973   p->next = initializer_stack;
4974   initializer_stack = p;
4975
4976   constructor_decl = decl;
4977   constructor_incremental = top_level;
4978   constructor_asmspec = asmspec;
4979   constructor_subconstants_deferred = 0;
4980   constructor_top_level = top_level;
4981
4982   if (decl != 0)
4983     {
4984       require_constant_value = TREE_STATIC (decl);
4985       require_constant_elements
4986         = ((TREE_STATIC (decl) || pedantic)
4987            /* For a scalar, you can always use any value to initialize,
4988               even within braces.  */
4989            && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
4990                || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
4991                || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
4992                || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
4993       locus = IDENTIFIER_POINTER (DECL_NAME (decl));
4994       constructor_incremental |= TREE_STATIC (decl);
4995     }
4996   else
4997     {
4998       require_constant_value = 0;
4999       require_constant_elements = 0;
5000       locus = "(anonymous)";
5001     }
5002
5003   constructor_stack = 0;
5004
5005   missing_braces_mentioned = 0;
5006
5007   spelling_base = 0;
5008   spelling_size = 0;
5009   RESTORE_SPELLING_DEPTH (0);
5010
5011   if (locus)
5012     push_string (locus);
5013 }
5014
5015 void
5016 finish_init ()
5017 {
5018   struct initializer_stack *p = initializer_stack;
5019
5020   /* Output subconstants (string constants, usually)
5021      that were referenced within this initializer and saved up.
5022      Must do this if and only if we called defer_addressed_constants.  */
5023   if (constructor_subconstants_deferred)
5024     output_deferred_addressed_constants ();
5025
5026   /* Free the whole constructor stack of this initializer.  */
5027   while (constructor_stack)
5028     {
5029       struct constructor_stack *q = constructor_stack;
5030       constructor_stack = q->next;
5031       free (q);
5032     }
5033
5034   /* Pop back to the data of the outer initializer (if any).  */
5035   constructor_decl = p->decl;
5036   constructor_asmspec = p->asmspec;
5037   constructor_incremental = p->incremental;
5038   require_constant_value = p->require_constant_value;
5039   require_constant_elements = p->require_constant_elements;
5040   constructor_stack = p->constructor_stack;
5041   constructor_elements = p->elements;
5042   spelling = p->spelling;
5043   spelling_base = p->spelling_base;
5044   spelling_size = p->spelling_size;
5045   constructor_subconstants_deferred = p->deferred;
5046   constructor_top_level = p->top_level;
5047   initializer_stack = p->next;
5048   free (p);
5049 }
5050 \f
5051 /* Call here when we see the initializer is surrounded by braces.
5052    This is instead of a call to push_init_level;
5053    it is matched by a call to pop_init_level.
5054
5055    TYPE is the type to initialize, for a constructor expression.
5056    For an initializer for a decl, TYPE is zero.  */
5057
5058 void
5059 really_start_incremental_init (type)
5060      tree type;
5061 {
5062   struct constructor_stack *p
5063     = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5064
5065   if (type == 0)
5066     type = TREE_TYPE (constructor_decl);
5067
5068   /* Turn off constructor_incremental if type is a struct with bitfields.
5069      Do this before the first push, so that the corrected value
5070      is available in finish_init.  */
5071   check_init_type_bitfields (type);
5072
5073   p->type = constructor_type;
5074   p->fields = constructor_fields;
5075   p->index = constructor_index;
5076   p->range_end = constructor_range_end;
5077   p->max_index = constructor_max_index;
5078   p->unfilled_index = constructor_unfilled_index;
5079   p->unfilled_fields = constructor_unfilled_fields;
5080   p->bit_index = constructor_bit_index;
5081   p->elements = constructor_elements;
5082   p->constant = constructor_constant;
5083   p->simple = constructor_simple;
5084   p->erroneous = constructor_erroneous;
5085   p->pending_elts = constructor_pending_elts;
5086   p->depth = constructor_depth;
5087   p->replacement_value = 0;
5088   p->implicit = 0;
5089   p->incremental = constructor_incremental;
5090   p->outer = 0;
5091   p->next = 0;
5092   constructor_stack = p;
5093
5094   constructor_constant = 1;
5095   constructor_simple = 1;
5096   constructor_depth = SPELLING_DEPTH ();
5097   constructor_elements = 0;
5098   constructor_pending_elts = 0;
5099   constructor_type = type;
5100
5101   if (TREE_CODE (constructor_type) == RECORD_TYPE
5102       || TREE_CODE (constructor_type) == UNION_TYPE)
5103     {
5104       constructor_fields = TYPE_FIELDS (constructor_type);
5105       /* Skip any nameless bit fields atthe beginning.  */
5106       while (constructor_fields != 0 && DECL_BIT_FIELD (constructor_fields)
5107              && DECL_NAME (constructor_fields) == 0)
5108         constructor_fields = TREE_CHAIN (constructor_fields);
5109       constructor_unfilled_fields = constructor_fields;
5110       constructor_bit_index = copy_node (integer_zero_node);
5111     }
5112   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5113     {
5114       constructor_range_end = 0;
5115       if (TYPE_DOMAIN (constructor_type))
5116         {
5117           constructor_max_index
5118             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5119           constructor_index
5120             = copy_node (TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5121         }
5122       else
5123         constructor_index = copy_node (integer_zero_node);
5124       constructor_unfilled_index = copy_node (constructor_index);
5125     }
5126   else
5127     {
5128       /* Handle the case of int x = {5}; */
5129       constructor_fields = constructor_type;
5130       constructor_unfilled_fields = constructor_type;
5131     }
5132
5133   if (constructor_incremental)
5134     {
5135       int momentary = suspend_momentary ();
5136       push_obstacks_nochange ();
5137       if (TREE_PERMANENT (constructor_decl))
5138         end_temporary_allocation ();
5139       make_decl_rtl (constructor_decl, constructor_asmspec,
5140                      constructor_top_level);
5141       assemble_variable (constructor_decl, constructor_top_level, 0, 1);
5142       pop_obstacks ();
5143       resume_momentary (momentary);
5144     }
5145
5146   if (constructor_incremental)
5147     {
5148       defer_addressed_constants ();
5149       constructor_subconstants_deferred = 1;
5150     }
5151 }
5152 \f
5153 /* Push down into a subobject, for initialization.
5154    If this is for an explicit set of braces, IMPLICIT is 0.
5155    If it is because the next element belongs at a lower level,
5156    IMPLICIT is 1.  */
5157
5158 void
5159 push_init_level (implicit)
5160      int implicit;
5161 {
5162   struct constructor_stack *p;
5163
5164   /* If we've exhausted any levels that didn't have braces,
5165      pop them now.  */
5166   while (constructor_stack->implicit)
5167     {
5168       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5169            || TREE_CODE (constructor_type) == UNION_TYPE)
5170           && constructor_fields == 0)
5171         process_init_element (pop_init_level (1));
5172       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5173                && tree_int_cst_lt (constructor_max_index, constructor_index))
5174         process_init_element (pop_init_level (1));
5175       else
5176         break;
5177     }
5178
5179   /* Structure elements may require alignment.  Do this now
5180      if necessary for the subaggregate.  */
5181   if (constructor_incremental && constructor_type != 0
5182       && TREE_CODE (constructor_type) == RECORD_TYPE && constructor_fields)
5183     {
5184       /* Advance to offset of this element.  */
5185       if (! tree_int_cst_equal (constructor_bit_index,
5186                                 DECL_FIELD_BITPOS (constructor_fields)))
5187         {
5188           int next = (TREE_INT_CST_LOW
5189                       (DECL_FIELD_BITPOS (constructor_fields))
5190                       / BITS_PER_UNIT);
5191           int here = (TREE_INT_CST_LOW (constructor_bit_index)
5192                       / BITS_PER_UNIT);
5193
5194           assemble_zeros (next - here);
5195         }
5196     }
5197
5198   p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5199   p->type = constructor_type;
5200   p->fields = constructor_fields;
5201   p->index = constructor_index;
5202   p->range_end = constructor_range_end;
5203   p->max_index = constructor_max_index;
5204   p->unfilled_index = constructor_unfilled_index;
5205   p->unfilled_fields = constructor_unfilled_fields;
5206   p->bit_index = constructor_bit_index;
5207   p->elements = constructor_elements;
5208   p->constant = constructor_constant;
5209   p->simple = constructor_simple;
5210   p->erroneous = constructor_erroneous;
5211   p->pending_elts = constructor_pending_elts;
5212   p->depth = constructor_depth;
5213   p->replacement_value = 0;
5214   p->implicit = implicit;
5215   p->incremental = constructor_incremental;
5216   p->outer = 0;
5217   p->next = constructor_stack;
5218   constructor_stack = p;
5219
5220   constructor_constant = 1;
5221   constructor_simple = 1;
5222   constructor_depth = SPELLING_DEPTH ();
5223   constructor_elements = 0;
5224   constructor_pending_elts = 0;
5225
5226   /* Don't die if an entire brace-pair level is superfluous
5227      in the containing level.  */
5228   if (constructor_type == 0)
5229     ;
5230   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5231            || TREE_CODE (constructor_type) == UNION_TYPE)
5232     {
5233       /* Don't die if there are extra init elts at the end.  */
5234       if (constructor_fields == 0)
5235         constructor_type = 0;
5236       else
5237         {
5238           constructor_type = TREE_TYPE (constructor_fields);
5239           push_member_name (constructor_fields);
5240           if (constructor_fields != constructor_unfilled_fields)
5241             constructor_incremental = 0;
5242         }
5243     }
5244   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5245     {
5246       constructor_type = TREE_TYPE (constructor_type);
5247       push_array_bounds (TREE_INT_CST_LOW (constructor_index));
5248       if (! tree_int_cst_equal (constructor_index, constructor_unfilled_index)
5249           || constructor_range_end != 0)
5250         constructor_incremental = 0;
5251     }
5252
5253   if (constructor_type == 0)
5254     {
5255       error_init ("extra brace group at end of initializer%s",
5256                   " for `%s'", NULL);
5257       constructor_fields = 0;
5258       constructor_unfilled_fields = 0;
5259       return;
5260     }
5261
5262   /* Turn off constructor_incremental if type is a struct with bitfields.  */
5263   check_init_type_bitfields (constructor_type);
5264
5265   if (implicit && warn_missing_braces && !missing_braces_mentioned)
5266     {
5267       missing_braces_mentioned = 1;
5268       warning_init ("missing braces around initializer%s", " for `%s'", NULL);
5269     }
5270
5271   if (TREE_CODE (constructor_type) == RECORD_TYPE
5272            || TREE_CODE (constructor_type) == UNION_TYPE)
5273     {
5274       constructor_fields = TYPE_FIELDS (constructor_type);
5275       /* Skip any nameless bit fields atthe beginning.  */
5276       while (constructor_fields != 0 && DECL_BIT_FIELD (constructor_fields)
5277              && DECL_NAME (constructor_fields) == 0)
5278         constructor_fields = TREE_CHAIN (constructor_fields);
5279       constructor_unfilled_fields = constructor_fields;
5280       constructor_bit_index = copy_node (integer_zero_node);
5281     }
5282   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5283     {
5284       constructor_range_end = 0;
5285       if (TYPE_DOMAIN (constructor_type))
5286         {
5287           constructor_max_index
5288             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5289           constructor_index
5290             = copy_node (TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5291         }
5292       else
5293         constructor_index = copy_node (integer_zero_node);
5294       constructor_unfilled_index = copy_node (constructor_index);
5295     }
5296   else
5297     {
5298       warning_init ("braces around scalar initializer%s", " for `%s'", NULL);
5299       constructor_fields = constructor_type;
5300       constructor_unfilled_fields = constructor_type;
5301     }
5302 }
5303
5304 /* Don't read a struct incrementally if it has any bitfields,
5305    because the incremental reading code doesn't know how to
5306    handle bitfields yet.  */
5307
5308 static void
5309 check_init_type_bitfields (type)
5310      tree type;
5311 {
5312   if (TREE_CODE (type) == RECORD_TYPE)
5313     {
5314       tree tail;
5315       for (tail = TYPE_FIELDS (type); tail;
5316            tail = TREE_CHAIN (tail))
5317         {
5318           if (DECL_BIT_FIELD (tail)
5319               /* This catches cases like `int foo : 8;'.  */
5320               || DECL_MODE (tail) != TYPE_MODE (TREE_TYPE (tail)))
5321             {
5322               constructor_incremental = 0;
5323               break;
5324             }
5325
5326           check_init_type_bitfields (TREE_TYPE (tail));
5327         }
5328     }
5329
5330   else if (TREE_CODE (type) == ARRAY_TYPE)
5331     check_init_type_bitfields (TREE_TYPE (type));
5332 }
5333
5334 /* At the end of an implicit or explicit brace level,
5335    finish up that level of constructor.
5336    If we were outputting the elements as they are read, return 0
5337    from inner levels (process_init_element ignores that),
5338    but return error_mark_node from the outermost level
5339    (that's what we want to put in DECL_INITIAL).
5340    Otherwise, return a CONSTRUCTOR expression.  */
5341
5342 tree
5343 pop_init_level (implicit)
5344      int implicit;
5345 {
5346   struct constructor_stack *p;
5347   int size = 0;
5348   tree constructor = 0;
5349
5350   if (implicit == 0)
5351     {
5352       /* When we come to an explicit close brace,
5353          pop any inner levels that didn't have explicit braces.  */
5354       while (constructor_stack->implicit)
5355         process_init_element (pop_init_level (1));
5356     }
5357
5358   p = constructor_stack;
5359
5360   if (constructor_type != 0)
5361     size = int_size_in_bytes (constructor_type);
5362
5363   /* Now output all pending elements.  */
5364   output_pending_init_elements (1);
5365
5366 #if 0 /* c-parse.in warns about {}.  */
5367   /* In ANSI, each brace level must have at least one element.  */
5368   if (! implicit && pedantic
5369       && (TREE_CODE (constructor_type) == ARRAY_TYPE
5370           ? integer_zerop (constructor_unfilled_index)
5371           : constructor_unfilled_fields == TYPE_FIELDS (constructor_type)))
5372     pedwarn_init ("empty braces in initializer%s", " for `%s'", NULL);
5373 #endif
5374
5375   /* Pad out the end of the structure.  */
5376
5377   if (p->replacement_value)
5378     {
5379       /* If this closes a superfluous brace pair,
5380          just pass out the element between them.  */
5381       constructor = p->replacement_value;
5382       /* If this is the top level thing within the initializer,
5383          and it's for a variable, then since we already called
5384          assemble_variable, we must output the value now.  */
5385       if (p->next == 0 && constructor_decl != 0
5386           && constructor_incremental)
5387         {
5388           constructor = digest_init (constructor_type, constructor,
5389                                      0, 0);
5390
5391           /* If initializing an array of unknown size,
5392              determine the size now.  */
5393           if (TREE_CODE (constructor_type) == ARRAY_TYPE
5394               && TYPE_DOMAIN (constructor_type) == 0)
5395             {
5396               int failure;
5397               int momentary_p;
5398
5399               push_obstacks_nochange ();
5400               if (TREE_PERMANENT (constructor_type))
5401                 end_temporary_allocation ();
5402
5403               momentary_p = suspend_momentary ();
5404
5405               /* We shouldn't have an incomplete array type within
5406                  some other type.  */
5407               if (constructor_stack->next)
5408                 abort ();
5409
5410               failure
5411                 = complete_array_type (constructor_type,
5412                                        constructor, 0);
5413               if (failure)
5414                 abort ();
5415
5416               size = int_size_in_bytes (constructor_type);
5417               resume_momentary (momentary_p);
5418               pop_obstacks ();
5419             }
5420
5421           output_constant (constructor, size);
5422         }
5423     }
5424   else if (constructor_type == 0)
5425     ;
5426   else if (TREE_CODE (constructor_type) != RECORD_TYPE
5427            && TREE_CODE (constructor_type) != UNION_TYPE
5428            && TREE_CODE (constructor_type) != ARRAY_TYPE
5429            && ! constructor_incremental)
5430     {
5431       /* A nonincremental scalar initializer--just return
5432          the element, after verifying there is just one.  */
5433       if (constructor_elements == 0)
5434         {
5435           error_init ("empty scalar initializer%s",
5436                       " for `%s'", NULL);
5437           constructor = error_mark_node;
5438         }
5439       else if (TREE_CHAIN (constructor_elements) != 0)
5440         {
5441           error_init ("extra elements in scalar initializer%s",
5442                       " for `%s'", NULL);
5443           constructor = TREE_VALUE (constructor_elements);
5444         }
5445       else
5446         constructor = TREE_VALUE (constructor_elements);
5447     }
5448   else if (! constructor_incremental)
5449     {
5450       if (constructor_erroneous)
5451         constructor = error_mark_node;
5452       else
5453         {
5454           int momentary = suspend_momentary ();
5455
5456           constructor = build (CONSTRUCTOR, constructor_type, NULL_TREE,
5457                                nreverse (constructor_elements));
5458           if (constructor_constant)
5459             TREE_CONSTANT (constructor) = 1;
5460           if (constructor_constant && constructor_simple)
5461             TREE_STATIC (constructor) = 1;
5462
5463           resume_momentary (momentary);
5464         }
5465     }
5466   else
5467     {
5468       tree filled;
5469       int momentary = suspend_momentary ();
5470
5471       if (TREE_CODE (constructor_type) == RECORD_TYPE
5472           || TREE_CODE (constructor_type) == UNION_TYPE)
5473         {
5474           /* Find the offset of the end of that field.  */
5475           filled = size_binop (CEIL_DIV_EXPR,
5476                                constructor_bit_index,
5477                                size_int (BITS_PER_UNIT));
5478         }
5479       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5480         {
5481           /* If initializing an array of unknown size,
5482              determine the size now.  */
5483           if (TREE_CODE (constructor_type) == ARRAY_TYPE
5484               && TYPE_DOMAIN (constructor_type) == 0)
5485             {
5486               tree maxindex
5487                 = size_binop (MINUS_EXPR,
5488                               constructor_unfilled_index,
5489                               integer_one_node);
5490
5491               push_obstacks_nochange ();
5492               if (TREE_PERMANENT (constructor_type))
5493                 end_temporary_allocation ();
5494               maxindex = copy_node (maxindex);
5495               TYPE_DOMAIN (constructor_type) = build_index_type (maxindex);
5496               TREE_TYPE (maxindex) = TYPE_DOMAIN (constructor_type);
5497
5498               /* TYPE_MAX_VALUE is always one less than the number of elements
5499                  in the array, because we start counting at zero.  Therefore,
5500                  warn only if the value is less than zero.  */
5501               if (pedantic
5502                   && (tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
5503                       < 0))
5504                 error_with_decl (constructor_decl,
5505                                  "zero or negative array size `%s'");
5506               layout_type (constructor_type);
5507               size = int_size_in_bytes (constructor_type);
5508               pop_obstacks ();
5509             }
5510
5511           filled = size_binop (MULT_EXPR, constructor_unfilled_index,
5512                                size_in_bytes (TREE_TYPE (constructor_type)));
5513         }
5514       else
5515         filled = 0;
5516
5517       if (filled != 0)
5518         assemble_zeros (size - TREE_INT_CST_LOW (filled));
5519
5520       resume_momentary (momentary);
5521     }
5522
5523
5524   constructor_type = p->type;
5525   constructor_fields = p->fields;
5526   constructor_index = p->index;
5527   constructor_range_end = p->range_end;
5528   constructor_max_index = p->max_index;
5529   constructor_unfilled_index = p->unfilled_index;
5530   constructor_unfilled_fields = p->unfilled_fields;
5531   constructor_bit_index = p->bit_index;
5532   constructor_elements = p->elements;
5533   constructor_constant = p->constant;
5534   constructor_simple = p->simple;
5535   constructor_erroneous = p->erroneous;
5536   constructor_pending_elts = p->pending_elts;
5537   constructor_depth = p->depth;
5538   constructor_incremental = p->incremental;
5539   RESTORE_SPELLING_DEPTH (constructor_depth);
5540
5541   constructor_stack = p->next;
5542   free (p);
5543
5544   if (constructor == 0)
5545     {
5546       if (constructor_stack == 0)
5547         return error_mark_node;
5548       return NULL_TREE;
5549     }
5550   return constructor;
5551 }
5552
5553 /* Within an array initializer, specify the next index to be initialized.
5554    FIRST is that index.  If LAST is nonzero, then initialize a range
5555    of indices, running from FIRST through LAST.  */
5556
5557 void
5558 set_init_index (first, last)
5559      tree first, last;
5560 {
5561   while ((TREE_CODE (first) == NOP_EXPR
5562           || TREE_CODE (first) == CONVERT_EXPR
5563           || TREE_CODE (first) == NON_LVALUE_EXPR)
5564          && (TYPE_MODE (TREE_TYPE (first))
5565              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5566     (first) = TREE_OPERAND (first, 0);
5567   if (last)
5568     while ((TREE_CODE (last) == NOP_EXPR
5569             || TREE_CODE (last) == CONVERT_EXPR
5570             || TREE_CODE (last) == NON_LVALUE_EXPR)
5571            && (TYPE_MODE (TREE_TYPE (last))
5572                == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5573       (last) = TREE_OPERAND (last, 0);
5574
5575   if (TREE_CODE (first) != INTEGER_CST)
5576     error_init ("nonconstant array index in initializer%s", " for `%s'", NULL);
5577   else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5578     error_init ("nonconstant array index in initializer%s", " for `%s'", NULL);
5579   else if (tree_int_cst_lt (first, constructor_unfilled_index))
5580     error_init ("duplicate array index in initializer%s", " for `%s'", NULL);
5581   else
5582     {
5583       TREE_INT_CST_LOW (constructor_index)
5584         = TREE_INT_CST_LOW (first);
5585       TREE_INT_CST_HIGH (constructor_index)
5586         = TREE_INT_CST_HIGH (first);
5587
5588       if (last != 0 && tree_int_cst_lt (last, first))
5589         error_init ("empty index range in initializer%s", " for `%s'", NULL);
5590       else
5591         {
5592           if (pedantic)
5593             pedwarn ("ANSI C forbids specifying element to initialize");
5594           constructor_range_end = last;
5595         }
5596     }
5597 }
5598
5599 /* Within a struct initializer, specify the next field to be initialized.  */
5600
5601 void
5602 set_init_label (fieldname)
5603      tree fieldname;
5604 {
5605   tree tail;
5606   int passed = 0;
5607
5608   for (tail = TYPE_FIELDS (constructor_type); tail;
5609        tail = TREE_CHAIN (tail))
5610     {
5611       if (tail == constructor_unfilled_fields)
5612         passed = 1;
5613       if (DECL_NAME (tail) == fieldname)
5614         break;
5615     }
5616
5617   if (tail == 0)
5618     error ("unknown field `%s' specified in initializer",
5619            IDENTIFIER_POINTER (fieldname));
5620   else if (!passed)
5621     error ("field `%s' already initialized",
5622            IDENTIFIER_POINTER (fieldname));
5623   else
5624     {
5625       constructor_fields = tail;
5626       if (pedantic)
5627         pedwarn ("ANSI C forbids specifying structure member to initialize");
5628     }
5629 }
5630 \f
5631 /* "Output" the next constructor element.
5632    At top level, really output it to assembler code now.
5633    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
5634    TYPE is the data type that the containing data type wants here.
5635    FIELD is the field (a FIELD_DECL) or the index that this element fills.
5636
5637    PENDING if non-nil means output pending elements that belong
5638    right after this element.  (PENDING is normally 1;
5639    it is 0 while outputting pending elements, to avoid recursion.)  */
5640
5641 static void
5642 output_init_element (value, type, field, pending)
5643      tree value, type, field;
5644      int pending;
5645 {
5646   int duplicate = 0;
5647
5648   if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
5649       || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
5650           && !(TREE_CODE (value) == STRING_CST
5651                && TREE_CODE (type) == ARRAY_TYPE
5652                && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
5653           && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
5654                          TYPE_MAIN_VARIANT (type))))
5655     value = default_conversion (value);
5656
5657   if (value == error_mark_node)
5658     constructor_erroneous = 1;
5659   else if (!TREE_CONSTANT (value))
5660     constructor_constant = 0;
5661   else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
5662     constructor_simple = 0;
5663
5664   if (require_constant_value && ! TREE_CONSTANT (value))
5665     {
5666       error_init ("initializer element%s is not constant",
5667                   " for `%s'", NULL);
5668       value = error_mark_node;
5669     }
5670   else if (require_constant_elements
5671            && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
5672     {
5673       error_init ("initializer element%s is not computable at load time",
5674                   " for `%s'", NULL);
5675       value = error_mark_node;
5676     }
5677
5678   /* If this element duplicates one on constructor_pending_elts,
5679      print a message and ignore it.  Don't do this when we're
5680      processing elements taken off constructor_pending_elts,
5681      because we'd always get spurious errors.  */
5682   if (pending)
5683     {
5684       if (TREE_CODE (constructor_type) == RECORD_TYPE
5685           || TREE_CODE (constructor_type) == UNION_TYPE)
5686         {
5687           if (purpose_member (field, constructor_pending_elts))
5688             {
5689               error_init ("duplicate initializer%s", " for `%s'", NULL);
5690               duplicate = 1;
5691             }
5692         }
5693       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5694         {
5695           tree tail;
5696           for (tail = constructor_pending_elts; tail;
5697                tail = TREE_CHAIN (tail))
5698             if (TREE_PURPOSE (tail) != 0
5699                 && TREE_CODE (TREE_PURPOSE (tail)) == INTEGER_CST
5700                 && tree_int_cst_equal (TREE_PURPOSE (tail), constructor_index))
5701               break;
5702
5703           if (tail != 0)
5704             {
5705               error_init ("duplicate initializer%s", " for `%s'", NULL);
5706               duplicate = 1;
5707             }
5708         }
5709     }
5710
5711   /* If this element doesn't come next in sequence,
5712      put it on constructor_pending_elts.  */
5713   if (TREE_CODE (constructor_type) == ARRAY_TYPE
5714       && !tree_int_cst_equal (field, constructor_unfilled_index))
5715     {
5716       if (! duplicate)
5717         /* The copy_node is needed in case field is actually
5718            constructor_index, which is modified in place.  */
5719         constructor_pending_elts
5720           = tree_cons (copy_node (field),
5721                        digest_init (type, value, 0, 0),
5722                        constructor_pending_elts);
5723     }
5724   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5725            && field != constructor_unfilled_fields)
5726     {
5727       /* We do this for records but not for unions.  In a union,
5728          no matter which field is specified, it can be initialized
5729          right away since it starts at the beginning of the union.  */
5730       if (!duplicate)
5731         constructor_pending_elts
5732           = tree_cons (field,
5733                        digest_init (type, value, 0, 0),
5734                        constructor_pending_elts);
5735     }
5736   else
5737     {
5738       /* Otherwise, output this element either to
5739          constructor_elements or to the assembler file.  */
5740
5741       if (!duplicate)
5742         {
5743           if (! constructor_incremental)
5744             {
5745               if (field && TREE_CODE (field) == INTEGER_CST)
5746                 field = copy_node (field);
5747               constructor_elements
5748                 = tree_cons (field, digest_init (type, value, 0, 0),
5749                              constructor_elements);
5750             }
5751           else
5752             {
5753               /* Structure elements may require alignment.
5754                  Do this, if necessary.  */
5755               if (TREE_CODE (constructor_type) == RECORD_TYPE)
5756                 {
5757                   /* Advance to offset of this element.  */
5758                   if (! tree_int_cst_equal (constructor_bit_index,
5759                                             DECL_FIELD_BITPOS (field)))
5760                     {
5761                       int next = (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field))
5762                                   / BITS_PER_UNIT);
5763                       int here = (TREE_INT_CST_LOW (constructor_bit_index)
5764                                   / BITS_PER_UNIT);
5765
5766                       assemble_zeros (next - here);
5767                     }
5768                 }
5769               output_constant (digest_init (type, value, 0, 0),
5770                                int_size_in_bytes (type));
5771
5772               /* For a record or union,
5773                  keep track of end position of last field.  */
5774               if (TREE_CODE (constructor_type) == RECORD_TYPE
5775                   || TREE_CODE (constructor_type) == UNION_TYPE)
5776                 {
5777                   tree temp = size_binop (PLUS_EXPR, DECL_FIELD_BITPOS (field),
5778                                           DECL_SIZE (field));
5779                   TREE_INT_CST_LOW (constructor_bit_index)
5780                     = TREE_INT_CST_LOW (temp);
5781                   TREE_INT_CST_HIGH (constructor_bit_index)
5782                     = TREE_INT_CST_HIGH (temp);
5783                 }
5784             }
5785         }
5786
5787       /* Advance the variable that indicates sequential elements output.  */
5788       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5789         {
5790           tree tem = size_binop (PLUS_EXPR, constructor_unfilled_index,
5791                                  integer_one_node);
5792           TREE_INT_CST_LOW (constructor_unfilled_index)
5793             = TREE_INT_CST_LOW (tem);
5794           TREE_INT_CST_HIGH (constructor_unfilled_index)
5795             = TREE_INT_CST_HIGH (tem);
5796         }
5797       else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5798         constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5799       else if (TREE_CODE (constructor_type) == UNION_TYPE)
5800         constructor_unfilled_fields = 0;
5801
5802       /* Now output any pending elements which have become next.  */
5803       if (pending)
5804         output_pending_init_elements (0);
5805     }
5806 }
5807
5808 /* Output any pending elements which have become next.
5809    As we output elements, constructor_unfilled_{fields,index}
5810    advances, which may cause other elements to become next;
5811    if so, they too are output.
5812
5813    If ALL is 0, we return when there are
5814    no more pending elements to output now.
5815
5816    If ALL is 1, we output space as necessary so that
5817    we can output all the pending elements.  */
5818
5819 static void
5820 output_pending_init_elements (all)
5821      int all;
5822 {
5823   tree tail;
5824   tree next;
5825
5826  retry:
5827
5828   /* Look thru the whole pending list.
5829      If we find an element that should be output now,
5830      output it.  Otherwise, set NEXT to the element
5831      that comes first among those still pending.  */
5832
5833   next = 0;
5834   for (tail = constructor_pending_elts; tail;
5835        tail = TREE_CHAIN (tail))
5836     {
5837       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5838         {
5839           if (tree_int_cst_equal (TREE_PURPOSE (tail),
5840                                   constructor_unfilled_index))
5841             {
5842               output_init_element (TREE_VALUE (tail),
5843                                    TREE_TYPE (constructor_type),
5844                                    constructor_unfilled_index, 0);
5845               goto retry;
5846             }
5847           else if (tree_int_cst_lt (TREE_PURPOSE (tail),
5848                                     constructor_unfilled_index))
5849             ;
5850           else if (next == 0
5851                    || tree_int_cst_lt (TREE_PURPOSE (tail), next))
5852             next = TREE_PURPOSE (tail);
5853         }
5854       else if (TREE_CODE (constructor_type) == RECORD_TYPE
5855                || TREE_CODE (constructor_type) == UNION_TYPE)
5856         {
5857           if (TREE_PURPOSE (tail) == constructor_unfilled_fields)
5858             {
5859               output_init_element (TREE_VALUE (tail),
5860                                    TREE_TYPE (constructor_unfilled_fields),
5861                                    constructor_unfilled_fields,
5862                                    0);
5863               goto retry;
5864             }
5865           else if (constructor_unfilled_fields == 0
5866                    || tree_int_cst_lt (DECL_FIELD_BITPOS (TREE_PURPOSE (tail)),
5867                                        DECL_FIELD_BITPOS (constructor_unfilled_fields)))
5868             ;
5869           else if (next == 0
5870                    || tree_int_cst_lt (DECL_FIELD_BITPOS (TREE_PURPOSE (tail)),
5871                                        DECL_FIELD_BITPOS (next)))
5872             next = TREE_PURPOSE (tail);
5873         }
5874     }
5875
5876   /* Ordinarily return, but not if we want to output all
5877      and there are elements left.  */
5878   if (! (all && next != 0))
5879     return;
5880
5881   /* Generate space up to the position of NEXT.  */
5882   if (constructor_incremental)
5883     {
5884       tree filled;
5885       tree nextpos_tree = size_int (0);
5886
5887       if (TREE_CODE (constructor_type) == RECORD_TYPE
5888           || TREE_CODE (constructor_type) == UNION_TYPE)
5889         {
5890           /* Find the last field written out, if any.  */
5891           for (tail = TYPE_FIELDS (constructor_type); tail;
5892                tail = TREE_CHAIN (tail))
5893             if (TREE_CHAIN (tail) == constructor_unfilled_fields)
5894               break;
5895
5896           if (tail)
5897             /* Find the offset of the end of that field.  */
5898             filled = size_binop (CEIL_DIV_EXPR,
5899                                  size_binop (PLUS_EXPR,
5900                                              DECL_FIELD_BITPOS (tail),
5901                                              DECL_SIZE (tail)),
5902                                  size_int (BITS_PER_UNIT));
5903           else
5904             filled = size_int (0);
5905
5906           nextpos_tree = size_binop (CEIL_DIV_EXPR,
5907                                      DECL_FIELD_BITPOS (next),
5908                                      size_int (BITS_PER_UNIT));
5909
5910           TREE_INT_CST_HIGH (constructor_bit_index)
5911             = TREE_INT_CST_HIGH (DECL_FIELD_BITPOS (next));
5912           TREE_INT_CST_LOW (constructor_bit_index)
5913             = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (next));
5914           constructor_unfilled_fields = next;
5915         }
5916       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5917         {
5918           filled = size_binop (MULT_EXPR, constructor_unfilled_index,
5919                                size_in_bytes (TREE_TYPE (constructor_type)));
5920           nextpos_tree
5921             = size_binop (MULT_EXPR, next,
5922                           size_in_bytes (TREE_TYPE (constructor_type)));
5923           TREE_INT_CST_LOW (constructor_unfilled_index)
5924             = TREE_INT_CST_LOW (next);
5925           TREE_INT_CST_HIGH (constructor_unfilled_index)
5926             = TREE_INT_CST_HIGH (next);
5927         }
5928       else
5929         filled = 0;
5930
5931       if (filled)
5932         {
5933           int nextpos = TREE_INT_CST_LOW (nextpos_tree);
5934
5935           assemble_zeros (nextpos - TREE_INT_CST_LOW (filled));
5936         }
5937     }
5938   else
5939     {
5940       /* If it's not incremental, just skip over the gap,
5941          so that after jumping to retry we will output the next
5942          successive element.  */
5943       if (TREE_CODE (constructor_type) == RECORD_TYPE
5944           || TREE_CODE (constructor_type) == UNION_TYPE)
5945         constructor_unfilled_fields = next;
5946       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5947         {
5948           TREE_INT_CST_LOW (constructor_unfilled_index)
5949             = TREE_INT_CST_LOW (next);
5950           TREE_INT_CST_HIGH (constructor_unfilled_index)
5951             = TREE_INT_CST_HIGH (next);
5952         }
5953     }
5954
5955   goto retry;
5956 }
5957 \f
5958 /* Add one non-braced element to the current constructor level.
5959    This adjusts the current position within the constructor's type.
5960    This may also start or terminate implicit levels
5961    to handle a partly-braced initializer.
5962
5963    Once this has found the correct level for the new element,
5964    it calls output_init_element.
5965
5966    Note: if we are incrementally outputting this constructor,
5967    this function may be called with a null argument
5968    representing a sub-constructor that was already incrementally output.
5969    When that happens, we output nothing, but we do the bookkeeping
5970    to skip past that element of the current constructor.  */
5971
5972 void
5973 process_init_element (value)
5974      tree value;
5975 {
5976   tree orig_value = value;
5977   int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
5978
5979   /* Handle superfluous braces around string cst as in
5980      char x[] = {"foo"}; */
5981   if (string_flag
5982       && constructor_type
5983       && TREE_CODE (constructor_type) == ARRAY_TYPE
5984       && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
5985       && integer_zerop (constructor_unfilled_index))
5986     {
5987       constructor_stack->replacement_value = value;
5988       return;
5989     }
5990
5991   if (constructor_stack->replacement_value != 0)
5992     {
5993       error_init ("excess elements in struct initializer%s",
5994                   " after `%s'", NULL_PTR);
5995       return;
5996     }
5997
5998   /* Ignore elements of a brace group if it is entirely superfluous
5999      and has already been diagnosed.  */
6000   if (constructor_type == 0)
6001     return;
6002
6003   /* If we've exhausted any levels that didn't have braces,
6004      pop them now.  */
6005   while (constructor_stack->implicit)
6006     {
6007       if ((TREE_CODE (constructor_type) == RECORD_TYPE
6008            || TREE_CODE (constructor_type) == UNION_TYPE)
6009           && constructor_fields == 0)
6010         process_init_element (pop_init_level (1));
6011       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6012                && tree_int_cst_lt (constructor_max_index, constructor_index))
6013         process_init_element (pop_init_level (1));
6014       else
6015         break;
6016     }
6017
6018   while (1)
6019     {
6020       if (TREE_CODE (constructor_type) == RECORD_TYPE)
6021         {
6022           tree fieldtype;
6023           enum tree_code fieldcode;
6024
6025           if (constructor_fields == 0)
6026             {
6027               pedwarn_init ("excess elements in struct initializer%s",
6028                             " after `%s'", NULL_PTR);
6029               break;
6030             }
6031
6032           fieldtype = TREE_TYPE (constructor_fields);
6033           if (fieldtype != error_mark_node)
6034             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6035           fieldcode = TREE_CODE (fieldtype);
6036
6037           /* Accept a string constant to initialize a subarray.  */
6038           if (value != 0
6039               && fieldcode == ARRAY_TYPE
6040               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6041               && string_flag)
6042             value = orig_value;
6043           /* Otherwise, if we have come to a subaggregate,
6044              and we don't have an element of its type, push into it.  */
6045           else if (value != 0 && !constructor_no_implicit
6046                    && value != error_mark_node
6047                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6048                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6049                        || fieldcode == UNION_TYPE))
6050             {
6051               push_init_level (1);
6052               continue;
6053             }
6054
6055           if (value)
6056             {
6057               push_member_name (constructor_fields);
6058               output_init_element (value, fieldtype, constructor_fields, 1);
6059               RESTORE_SPELLING_DEPTH (constructor_depth);
6060             }
6061           else
6062             /* Do the bookkeeping for an element that was
6063                directly output as a constructor.  */
6064             {
6065               /* For a record, keep track of end position of last field.  */
6066               tree temp = size_binop (PLUS_EXPR,
6067                                       DECL_FIELD_BITPOS (constructor_fields),
6068                                       DECL_SIZE (constructor_fields));
6069               TREE_INT_CST_LOW (constructor_bit_index)
6070                 = TREE_INT_CST_LOW (temp);
6071               TREE_INT_CST_HIGH (constructor_bit_index)
6072                 = TREE_INT_CST_HIGH (temp);
6073
6074               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6075             }
6076
6077           constructor_fields = TREE_CHAIN (constructor_fields);
6078           /* Skip any nameless bit fields atthe beginning.  */
6079           while (constructor_fields != 0 && DECL_BIT_FIELD (constructor_fields)
6080                  && DECL_NAME (constructor_fields) == 0)
6081             constructor_fields = TREE_CHAIN (constructor_fields);
6082           break;
6083         }
6084       if (TREE_CODE (constructor_type) == UNION_TYPE)
6085         {
6086           tree fieldtype;
6087           enum tree_code fieldcode;
6088
6089           if (constructor_fields == 0)
6090             {
6091               pedwarn_init ("excess elements in union initializer%s",
6092                             " after `%s'", NULL_PTR);
6093               break;
6094             }
6095
6096           fieldtype = TREE_TYPE (constructor_fields);
6097           if (fieldtype != error_mark_node)
6098             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6099           fieldcode = TREE_CODE (fieldtype);
6100
6101           /* Accept a string constant to initialize a subarray.  */
6102           if (value != 0
6103               && fieldcode == ARRAY_TYPE
6104               && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6105               && string_flag)
6106             value = orig_value;
6107           /* Otherwise, if we have come to a subaggregate,
6108              and we don't have an element of its type, push into it.  */
6109           else if (value != 0 && !constructor_no_implicit
6110                    && value != error_mark_node
6111                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6112                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6113                        || fieldcode == UNION_TYPE))
6114             {
6115               push_init_level (1);
6116               continue;
6117             }
6118
6119           if (value)
6120             {
6121               push_member_name (constructor_fields);
6122               output_init_element (value, fieldtype, constructor_fields, 1);
6123               RESTORE_SPELLING_DEPTH (constructor_depth);
6124             }
6125           else
6126             /* Do the bookkeeping for an element that was
6127                directly output as a constructor.  */
6128             {
6129               TREE_INT_CST_LOW (constructor_bit_index)
6130                 = TREE_INT_CST_LOW (DECL_SIZE (constructor_fields));
6131               TREE_INT_CST_HIGH (constructor_bit_index)
6132                 = TREE_INT_CST_HIGH (DECL_SIZE (constructor_fields));
6133
6134               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6135             }
6136
6137           constructor_fields = 0;
6138           break;
6139         }
6140       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6141         {
6142           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6143           enum tree_code eltcode = TREE_CODE (elttype);
6144
6145           /* Accept a string constant to initialize a subarray.  */
6146           if (value != 0
6147               && eltcode == ARRAY_TYPE
6148               && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
6149               && string_flag)
6150             value = orig_value;
6151           /* Otherwise, if we have come to a subaggregate,
6152              and we don't have an element of its type, push into it.  */
6153           else if (value != 0 && !constructor_no_implicit
6154                    && value != error_mark_node
6155                    && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
6156                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6157                        || eltcode == UNION_TYPE))
6158             {
6159               push_init_level (1);
6160               continue;
6161             }
6162
6163           if (constructor_max_index != 0
6164               && tree_int_cst_lt (constructor_max_index, constructor_index))
6165             {
6166               pedwarn_init ("excess elements in array initializer%s",
6167                             " after `%s'", NULL_PTR);
6168               break;
6169             }
6170
6171           /* In the case of [LO .. HI] = VALUE, only evaluate VALUE once. */
6172           if (constructor_range_end)
6173             value = save_expr (value);
6174
6175           /* Now output the actual element.
6176              Ordinarily, output once.
6177              If there is a range, repeat it till we advance past the range.  */
6178           do
6179             {
6180               tree tem;
6181
6182               if (value)
6183                 {
6184                   push_array_bounds (TREE_INT_CST_LOW (constructor_index));
6185                   output_init_element (value, elttype, constructor_index, 1);
6186                   RESTORE_SPELLING_DEPTH (constructor_depth);
6187                 }
6188
6189               tem = size_binop (PLUS_EXPR, constructor_index,
6190                                 integer_one_node);
6191               TREE_INT_CST_LOW (constructor_index)
6192                 = TREE_INT_CST_LOW (tem);
6193               TREE_INT_CST_HIGH (constructor_index)
6194                 = TREE_INT_CST_HIGH (tem);
6195
6196               if (!value)
6197                 /* If we are doing the bookkeeping for an element that was
6198                    directly output as a constructor,
6199                    we must update constructor_unfilled_index.  */
6200                 {
6201                   TREE_INT_CST_LOW (constructor_unfilled_index)
6202                     = TREE_INT_CST_LOW (constructor_index);
6203                   TREE_INT_CST_HIGH (constructor_unfilled_index)
6204                     = TREE_INT_CST_HIGH (constructor_index);
6205                 }
6206             }
6207           while (! (constructor_range_end == 0
6208                     || tree_int_cst_lt (constructor_range_end,
6209                                         constructor_index)));
6210
6211           break;
6212         }
6213
6214       /* Handle the sole element allowed in a braced initializer
6215          for a scalar variable.  */
6216       if (constructor_fields == 0)
6217         {
6218           pedwarn_init ("excess elements in scalar initializer%s",
6219                         " after `%s'", NULL_PTR);
6220           break;
6221         }
6222
6223       if (value)
6224         output_init_element (value, constructor_type, NULL_TREE, 1);
6225       constructor_fields = 0;
6226       break;
6227     }
6228
6229   /* If the (lexically) previous elments are not now saved,
6230      we can discard the storage for them.  */
6231   if (constructor_incremental && constructor_pending_elts == 0 && value != 0)
6232     clear_momentary ();
6233 }
6234 \f
6235 /* Expand an ASM statement with operands, handling output operands
6236    that are not variables or INDIRECT_REFS by transforming such
6237    cases into cases that expand_asm_operands can handle.
6238
6239    Arguments are same as for expand_asm_operands.  */
6240
6241 void
6242 c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
6243      tree string, outputs, inputs, clobbers;
6244      int vol;
6245      char *filename;
6246      int line;
6247 {
6248   int noutputs = list_length (outputs);
6249   register int i;
6250   /* o[I] is the place that output number I should be written.  */
6251   register tree *o = (tree *) alloca (noutputs * sizeof (tree));
6252   register tree tail;
6253
6254   if (TREE_CODE (string) == ADDR_EXPR)
6255     string = TREE_OPERAND (string, 0);
6256   if (TREE_CODE (string) != STRING_CST)
6257     {
6258       error ("asm template is not a string constant");
6259       return;
6260     }
6261
6262   /* Record the contents of OUTPUTS before it is modified.  */
6263   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6264     o[i] = TREE_VALUE (tail);
6265
6266   /* Perform default conversions on array and function inputs.  */
6267   /* Don't do this for other types--
6268      it would screw up operands expected to be in memory.  */
6269   for (i = 0, tail = inputs; tail; tail = TREE_CHAIN (tail), i++)
6270     if (TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == ARRAY_TYPE
6271         || TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == FUNCTION_TYPE)
6272       TREE_VALUE (tail) = default_conversion (TREE_VALUE (tail));
6273
6274   /* Generate the ASM_OPERANDS insn;
6275      store into the TREE_VALUEs of OUTPUTS some trees for
6276      where the values were actually stored.  */
6277   expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
6278
6279   /* Copy all the intermediate outputs into the specified outputs.  */
6280   for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6281     {
6282       if (o[i] != TREE_VALUE (tail))
6283         {
6284           expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6285                        0, VOIDmode, 0);
6286           free_temp_slots ();
6287         }
6288       /* Detect modification of read-only values.
6289          (Otherwise done by build_modify_expr.)  */
6290       else
6291         {
6292           tree type = TREE_TYPE (o[i]);
6293           if (TYPE_READONLY (type)
6294               || ((TREE_CODE (type) == RECORD_TYPE
6295                    || TREE_CODE (type) == UNION_TYPE)
6296                   && C_TYPE_FIELDS_READONLY (type)))
6297             readonly_warning (o[i], "modification by `asm'");
6298         }
6299     }
6300
6301   /* Those MODIFY_EXPRs could do autoincrements.  */
6302   emit_queue ();
6303 }
6304 \f
6305 /* Expand a C `return' statement.
6306    RETVAL is the expression for what to return,
6307    or a null pointer for `return;' with no value.  */
6308
6309 void
6310 c_expand_return (retval)
6311      tree retval;
6312 {
6313   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6314
6315   if (TREE_THIS_VOLATILE (current_function_decl))
6316     warning ("function declared `noreturn' has a `return' statement");
6317
6318   if (!retval)
6319     {
6320       current_function_returns_null = 1;
6321       if (warn_return_type && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6322         warning ("`return' with no value, in function returning non-void");
6323       expand_null_return ();
6324     }
6325   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6326     {
6327       current_function_returns_null = 1;
6328       if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6329         pedwarn ("`return' with a value, in function returning void");
6330       expand_return (retval);
6331     }
6332   else
6333     {
6334       tree t = convert_for_assignment (valtype, retval, "return",
6335                                        NULL_TREE, NULL_TREE, 0);
6336       tree res = DECL_RESULT (current_function_decl);
6337       tree inner;
6338
6339       if (t == error_mark_node)
6340         return;
6341
6342       inner = t = convert (TREE_TYPE (res), t);
6343
6344       /* Strip any conversions, additions, and subtractions, and see if
6345          we are returning the address of a local variable.  Warn if so.  */
6346       while (1)
6347         {
6348           switch (TREE_CODE (inner))
6349             {
6350             case NOP_EXPR:   case NON_LVALUE_EXPR:  case CONVERT_EXPR:
6351             case PLUS_EXPR:
6352               inner = TREE_OPERAND (inner, 0);
6353               continue;
6354
6355             case MINUS_EXPR:
6356               /* If the second operand of the MINUS_EXPR has a pointer
6357                  type (or is converted from it), this may be valid, so
6358                  don't give a warning.  */
6359               {
6360                 tree op1 = TREE_OPERAND (inner, 1);
6361
6362                 while (! POINTER_TYPE_P (TREE_TYPE (op1))
6363                        && (TREE_CODE (op1) == NOP_EXPR
6364                            || TREE_CODE (op1) == NON_LVALUE_EXPR
6365                            || TREE_CODE (op1) == CONVERT_EXPR))
6366                   op1 = TREE_OPERAND (op1, 0);
6367
6368                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6369                   break;
6370
6371                 inner = TREE_OPERAND (inner, 0);
6372                 continue;
6373               }
6374
6375             case ADDR_EXPR:
6376               inner = TREE_OPERAND (inner, 0);
6377
6378               while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
6379                 inner = TREE_OPERAND (inner, 0);
6380
6381               if (TREE_CODE (inner) == VAR_DECL
6382                   && ! DECL_EXTERNAL (inner)
6383                   && ! TREE_STATIC (inner)
6384                   && DECL_CONTEXT (inner) == current_function_decl)
6385                 warning ("function returns address of local variable");
6386               break;
6387             }
6388
6389           break;
6390         }
6391
6392       t = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
6393       TREE_SIDE_EFFECTS (t) = 1;
6394       expand_return (t);
6395       current_function_returns_value = 1;
6396     }
6397 }
6398 \f
6399 /* Start a C switch statement, testing expression EXP.
6400    Return EXP if it is valid, an error node otherwise.  */
6401
6402 tree
6403 c_expand_start_case (exp)
6404      tree exp;
6405 {
6406   register enum tree_code code = TREE_CODE (TREE_TYPE (exp));
6407   tree type = TREE_TYPE (exp);
6408
6409   if (code != INTEGER_TYPE && code != ENUMERAL_TYPE && code != ERROR_MARK)
6410     {
6411       error ("switch quantity not an integer");
6412       exp = error_mark_node;
6413     }
6414   else
6415     {
6416       tree index;
6417       type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
6418
6419       if (warn_traditional
6420           && (type == long_integer_type_node
6421               || type == long_unsigned_type_node))
6422         pedwarn ("`long' switch expression not converted to `int' in ANSI C");
6423
6424       exp = default_conversion (exp);
6425       type = TREE_TYPE (exp);
6426       index = get_unwidened (exp, NULL_TREE);
6427       /* We can't strip a conversion from a signed type to an unsigned,
6428          because if we did, int_fits_type_p would do the wrong thing
6429          when checking case values for being in range,
6430          and it's too hard to do the right thing.  */
6431       if (TREE_UNSIGNED (TREE_TYPE (exp))
6432           == TREE_UNSIGNED (TREE_TYPE (index)))
6433         exp = index;
6434     }
6435
6436   expand_start_case (1, exp, type, "switch statement");
6437
6438   return exp;
6439 }