gcc/c-typeck.c

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