gcc/c-typeck.c

   1 /* Build expressions with type checking for C compiler.
   2    Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22
  23 /* This file is part of the C front end.
  24    It contains routines to build C expressions given their operands,
  25    including computing the types of the result, C-specific error checks,
  26    and some optimization.  */
  27
  28 #include "config.h"
  29 #include "system.h"
  30 #include "coretypes.h"
  31 #include "tm.h"
  32 #include "rtl.h"
  33 #include "tree.h"
  34 #include "langhooks.h"
  35 #include "c-tree.h"
  36 #include "c-lang.h"
  37 #include "tm_p.h"
  38 #include "flags.h"
  39 #include "output.h"
  40 #include "expr.h"
  41 #include "toplev.h"
  42 #include "intl.h"
  43 #include "ggc.h"
  44 #include "target.h"
  45 #include "tree-iterator.h"
  46 #include "gimple.h"
  47 #include "tree-flow.h"
  48
  49 /* Possible cases of implicit bad conversions.  Used to select
  50    diagnostic messages in convert_for_assignment.  */
  51 enum impl_conv {
  52   ic_argpass,
  53   ic_assign,
  54   ic_init,
  55   ic_return
  56 };
  57
  58 /* Whether we are building a boolean conversion inside
  59    convert_for_assignment, or some other late binary operation.  If
  60    build_binary_op is called (from code shared with C++) in this case,
  61    then the operands have already been folded and the result will not
  62    be folded again, so C_MAYBE_CONST_EXPR should not be generated.  */
  63 bool in_late_binary_op;
  64
  65 /* The level of nesting inside "__alignof__".  */
  66 int in_alignof;
  67
  68 /* The level of nesting inside "sizeof".  */
  69 int in_sizeof;
  70
  71 /* The level of nesting inside "typeof".  */
  72 int in_typeof;
  73
  74 /* Nonzero if we've already printed a "missing braces around initializer"
  75    message within this initializer.  */
  76 static int missing_braces_mentioned;
  77
  78 static int require_constant_value;
  79 static int require_constant_elements;
  80
  81 static bool null_pointer_constant_p (const_tree);
  82 static tree qualify_type (tree, tree);
  83 static int tagged_types_tu_compatible_p (const_tree, const_tree, bool *);
  84 static int comp_target_types (location_t, tree, tree);
  85 static int function_types_compatible_p (const_tree, const_tree, bool *);
  86 static int type_lists_compatible_p (const_tree, const_tree, bool *);
  87 static tree lookup_field (tree, tree);
  88 static int convert_arguments (tree, VEC(tree,gc) *, VEC(tree,gc) *, tree,
  89                               tree);
  90 static tree pointer_diff (location_t, tree, tree);
  91 static tree convert_for_assignment (location_t, tree, tree, tree,
  92                                     enum impl_conv, bool, tree, tree, int);
  93 static tree valid_compound_expr_initializer (tree, tree);
  94 static void push_string (const char *);
  95 static void push_member_name (tree);
  96 static int spelling_length (void);
  97 static char *print_spelling (char *);
  98 static void warning_init (int, const char *);
  99 static tree digest_init (location_t, tree, tree, tree, bool, bool, int);
 100 static void output_init_element (tree, tree, bool, tree, tree, int, bool,
 101                                  struct obstack *);
 102 static void output_pending_init_elements (int, struct obstack *);
 103 static int set_designator (int, struct obstack *);
 104 static void push_range_stack (tree, struct obstack *);
 105 static void add_pending_init (tree, tree, tree, bool, struct obstack *);
 106 static void set_nonincremental_init (struct obstack *);
 107 static void set_nonincremental_init_from_string (tree, struct obstack *);
 108 static tree find_init_member (tree, struct obstack *);
 109 static void readonly_error (tree, enum lvalue_use);
 110 static void readonly_warning (tree, enum lvalue_use);
 111 static int lvalue_or_else (const_tree, enum lvalue_use);
 112 static void record_maybe_used_decl (tree);
 113 static int comptypes_internal (const_tree, const_tree, bool *);
 114 \f
 115 /* Return true if EXP is a null pointer constant, false otherwise.  */
 116
 117 static bool
 118 null_pointer_constant_p (const_tree expr)
 119 {
 120   /* This should really operate on c_expr structures, but they aren't
 121      yet available everywhere required.  */
 122   tree type = TREE_TYPE (expr);
 123   return (TREE_CODE (expr) == INTEGER_CST
 124           && !TREE_OVERFLOW (expr)
 125           && integer_zerop (expr)
 126           && (INTEGRAL_TYPE_P (type)
 127               || (TREE_CODE (type) == POINTER_TYPE
 128                   && VOID_TYPE_P (TREE_TYPE (type))
 129                   && TYPE_QUALS (TREE_TYPE (type)) == TYPE_UNQUALIFIED)));
 130 }
 131
 132 /* EXPR may appear in an unevaluated part of an integer constant
 133    expression, but not in an evaluated part.  Wrap it in a
 134    C_MAYBE_CONST_EXPR, or mark it with TREE_OVERFLOW if it is just an
 135    INTEGER_CST and we cannot create a C_MAYBE_CONST_EXPR.  */
 136
 137 static tree
 138 note_integer_operands (tree expr)
 139 {
 140   tree ret;
 141   if (TREE_CODE (expr) == INTEGER_CST && in_late_binary_op)
 142     {
 143       ret = copy_node (expr);
 144       TREE_OVERFLOW (ret) = 1;
 145     }
 146   else
 147     {
 148       ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL_TREE, expr);
 149       C_MAYBE_CONST_EXPR_INT_OPERANDS (ret) = 1;
 150     }
 151   return ret;
 152 }
 153
 154 /* Having checked whether EXPR may appear in an unevaluated part of an
 155    integer constant expression and found that it may, remove any
 156    C_MAYBE_CONST_EXPR noting this fact and return the resulting
 157    expression.  */
 158
 159 static inline tree
 160 remove_c_maybe_const_expr (tree expr)
 161 {
 162   if (TREE_CODE (expr) == C_MAYBE_CONST_EXPR)
 163     return C_MAYBE_CONST_EXPR_EXPR (expr);
 164   else
 165     return expr;
 166 }
 167
 168 \f/* This is a cache to hold if two types are compatible or not.  */
 169
 170 struct tagged_tu_seen_cache {
 171   const struct tagged_tu_seen_cache * next;
 172   const_tree t1;
 173   const_tree t2;
 174   /* The return value of tagged_types_tu_compatible_p if we had seen
 175      these two types already.  */
 176   int val;
 177 };
 178
 179 static const struct tagged_tu_seen_cache * tagged_tu_seen_base;
 180 static void free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *);
 181
 182 /* Do `exp = require_complete_type (exp);' to make sure exp
 183    does not have an incomplete type.  (That includes void types.)  */
 184
 185 tree
 186 require_complete_type (tree value)
 187 {
 188   tree type = TREE_TYPE (value);
 189
 190   if (value == error_mark_node || type == error_mark_node)
 191     return error_mark_node;
 192
 193   /* First, detect a valid value with a complete type.  */
 194   if (COMPLETE_TYPE_P (type))
 195     return value;
 196
 197   c_incomplete_type_error (value, type);
 198   return error_mark_node;
 199 }
 200
 201 /* Print an error message for invalid use of an incomplete type.
 202    VALUE is the expression that was used (or 0 if that isn't known)
 203    and TYPE is the type that was invalid.  */
 204
 205 void
 206 c_incomplete_type_error (const_tree value, const_tree type)
 207 {
 208   const char *type_code_string;
 209
 210   /* Avoid duplicate error message.  */
 211   if (TREE_CODE (type) == ERROR_MARK)
 212     return;
 213
 214   if (value != 0 && (TREE_CODE (value) == VAR_DECL
 215                      || TREE_CODE (value) == PARM_DECL))
 216     error ("%qD has an incomplete type", value);
 217   else
 218     {
 219     retry:
 220       /* We must print an error message.  Be clever about what it says.  */
 221
 222       switch (TREE_CODE (type))
 223         {
 224         case RECORD_TYPE:
 225           type_code_string = "struct";
 226           break;
 227
 228         case UNION_TYPE:
 229           type_code_string = "union";
 230           break;
 231
 232         case ENUMERAL_TYPE:
 233           type_code_string = "enum";
 234           break;
 235
 236         case VOID_TYPE:
 237           error ("invalid use of void expression");
 238           return;
 239
 240         case ARRAY_TYPE:
 241           if (TYPE_DOMAIN (type))
 242             {
 243               if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL)
 244                 {
 245                   error ("invalid use of flexible array member");
 246                   return;
 247                 }
 248               type = TREE_TYPE (type);
 249               goto retry;
 250             }
 251           error ("invalid use of array with unspecified bounds");
 252           return;
 253
 254         default:
 255           gcc_unreachable ();
 256         }
 257
 258       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
 259         error ("invalid use of undefined type %<%s %E%>",
 260                type_code_string, TYPE_NAME (type));
 261       else
 262         /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL.  */
 263         error ("invalid use of incomplete typedef %qD", TYPE_NAME (type));
 264     }
 265 }
 266
 267 /* Given a type, apply default promotions wrt unnamed function
 268    arguments and return the new type.  */
 269
 270 tree
 271 c_type_promotes_to (tree type)
 272 {
 273   if (TYPE_MAIN_VARIANT (type) == float_type_node)
 274     return double_type_node;
 275
 276   if (c_promoting_integer_type_p (type))
 277     {
 278       /* Preserve unsignedness if not really getting any wider.  */
 279       if (TYPE_UNSIGNED (type)
 280           && (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
 281         return unsigned_type_node;
 282       return integer_type_node;
 283     }
 284
 285   return type;
 286 }
 287
 288 /* Return true if between two named address spaces, whether there is a superset
 289    named address space that encompasses both address spaces.  If there is a
 290    superset, return which address space is the superset.  */
 291
 292 static bool
 293 addr_space_superset (addr_space_t as1, addr_space_t as2, addr_space_t *common)
 294 {
 295   if (as1 == as2)
 296     {
 297       *common = as1;
 298       return true;
 299     }
 300   else if (targetm.addr_space.subset_p (as1, as2))
 301     {
 302       *common = as2;
 303       return true;
 304     }
 305   else if (targetm.addr_space.subset_p (as2, as1))
 306     {
 307       *common = as1;
 308       return true;
 309     }
 310   else
 311     return false;
 312 }
 313
 314 /* Return a variant of TYPE which has all the type qualifiers of LIKE
 315    as well as those of TYPE.  */
 316
 317 static tree
 318 qualify_type (tree type, tree like)
 319 {
 320   addr_space_t as_type = TYPE_ADDR_SPACE (type);
 321   addr_space_t as_like = TYPE_ADDR_SPACE (like);
 322   addr_space_t as_common;
 323
 324   /* If the two named address spaces are different, determine the common
 325      superset address space.  If there isn't one, raise an error.  */
 326   if (!addr_space_superset (as_type, as_like, &as_common))
 327     {
 328       as_common = as_type;
 329       error ("%qT and %qT are in disjoint named address spaces",
 330              type, like);
 331     }
 332
 333   return c_build_qualified_type (type,
 334                                  TYPE_QUALS_NO_ADDR_SPACE (type)
 335                                  | TYPE_QUALS_NO_ADDR_SPACE (like)
 336                                  | ENCODE_QUAL_ADDR_SPACE (as_common));
 337 }
 338
 339 /* Return true iff the given tree T is a variable length array.  */
 340
 341 bool
 342 c_vla_type_p (const_tree t)
 343 {
 344   if (TREE_CODE (t) == ARRAY_TYPE
 345       && C_TYPE_VARIABLE_SIZE (t))
 346     return true;
 347   return false;
 348 }
 349 \f
 350 /* Return the composite type of two compatible types.
 351
 352    We assume that comptypes has already been done and returned
 353    nonzero; if that isn't so, this may crash.  In particular, we
 354    assume that qualifiers match.  */
 355
 356 tree
 357 composite_type (tree t1, tree t2)
 358 {
 359   enum tree_code code1;
 360   enum tree_code code2;
 361   tree attributes;
 362
 363   /* Save time if the two types are the same.  */
 364
 365   if (t1 == t2) return t1;
 366
 367   /* If one type is nonsense, use the other.  */
 368   if (t1 == error_mark_node)
 369     return t2;
 370   if (t2 == error_mark_node)
 371     return t1;
 372
 373   code1 = TREE_CODE (t1);
 374   code2 = TREE_CODE (t2);
 375
 376   /* Merge the attributes.  */
 377   attributes = targetm.merge_type_attributes (t1, t2);
 378
 379   /* If one is an enumerated type and the other is the compatible
 380      integer type, the composite type might be either of the two
 381      (DR#013 question 3).  For consistency, use the enumerated type as
 382      the composite type.  */
 383
 384   if (code1 == ENUMERAL_TYPE && code2 == INTEGER_TYPE)
 385     return t1;
 386   if (code2 == ENUMERAL_TYPE && code1 == INTEGER_TYPE)
 387     return t2;
 388
 389   gcc_assert (code1 == code2);
 390
 391   switch (code1)
 392     {
 393     case POINTER_TYPE:
 394       /* For two pointers, do this recursively on the target type.  */
 395       {
 396         tree pointed_to_1 = TREE_TYPE (t1);
 397         tree pointed_to_2 = TREE_TYPE (t2);
 398         tree target = composite_type (pointed_to_1, pointed_to_2);
 399         t1 = build_pointer_type (target);
 400         t1 = build_type_attribute_variant (t1, attributes);
 401         return qualify_type (t1, t2);
 402       }
 403
 404     case ARRAY_TYPE:
 405       {
 406         tree elt = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
 407         int quals;
 408         tree unqual_elt;
 409         tree d1 = TYPE_DOMAIN (t1);
 410         tree d2 = TYPE_DOMAIN (t2);
 411         bool d1_variable, d2_variable;
 412         bool d1_zero, d2_zero;
 413         bool t1_complete, t2_complete;
 414
 415         /* We should not have any type quals on arrays at all.  */
 416         gcc_assert (!TYPE_QUALS_NO_ADDR_SPACE (t1)
 417                     && !TYPE_QUALS_NO_ADDR_SPACE (t2));
 418
 419         t1_complete = COMPLETE_TYPE_P (t1);
 420         t2_complete = COMPLETE_TYPE_P (t2);
 421
 422         d1_zero = d1 == 0 || !TYPE_MAX_VALUE (d1);
 423         d2_zero = d2 == 0 || !TYPE_MAX_VALUE (d2);
 424
 425         d1_variable = (!d1_zero
 426                        && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
 427                            || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
 428         d2_variable = (!d2_zero
 429                        && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
 430                            || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
 431         d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1));
 432         d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2));
 433
 434         /* Save space: see if the result is identical to one of the args.  */
 435         if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1)
 436             && (d2_variable || d2_zero || !d1_variable))
 437           return build_type_attribute_variant (t1, attributes);
 438         if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2)
 439             && (d1_variable || d1_zero || !d2_variable))
 440           return build_type_attribute_variant (t2, attributes);
 441
 442         if (elt == TREE_TYPE (t1) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
 443           return build_type_attribute_variant (t1, attributes);
 444         if (elt == TREE_TYPE (t2) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
 445           return build_type_attribute_variant (t2, attributes);
 446
 447         /* Merge the element types, and have a size if either arg has
 448            one.  We may have qualifiers on the element types.  To set
 449            up TYPE_MAIN_VARIANT correctly, we need to form the
 450            composite of the unqualified types and add the qualifiers
 451            back at the end.  */
 452         quals = TYPE_QUALS (strip_array_types (elt));
 453         unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
 454         t1 = build_array_type (unqual_elt,
 455                                TYPE_DOMAIN ((TYPE_DOMAIN (t1)
 456                                              && (d2_variable
 457                                                  || d2_zero
 458                                                  || !d1_variable))
 459                                             ? t1
 460                                             : t2));
 461         /* Ensure a composite type involving a zero-length array type
 462            is a zero-length type not an incomplete type.  */
 463         if (d1_zero && d2_zero
 464             && (t1_complete || t2_complete)
 465             && !COMPLETE_TYPE_P (t1))
 466           {
 467             TYPE_SIZE (t1) = bitsize_zero_node;
 468             TYPE_SIZE_UNIT (t1) = size_zero_node;
 469           }
 470         t1 = c_build_qualified_type (t1, quals);
 471         return build_type_attribute_variant (t1, attributes);
 472       }
 473
 474     case ENUMERAL_TYPE:
 475     case RECORD_TYPE:
 476     case UNION_TYPE:
 477       if (attributes != NULL)
 478         {
 479           /* Try harder not to create a new aggregate type.  */
 480           if (attribute_list_equal (TYPE_ATTRIBUTES (t1), attributes))
 481             return t1;
 482           if (attribute_list_equal (TYPE_ATTRIBUTES (t2), attributes))
 483             return t2;
 484         }
 485       return build_type_attribute_variant (t1, attributes);
 486
 487     case FUNCTION_TYPE:
 488       /* Function types: prefer the one that specified arg types.
 489          If both do, merge the arg types.  Also merge the return types.  */
 490       {
 491         tree valtype = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
 492         tree p1 = TYPE_ARG_TYPES (t1);
 493         tree p2 = TYPE_ARG_TYPES (t2);
 494         int len;
 495         tree newargs, n;
 496         int i;
 497
 498         /* Save space: see if the result is identical to one of the args.  */
 499         if (valtype == TREE_TYPE (t1) && !TYPE_ARG_TYPES (t2))
 500           return build_type_attribute_variant (t1, attributes);
 501         if (valtype == TREE_TYPE (t2) && !TYPE_ARG_TYPES (t1))
 502           return build_type_attribute_variant (t2, attributes);
 503
 504         /* Simple way if one arg fails to specify argument types.  */
 505         if (TYPE_ARG_TYPES (t1) == 0)
 506          {
 507             t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
 508             t1 = build_type_attribute_variant (t1, attributes);
 509             return qualify_type (t1, t2);
 510          }
 511         if (TYPE_ARG_TYPES (t2) == 0)
 512          {
 513            t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
 514            t1 = build_type_attribute_variant (t1, attributes);
 515            return qualify_type (t1, t2);
 516          }
 517
 518         /* If both args specify argument types, we must merge the two
 519            lists, argument by argument.  */
 520         /* Tell global_bindings_p to return false so that variable_size
 521            doesn't die on VLAs in parameter types.  */
 522         c_override_global_bindings_to_false = true;
 523
 524         len = list_length (p1);
 525         newargs = 0;
 526
 527         for (i = 0; i < len; i++)
 528           newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
 529
 530         n = newargs;
 531
 532         for (; p1;
 533              p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
 534           {
 535             /* A null type means arg type is not specified.
 536                Take whatever the other function type has.  */
 537             if (TREE_VALUE (p1) == 0)
 538               {
 539                 TREE_VALUE (n) = TREE_VALUE (p2);
 540                 goto parm_done;
 541               }
 542             if (TREE_VALUE (p2) == 0)
 543               {
 544                 TREE_VALUE (n) = TREE_VALUE (p1);
 545                 goto parm_done;
 546               }
 547
 548             /* Given  wait (union {union wait *u; int *i} *)
 549                and  wait (union wait *),
 550                prefer  union wait *  as type of parm.  */
 551             if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
 552                 && TREE_VALUE (p1) != TREE_VALUE (p2))
 553               {
 554                 tree memb;
 555                 tree mv2 = TREE_VALUE (p2);
 556                 if (mv2 && mv2 != error_mark_node
 557                     && TREE_CODE (mv2) != ARRAY_TYPE)
 558                   mv2 = TYPE_MAIN_VARIANT (mv2);
 559                 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
 560                      memb; memb = TREE_CHAIN (memb))
 561                   {
 562                     tree mv3 = TREE_TYPE (memb);
 563                     if (mv3 && mv3 != error_mark_node
 564                         && TREE_CODE (mv3) != ARRAY_TYPE)
 565                       mv3 = TYPE_MAIN_VARIANT (mv3);
 566                     if (comptypes (mv3, mv2))
 567                       {
 568                         TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
 569                                                          TREE_VALUE (p2));
 570                         pedwarn (input_location, OPT_pedantic,
 571                                  "function types not truly compatible in ISO C");
 572                         goto parm_done;
 573                       }
 574                   }
 575               }
 576             if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
 577                 && TREE_VALUE (p2) != TREE_VALUE (p1))
 578               {
 579                 tree memb;
 580                 tree mv1 = TREE_VALUE (p1);
 581                 if (mv1 && mv1 != error_mark_node
 582                     && TREE_CODE (mv1) != ARRAY_TYPE)
 583                   mv1 = TYPE_MAIN_VARIANT (mv1);
 584                 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
 585                      memb; memb = TREE_CHAIN (memb))
 586                   {
 587                     tree mv3 = TREE_TYPE (memb);
 588                     if (mv3 && mv3 != error_mark_node
 589                         && TREE_CODE (mv3) != ARRAY_TYPE)
 590                       mv3 = TYPE_MAIN_VARIANT (mv3);
 591                     if (comptypes (mv3, mv1))
 592                       {
 593                         TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
 594                                                          TREE_VALUE (p1));
 595                         pedwarn (input_location, OPT_pedantic,
 596                                  "function types not truly compatible in ISO C");
 597                         goto parm_done;
 598                       }
 599                   }
 600               }
 601             TREE_VALUE (n) = composite_type (TREE_VALUE (p1), TREE_VALUE (p2));
 602           parm_done: ;
 603           }
 604
 605         c_override_global_bindings_to_false = false;
 606         t1 = build_function_type (valtype, newargs);
 607         t1 = qualify_type (t1, t2);
 608         /* ... falls through ...  */
 609       }
 610
 611     default:
 612       return build_type_attribute_variant (t1, attributes);
 613     }
 614
 615 }
 616
 617 /* Return the type of a conditional expression between pointers to
 618    possibly differently qualified versions of compatible types.
 619
 620    We assume that comp_target_types has already been done and returned
 621    nonzero; if that isn't so, this may crash.  */
 622
 623 static tree
 624 common_pointer_type (tree t1, tree t2)
 625 {
 626   tree attributes;
 627   tree pointed_to_1, mv1;
 628   tree pointed_to_2, mv2;
 629   tree target;
 630   unsigned target_quals;
 631   addr_space_t as1, as2, as_common;
 632   int quals1, quals2;
 633
 634   /* Save time if the two types are the same.  */
 635
 636   if (t1 == t2) return t1;
 637
 638   /* If one type is nonsense, use the other.  */
 639   if (t1 == error_mark_node)
 640     return t2;
 641   if (t2 == error_mark_node)
 642     return t1;
 643
 644   gcc_assert (TREE_CODE (t1) == POINTER_TYPE
 645               && TREE_CODE (t2) == POINTER_TYPE);
 646
 647   /* Merge the attributes.  */
 648   attributes = targetm.merge_type_attributes (t1, t2);
 649
 650   /* Find the composite type of the target types, and combine the
 651      qualifiers of the two types' targets.  Do not lose qualifiers on
 652      array element types by taking the TYPE_MAIN_VARIANT.  */
 653   mv1 = pointed_to_1 = TREE_TYPE (t1);
 654   mv2 = pointed_to_2 = TREE_TYPE (t2);
 655   if (TREE_CODE (mv1) != ARRAY_TYPE)
 656     mv1 = TYPE_MAIN_VARIANT (pointed_to_1);
 657   if (TREE_CODE (mv2) != ARRAY_TYPE)
 658     mv2 = TYPE_MAIN_VARIANT (pointed_to_2);
 659   target = composite_type (mv1, mv2);
 660
 661   /* For function types do not merge const qualifiers, but drop them
 662      if used inconsistently.  The middle-end uses these to mark const
 663      and noreturn functions.  */
 664   quals1 = TYPE_QUALS_NO_ADDR_SPACE (pointed_to_1);
 665   quals2 = TYPE_QUALS_NO_ADDR_SPACE (pointed_to_2);
 666
 667   if (TREE_CODE (pointed_to_1) == FUNCTION_TYPE)
 668     target_quals = (quals1 & quals2);
 669   else
 670     target_quals = (quals1 | quals2);
 671
 672   /* If the two named address spaces are different, determine the common
 673      superset address space.  This is guaranteed to exist due to the
 674      assumption that comp_target_type returned non-zero.  */
 675   as1 = TYPE_ADDR_SPACE (pointed_to_1);
 676   as2 = TYPE_ADDR_SPACE (pointed_to_2);
 677   if (!addr_space_superset (as1, as2, &as_common))
 678     gcc_unreachable ();
 679
 680   target_quals |= ENCODE_QUAL_ADDR_SPACE (as_common);
 681
 682   t1 = build_pointer_type (c_build_qualified_type (target, target_quals));
 683   return build_type_attribute_variant (t1, attributes);
 684 }
 685
 686 /* Return the common type for two arithmetic types under the usual
 687    arithmetic conversions.  The default conversions have already been
 688    applied, and enumerated types converted to their compatible integer
 689    types.  The resulting type is unqualified and has no attributes.
 690
 691    This is the type for the result of most arithmetic operations
 692    if the operands have the given two types.  */
 693
 694 static tree
 695 c_common_type (tree t1, tree t2)
 696 {
 697   enum tree_code code1;
 698   enum tree_code code2;
 699
 700   /* If one type is nonsense, use the other.  */
 701   if (t1 == error_mark_node)
 702     return t2;
 703   if (t2 == error_mark_node)
 704     return t1;
 705
 706   if (TYPE_QUALS (t1) != TYPE_UNQUALIFIED)
 707     t1 = TYPE_MAIN_VARIANT (t1);
 708
 709   if (TYPE_QUALS (t2) != TYPE_UNQUALIFIED)
 710     t2 = TYPE_MAIN_VARIANT (t2);
 711
 712   if (TYPE_ATTRIBUTES (t1) != NULL_TREE)
 713     t1 = build_type_attribute_variant (t1, NULL_TREE);
 714
 715   if (TYPE_ATTRIBUTES (t2) != NULL_TREE)
 716     t2 = build_type_attribute_variant (t2, NULL_TREE);
 717
 718   /* Save time if the two types are the same.  */
 719
 720   if (t1 == t2) return t1;
 721
 722   code1 = TREE_CODE (t1);
 723   code2 = TREE_CODE (t2);
 724
 725   gcc_assert (code1 == VECTOR_TYPE || code1 == COMPLEX_TYPE
 726               || code1 == FIXED_POINT_TYPE || code1 == REAL_TYPE
 727               || code1 == INTEGER_TYPE);
 728   gcc_assert (code2 == VECTOR_TYPE || code2 == COMPLEX_TYPE
 729               || code2 == FIXED_POINT_TYPE || code2 == REAL_TYPE
 730               || code2 == INTEGER_TYPE);
 731
 732   /* When one operand is a decimal float type, the other operand cannot be
 733      a generic float type or a complex type.  We also disallow vector types
 734      here.  */
 735   if ((DECIMAL_FLOAT_TYPE_P (t1) || DECIMAL_FLOAT_TYPE_P (t2))
 736       && !(DECIMAL_FLOAT_TYPE_P (t1) && DECIMAL_FLOAT_TYPE_P (t2)))
 737     {
 738       if (code1 == VECTOR_TYPE || code2 == VECTOR_TYPE)
 739         {
 740           error ("can%'t mix operands of decimal float and vector types");
 741           return error_mark_node;
 742         }
 743       if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
 744         {
 745           error ("can%'t mix operands of decimal float and complex types");
 746           return error_mark_node;
 747         }
 748       if (code1 == REAL_TYPE && code2 == REAL_TYPE)
 749         {
 750           error ("can%'t mix operands of decimal float and other float types");
 751           return error_mark_node;
 752         }
 753     }
 754
 755   /* If one type is a vector type, return that type.  (How the usual
 756      arithmetic conversions apply to the vector types extension is not
 757      precisely specified.)  */
 758   if (code1 == VECTOR_TYPE)
 759     return t1;
 760
 761   if (code2 == VECTOR_TYPE)
 762     return t2;
 763
 764   /* If one type is complex, form the common type of the non-complex
 765      components, then make that complex.  Use T1 or T2 if it is the
 766      required type.  */
 767   if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
 768     {
 769       tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
 770       tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
 771       tree subtype = c_common_type (subtype1, subtype2);
 772
 773       if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
 774         return t1;
 775       else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
 776         return t2;
 777       else
 778         return build_complex_type (subtype);
 779     }
 780
 781   /* If only one is real, use it as the result.  */
 782
 783   if (code1 == REAL_TYPE && code2 != REAL_TYPE)
 784     return t1;
 785
 786   if (code2 == REAL_TYPE && code1 != REAL_TYPE)
 787     return t2;
 788
 789   /* If both are real and either are decimal floating point types, use
 790      the decimal floating point type with the greater precision. */
 791
 792   if (code1 == REAL_TYPE && code2 == REAL_TYPE)
 793     {
 794       if (TYPE_MAIN_VARIANT (t1) == dfloat128_type_node
 795           || TYPE_MAIN_VARIANT (t2) == dfloat128_type_node)
 796         return dfloat128_type_node;
 797       else if (TYPE_MAIN_VARIANT (t1) == dfloat64_type_node
 798                || TYPE_MAIN_VARIANT (t2) == dfloat64_type_node)
 799         return dfloat64_type_node;
 800       else if (TYPE_MAIN_VARIANT (t1) == dfloat32_type_node
 801                || TYPE_MAIN_VARIANT (t2) == dfloat32_type_node)
 802         return dfloat32_type_node;
 803     }
 804
 805   /* Deal with fixed-point types.  */
 806   if (code1 == FIXED_POINT_TYPE || code2 == FIXED_POINT_TYPE)
 807     {
 808       unsigned int unsignedp = 0, satp = 0;
 809       enum machine_mode m1, m2;
 810       unsigned int fbit1, ibit1, fbit2, ibit2, max_fbit, max_ibit;
 811
 812       m1 = TYPE_MODE (t1);
 813       m2 = TYPE_MODE (t2);
 814
 815       /* If one input type is saturating, the result type is saturating.  */
 816       if (TYPE_SATURATING (t1) || TYPE_SATURATING (t2))
 817         satp = 1;
 818
 819       /* If both fixed-point types are unsigned, the result type is unsigned.
 820          When mixing fixed-point and integer types, follow the sign of the
 821          fixed-point type.
 822          Otherwise, the result type is signed.  */
 823       if ((TYPE_UNSIGNED (t1) && TYPE_UNSIGNED (t2)
 824            && code1 == FIXED_POINT_TYPE && code2 == FIXED_POINT_TYPE)
 825           || (code1 == FIXED_POINT_TYPE && code2 != FIXED_POINT_TYPE
 826               && TYPE_UNSIGNED (t1))
 827           || (code1 != FIXED_POINT_TYPE && code2 == FIXED_POINT_TYPE
 828               && TYPE_UNSIGNED (t2)))
 829         unsignedp = 1;
 830
 831       /* The result type is signed.  */
 832       if (unsignedp == 0)
 833         {
 834           /* If the input type is unsigned, we need to convert to the
 835              signed type.  */
 836           if (code1 == FIXED_POINT_TYPE && TYPE_UNSIGNED (t1))
 837             {
 838               enum mode_class mclass = (enum mode_class) 0;
 839               if (GET_MODE_CLASS (m1) == MODE_UFRACT)
 840                 mclass = MODE_FRACT;
 841               else if (GET_MODE_CLASS (m1) == MODE_UACCUM)
 842                 mclass = MODE_ACCUM;
 843               else
 844                 gcc_unreachable ();
 845               m1 = mode_for_size (GET_MODE_PRECISION (m1), mclass, 0);
 846             }
 847           if (code2 == FIXED_POINT_TYPE && TYPE_UNSIGNED (t2))
 848             {
 849               enum mode_class mclass = (enum mode_class) 0;
 850               if (GET_MODE_CLASS (m2) == MODE_UFRACT)
 851                 mclass = MODE_FRACT;
 852               else if (GET_MODE_CLASS (m2) == MODE_UACCUM)
 853                 mclass = MODE_ACCUM;
 854               else
 855                 gcc_unreachable ();
 856               m2 = mode_for_size (GET_MODE_PRECISION (m2), mclass, 0);
 857             }
 858         }
 859
 860       if (code1 == FIXED_POINT_TYPE)
 861         {
 862           fbit1 = GET_MODE_FBIT (m1);
 863           ibit1 = GET_MODE_IBIT (m1);
 864         }
 865       else
 866         {
 867           fbit1 = 0;
 868           /* Signed integers need to subtract one sign bit.  */
 869           ibit1 = TYPE_PRECISION (t1) - (!TYPE_UNSIGNED (t1));
 870         }
 871
 872       if (code2 == FIXED_POINT_TYPE)
 873         {
 874           fbit2 = GET_MODE_FBIT (m2);
 875           ibit2 = GET_MODE_IBIT (m2);
 876         }
 877       else
 878         {
 879           fbit2 = 0;
 880           /* Signed integers need to subtract one sign bit.  */
 881           ibit2 = TYPE_PRECISION (t2) - (!TYPE_UNSIGNED (t2));
 882         }
 883
 884       max_ibit = ibit1 >= ibit2 ?  ibit1 : ibit2;
 885       max_fbit = fbit1 >= fbit2 ?  fbit1 : fbit2;
 886       return c_common_fixed_point_type_for_size (max_ibit, max_fbit, unsignedp,
 887                                                  satp);
 888     }
 889
 890   /* Both real or both integers; use the one with greater precision.  */
 891
 892   if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
 893     return t1;
 894   else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
 895     return t2;
 896
 897   /* Same precision.  Prefer long longs to longs to ints when the
 898      same precision, following the C99 rules on integer type rank
 899      (which are equivalent to the C90 rules for C90 types).  */
 900
 901   if (TYPE_MAIN_VARIANT (t1) == long_long_unsigned_type_node
 902       || TYPE_MAIN_VARIANT (t2) == long_long_unsigned_type_node)
 903     return long_long_unsigned_type_node;
 904
 905   if (TYPE_MAIN_VARIANT (t1) == long_long_integer_type_node
 906       || TYPE_MAIN_VARIANT (t2) == long_long_integer_type_node)
 907     {
 908       if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
 909         return long_long_unsigned_type_node;
 910       else
 911         return long_long_integer_type_node;
 912     }
 913
 914   if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
 915       || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
 916     return long_unsigned_type_node;
 917
 918   if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
 919       || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
 920     {
 921       /* But preserve unsignedness from the other type,
 922          since long cannot hold all the values of an unsigned int.  */
 923       if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
 924         return long_unsigned_type_node;
 925       else
 926         return long_integer_type_node;
 927     }
 928
 929   /* Likewise, prefer long double to double even if same size.  */
 930   if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
 931       || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
 932     return long_double_type_node;
 933
 934   /* Otherwise prefer the unsigned one.  */
 935
 936   if (TYPE_UNSIGNED (t1))
 937     return t1;
 938   else
 939     return t2;
 940 }
 941 \f
 942 /* Wrapper around c_common_type that is used by c-common.c and other
 943    front end optimizations that remove promotions.  ENUMERAL_TYPEs
 944    are allowed here and are converted to their compatible integer types.
 945    BOOLEAN_TYPEs are allowed here and return either boolean_type_node or
 946    preferably a non-Boolean type as the common type.  */
 947 tree
 948 common_type (tree t1, tree t2)
 949 {
 950   if (TREE_CODE (t1) == ENUMERAL_TYPE)
 951     t1 = c_common_type_for_size (TYPE_PRECISION (t1), 1);
 952   if (TREE_CODE (t2) == ENUMERAL_TYPE)
 953     t2 = c_common_type_for_size (TYPE_PRECISION (t2), 1);
 954
 955   /* If both types are BOOLEAN_TYPE, then return boolean_type_node.  */
 956   if (TREE_CODE (t1) == BOOLEAN_TYPE
 957       && TREE_CODE (t2) == BOOLEAN_TYPE)
 958     return boolean_type_node;
 959
 960   /* If either type is BOOLEAN_TYPE, then return the other.  */
 961   if (TREE_CODE (t1) == BOOLEAN_TYPE)
 962     return t2;
 963   if (TREE_CODE (t2) == BOOLEAN_TYPE)
 964     return t1;
 965
 966   return c_common_type (t1, t2);
 967 }
 968
 969 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
 970    or various other operations.  Return 2 if they are compatible
 971    but a warning may be needed if you use them together.  */
 972
 973 int
 974 comptypes (tree type1, tree type2)
 975 {
 976   const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base;
 977   int val;
 978
 979   val = comptypes_internal (type1, type2, NULL);
 980   free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1);
 981
 982   return val;
 983 }
 984
 985 /* Like comptypes, but if it returns non-zero because enum and int are
 986    compatible, it sets *ENUM_AND_INT_P to true.  */
 987
 988 static int
 989 comptypes_check_enum_int (tree type1, tree type2, bool *enum_and_int_p)
 990 {
 991   const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base;
 992   int val;
 993
 994   val = comptypes_internal (type1, type2, enum_and_int_p);
 995   free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1);
 996
 997   return val;
 998 }
 999 \f
1000 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
1001    or various other operations.  Return 2 if they are compatible
1002    but a warning may be needed if you use them together.  If
1003    ENUM_AND_INT_P is not NULL, and one type is an enum and the other a
1004    compatible integer type, then this sets *ENUM_AND_INT_P to true;
1005    *ENUM_AND_INT_P is never set to false.  This differs from
1006    comptypes, in that we don't free the seen types.  */
1007
1008 static int
1009 comptypes_internal (const_tree type1, const_tree type2, bool *enum_and_int_p)
1010 {
1011   const_tree t1 = type1;
1012   const_tree t2 = type2;
1013   int attrval, val;
1014
1015   /* Suppress errors caused by previously reported errors.  */
1016
1017   if (t1 == t2 || !t1 || !t2
1018       || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
1019     return 1;
1020
1021   /* If either type is the internal version of sizetype, return the
1022      language version.  */
1023   if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
1024       && TYPE_ORIG_SIZE_TYPE (t1))
1025     t1 = TYPE_ORIG_SIZE_TYPE (t1);
1026
1027   if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
1028       && TYPE_ORIG_SIZE_TYPE (t2))
1029     t2 = TYPE_ORIG_SIZE_TYPE (t2);
1030
1031
1032   /* Enumerated types are compatible with integer types, but this is
1033      not transitive: two enumerated types in the same translation unit
1034      are compatible with each other only if they are the same type.  */
1035
1036   if (TREE_CODE (t1) == ENUMERAL_TYPE && TREE_CODE (t2) != ENUMERAL_TYPE)
1037     {
1038       t1 = c_common_type_for_size (TYPE_PRECISION (t1), TYPE_UNSIGNED (t1));
1039       if (enum_and_int_p != NULL && TREE_CODE (t2) != VOID_TYPE)
1040         *enum_and_int_p = true;
1041     }
1042   else if (TREE_CODE (t2) == ENUMERAL_TYPE && TREE_CODE (t1) != ENUMERAL_TYPE)
1043     {
1044       t2 = c_common_type_for_size (TYPE_PRECISION (t2), TYPE_UNSIGNED (t2));
1045       if (enum_and_int_p != NULL && TREE_CODE (t1) != VOID_TYPE)
1046         *enum_and_int_p = true;
1047     }
1048
1049   if (t1 == t2)
1050     return 1;
1051
1052   /* Different classes of types can't be compatible.  */
1053
1054   if (TREE_CODE (t1) != TREE_CODE (t2))
1055     return 0;
1056
1057   /* Qualifiers must match. C99 6.7.3p9 */
1058
1059   if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
1060     return 0;
1061
1062   /* Allow for two different type nodes which have essentially the same
1063      definition.  Note that we already checked for equality of the type
1064      qualifiers (just above).  */
1065
1066   if (TREE_CODE (t1) != ARRAY_TYPE
1067       && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
1068     return 1;
1069
1070   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
1071   if (!(attrval = targetm.comp_type_attributes (t1, t2)))
1072      return 0;
1073
1074   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
1075   val = 0;
1076
1077   switch (TREE_CODE (t1))
1078     {
1079     case POINTER_TYPE:
1080       /* Do not remove mode or aliasing information.  */
1081       if (TYPE_MODE (t1) != TYPE_MODE (t2)
1082           || TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2))
1083         break;
1084       val = (TREE_TYPE (t1) == TREE_TYPE (t2)
1085              ? 1 : comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
1086                                        enum_and_int_p));
1087       break;
1088
1089     case FUNCTION_TYPE:
1090       val = function_types_compatible_p (t1, t2, enum_and_int_p);
1091       break;
1092
1093     case ARRAY_TYPE:
1094       {
1095         tree d1 = TYPE_DOMAIN (t1);
1096         tree d2 = TYPE_DOMAIN (t2);
1097         bool d1_variable, d2_variable;
1098         bool d1_zero, d2_zero;
1099         val = 1;
1100
1101         /* Target types must match incl. qualifiers.  */
1102         if (TREE_TYPE (t1) != TREE_TYPE (t2)
1103             && 0 == (val = comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
1104                                                enum_and_int_p)))
1105           return 0;
1106
1107         /* Sizes must match unless one is missing or variable.  */
1108         if (d1 == 0 || d2 == 0 || d1 == d2)
1109           break;
1110
1111         d1_zero = !TYPE_MAX_VALUE (d1);
1112         d2_zero = !TYPE_MAX_VALUE (d2);
1113
1114         d1_variable = (!d1_zero
1115                        && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
1116                            || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
1117         d2_variable = (!d2_zero
1118                        && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
1119                            || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
1120         d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1));
1121         d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2));
1122
1123         if (d1_variable || d2_variable)
1124           break;
1125         if (d1_zero && d2_zero)
1126           break;
1127         if (d1_zero || d2_zero
1128             || !tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
1129             || !tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
1130           val = 0;
1131
1132         break;
1133       }
1134
1135     case ENUMERAL_TYPE:
1136     case RECORD_TYPE:
1137     case UNION_TYPE:
1138       if (val != 1 && !same_translation_unit_p (t1, t2))
1139         {
1140           tree a1 = TYPE_ATTRIBUTES (t1);
1141           tree a2 = TYPE_ATTRIBUTES (t2);
1142
1143           if (! attribute_list_contained (a1, a2)
1144               && ! attribute_list_contained (a2, a1))
1145             break;
1146
1147           if (attrval != 2)
1148             return tagged_types_tu_compatible_p (t1, t2, enum_and_int_p);
1149           val = tagged_types_tu_compatible_p (t1, t2, enum_and_int_p);
1150         }
1151       break;
1152
1153     case VECTOR_TYPE:
1154       val = (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1155              && comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
1156                                     enum_and_int_p));
1157       break;
1158
1159     default:
1160       break;
1161     }
1162   return attrval == 2 && val == 1 ? 2 : val;
1163 }
1164
1165 /* Return 1 if TTL and TTR are pointers to types that are equivalent, ignoring
1166    their qualifiers, except for named address spaces.  If the pointers point to
1167    different named addresses, then we must determine if one address space is a
1168    subset of the other.  */
1169
1170 static int
1171 comp_target_types (location_t location, tree ttl, tree ttr)
1172 {
1173   int val;
1174   tree mvl = TREE_TYPE (ttl);
1175   tree mvr = TREE_TYPE (ttr);
1176   addr_space_t asl = TYPE_ADDR_SPACE (mvl);
1177   addr_space_t asr = TYPE_ADDR_SPACE (mvr);
1178   addr_space_t as_common;
1179   bool enum_and_int_p;
1180
1181   /* Fail if pointers point to incompatible address spaces.  */
1182   if (!addr_space_superset (asl, asr, &as_common))
1183     return 0;
1184
1185   /* Do not lose qualifiers on element types of array types that are
1186      pointer targets by taking their TYPE_MAIN_VARIANT.  */
1187   if (TREE_CODE (mvl) != ARRAY_TYPE)
1188     mvl = TYPE_MAIN_VARIANT (mvl);
1189   if (TREE_CODE (mvr) != ARRAY_TYPE)
1190     mvr = TYPE_MAIN_VARIANT (mvr);
1191   enum_and_int_p = false;
1192   val = comptypes_check_enum_int (mvl, mvr, &enum_and_int_p);
1193
1194   if (val == 2)
1195     pedwarn (location, OPT_pedantic, "types are not quite compatible");
1196
1197   if (val == 1 && enum_and_int_p && warn_cxx_compat)
1198     warning_at (location, OPT_Wc___compat,
1199                 "pointer target types incompatible in C++");
1200
1201   return val;
1202 }
1203 \f
1204 /* Subroutines of `comptypes'.  */
1205
1206 /* Determine whether two trees derive from the same translation unit.
1207    If the CONTEXT chain ends in a null, that tree's context is still
1208    being parsed, so if two trees have context chains ending in null,
1209    they're in the same translation unit.  */
1210 int
1211 same_translation_unit_p (const_tree t1, const_tree t2)
1212 {
1213   while (t1 && TREE_CODE (t1) != TRANSLATION_UNIT_DECL)
1214     switch (TREE_CODE_CLASS (TREE_CODE (t1)))
1215       {
1216       case tcc_declaration:
1217         t1 = DECL_CONTEXT (t1); break;
1218       case tcc_type:
1219         t1 = TYPE_CONTEXT (t1); break;
1220       case tcc_exceptional:
1221         t1 = BLOCK_SUPERCONTEXT (t1); break;  /* assume block */
1222       default: gcc_unreachable ();
1223       }
1224
1225   while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL)
1226     switch (TREE_CODE_CLASS (TREE_CODE (t2)))
1227       {
1228       case tcc_declaration:
1229         t2 = DECL_CONTEXT (t2); break;
1230       case tcc_type:
1231         t2 = TYPE_CONTEXT (t2); break;
1232       case tcc_exceptional:
1233         t2 = BLOCK_SUPERCONTEXT (t2); break;  /* assume block */
1234       default: gcc_unreachable ();
1235       }
1236
1237   return t1 == t2;
1238 }
1239
1240 /* Allocate the seen two types, assuming that they are compatible. */
1241
1242 static struct tagged_tu_seen_cache *
1243 alloc_tagged_tu_seen_cache (const_tree t1, const_tree t2)
1244 {
1245   struct tagged_tu_seen_cache *tu = XNEW (struct tagged_tu_seen_cache);
1246   tu->next = tagged_tu_seen_base;
1247   tu->t1 = t1;
1248   tu->t2 = t2;
1249
1250   tagged_tu_seen_base = tu;
1251
1252   /* The C standard says that two structures in different translation
1253      units are compatible with each other only if the types of their
1254      fields are compatible (among other things).  We assume that they
1255      are compatible until proven otherwise when building the cache.
1256      An example where this can occur is:
1257      struct a
1258      {
1259        struct a *next;
1260      };
1261      If we are comparing this against a similar struct in another TU,
1262      and did not assume they were compatible, we end up with an infinite
1263      loop.  */
1264   tu->val = 1;
1265   return tu;
1266 }
1267
1268 /* Free the seen types until we get to TU_TIL. */
1269
1270 static void
1271 free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *tu_til)
1272 {
1273   const struct tagged_tu_seen_cache *tu = tagged_tu_seen_base;
1274   while (tu != tu_til)
1275     {
1276       const struct tagged_tu_seen_cache *const tu1
1277         = (const struct tagged_tu_seen_cache *) tu;
1278       tu = tu1->next;
1279       free (CONST_CAST (struct tagged_tu_seen_cache *, tu1));
1280     }
1281   tagged_tu_seen_base = tu_til;
1282 }
1283
1284 /* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are
1285    compatible.  If the two types are not the same (which has been
1286    checked earlier), this can only happen when multiple translation
1287    units are being compiled.  See C99 6.2.7 paragraph 1 for the exact
1288    rules.  ENUM_AND_INT_P is as in comptypes_internal.  */
1289
1290 static int
1291 tagged_types_tu_compatible_p (const_tree t1, const_tree t2,
1292                               bool *enum_and_int_p)
1293 {
1294   tree s1, s2;
1295   bool needs_warning = false;
1296
1297   /* We have to verify that the tags of the types are the same.  This
1298      is harder than it looks because this may be a typedef, so we have
1299      to go look at the original type.  It may even be a typedef of a
1300      typedef...
1301      In the case of compiler-created builtin structs the TYPE_DECL
1302      may be a dummy, with no DECL_ORIGINAL_TYPE.  Don't fault.  */
1303   while (TYPE_NAME (t1)
1304          && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL
1305          && DECL_ORIGINAL_TYPE (TYPE_NAME (t1)))
1306     t1 = DECL_ORIGINAL_TYPE (TYPE_NAME (t1));
1307
1308   while (TYPE_NAME (t2)
1309          && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL
1310          && DECL_ORIGINAL_TYPE (TYPE_NAME (t2)))
1311     t2 = DECL_ORIGINAL_TYPE (TYPE_NAME (t2));
1312
1313   /* C90 didn't have the requirement that the two tags be the same.  */
1314   if (flag_isoc99 && TYPE_NAME (t1) != TYPE_NAME (t2))
1315     return 0;
1316
1317   /* C90 didn't say what happened if one or both of the types were
1318      incomplete; we choose to follow C99 rules here, which is that they
1319      are compatible.  */
1320   if (TYPE_SIZE (t1) == NULL
1321       || TYPE_SIZE (t2) == NULL)
1322     return 1;
1323
1324   {
1325     const struct tagged_tu_seen_cache * tts_i;
1326     for (tts_i = tagged_tu_seen_base; tts_i != NULL; tts_i = tts_i->next)
1327       if (tts_i->t1 == t1 && tts_i->t2 == t2)
1328         return tts_i->val;
1329   }
1330
1331   switch (TREE_CODE (t1))
1332     {
1333     case ENUMERAL_TYPE:
1334       {
1335         struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
1336         /* Speed up the case where the type values are in the same order.  */
1337         tree tv1 = TYPE_VALUES (t1);
1338         tree tv2 = TYPE_VALUES (t2);
1339
1340         if (tv1 == tv2)
1341           {
1342             return 1;
1343           }
1344
1345         for (;tv1 && tv2; tv1 = TREE_CHAIN (tv1), tv2 = TREE_CHAIN (tv2))
1346           {
1347             if (TREE_PURPOSE (tv1) != TREE_PURPOSE (tv2))
1348               break;
1349             if (simple_cst_equal (TREE_VALUE (tv1), TREE_VALUE (tv2)) != 1)
1350               {
1351                 tu->val = 0;
1352                 return 0;
1353               }
1354           }
1355
1356         if (tv1 == NULL_TREE && tv2 == NULL_TREE)
1357           {
1358             return 1;
1359           }
1360         if (tv1 == NULL_TREE || tv2 == NULL_TREE)
1361           {
1362             tu->val = 0;
1363             return 0;
1364           }
1365
1366         if (list_length (TYPE_VALUES (t1)) != list_length (TYPE_VALUES (t2)))
1367           {
1368             tu->val = 0;
1369             return 0;
1370           }
1371
1372         for (s1 = TYPE_VALUES (t1); s1; s1 = TREE_CHAIN (s1))
1373           {
1374             s2 = purpose_member (TREE_PURPOSE (s1), TYPE_VALUES (t2));
1375             if (s2 == NULL
1376                 || simple_cst_equal (TREE_VALUE (s1), TREE_VALUE (s2)) != 1)
1377               {
1378                 tu->val = 0;
1379                 return 0;
1380               }
1381           }
1382         return 1;
1383       }
1384
1385     case UNION_TYPE:
1386       {
1387         struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
1388         if (list_length (TYPE_FIELDS (t1)) != list_length (TYPE_FIELDS (t2)))
1389           {
1390             tu->val = 0;
1391             return 0;
1392           }
1393
1394         /*  Speed up the common case where the fields are in the same order. */
1395         for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2); s1 && s2;
1396              s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2))
1397           {
1398             int result;
1399
1400             if (DECL_NAME (s1) != DECL_NAME (s2))
1401               break;
1402             result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2),
1403                                          enum_and_int_p);
1404
1405             if (result != 1 && !DECL_NAME (s1))
1406               break;
1407             if (result == 0)
1408               {
1409                 tu->val = 0;
1410                 return 0;
1411               }
1412             if (result == 2)
1413               needs_warning = true;
1414
1415             if (TREE_CODE (s1) == FIELD_DECL
1416                 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
1417                                      DECL_FIELD_BIT_OFFSET (s2)) != 1)
1418               {
1419                 tu->val = 0;
1420                 return 0;
1421               }
1422           }
1423         if (!s1 && !s2)
1424           {
1425             tu->val = needs_warning ? 2 : 1;
1426             return tu->val;
1427           }
1428
1429         for (s1 = TYPE_FIELDS (t1); s1; s1 = TREE_CHAIN (s1))
1430           {
1431             bool ok = false;
1432
1433             for (s2 = TYPE_FIELDS (t2); s2; s2 = TREE_CHAIN (s2))
1434               if (DECL_NAME (s1) == DECL_NAME (s2))
1435                 {
1436                   int result;
1437
1438                   result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2),
1439                                                enum_and_int_p);
1440
1441                   if (result != 1 && !DECL_NAME (s1))
1442                     continue;
1443                   if (result == 0)
1444                     {
1445                       tu->val = 0;
1446                       return 0;
1447                     }
1448                   if (result == 2)
1449                     needs_warning = true;
1450
1451                   if (TREE_CODE (s1) == FIELD_DECL
1452                       && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
1453                                            DECL_FIELD_BIT_OFFSET (s2)) != 1)
1454                     break;
1455
1456                   ok = true;
1457                   break;
1458                 }
1459             if (!ok)
1460               {
1461                 tu->val = 0;
1462                 return 0;
1463               }
1464           }
1465         tu->val = needs_warning ? 2 : 10;
1466         return tu->val;
1467       }
1468
1469     case RECORD_TYPE:
1470       {
1471         struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
1472
1473         for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2);
1474              s1 && s2;
1475              s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2))
1476           {
1477             int result;
1478             if (TREE_CODE (s1) != TREE_CODE (s2)
1479                 || DECL_NAME (s1) != DECL_NAME (s2))
1480               break;
1481             result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2),
1482                                          enum_and_int_p);
1483             if (result == 0)
1484               break;
1485             if (result == 2)
1486               needs_warning = true;
1487
1488             if (TREE_CODE (s1) == FIELD_DECL
1489                 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
1490                                      DECL_FIELD_BIT_OFFSET (s2)) != 1)
1491               break;
1492           }
1493         if (s1 && s2)
1494           tu->val = 0;
1495         else
1496           tu->val = needs_warning ? 2 : 1;
1497         return tu->val;
1498       }
1499
1500     default:
1501       gcc_unreachable ();
1502     }
1503 }
1504
1505 /* Return 1 if two function types F1 and F2 are compatible.
1506    If either type specifies no argument types,
1507    the other must specify a fixed number of self-promoting arg types.
1508    Otherwise, if one type specifies only the number of arguments,
1509    the other must specify that number of self-promoting arg types.
1510    Otherwise, the argument types must match.
1511    ENUM_AND_INT_P is as in comptypes_internal.  */
1512
1513 static int
1514 function_types_compatible_p (const_tree f1, const_tree f2,
1515                              bool *enum_and_int_p)
1516 {
1517   tree args1, args2;
1518   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
1519   int val = 1;
1520   int val1;
1521   tree ret1, ret2;
1522
1523   ret1 = TREE_TYPE (f1);
1524   ret2 = TREE_TYPE (f2);
1525
1526   /* 'volatile' qualifiers on a function's return type used to mean
1527      the function is noreturn.  */
1528   if (TYPE_VOLATILE (ret1) != TYPE_VOLATILE (ret2))
1529     pedwarn (input_location, 0, "function return types not compatible due to %<volatile%>");
1530   if (TYPE_VOLATILE (ret1))
1531     ret1 = build_qualified_type (TYPE_MAIN_VARIANT (ret1),
1532                                  TYPE_QUALS (ret1) & ~TYPE_QUAL_VOLATILE);
1533   if (TYPE_VOLATILE (ret2))
1534     ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2),
1535                                  TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE);
1536   val = comptypes_internal (ret1, ret2, enum_and_int_p);
1537   if (val == 0)
1538     return 0;
1539
1540   args1 = TYPE_ARG_TYPES (f1);
1541   args2 = TYPE_ARG_TYPES (f2);
1542
1543   /* An unspecified parmlist matches any specified parmlist
1544      whose argument types don't need default promotions.  */
1545
1546   if (args1 == 0)
1547     {
1548       if (!self_promoting_args_p (args2))
1549         return 0;
1550       /* If one of these types comes from a non-prototype fn definition,
1551          compare that with the other type's arglist.
1552          If they don't match, ask for a warning (but no error).  */
1553       if (TYPE_ACTUAL_ARG_TYPES (f1)
1554           && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1),
1555                                            enum_and_int_p))
1556         val = 2;
1557       return val;
1558     }
1559   if (args2 == 0)
1560     {
1561       if (!self_promoting_args_p (args1))
1562         return 0;
1563       if (TYPE_ACTUAL_ARG_TYPES (f2)
1564           && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2),
1565                                            enum_and_int_p))
1566         val = 2;
1567       return val;
1568     }
1569
1570   /* Both types have argument lists: compare them and propagate results.  */
1571   val1 = type_lists_compatible_p (args1, args2, enum_and_int_p);
1572   return val1 != 1 ? val1 : val;
1573 }
1574
1575 /* Check two lists of types for compatibility, returning 0 for
1576    incompatible, 1 for compatible, or 2 for compatible with
1577    warning.  ENUM_AND_INT_P is as in comptypes_internal.  */
1578
1579 static int
1580 type_lists_compatible_p (const_tree args1, const_tree args2,
1581                          bool *enum_and_int_p)
1582 {
1583   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
1584   int val = 1;
1585   int newval = 0;
1586
1587   while (1)
1588     {
1589       tree a1, mv1, a2, mv2;
1590       if (args1 == 0 && args2 == 0)
1591         return val;
1592       /* If one list is shorter than the other,
1593          they fail to match.  */
1594       if (args1 == 0 || args2 == 0)
1595         return 0;
1596       mv1 = a1 = TREE_VALUE (args1);
1597       mv2 = a2 = TREE_VALUE (args2);
1598       if (mv1 && mv1 != error_mark_node && TREE_CODE (mv1) != ARRAY_TYPE)
1599         mv1 = TYPE_MAIN_VARIANT (mv1);
1600       if (mv2 && mv2 != error_mark_node && TREE_CODE (mv2) != ARRAY_TYPE)
1601         mv2 = TYPE_MAIN_VARIANT (mv2);
1602       /* A null pointer instead of a type
1603          means there is supposed to be an argument
1604          but nothing is specified about what type it has.
1605          So match anything that self-promotes.  */
1606       if (a1 == 0)
1607         {
1608           if (c_type_promotes_to (a2) != a2)
1609             return 0;
1610         }
1611       else if (a2 == 0)
1612         {
1613           if (c_type_promotes_to (a1) != a1)
1614             return 0;
1615         }
1616       /* If one of the lists has an error marker, ignore this arg.  */
1617       else if (TREE_CODE (a1) == ERROR_MARK
1618                || TREE_CODE (a2) == ERROR_MARK)
1619         ;
1620       else if (!(newval = comptypes_internal (mv1, mv2, enum_and_int_p)))
1621         {
1622           /* Allow  wait (union {union wait *u; int *i} *)
1623              and  wait (union wait *)  to be compatible.  */
1624           if (TREE_CODE (a1) == UNION_TYPE
1625               && (TYPE_NAME (a1) == 0
1626                   || TYPE_TRANSPARENT_AGGR (a1))
1627               && TREE_CODE (TYPE_SIZE (a1)) == INTEGER_CST
1628               && tree_int_cst_equal (TYPE_SIZE (a1),
1629                                      TYPE_SIZE (a2)))
1630             {
1631               tree memb;
1632               for (memb = TYPE_FIELDS (a1);
1633                    memb; memb = TREE_CHAIN (memb))
1634                 {
1635                   tree mv3 = TREE_TYPE (memb);
1636                   if (mv3 && mv3 != error_mark_node
1637                       && TREE_CODE (mv3) != ARRAY_TYPE)
1638                     mv3 = TYPE_MAIN_VARIANT (mv3);
1639                   if (comptypes_internal (mv3, mv2, enum_and_int_p))
1640                     break;
1641                 }
1642               if (memb == 0)
1643                 return 0;
1644             }
1645           else if (TREE_CODE (a2) == UNION_TYPE
1646                    && (TYPE_NAME (a2) == 0
1647                        || TYPE_TRANSPARENT_AGGR (a2))
1648                    && TREE_CODE (TYPE_SIZE (a2)) == INTEGER_CST
1649                    && tree_int_cst_equal (TYPE_SIZE (a2),
1650                                           TYPE_SIZE (a1)))
1651             {
1652               tree memb;
1653               for (memb = TYPE_FIELDS (a2);
1654                    memb; memb = TREE_CHAIN (memb))
1655                 {
1656                   tree mv3 = TREE_TYPE (memb);
1657                   if (mv3 && mv3 != error_mark_node
1658                       && TREE_CODE (mv3) != ARRAY_TYPE)
1659                     mv3 = TYPE_MAIN_VARIANT (mv3);
1660                   if (comptypes_internal (mv3, mv1, enum_and_int_p))
1661                     break;
1662                 }
1663               if (memb == 0)
1664                 return 0;
1665             }
1666           else
1667             return 0;
1668         }
1669
1670       /* comptypes said ok, but record if it said to warn.  */
1671       if (newval > val)
1672         val = newval;
1673
1674       args1 = TREE_CHAIN (args1);
1675       args2 = TREE_CHAIN (args2);
1676     }
1677 }
1678 \f
1679 /* Compute the size to increment a pointer by.  */
1680
1681 static tree
1682 c_size_in_bytes (const_tree type)
1683 {
1684   enum tree_code code = TREE_CODE (type);
1685
1686   if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
1687     return size_one_node;
1688
1689   if (!COMPLETE_OR_VOID_TYPE_P (type))
1690     {
1691       error ("arithmetic on pointer to an incomplete type");
1692       return size_one_node;
1693     }
1694
1695   /* Convert in case a char is more than one unit.  */
1696   return size_binop_loc (input_location, CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
1697                          size_int (TYPE_PRECISION (char_type_node)
1698                                    / BITS_PER_UNIT));
1699 }
1700 \f
1701 /* Return either DECL or its known constant value (if it has one).  */
1702
1703 tree
1704 decl_constant_value (tree decl)
1705 {
1706   if (/* Don't change a variable array bound or initial value to a constant
1707          in a place where a variable is invalid.  Note that DECL_INITIAL
1708          isn't valid for a PARM_DECL.  */
1709       current_function_decl != 0
1710       && TREE_CODE (decl) != PARM_DECL
1711       && !TREE_THIS_VOLATILE (decl)
1712       && TREE_READONLY (decl)
1713       && DECL_INITIAL (decl) != 0
1714       && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
1715       /* This is invalid if initial value is not constant.
1716          If it has either a function call, a memory reference,
1717          or a variable, then re-evaluating it could give different results.  */
1718       && TREE_CONSTANT (DECL_INITIAL (decl))
1719       /* Check for cases where this is sub-optimal, even though valid.  */
1720       && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
1721     return DECL_INITIAL (decl);
1722   return decl;
1723 }
1724
1725 /* Convert the array expression EXP to a pointer.  */
1726 static tree
1727 array_to_pointer_conversion (location_t loc, tree exp)
1728 {
1729   tree orig_exp = exp;
1730   tree type = TREE_TYPE (exp);
1731   tree adr;
1732   tree restype = TREE_TYPE (type);
1733   tree ptrtype;
1734
1735   gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
1736
1737   STRIP_TYPE_NOPS (exp);
1738
1739   if (TREE_NO_WARNING (orig_exp))
1740     TREE_NO_WARNING (exp) = 1;
1741
1742   ptrtype = build_pointer_type (restype);
1743
1744   if (TREE_CODE (exp) == INDIRECT_REF)
1745     return convert (ptrtype, TREE_OPERAND (exp, 0));
1746
1747   adr = build_unary_op (loc, ADDR_EXPR, exp, 1);
1748   return convert (ptrtype, adr);
1749 }
1750
1751 /* Convert the function expression EXP to a pointer.  */
1752 static tree
1753 function_to_pointer_conversion (location_t loc, tree exp)
1754 {
1755   tree orig_exp = exp;
1756
1757   gcc_assert (TREE_CODE (TREE_TYPE (exp)) == FUNCTION_TYPE);
1758
1759   STRIP_TYPE_NOPS (exp);
1760
1761   if (TREE_NO_WARNING (orig_exp))
1762     TREE_NO_WARNING (exp) = 1;
1763
1764   return build_unary_op (loc, ADDR_EXPR, exp, 0);
1765 }
1766
1767 /* Mark EXP as read, not just set, for set but not used -Wunused
1768    warning purposes.  */
1769
1770 void
1771 mark_exp_read (tree exp)
1772 {
1773   switch (TREE_CODE (exp))
1774     {
1775     case VAR_DECL:
1776     case PARM_DECL:
1777       DECL_READ_P (exp) = 1;
1778       break;
1779     case ARRAY_REF:
1780     case COMPONENT_REF:
1781     case MODIFY_EXPR:
1782     case REALPART_EXPR:
1783     case IMAGPART_EXPR:
1784     CASE_CONVERT:
1785     case ADDR_EXPR:
1786       mark_exp_read (TREE_OPERAND (exp, 0));
1787       break;
1788     case COMPOUND_EXPR:
1789       mark_exp_read (TREE_OPERAND (exp, 1));
1790       break;
1791     default:
1792       break;
1793     }
1794 }
1795
1796 /* Perform the default conversion of arrays and functions to pointers.
1797    Return the result of converting EXP.  For any other expression, just
1798    return EXP.
1799
1800    LOC is the location of the expression.  */
1801
1802 struct c_expr
1803 default_function_array_conversion (location_t loc, struct c_expr exp)
1804 {
1805   tree orig_exp = exp.value;
1806   tree type = TREE_TYPE (exp.value);
1807   enum tree_code code = TREE_CODE (type);
1808
1809   switch (code)
1810     {
1811     case ARRAY_TYPE:
1812       {
1813         bool not_lvalue = false;
1814         bool lvalue_array_p;
1815
1816         while ((TREE_CODE (exp.value) == NON_LVALUE_EXPR
1817                 || CONVERT_EXPR_P (exp.value))
1818                && TREE_TYPE (TREE_OPERAND (exp.value, 0)) == type)
1819           {
1820             if (TREE_CODE (exp.value) == NON_LVALUE_EXPR)
1821               not_lvalue = true;
1822             exp.value = TREE_OPERAND (exp.value, 0);
1823           }
1824
1825         if (TREE_NO_WARNING (orig_exp))
1826           TREE_NO_WARNING (exp.value) = 1;
1827
1828         lvalue_array_p = !not_lvalue && lvalue_p (exp.value);
1829         if (!flag_isoc99 && !lvalue_array_p)
1830           {
1831             /* Before C99, non-lvalue arrays do not decay to pointers.
1832                Normally, using such an array would be invalid; but it can
1833                be used correctly inside sizeof or as a statement expression.
1834                Thus, do not give an error here; an error will result later.  */
1835             return exp;
1836           }
1837
1838         exp.value = array_to_pointer_conversion (loc, exp.value);
1839       }
1840       break;
1841     case FUNCTION_TYPE:
1842       exp.value = function_to_pointer_conversion (loc, exp.value);
1843       break;
1844     default:
1845       break;
1846     }
1847
1848   return exp;
1849 }
1850
1851 struct c_expr
1852 default_function_array_read_conversion (location_t loc, struct c_expr exp)
1853 {
1854   mark_exp_read (exp.value);
1855   return default_function_array_conversion (loc, exp);
1856 }
1857
1858 /* EXP is an expression of integer type.  Apply the integer promotions
1859    to it and return the promoted value.  */
1860
1861 tree
1862 perform_integral_promotions (tree exp)
1863 {
1864   tree type = TREE_TYPE (exp);
1865   enum tree_code code = TREE_CODE (type);
1866
1867   gcc_assert (INTEGRAL_TYPE_P (type));
1868
1869   /* Normally convert enums to int,
1870      but convert wide enums to something wider.  */
1871   if (code == ENUMERAL_TYPE)
1872     {
1873       type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
1874                                           TYPE_PRECISION (integer_type_node)),
1875                                      ((TYPE_PRECISION (type)
1876                                        >= TYPE_PRECISION (integer_type_node))
1877                                       && TYPE_UNSIGNED (type)));
1878
1879       return convert (type, exp);
1880     }
1881
1882   /* ??? This should no longer be needed now bit-fields have their
1883      proper types.  */
1884   if (TREE_CODE (exp) == COMPONENT_REF
1885       && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
1886       /* If it's thinner than an int, promote it like a
1887          c_promoting_integer_type_p, otherwise leave it alone.  */
1888       && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
1889                                TYPE_PRECISION (integer_type_node)))
1890     return convert (integer_type_node, exp);
1891
1892   if (c_promoting_integer_type_p (type))
1893     {
1894       /* Preserve unsignedness if not really getting any wider.  */
1895       if (TYPE_UNSIGNED (type)
1896           && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1897         return convert (unsigned_type_node, exp);
1898
1899       return convert (integer_type_node, exp);
1900     }
1901
1902   return exp;
1903 }
1904
1905
1906 /* Perform default promotions for C data used in expressions.
1907    Enumeral types or short or char are converted to int.
1908    In addition, manifest constants symbols are replaced by their values.  */
1909
1910 tree
1911 default_conversion (tree exp)
1912 {
1913   tree orig_exp;
1914   tree type = TREE_TYPE (exp);
1915   enum tree_code code = TREE_CODE (type);
1916   tree promoted_type;
1917
1918   mark_exp_read (exp);
1919
1920   /* Functions and arrays have been converted during parsing.  */
1921   gcc_assert (code != FUNCTION_TYPE);
1922   if (code == ARRAY_TYPE)
1923     return exp;
1924
1925   /* Constants can be used directly unless they're not loadable.  */
1926   if (TREE_CODE (exp) == CONST_DECL)
1927     exp = DECL_INITIAL (exp);
1928
1929   /* Strip no-op conversions.  */
1930   orig_exp = exp;
1931   STRIP_TYPE_NOPS (exp);
1932
1933   if (TREE_NO_WARNING (orig_exp))
1934     TREE_NO_WARNING (exp) = 1;
1935
1936   if (code == VOID_TYPE)
1937     {
1938       error ("void value not ignored as it ought to be");
1939       return error_mark_node;
1940     }
1941
1942   exp = require_complete_type (exp);
1943   if (exp == error_mark_node)
1944     return error_mark_node;
1945
1946   promoted_type = targetm.promoted_type (type);
1947   if (promoted_type)
1948     return convert (promoted_type, exp);
1949
1950   if (INTEGRAL_TYPE_P (type))
1951     return perform_integral_promotions (exp);
1952
1953   return exp;
1954 }
1955 \f
1956 /* Look up COMPONENT in a structure or union DECL.
1957
1958    If the component name is not found, returns NULL_TREE.  Otherwise,
1959    the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
1960    stepping down the chain to the component, which is in the last
1961    TREE_VALUE of the list.  Normally the list is of length one, but if
1962    the component is embedded within (nested) anonymous structures or
1963    unions, the list steps down the chain to the component.  */
1964
1965 static tree
1966 lookup_field (tree decl, tree component)
1967 {
1968   tree type = TREE_TYPE (decl);
1969   tree field;
1970
1971   /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1972      to the field elements.  Use a binary search on this array to quickly
1973      find the element.  Otherwise, do a linear search.  TYPE_LANG_SPECIFIC
1974      will always be set for structures which have many elements.  */
1975
1976   if (TYPE_LANG_SPECIFIC (type) && TYPE_LANG_SPECIFIC (type)->s)
1977     {
1978       int bot, top, half;
1979       tree *field_array = &TYPE_LANG_SPECIFIC (type)->s->elts[0];
1980
1981       field = TYPE_FIELDS (type);
1982       bot = 0;
1983       top = TYPE_LANG_SPECIFIC (type)->s->len;
1984       while (top - bot > 1)
1985         {
1986           half = (top - bot + 1) >> 1;
1987           field = field_array[bot+half];
1988
1989           if (DECL_NAME (field) == NULL_TREE)
1990             {
1991               /* Step through all anon unions in linear fashion.  */
1992               while (DECL_NAME (field_array[bot]) == NULL_TREE)
1993                 {
1994                   field = field_array[bot++];
1995                   if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1996                       || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1997                     {
1998                       tree anon = lookup_field (field, component);
1999
2000                       if (anon)
2001                         return tree_cons (NULL_TREE, field, anon);
2002                     }
2003                 }
2004
2005               /* Entire record is only anon unions.  */
2006               if (bot > top)
2007                 return NULL_TREE;
2008
2009               /* Restart the binary search, with new lower bound.  */
2010               continue;
2011             }
2012
2013           if (DECL_NAME (field) == component)
2014             break;
2015           if (DECL_NAME (field) < component)
2016             bot += half;
2017           else
2018             top = bot + half;
2019         }
2020
2021       if (DECL_NAME (field_array[bot]) == component)
2022         field = field_array[bot];
2023       else if (DECL_NAME (field) != component)
2024         return NULL_TREE;
2025     }
2026   else
2027     {
2028       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2029         {
2030           if (DECL_NAME (field) == NULL_TREE
2031               && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
2032                   || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE))
2033             {
2034               tree anon = lookup_field (field, component);
2035
2036               if (anon)
2037                 return tree_cons (NULL_TREE, field, anon);
2038             }
2039
2040           if (DECL_NAME (field) == component)
2041             break;
2042         }
2043
2044       if (field == NULL_TREE)
2045         return NULL_TREE;
2046     }
2047
2048   return tree_cons (NULL_TREE, field, NULL_TREE);
2049 }
2050
2051 /* Make an expression to refer to the COMPONENT field of structure or
2052    union value DATUM.  COMPONENT is an IDENTIFIER_NODE.  LOC is the
2053    location of the COMPONENT_REF.  */
2054
2055 tree
2056 build_component_ref (location_t loc, tree datum, tree component)
2057 {
2058   tree type = TREE_TYPE (datum);
2059   enum tree_code code = TREE_CODE (type);
2060   tree field = NULL;
2061   tree ref;
2062   bool datum_lvalue = lvalue_p (datum);
2063
2064   if (!objc_is_public (datum, component))
2065     return error_mark_node;
2066
2067   /* See if there is a field or component with name COMPONENT.  */
2068
2069   if (code == RECORD_TYPE || code == UNION_TYPE)
2070     {
2071       if (!COMPLETE_TYPE_P (type))
2072         {
2073           c_incomplete_type_error (NULL_TREE, type);
2074           return error_mark_node;
2075         }
2076
2077       field = lookup_field (datum, component);
2078
2079       if (!field)
2080         {
2081           error_at (loc, "%qT has no member named %qE", type, component);
2082           return error_mark_node;
2083         }
2084
2085       /* Chain the COMPONENT_REFs if necessary down to the FIELD.
2086          This might be better solved in future the way the C++ front
2087          end does it - by giving the anonymous entities each a
2088          separate name and type, and then have build_component_ref
2089          recursively call itself.  We can't do that here.  */
2090       do
2091         {
2092           tree subdatum = TREE_VALUE (field);
2093           int quals;
2094           tree subtype;
2095           bool use_datum_quals;
2096
2097           if (TREE_TYPE (subdatum) == error_mark_node)
2098             return error_mark_node;
2099
2100           /* If this is an rvalue, it does not have qualifiers in C
2101              standard terms and we must avoid propagating such
2102              qualifiers down to a non-lvalue array that is then
2103              converted to a pointer.  */
2104           use_datum_quals = (datum_lvalue
2105                              || TREE_CODE (TREE_TYPE (subdatum)) != ARRAY_TYPE);
2106
2107           quals = TYPE_QUALS (strip_array_types (TREE_TYPE (subdatum)));
2108           if (use_datum_quals)
2109             quals |= TYPE_QUALS (TREE_TYPE (datum));
2110           subtype = c_build_qualified_type (TREE_TYPE (subdatum), quals);
2111
2112           ref = build3 (COMPONENT_REF, subtype, datum, subdatum,
2113                         NULL_TREE);
2114           SET_EXPR_LOCATION (ref, loc);
2115           if (TREE_READONLY (subdatum)
2116               || (use_datum_quals && TREE_READONLY (datum)))
2117             TREE_READONLY (ref) = 1;
2118           if (TREE_THIS_VOLATILE (subdatum)
2119               || (use_datum_quals && TREE_THIS_VOLATILE (datum)))
2120             TREE_THIS_VOLATILE (ref) = 1;
2121
2122           if (TREE_DEPRECATED (subdatum))
2123             warn_deprecated_use (subdatum, NULL_TREE);
2124
2125           datum = ref;
2126
2127           field = TREE_CHAIN (field);
2128         }
2129       while (field);
2130
2131       return ref;
2132     }
2133   else if (code != ERROR_MARK)
2134     error_at (loc,
2135               "request for member %qE in something not a structure or union",
2136               component);
2137
2138   return error_mark_node;
2139 }
2140 \f
2141 /* Given an expression PTR for a pointer, return an expression
2142    for the value pointed to.
2143    ERRORSTRING is the name of the operator to appear in error messages.
2144
2145    LOC is the location to use for the generated tree.  */
2146
2147 tree
2148 build_indirect_ref (location_t loc, tree ptr, ref_operator errstring)
2149 {
2150   tree pointer = default_conversion (ptr);
2151   tree type = TREE_TYPE (pointer);
2152   tree ref;
2153
2154   if (TREE_CODE (type) == POINTER_TYPE)
2155     {
2156       if (CONVERT_EXPR_P (pointer)
2157           || TREE_CODE (pointer) == VIEW_CONVERT_EXPR)
2158         {
2159           /* If a warning is issued, mark it to avoid duplicates from
2160              the backend.  This only needs to be done at
2161              warn_strict_aliasing > 2.  */
2162           if (warn_strict_aliasing > 2)
2163             if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (pointer, 0)),
2164                                          type, TREE_OPERAND (pointer, 0)))
2165               TREE_NO_WARNING (pointer) = 1;
2166         }
2167
2168       if (TREE_CODE (pointer) == ADDR_EXPR
2169           && (TREE_TYPE (TREE_OPERAND (pointer, 0))
2170               == TREE_TYPE (type)))
2171         {
2172           ref = TREE_OPERAND (pointer, 0);
2173           protected_set_expr_location (ref, loc);
2174           return ref;
2175         }
2176       else
2177         {
2178           tree t = TREE_TYPE (type);
2179
2180           ref = build1 (INDIRECT_REF, t, pointer);
2181
2182           if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
2183             {
2184               error_at (loc, "dereferencing pointer to incomplete type");
2185               return error_mark_node;
2186             }
2187           if (VOID_TYPE_P (t) && c_inhibit_evaluation_warnings == 0)
2188             warning_at (loc, 0, "dereferencing %<void *%> pointer");
2189
2190           /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2191              so that we get the proper error message if the result is used
2192              to assign to.  Also, &* is supposed to be a no-op.
2193              And ANSI C seems to specify that the type of the result
2194              should be the const type.  */
2195           /* A de-reference of a pointer to const is not a const.  It is valid
2196              to change it via some other pointer.  */
2197           TREE_READONLY (ref) = TYPE_READONLY (t);
2198           TREE_SIDE_EFFECTS (ref)
2199             = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer);
2200           TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
2201           protected_set_expr_location (ref, loc);
2202           return ref;
2203         }
2204     }
2205   else if (TREE_CODE (pointer) != ERROR_MARK)
2206     switch (errstring)
2207       {
2208          case RO_ARRAY_INDEXING:
2209            error_at (loc,
2210                      "invalid type argument of array indexing (have %qT)",
2211                      type);
2212            break;
2213          case RO_UNARY_STAR:
2214            error_at (loc,
2215                      "invalid type argument of unary %<*%> (have %qT)",
2216                      type);
2217            break;
2218          case RO_ARROW:
2219            error_at (loc,
2220                      "invalid type argument of %<->%> (have %qT)",
2221                      type);
2222            break;
2223          default:
2224            gcc_unreachable ();
2225       }
2226   return error_mark_node;
2227 }
2228
2229 /* This handles expressions of the form "a[i]", which denotes
2230    an array reference.
2231
2232    This is logically equivalent in C to *(a+i), but we may do it differently.
2233    If A is a variable or a member, we generate a primitive ARRAY_REF.
2234    This avoids forcing the array out of registers, and can work on
2235    arrays that are not lvalues (for example, members of structures returned
2236    by functions).
2237
2238    LOC is the location to use for the returned expression.  */
2239
2240 tree
2241 build_array_ref (location_t loc, tree array, tree index)
2242 {
2243   tree ret;
2244   bool swapped = false;
2245   if (TREE_TYPE (array) == error_mark_node
2246       || TREE_TYPE (index) == error_mark_node)
2247     return error_mark_node;
2248
2249   if (TREE_CODE (TREE_TYPE (array)) != ARRAY_TYPE
2250       && TREE_CODE (TREE_TYPE (array)) != POINTER_TYPE)
2251     {
2252       tree temp;
2253       if (TREE_CODE (TREE_TYPE (index)) != ARRAY_TYPE
2254           && TREE_CODE (TREE_TYPE (index)) != POINTER_TYPE)
2255         {
2256           error_at (loc, "subscripted value is neither array nor pointer");
2257           return error_mark_node;
2258         }
2259       temp = array;
2260       array = index;
2261       index = temp;
2262       swapped = true;
2263     }
2264
2265   if (!INTEGRAL_TYPE_P (TREE_TYPE (index)))
2266     {
2267       error_at (loc, "array subscript is not an integer");
2268       return error_mark_node;
2269     }
2270
2271   if (TREE_CODE (TREE_TYPE (TREE_TYPE (array))) == FUNCTION_TYPE)
2272     {
2273       error_at (loc, "subscripted value is pointer to function");
2274       return error_mark_node;
2275     }
2276
2277   /* ??? Existing practice has been to warn only when the char
2278      index is syntactically the index, not for char[array].  */
2279   if (!swapped)
2280      warn_array_subscript_with_type_char (index);
2281
2282   /* Apply default promotions *after* noticing character types.  */
2283   index = default_conversion (index);
2284
2285   gcc_assert (TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE);
2286
2287   if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
2288     {
2289       tree rval, type;
2290
2291       /* An array that is indexed by a non-constant
2292          cannot be stored in a register; we must be able to do
2293          address arithmetic on its address.
2294          Likewise an array of elements of variable size.  */
2295       if (TREE_CODE (index) != INTEGER_CST
2296           || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
2297               && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
2298         {
2299           if (!c_mark_addressable (array))
2300             return error_mark_node;
2301         }
2302       /* An array that is indexed by a constant value which is not within
2303          the array bounds cannot be stored in a register either; because we
2304          would get a crash in store_bit_field/extract_bit_field when trying
2305          to access a non-existent part of the register.  */
2306       if (TREE_CODE (index) == INTEGER_CST
2307           && TYPE_DOMAIN (TREE_TYPE (array))
2308           && !int_fits_type_p (index, TYPE_DOMAIN (TREE_TYPE (array))))
2309         {
2310           if (!c_mark_addressable (array))
2311             return error_mark_node;
2312         }
2313
2314       if (pedantic)
2315         {
2316           tree foo = array;
2317           while (TREE_CODE (foo) == COMPONENT_REF)
2318             foo = TREE_OPERAND (foo, 0);
2319           if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo))
2320             pedwarn (loc, OPT_pedantic,
2321                      "ISO C forbids subscripting %<register%> array");
2322           else if (!flag_isoc99 && !lvalue_p (foo))
2323             pedwarn (loc, OPT_pedantic,
2324                      "ISO C90 forbids subscripting non-lvalue array");
2325         }
2326
2327       type = TREE_TYPE (TREE_TYPE (array));
2328       rval = build4 (ARRAY_REF, type, array, index, NULL_TREE, NULL_TREE);
2329       /* Array ref is const/volatile if the array elements are
2330          or if the array is.  */
2331       TREE_READONLY (rval)
2332         |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
2333             | TREE_READONLY (array));
2334       TREE_SIDE_EFFECTS (rval)
2335         |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
2336             | TREE_SIDE_EFFECTS (array));
2337       TREE_THIS_VOLATILE (rval)
2338         |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
2339             /* This was added by rms on 16 Nov 91.
2340                It fixes  vol struct foo *a;  a->elts[1]
2341                in an inline function.
2342                Hope it doesn't break something else.  */
2343             | TREE_THIS_VOLATILE (array));
2344       ret = require_complete_type (rval);
2345       protected_set_expr_location (ret, loc);
2346       return ret;
2347     }
2348   else
2349     {
2350       tree ar = default_conversion (array);
2351
2352       if (ar == error_mark_node)
2353         return ar;
2354
2355       gcc_assert (TREE_CODE (TREE_TYPE (ar)) == POINTER_TYPE);
2356       gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) != FUNCTION_TYPE);
2357
2358       return build_indirect_ref
2359         (loc, build_binary_op (loc, PLUS_EXPR, ar, index, 0),
2360          RO_ARRAY_INDEXING);
2361     }
2362 }
2363 \f
2364 /* Build an external reference to identifier ID.  FUN indicates
2365    whether this will be used for a function call.  LOC is the source
2366    location of the identifier.  This sets *TYPE to the type of the
2367    identifier, which is not the same as the type of the returned value
2368    for CONST_DECLs defined as enum constants.  If the type of the
2369    identifier is not available, *TYPE is set to NULL.  */
2370 tree
2371 build_external_ref (location_t loc, tree id, int fun, tree *type)
2372 {
2373   tree ref;
2374   tree decl = lookup_name (id);
2375
2376   /* In Objective-C, an instance variable (ivar) may be preferred to
2377      whatever lookup_name() found.  */
2378   decl = objc_lookup_ivar (decl, id);
2379
2380   *type = NULL;
2381   if (decl && decl != error_mark_node)
2382     {
2383       ref = decl;
2384       *type = TREE_TYPE (ref);
2385     }
2386   else if (fun)
2387     /* Implicit function declaration.  */
2388     ref = implicitly_declare (loc, id);
2389   else if (decl == error_mark_node)
2390     /* Don't complain about something that's already been
2391        complained about.  */
2392     return error_mark_node;
2393   else
2394     {
2395       undeclared_variable (loc, id);
2396       return error_mark_node;
2397     }
2398
2399   if (TREE_TYPE (ref) == error_mark_node)
2400     return error_mark_node;
2401
2402   if (TREE_DEPRECATED (ref))
2403     warn_deprecated_use (ref, NULL_TREE);
2404
2405   /* Recursive call does not count as usage.  */
2406   if (ref != current_function_decl)
2407     {
2408       TREE_USED (ref) = 1;
2409     }
2410
2411   if (TREE_CODE (ref) == FUNCTION_DECL && !in_alignof)
2412     {
2413       if (!in_sizeof && !in_typeof)
2414         C_DECL_USED (ref) = 1;
2415       else if (DECL_INITIAL (ref) == 0
2416                && DECL_EXTERNAL (ref)
2417                && !TREE_PUBLIC (ref))
2418         record_maybe_used_decl (ref);
2419     }
2420
2421   if (TREE_CODE (ref) == CONST_DECL)
2422     {
2423       used_types_insert (TREE_TYPE (ref));
2424
2425       if (warn_cxx_compat
2426           && TREE_CODE (TREE_TYPE (ref)) == ENUMERAL_TYPE
2427           && C_TYPE_DEFINED_IN_STRUCT (TREE_TYPE (ref)))
2428         {
2429           warning_at (loc, OPT_Wc___compat,
2430                       ("enum constant defined in struct or union "
2431                        "is not visible in C++"));
2432           inform (DECL_SOURCE_LOCATION (ref), "enum constant defined here");
2433         }
2434
2435       ref = DECL_INITIAL (ref);
2436       TREE_CONSTANT (ref) = 1;
2437     }
2438   else if (current_function_decl != 0
2439            && !DECL_FILE_SCOPE_P (current_function_decl)
2440            && (TREE_CODE (ref) == VAR_DECL
2441                || TREE_CODE (ref) == PARM_DECL
2442                || TREE_CODE (ref) == FUNCTION_DECL))
2443     {
2444       tree context = decl_function_context (ref);
2445
2446       if (context != 0 && context != current_function_decl)
2447         DECL_NONLOCAL (ref) = 1;
2448     }
2449   /* C99 6.7.4p3: An inline definition of a function with external
2450      linkage ... shall not contain a reference to an identifier with
2451      internal linkage.  */
2452   else if (current_function_decl != 0
2453            && DECL_DECLARED_INLINE_P (current_function_decl)
2454            && DECL_EXTERNAL (current_function_decl)
2455            && VAR_OR_FUNCTION_DECL_P (ref)
2456            && (TREE_CODE (ref) != VAR_DECL || TREE_STATIC (ref))
2457            && ! TREE_PUBLIC (ref)
2458            && DECL_CONTEXT (ref) != current_function_decl)
2459     record_inline_static (loc, current_function_decl, ref,
2460                           csi_internal);
2461
2462   return ref;
2463 }
2464
2465 /* Record details of decls possibly used inside sizeof or typeof.  */
2466 struct maybe_used_decl
2467 {
2468   /* The decl.  */
2469   tree decl;
2470   /* The level seen at (in_sizeof + in_typeof).  */
2471   int level;
2472   /* The next one at this level or above, or NULL.  */
2473   struct maybe_used_decl *next;
2474 };
2475
2476 static struct maybe_used_decl *maybe_used_decls;
2477
2478 /* Record that DECL, an undefined static function reference seen
2479    inside sizeof or typeof, might be used if the operand of sizeof is
2480    a VLA type or the operand of typeof is a variably modified
2481    type.  */
2482
2483 static void
2484 record_maybe_used_decl (tree decl)
2485 {
2486   struct maybe_used_decl *t = XOBNEW (&parser_obstack, struct maybe_used_decl);
2487   t->decl = decl;
2488   t->level = in_sizeof + in_typeof;
2489   t->next = maybe_used_decls;
2490   maybe_used_decls = t;
2491 }
2492
2493 /* Pop the stack of decls possibly used inside sizeof or typeof.  If
2494    USED is false, just discard them.  If it is true, mark them used
2495    (if no longer inside sizeof or typeof) or move them to the next
2496    level up (if still inside sizeof or typeof).  */
2497
2498 void
2499 pop_maybe_used (bool used)
2500 {
2501   struct maybe_used_decl *p = maybe_used_decls;
2502   int cur_level = in_sizeof + in_typeof;
2503   while (p && p->level > cur_level)
2504     {
2505       if (used)
2506         {
2507           if (cur_level == 0)
2508             C_DECL_USED (p->decl) = 1;
2509           else
2510             p->level = cur_level;
2511         }
2512       p = p->next;
2513     }
2514   if (!used || cur_level == 0)
2515     maybe_used_decls = p;
2516 }
2517
2518 /* Return the result of sizeof applied to EXPR.  */
2519
2520 struct c_expr
2521 c_expr_sizeof_expr (location_t loc, struct c_expr expr)
2522 {
2523   struct c_expr ret;
2524   if (expr.value == error_mark_node)
2525     {
2526       ret.value = error_mark_node;
2527       ret.original_code = ERROR_MARK;
2528       ret.original_type = NULL;
2529       pop_maybe_used (false);
2530     }
2531   else
2532     {
2533       bool expr_const_operands = true;
2534       tree folded_expr = c_fully_fold (expr.value, require_constant_value,
2535                                        &expr_const_operands);
2536       ret.value = c_sizeof (loc, TREE_TYPE (folded_expr));
2537       ret.original_code = ERROR_MARK;
2538       ret.original_type = NULL;
2539       if (c_vla_type_p (TREE_TYPE (folded_expr)))
2540         {
2541           /* sizeof is evaluated when given a vla (C99 6.5.3.4p2).  */
2542           ret.value = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret.value),
2543                               folded_expr, ret.value);
2544           C_MAYBE_CONST_EXPR_NON_CONST (ret.value) = !expr_const_operands;
2545           SET_EXPR_LOCATION (ret.value, loc);
2546         }
2547       pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (folded_expr)));
2548     }
2549   return ret;
2550 }
2551
2552 /* Return the result of sizeof applied to T, a structure for the type
2553    name passed to sizeof (rather than the type itself).  LOC is the
2554    location of the original expression.  */
2555
2556 struct c_expr
2557 c_expr_sizeof_type (location_t loc, struct c_type_name *t)
2558 {
2559   tree type;
2560   struct c_expr ret;
2561   tree type_expr = NULL_TREE;
2562   bool type_expr_const = true;
2563   type = groktypename (t, &type_expr, &type_expr_const);
2564   ret.value = c_sizeof (loc, type);
2565   ret.original_code = ERROR_MARK;
2566   ret.original_type = NULL;
2567   if ((type_expr || TREE_CODE (ret.value) == INTEGER_CST)
2568       && c_vla_type_p (type))
2569     {
2570       /* If the type is a [*] array, it is a VLA but is represented as
2571          having a size of zero.  In such a case we must ensure that
2572          the result of sizeof does not get folded to a constant by
2573          c_fully_fold, because if the size is evaluated the result is
2574          not constant and so constraints on zero or negative size
2575          arrays must not be applied when this sizeof call is inside
2576          another array declarator.  */
2577       if (!type_expr)
2578         type_expr = integer_zero_node;
2579       ret.value = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret.value),
2580                           type_expr, ret.value);
2581       C_MAYBE_CONST_EXPR_NON_CONST (ret.value) = !type_expr_const;
2582     }
2583   pop_maybe_used (type != error_mark_node
2584                   ? C_TYPE_VARIABLE_SIZE (type) : false);
2585   return ret;
2586 }
2587
2588 /* Build a function call to function FUNCTION with parameters PARAMS.
2589    The function call is at LOC.
2590    PARAMS is a list--a chain of TREE_LIST nodes--in which the
2591    TREE_VALUE of each node is a parameter-expression.
2592    FUNCTION's data type may be a function type or a pointer-to-function.  */
2593
2594 tree
2595 build_function_call (location_t loc, tree function, tree params)
2596 {
2597   VEC(tree,gc) *vec;
2598   tree ret;
2599
2600   vec = VEC_alloc (tree, gc, list_length (params));
2601   for (; params; params = TREE_CHAIN (params))
2602     VEC_quick_push (tree, vec, TREE_VALUE (params));
2603   ret = build_function_call_vec (loc, function, vec, NULL);
2604   VEC_free (tree, gc, vec);
2605   return ret;
2606 }
2607
2608 /* Build a function call to function FUNCTION with parameters PARAMS.
2609    ORIGTYPES, if not NULL, is a vector of types; each element is
2610    either NULL or the original type of the corresponding element in
2611    PARAMS.  The original type may differ from TREE_TYPE of the
2612    parameter for enums.  FUNCTION's data type may be a function type
2613    or pointer-to-function.  This function changes the elements of
2614    PARAMS.  */
2615
2616 tree
2617 build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
2618                          VEC(tree,gc) *origtypes)
2619 {
2620   tree fntype, fundecl = 0;
2621   tree name = NULL_TREE, result;
2622   tree tem;
2623   int nargs;
2624   tree *argarray;
2625
2626
2627   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
2628   STRIP_TYPE_NOPS (function);
2629
2630   /* Convert anything with function type to a pointer-to-function.  */
2631   if (TREE_CODE (function) == FUNCTION_DECL)
2632     {
2633       /* Implement type-directed function overloading for builtins.
2634          resolve_overloaded_builtin and targetm.resolve_overloaded_builtin
2635          handle all the type checking.  The result is a complete expression
2636          that implements this function call.  */
2637       tem = resolve_overloaded_builtin (loc, function, params);
2638       if (tem)
2639         return tem;
2640
2641       name = DECL_NAME (function);
2642       fundecl = function;
2643     }
2644   if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE)
2645     function = function_to_pointer_conversion (loc, function);
2646
2647   /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
2648      expressions, like those used for ObjC messenger dispatches.  */
2649   if (!VEC_empty (tree, params))
2650     function = objc_rewrite_function_call (function,
2651                                            VEC_index (tree, params, 0));
2652
2653   function = c_fully_fold (function, false, NULL);
2654
2655   fntype = TREE_TYPE (function);
2656
2657   if (TREE_CODE (fntype) == ERROR_MARK)
2658     return error_mark_node;
2659
2660   if (!(TREE_CODE (fntype) == POINTER_TYPE
2661         && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
2662     {
2663       error_at (loc, "called object %qE is not a function", function);
2664       return error_mark_node;
2665     }
2666
2667   if (fundecl && TREE_THIS_VOLATILE (fundecl))
2668     current_function_returns_abnormally = 1;
2669
2670   /* fntype now gets the type of function pointed to.  */
2671   fntype = TREE_TYPE (fntype);
2672
2673   /* Convert the parameters to the types declared in the
2674      function prototype, or apply default promotions.  */
2675
2676   nargs = convert_arguments (TYPE_ARG_TYPES (fntype), params, origtypes,
2677                              function, fundecl);
2678   if (nargs < 0)
2679     return error_mark_node;
2680
2681   /* Check that the function is called through a compatible prototype.
2682      If it is not, replace the call by a trap, wrapped up in a compound
2683      expression if necessary.  This has the nice side-effect to prevent
2684      the tree-inliner from generating invalid assignment trees which may
2685      blow up in the RTL expander later.  */
2686   if (CONVERT_EXPR_P (function)
2687       && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR
2688       && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL
2689       && !comptypes (fntype, TREE_TYPE (tem)))
2690     {
2691       tree return_type = TREE_TYPE (fntype);
2692       tree trap = build_function_call (loc, built_in_decls[BUILT_IN_TRAP],
2693                                        NULL_TREE);
2694       int i;
2695
2696       /* This situation leads to run-time undefined behavior.  We can't,
2697          therefore, simply error unless we can prove that all possible
2698          executions of the program must execute the code.  */
2699       if (warning_at (loc, 0, "function called through a non-compatible type"))
2700         /* We can, however, treat "undefined" any way we please.
2701            Call abort to encourage the user to fix the program.  */
2702         inform (loc, "if this code is reached, the program will abort");
2703       /* Before the abort, allow the function arguments to exit or
2704          call longjmp.  */
2705       for (i = 0; i < nargs; i++)
2706         trap = build2 (COMPOUND_EXPR, void_type_node,
2707                        VEC_index (tree, params, i), trap);
2708
2709       if (VOID_TYPE_P (return_type))
2710         {
2711           if (TYPE_QUALS (return_type) != TYPE_UNQUALIFIED)
2712             pedwarn (loc, 0,
2713                      "function with qualified void return type called");
2714           return trap;
2715         }
2716       else
2717         {
2718           tree rhs;
2719
2720           if (AGGREGATE_TYPE_P (return_type))
2721             rhs = build_compound_literal (loc, return_type,
2722                                           build_constructor (return_type, 0),
2723                                           false);
2724           else
2725             rhs = fold_convert_loc (loc, return_type, integer_zero_node);
2726
2727           return require_complete_type (build2 (COMPOUND_EXPR, return_type,
2728                                                 trap, rhs));
2729         }
2730     }
2731
2732   argarray = VEC_address (tree, params);
2733
2734   /* Check that arguments to builtin functions match the expectations.  */
2735   if (fundecl
2736       && DECL_BUILT_IN (fundecl)
2737       && DECL_BUILT_IN_CLASS (fundecl) == BUILT_IN_NORMAL
2738       && !check_builtin_function_arguments (fundecl, nargs, argarray))
2739     return error_mark_node;
2740
2741   /* Check that the arguments to the function are valid.  */
2742   check_function_arguments (TYPE_ATTRIBUTES (fntype), nargs, argarray,
2743                             TYPE_ARG_TYPES (fntype));
2744
2745   if (name != NULL_TREE
2746       && !strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10))
2747     {
2748       if (require_constant_value)
2749         result =
2750           fold_build_call_array_initializer_loc (loc, TREE_TYPE (fntype),
2751                                                  function, nargs, argarray);
2752       else
2753         result = fold_build_call_array_loc (loc, TREE_TYPE (fntype),
2754                                             function, nargs, argarray);
2755       if (TREE_CODE (result) == NOP_EXPR
2756           && TREE_CODE (TREE_OPERAND (result, 0)) == INTEGER_CST)
2757         STRIP_TYPE_NOPS (result);
2758     }
2759   else
2760     result = build_call_array_loc (loc, TREE_TYPE (fntype),
2761                                    function, nargs, argarray);
2762
2763   if (VOID_TYPE_P (TREE_TYPE (result)))
2764     {
2765       if (TYPE_QUALS (TREE_TYPE (result)) != TYPE_UNQUALIFIED)
2766         pedwarn (loc, 0,
2767                  "function with qualified void return type called");
2768       return result;
2769     }
2770   return require_complete_type (result);
2771 }
2772 \f
2773 /* Convert the argument expressions in the vector VALUES
2774    to the types in the list TYPELIST.
2775
2776    If TYPELIST is exhausted, or when an element has NULL as its type,
2777    perform the default conversions.
2778
2779    ORIGTYPES is the original types of the expressions in VALUES.  This
2780    holds the type of enum values which have been converted to integral
2781    types.  It may be NULL.
2782
2783    FUNCTION is a tree for the called function.  It is used only for
2784    error messages, where it is formatted with %qE.
2785
2786    This is also where warnings about wrong number of args are generated.
2787
2788    Returns the actual number of arguments processed (which may be less
2789    than the length of VALUES in some error situations), or -1 on
2790    failure.  */
2791
2792 static int
2793 convert_arguments (tree typelist, VEC(tree,gc) *values,
2794                    VEC(tree,gc) *origtypes, tree function, tree fundecl)
2795 {
2796   tree typetail, val;
2797   unsigned int parmnum;
2798   bool error_args = false;
2799   const bool type_generic = fundecl
2800     && lookup_attribute ("type generic", TYPE_ATTRIBUTES(TREE_TYPE (fundecl)));
2801   bool type_generic_remove_excess_precision = false;
2802   tree selector;
2803
2804   /* Change pointer to function to the function itself for
2805      diagnostics.  */
2806   if (TREE_CODE (function) == ADDR_EXPR
2807       && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
2808     function = TREE_OPERAND (function, 0);
2809
2810   /* Handle an ObjC selector specially for diagnostics.  */
2811   selector = objc_message_selector ();
2812
2813   /* For type-generic built-in functions, determine whether excess
2814      precision should be removed (classification) or not
2815      (comparison).  */
2816   if (type_generic
2817       && DECL_BUILT_IN (fundecl)
2818       && DECL_BUILT_IN_CLASS (fundecl) == BUILT_IN_NORMAL)
2819     {
2820       switch (DECL_FUNCTION_CODE (fundecl))
2821         {
2822         case BUILT_IN_ISFINITE:
2823         case BUILT_IN_ISINF:
2824         case BUILT_IN_ISINF_SIGN:
2825         case BUILT_IN_ISNAN:
2826         case BUILT_IN_ISNORMAL:
2827         case BUILT_IN_FPCLASSIFY:
2828           type_generic_remove_excess_precision = true;
2829           break;
2830
2831         default:
2832           type_generic_remove_excess_precision = false;
2833           break;
2834         }
2835     }
2836
2837   /* Scan the given expressions and types, producing individual
2838      converted arguments.  */
2839
2840   for (typetail = typelist, parmnum = 0;
2841        VEC_iterate (tree, values, parmnum, val);
2842        ++parmnum)
2843     {
2844       tree type = typetail ? TREE_VALUE (typetail) : 0;
2845       tree valtype = TREE_TYPE (val);
2846       tree rname = function;
2847       int argnum = parmnum + 1;
2848       const char *invalid_func_diag;
2849       bool excess_precision = false;
2850       bool npc;
2851       tree parmval;
2852
2853       if (type == void_type_node)
2854         {
2855           error_at (input_location,
2856                     "too many arguments to function %qE", function);
2857           if (fundecl && !DECL_BUILT_IN (fundecl))
2858             inform (DECL_SOURCE_LOCATION (fundecl), "declared here");
2859           return parmnum;
2860         }
2861
2862       if (selector && argnum > 2)
2863         {
2864           rname = selector;
2865           argnum -= 2;
2866         }
2867
2868       npc = null_pointer_constant_p (val);
2869
2870       /* If there is excess precision and a prototype, convert once to
2871          the required type rather than converting via the semantic
2872          type.  Likewise without a prototype a float value represented
2873          as long double should be converted once to double.  But for
2874          type-generic classification functions excess precision must
2875          be removed here.  */
2876       if (TREE_CODE (val) == EXCESS_PRECISION_EXPR
2877           && (type || !type_generic || !type_generic_remove_excess_precision))
2878         {
2879           val = TREE_OPERAND (val, 0);
2880           excess_precision = true;
2881         }
2882       val = c_fully_fold (val, false, NULL);
2883       STRIP_TYPE_NOPS (val);
2884
2885       val = require_complete_type (val);
2886
2887       if (type != 0)
2888         {
2889           /* Formal parm type is specified by a function prototype.  */
2890
2891           if (type == error_mark_node || !COMPLETE_TYPE_P (type))
2892             {
2893               error ("type of formal parameter %d is incomplete", parmnum + 1);
2894               parmval = val;
2895             }
2896           else
2897             {
2898               tree origtype;
2899
2900               /* Optionally warn about conversions that
2901                  differ from the default conversions.  */
2902               if (warn_traditional_conversion || warn_traditional)
2903                 {
2904                   unsigned int formal_prec = TYPE_PRECISION (type);
2905
2906                   if (INTEGRAL_TYPE_P (type)
2907                       && TREE_CODE (valtype) == REAL_TYPE)
2908                     warning (0, "passing argument %d of %qE as integer "
2909                              "rather than floating due to prototype",
2910                              argnum, rname);
2911                   if (INTEGRAL_TYPE_P (type)
2912                       && TREE_CODE (valtype) == COMPLEX_TYPE)
2913                     warning (0, "passing argument %d of %qE as integer "
2914                              "rather than complex due to prototype",
2915                              argnum, rname);
2916                   else if (TREE_CODE (type) == COMPLEX_TYPE
2917                            && TREE_CODE (valtype) == REAL_TYPE)
2918                     warning (0, "passing argument %d of %qE as complex "
2919                              "rather than floating due to prototype",
2920                              argnum, rname);
2921                   else if (TREE_CODE (type) == REAL_TYPE
2922                            && INTEGRAL_TYPE_P (valtype))
2923                     warning (0, "passing argument %d of %qE as floating "
2924                              "rather than integer due to prototype",
2925                              argnum, rname);
2926                   else if (TREE_CODE (type) == COMPLEX_TYPE
2927                            && INTEGRAL_TYPE_P (valtype))
2928                     warning (0, "passing argument %d of %qE as complex "
2929                              "rather than integer due to prototype",
2930                              argnum, rname);
2931                   else if (TREE_CODE (type) == REAL_TYPE
2932                            && TREE_CODE (valtype) == COMPLEX_TYPE)
2933                     warning (0, "passing argument %d of %qE as floating "
2934                              "rather than complex due to prototype",
2935                              argnum, rname);
2936                   /* ??? At some point, messages should be written about
2937                      conversions between complex types, but that's too messy
2938                      to do now.  */
2939                   else if (TREE_CODE (type) == REAL_TYPE
2940                            && TREE_CODE (valtype) == REAL_TYPE)
2941                     {
2942                       /* Warn if any argument is passed as `float',
2943                          since without a prototype it would be `double'.  */
2944                       if (formal_prec == TYPE_PRECISION (float_type_node)
2945                           && type != dfloat32_type_node)
2946                         warning (0, "passing argument %d of %qE as %<float%> "
2947                                  "rather than %<double%> due to prototype",
2948                                  argnum, rname);
2949
2950                       /* Warn if mismatch between argument and prototype
2951                          for decimal float types.  Warn of conversions with
2952                          binary float types and of precision narrowing due to
2953                          prototype. */
2954                       else if (type != valtype
2955                                && (type == dfloat32_type_node
2956                                    || type == dfloat64_type_node
2957                                    || type == dfloat128_type_node
2958                                    || valtype == dfloat32_type_node
2959                                    || valtype == dfloat64_type_node
2960                                    || valtype == dfloat128_type_node)
2961                                && (formal_prec
2962                                    <= TYPE_PRECISION (valtype)
2963                                    || (type == dfloat128_type_node
2964                                        && (valtype
2965                                            != dfloat64_type_node
2966                                            && (valtype
2967                                                != dfloat32_type_node)))
2968                                    || (type == dfloat64_type_node
2969                                        && (valtype
2970                                            != dfloat32_type_node))))
2971                         warning (0, "passing argument %d of %qE as %qT "
2972                                  "rather than %qT due to prototype",
2973                                  argnum, rname, type, valtype);
2974
2975                     }
2976                   /* Detect integer changing in width or signedness.
2977                      These warnings are only activated with
2978                      -Wtraditional-conversion, not with -Wtraditional.  */
2979                   else if (warn_traditional_conversion && INTEGRAL_TYPE_P (type)
2980                            && INTEGRAL_TYPE_P (valtype))
2981                     {
2982                       tree would_have_been = default_conversion (val);
2983                       tree type1 = TREE_TYPE (would_have_been);
2984
2985                       if (TREE_CODE (type) == ENUMERAL_TYPE
2986                           && (TYPE_MAIN_VARIANT (type)
2987                               == TYPE_MAIN_VARIANT (valtype)))
2988                         /* No warning if function asks for enum
2989                            and the actual arg is that enum type.  */
2990                         ;
2991                       else if (formal_prec != TYPE_PRECISION (type1))
2992                         warning (OPT_Wtraditional_conversion,
2993                                  "passing argument %d of %qE "
2994                                  "with different width due to prototype",
2995                                  argnum, rname);
2996                       else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1))
2997                         ;
2998                       /* Don't complain if the formal parameter type
2999                          is an enum, because we can't tell now whether
3000                          the value was an enum--even the same enum.  */
3001                       else if (TREE_CODE (type) == ENUMERAL_TYPE)
3002                         ;
3003                       else if (TREE_CODE (val) == INTEGER_CST
3004                                && int_fits_type_p (val, type))
3005                         /* Change in signedness doesn't matter
3006                            if a constant value is unaffected.  */
3007                         ;
3008                       /* If the value is extended from a narrower
3009                          unsigned type, it doesn't matter whether we
3010                          pass it as signed or unsigned; the value
3011                          certainly is the same either way.  */
3012                       else if (TYPE_PRECISION (valtype) < TYPE_PRECISION (type)
3013                                && TYPE_UNSIGNED (valtype))
3014                         ;
3015                       else if (TYPE_UNSIGNED (type))
3016                         warning (OPT_Wtraditional_conversion,
3017                                  "passing argument %d of %qE "
3018                                  "as unsigned due to prototype",
3019                                  argnum, rname);
3020                       else
3021                         warning (OPT_Wtraditional_conversion,
3022                                  "passing argument %d of %qE "
3023                                  "as signed due to prototype", argnum, rname);
3024                     }
3025                 }
3026
3027               /* Possibly restore an EXCESS_PRECISION_EXPR for the
3028                  sake of better warnings from convert_and_check.  */
3029               if (excess_precision)
3030                 val = build1 (EXCESS_PRECISION_EXPR, valtype, val);
3031               origtype = (origtypes == NULL
3032                           ? NULL_TREE
3033                           : VEC_index (tree, origtypes, parmnum));
3034               parmval = convert_for_assignment (input_location, type, val,
3035                                                 origtype, ic_argpass, npc,
3036                                                 fundecl, function,
3037                                                 parmnum + 1);
3038
3039               if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0)
3040                   && INTEGRAL_TYPE_P (type)
3041                   && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
3042                 parmval = default_conversion (parmval);
3043             }
3044         }
3045       else if (TREE_CODE (valtype) == REAL_TYPE
3046                && (TYPE_PRECISION (valtype)
3047                    < TYPE_PRECISION (double_type_node))
3048                && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (valtype)))
3049         {
3050           if (type_generic)
3051             parmval = val;
3052           else
3053             /* Convert `float' to `double'.  */
3054             parmval = convert (double_type_node, val);
3055         }
3056       else if (excess_precision && !type_generic)
3057         /* A "double" argument with excess precision being passed
3058            without a prototype or in variable arguments.  */
3059         parmval = convert (valtype, val);
3060       else if ((invalid_func_diag =
3061                 targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val)))
3062         {
3063           error (invalid_func_diag);
3064           return -1;
3065         }
3066       else
3067         /* Convert `short' and `char' to full-size `int'.  */
3068         parmval = default_conversion (val);
3069
3070       VEC_replace (tree, values, parmnum, parmval);
3071       if (parmval == error_mark_node)
3072         error_args = true;
3073
3074       if (typetail)
3075         typetail = TREE_CHAIN (typetail);
3076     }
3077
3078   gcc_assert (parmnum == VEC_length (tree, values));
3079
3080   if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
3081     {
3082       error_at (input_location,
3083                 "too few arguments to function %qE", function);
3084       if (fundecl && !DECL_BUILT_IN (fundecl))
3085         inform (DECL_SOURCE_LOCATION (fundecl), "declared here");
3086       return -1;
3087     }
3088
3089   return error_args ? -1 : (int) parmnum;
3090 }
3091 \f
3092 /* This is the entry point used by the parser to build unary operators
3093    in the input.  CODE, a tree_code, specifies the unary operator, and
3094    ARG is the operand.  For unary plus, the C parser currently uses
3095    CONVERT_EXPR for code.
3096
3097    LOC is the location to use for the tree generated.
3098 */
3099
3100 struct c_expr
3101 parser_build_unary_op (location_t loc, enum tree_code code, struct c_expr arg)
3102 {
3103   struct c_expr result;
3104
3105   result.value = build_unary_op (loc, code, arg.value, 0);
3106   result.original_code = code;
3107   result.original_type = NULL;
3108
3109   if (TREE_OVERFLOW_P (result.value) && !TREE_OVERFLOW_P (arg.value))
3110     overflow_warning (loc, result.value);
3111
3112   return result;
3113 }
3114
3115 /* This is the entry point used by the parser to build binary operators
3116    in the input.  CODE, a tree_code, specifies the binary operator, and
3117    ARG1 and ARG2 are the operands.  In addition to constructing the
3118    expression, we check for operands that were written with other binary
3119    operators in a way that is likely to confuse the user.
3120
3121    LOCATION is the location of the binary operator.  */
3122
3123 struct c_expr
3124 parser_build_binary_op (location_t location, enum tree_code code,
3125                         struct c_expr arg1, struct c_expr arg2)
3126 {
3127   struct c_expr result;
3128
3129   enum tree_code code1 = arg1.original_code;
3130   enum tree_code code2 = arg2.original_code;
3131   tree type1 = (arg1.original_type
3132                 ? arg1.original_type
3133                 : TREE_TYPE (arg1.value));
3134   tree type2 = (arg2.original_type
3135                 ? arg2.original_type
3136                 : TREE_TYPE (arg2.value));
3137
3138   result.value = build_binary_op (location, code,
3139                                   arg1.value, arg2.value, 1);
3140   result.original_code = code;
3141   result.original_type = NULL;
3142
3143   if (TREE_CODE (result.value) == ERROR_MARK)
3144     return result;
3145
3146   if (location != UNKNOWN_LOCATION)
3147     protected_set_expr_location (result.value, location);
3148
3149   /* Check for cases such as x+y<<z which users are likely
3150      to misinterpret.  */
3151   if (warn_parentheses)
3152     warn_about_parentheses (code, code1, arg1.value, code2, arg2.value);
3153
3154   if (warn_logical_op)
3155     warn_logical_operator (input_location, code, TREE_TYPE (result.value),
3156                            code1, arg1.value, code2, arg2.value);
3157
3158   /* Warn about comparisons against string literals, with the exception
3159      of testing for equality or inequality of a string literal with NULL.  */
3160   if (code == EQ_EXPR || code == NE_EXPR)
3161     {
3162       if ((code1 == STRING_CST && !integer_zerop (arg2.value))
3163           || (code2 == STRING_CST && !integer_zerop (arg1.value)))
3164         warning_at (location, OPT_Waddress,
3165                     "comparison with string literal results in unspecified behavior");
3166     }
3167   else if (TREE_CODE_CLASS (code) == tcc_comparison
3168            && (code1 == STRING_CST || code2 == STRING_CST))
3169     warning_at (location, OPT_Waddress,
3170                 "comparison with string literal results in unspecified behavior");
3171
3172   if (TREE_OVERFLOW_P (result.value)
3173       && !TREE_OVERFLOW_P (arg1.value)
3174       && !TREE_OVERFLOW_P (arg2.value))
3175     overflow_warning (location, result.value);
3176
3177   /* Warn about comparisons of different enum types.  */
3178   if (warn_enum_compare
3179       && TREE_CODE_CLASS (code) == tcc_comparison
3180       && TREE_CODE (type1) == ENUMERAL_TYPE
3181       && TREE_CODE (type2) == ENUMERAL_TYPE
3182       && TYPE_MAIN_VARIANT (type1) != TYPE_MAIN_VARIANT (type2))
3183     warning_at (location, OPT_Wenum_compare,
3184                 "comparison between %qT and %qT",
3185                 type1, type2);
3186
3187   return result;
3188 }
3189 \f
3190 /* Return a tree for the difference of pointers OP0 and OP1.
3191    The resulting tree has type int.  */
3192
3193 static tree
3194 pointer_diff (location_t loc, tree op0, tree op1)
3195 {
3196   tree restype = ptrdiff_type_node;
3197   tree result, inttype;
3198
3199   addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op0)));
3200   addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op1)));
3201   tree target_type = TREE_TYPE (TREE_TYPE (op0));
3202   tree con0, con1, lit0, lit1;
3203   tree orig_op1 = op1;
3204
3205   /* If the operands point into different address spaces, we need to
3206      explicitly convert them to pointers into the common address space
3207      before we can subtract the numerical address values.  */
3208   if (as0 != as1)
3209     {
3210       addr_space_t as_common;
3211       tree common_type;
3212
3213       /* Determine the common superset address space.  This is guaranteed
3214          to exist because the caller verified that comp_target_types
3215          returned non-zero.  */
3216       if (!addr_space_superset (as0, as1, &as_common))
3217         gcc_unreachable ();
3218
3219       common_type = common_pointer_type (TREE_TYPE (op0), TREE_TYPE (op1));
3220       op0 = convert (common_type, op0);
3221       op1 = convert (common_type, op1);
3222     }
3223
3224   /* Determine integer type to perform computations in.  This will usually
3225      be the same as the result type (ptrdiff_t), but may need to be a wider
3226      type if pointers for the address space are wider than ptrdiff_t.  */
3227   if (TYPE_PRECISION (restype) < TYPE_PRECISION (TREE_TYPE (op0)))
3228     inttype = lang_hooks.types.type_for_size
3229                 (TYPE_PRECISION (TREE_TYPE (op0)), 0);
3230   else
3231     inttype = restype;
3232
3233
3234   if (TREE_CODE (target_type) == VOID_TYPE)
3235     pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3236              "pointer of type %<void *%> used in subtraction");
3237   if (TREE_CODE (target_type) == FUNCTION_TYPE)
3238     pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3239              "pointer to a function used in subtraction");
3240
3241   /* If the conversion to ptrdiff_type does anything like widening or
3242      converting a partial to an integral mode, we get a convert_expression
3243      that is in the way to do any simplifications.
3244      (fold-const.c doesn't know that the extra bits won't be needed.
3245      split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
3246      different mode in place.)
3247      So first try to find a common term here 'by hand'; we want to cover
3248      at least the cases that occur in legal static initializers.  */
3249   if (CONVERT_EXPR_P (op0)
3250       && (TYPE_PRECISION (TREE_TYPE (op0))
3251           == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))))
3252     con0 = TREE_OPERAND (op0, 0);
3253   else
3254     con0 = op0;
3255   if (CONVERT_EXPR_P (op1)
3256       && (TYPE_PRECISION (TREE_TYPE (op1))
3257           == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))))
3258     con1 = TREE_OPERAND (op1, 0);
3259   else
3260     con1 = op1;
3261
3262   if (TREE_CODE (con0) == PLUS_EXPR)
3263     {
3264       lit0 = TREE_OPERAND (con0, 1);
3265       con0 = TREE_OPERAND (con0, 0);
3266     }
3267   else
3268     lit0 = integer_zero_node;
3269
3270   if (TREE_CODE (con1) == PLUS_EXPR)
3271     {
3272       lit1 = TREE_OPERAND (con1, 1);
3273       con1 = TREE_OPERAND (con1, 0);
3274     }
3275   else
3276     lit1 = integer_zero_node;
3277
3278   if (operand_equal_p (con0, con1, 0))
3279     {
3280       op0 = lit0;
3281       op1 = lit1;
3282     }
3283
3284
3285   /* First do the subtraction as integers;
3286      then drop through to build the divide operator.
3287      Do not do default conversions on the minus operator
3288      in case restype is a short type.  */
3289
3290   op0 = build_binary_op (loc,
3291                          MINUS_EXPR, convert (inttype, op0),
3292                          convert (inttype, op1), 0);
3293   /* This generates an error if op1 is pointer to incomplete type.  */
3294   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
3295     error_at (loc, "arithmetic on pointer to an incomplete type");
3296
3297   /* This generates an error if op0 is pointer to incomplete type.  */
3298   op1 = c_size_in_bytes (target_type);
3299
3300   /* Divide by the size, in easiest possible way.  */
3301   result = fold_build2_loc (loc, EXACT_DIV_EXPR, inttype,
3302                             op0, convert (inttype, op1));
3303
3304   /* Convert to final result type if necessary.  */
3305   return convert (restype, result);
3306 }
3307 \f
3308 /* Construct and perhaps optimize a tree representation
3309    for a unary operation.  CODE, a tree_code, specifies the operation
3310    and XARG is the operand.
3311    For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
3312    the default promotions (such as from short to int).
3313    For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
3314    allows non-lvalues; this is only used to handle conversion of non-lvalue
3315    arrays to pointers in C99.
3316
3317    LOCATION is the location of the operator.  */
3318
3319 tree
3320 build_unary_op (location_t location,
3321                 enum tree_code code, tree xarg, int flag)
3322 {
3323   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
3324   tree arg = xarg;
3325   tree argtype = 0;
3326   enum tree_code typecode;
3327   tree val;
3328   tree ret = error_mark_node;
3329   tree eptype = NULL_TREE;
3330   int noconvert = flag;
3331   const char *invalid_op_diag;
3332   bool int_operands;
3333
3334   int_operands = EXPR_INT_CONST_OPERANDS (xarg);
3335   if (int_operands)
3336     arg = remove_c_maybe_const_expr (arg);
3337
3338   if (code != ADDR_EXPR)
3339     arg = require_complete_type (arg);
3340
3341   typecode = TREE_CODE (TREE_TYPE (arg));
3342   if (typecode == ERROR_MARK)
3343     return error_mark_node;
3344   if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
3345     typecode = INTEGER_TYPE;
3346
3347   if ((invalid_op_diag
3348        = targetm.invalid_unary_op (code, TREE_TYPE (xarg))))
3349     {
3350       error_at (location, invalid_op_diag);
3351       return error_mark_node;
3352     }
3353
3354   if (TREE_CODE (arg) == EXCESS_PRECISION_EXPR)
3355     {
3356       eptype = TREE_TYPE (arg);
3357       arg = TREE_OPERAND (arg, 0);
3358     }
3359
3360   switch (code)
3361     {
3362     case CONVERT_EXPR:
3363       /* This is used for unary plus, because a CONVERT_EXPR
3364          is enough to prevent anybody from looking inside for
3365          associativity, but won't generate any code.  */
3366       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
3367             || typecode == FIXED_POINT_TYPE || typecode == COMPLEX_TYPE
3368             || typecode == VECTOR_TYPE))
3369         {
3370           error_at (location, "wrong type argument to unary plus");
3371           return error_mark_node;
3372         }
3373       else if (!noconvert)
3374         arg = default_conversion (arg);
3375       arg = non_lvalue_loc (location, arg);
3376       break;
3377
3378     case NEGATE_EXPR:
3379       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
3380             || typecode == FIXED_POINT_TYPE || typecode == COMPLEX_TYPE
3381             || typecode == VECTOR_TYPE))
3382         {
3383           error_at (location, "wrong type argument to unary minus");
3384           return error_mark_node;
3385         }
3386       else if (!noconvert)
3387         arg = default_conversion (arg);
3388       break;
3389
3390     case BIT_NOT_EXPR:
3391       /* ~ works on integer types and non float vectors. */
3392       if (typecode == INTEGER_TYPE
3393           || (typecode == VECTOR_TYPE
3394               && !VECTOR_FLOAT_TYPE_P (TREE_TYPE (arg))))
3395         {
3396           if (!noconvert)
3397             arg = default_conversion (arg);
3398         }
3399       else if (typecode == COMPLEX_TYPE)
3400         {
3401           code = CONJ_EXPR;
3402           pedwarn (location, OPT_pedantic,
3403                    "ISO C does not support %<~%> for complex conjugation");
3404           if (!noconvert)
3405             arg = default_conversion (arg);
3406         }
3407       else
3408         {
3409           error_at (location, "wrong type argument to bit-complement");
3410           return error_mark_node;
3411         }
3412       break;
3413
3414     case ABS_EXPR:
3415       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
3416         {
3417           error_at (location, "wrong type argument to abs");
3418           return error_mark_node;
3419         }
3420       else if (!noconvert)
3421         arg = default_conversion (arg);
3422       break;
3423
3424     case CONJ_EXPR:
3425       /* Conjugating a real value is a no-op, but allow it anyway.  */
3426       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
3427             || typecode == COMPLEX_TYPE))
3428         {
3429           error_at (location, "wrong type argument to conjugation");
3430           return error_mark_node;
3431         }
3432       else if (!noconvert)
3433         arg = default_conversion (arg);
3434       break;
3435
3436     case TRUTH_NOT_EXPR:
3437       if (typecode != INTEGER_TYPE && typecode != FIXED_POINT_TYPE
3438           && typecode != REAL_TYPE && typecode != POINTER_TYPE
3439           && typecode != COMPLEX_TYPE)
3440         {
3441      &