118334Speter/* Build expressions with type checking for C++ compiler. 290075Sobrien Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3146895Skan 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. 418334Speter Hacked by Michael Tiemann (tiemann@cygnus.com) 518334Speter 6132718SkanThis file is part of GCC. 718334Speter 8132718SkanGCC is free software; you can redistribute it and/or modify 918334Speterit under the terms of the GNU General Public License as published by 1018334Speterthe Free Software Foundation; either version 2, or (at your option) 1118334Speterany later version. 1218334Speter 13132718SkanGCC is distributed in the hope that it will be useful, 1418334Speterbut WITHOUT ANY WARRANTY; without even the implied warranty of 1518334SpeterMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1618334SpeterGNU General Public License for more details. 1718334Speter 1818334SpeterYou should have received a copy of the GNU General Public License 19132718Skanalong with GCC; see the file COPYING. If not, write to 20169689Skanthe Free Software Foundation, 51 Franklin Street, Fifth Floor, 21169689SkanBoston, MA 02110-1301, USA. */ 2218334Speter 2318334Speter 2418334Speter/* This file is part of the C++ front end. 2518334Speter It contains routines to build C++ expressions given their operands, 2618334Speter including computing the types of the result, C and C++ specific error 27169689Skan checks, and some optimization. */ 2818334Speter 2918334Speter#include "config.h" 3050397Sobrien#include "system.h" 31132718Skan#include "coretypes.h" 32132718Skan#include "tm.h" 3318334Speter#include "tree.h" 3418334Speter#include "rtl.h" 3590075Sobrien#include "expr.h" 3618334Speter#include "cp-tree.h" 3790075Sobrien#include "tm_p.h" 3818334Speter#include "flags.h" 3918334Speter#include "output.h" 4050397Sobrien#include "toplev.h" 4190075Sobrien#include "diagnostic.h" 4290075Sobrien#include "target.h" 43132718Skan#include "convert.h" 44169689Skan#include "c-common.h" 4518334Speter 46169689Skanstatic tree pfn_from_ptrmemfunc (tree); 47132718Skanstatic tree convert_for_assignment (tree, tree, const char *, tree, int); 48132718Skanstatic tree cp_pointer_int_sum (enum tree_code, tree, tree); 49132718Skanstatic tree rationalize_conditional_expr (enum tree_code, tree); 50132718Skanstatic int comp_ptr_ttypes_real (tree, tree, int); 51132718Skanstatic bool comp_except_types (tree, tree, bool); 52132718Skanstatic bool comp_array_types (tree, tree, bool); 53132718Skanstatic tree common_base_type (tree, tree); 54132718Skanstatic tree pointer_diff (tree, tree, tree); 55169689Skanstatic tree get_delta_difference (tree, tree, bool, bool); 56132718Skanstatic void casts_away_constness_r (tree *, tree *); 57132718Skanstatic bool casts_away_constness (tree, tree); 58132718Skanstatic void maybe_warn_about_returning_address_of_local (tree); 59132718Skanstatic tree lookup_destructor (tree, tree, tree); 60169689Skanstatic tree convert_arguments (tree, tree, tree, int); 6118334Speter 6218334Speter/* Do `exp = require_complete_type (exp);' to make sure exp 6352284Sobrien does not have an incomplete type. (That includes void types.) 6452284Sobrien Returns the error_mark_node if the VALUE does not have 6552284Sobrien complete type when this function returns. */ 6618334Speter 6718334Spetertree 68132718Skanrequire_complete_type (tree value) 6918334Speter{ 7050397Sobrien tree type; 7118334Speter 7252284Sobrien if (processing_template_decl || value == error_mark_node) 7350397Sobrien return value; 7450397Sobrien 7550397Sobrien if (TREE_CODE (value) == OVERLOAD) 7650397Sobrien type = unknown_type_node; 7750397Sobrien else 7850397Sobrien type = TREE_TYPE (value); 7950397Sobrien 80161651Skan if (type == error_mark_node) 81161651Skan return error_mark_node; 82161651Skan 8318334Speter /* First, detect a valid value with a complete type. */ 8490075Sobrien if (COMPLETE_TYPE_P (type)) 8518334Speter return value; 8618334Speter 8752284Sobrien if (complete_type_or_else (type, value)) 8850397Sobrien return value; 8950397Sobrien else 9052284Sobrien return error_mark_node; 9152284Sobrien} 9252284Sobrien 9350397Sobrien/* Try to complete TYPE, if it is incomplete. For example, if TYPE is 9450397Sobrien a template instantiation, do the instantiation. Returns TYPE, 9550397Sobrien whether or not it could be completed, unless something goes 9650397Sobrien horribly wrong, in which case the error_mark_node is returned. */ 9750397Sobrien 9850397Sobrientree 99132718Skancomplete_type (tree type) 10050397Sobrien{ 10150397Sobrien if (type == NULL_TREE) 10250397Sobrien /* Rather than crash, we return something sure to cause an error 10350397Sobrien at some point. */ 10450397Sobrien return error_mark_node; 10550397Sobrien 10690075Sobrien if (type == error_mark_node || COMPLETE_TYPE_P (type)) 10750397Sobrien ; 10850397Sobrien else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type)) 10950397Sobrien { 11050397Sobrien tree t = complete_type (TREE_TYPE (type)); 111169689Skan unsigned int needs_constructing, has_nontrivial_dtor; 112132718Skan if (COMPLETE_TYPE_P (t) && !dependent_type_p (type)) 11350397Sobrien layout_type (type); 114169689Skan needs_constructing 11550397Sobrien = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t)); 116169689Skan has_nontrivial_dtor 11790075Sobrien = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (t)); 118169689Skan for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t)) 119169689Skan { 120169689Skan TYPE_NEEDS_CONSTRUCTING (t) = needs_constructing; 121169689Skan TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t) = has_nontrivial_dtor; 122169689Skan } 12350397Sobrien } 12452284Sobrien else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INSTANTIATION (type)) 12550397Sobrien instantiate_class_template (TYPE_MAIN_VARIANT (type)); 12650397Sobrien 12750397Sobrien return type; 12850397Sobrien} 12950397Sobrien 130117395Skan/* Like complete_type, but issue an error if the TYPE cannot be completed. 131169689Skan VALUE is used for informative diagnostics. 13252284Sobrien Returns NULL_TREE if the type cannot be made complete. */ 13350397Sobrien 13450397Sobrientree 135169689Skancomplete_type_or_else (tree type, tree value) 13650397Sobrien{ 13750397Sobrien type = complete_type (type); 13852284Sobrien if (type == error_mark_node) 13952284Sobrien /* We already issued an error. */ 14052284Sobrien return NULL_TREE; 14190075Sobrien else if (!COMPLETE_TYPE_P (type)) 14250397Sobrien { 143169689Skan cxx_incomplete_type_diagnostic (value, type, 0); 14450397Sobrien return NULL_TREE; 14550397Sobrien } 14650397Sobrien else 14750397Sobrien return type; 14850397Sobrien} 14950397Sobrien 15018334Speter/* Return truthvalue of whether type of EXP is instantiated. */ 15150397Sobrien 15218334Speterint 153132718Skantype_unknown_p (tree exp) 15418334Speter{ 155132718Skan return (TREE_CODE (exp) == TREE_LIST 156132718Skan || TREE_TYPE (exp) == unknown_type_node); 15718334Speter} 15818334Speter 15918334Speter 16018334Speter/* Return the common type of two parameter lists. 16118334Speter We assume that comptypes has already been done and returned 1; 16218334Speter if that isn't so, this may crash. 16318334Speter 16418334Speter As an optimization, free the space we allocate if the parameter 16518334Speter lists are already common. */ 16618334Speter 167169689Skanstatic tree 168132718Skancommonparms (tree p1, tree p2) 16918334Speter{ 17018334Speter tree oldargs = p1, newargs, n; 17118334Speter int i, len; 17218334Speter int any_change = 0; 17318334Speter 17418334Speter len = list_length (p1); 17518334Speter newargs = tree_last (p1); 17618334Speter 17718334Speter if (newargs == void_list_node) 17818334Speter i = 1; 17918334Speter else 18018334Speter { 18118334Speter i = 0; 18218334Speter newargs = 0; 18318334Speter } 18418334Speter 18518334Speter for (; i < len; i++) 18618334Speter newargs = tree_cons (NULL_TREE, NULL_TREE, newargs); 18718334Speter 18818334Speter n = newargs; 18918334Speter 19018334Speter for (i = 0; p1; 19118334Speter p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n), i++) 19218334Speter { 19318334Speter if (TREE_PURPOSE (p1) && !TREE_PURPOSE (p2)) 19418334Speter { 19518334Speter TREE_PURPOSE (n) = TREE_PURPOSE (p1); 19618334Speter any_change = 1; 19718334Speter } 19818334Speter else if (! TREE_PURPOSE (p1)) 19918334Speter { 20018334Speter if (TREE_PURPOSE (p2)) 20118334Speter { 20218334Speter TREE_PURPOSE (n) = TREE_PURPOSE (p2); 20318334Speter any_change = 1; 20418334Speter } 20518334Speter } 20618334Speter else 20718334Speter { 20818334Speter if (1 != simple_cst_equal (TREE_PURPOSE (p1), TREE_PURPOSE (p2))) 20918334Speter any_change = 1; 21018334Speter TREE_PURPOSE (n) = TREE_PURPOSE (p2); 21118334Speter } 21218334Speter if (TREE_VALUE (p1) != TREE_VALUE (p2)) 21318334Speter { 21418334Speter any_change = 1; 21596263Sobrien TREE_VALUE (n) = merge_types (TREE_VALUE (p1), TREE_VALUE (p2)); 21618334Speter } 21718334Speter else 21818334Speter TREE_VALUE (n) = TREE_VALUE (p1); 21918334Speter } 22018334Speter if (! any_change) 22190075Sobrien return oldargs; 22218334Speter 22318334Speter return newargs; 22418334Speter} 22518334Speter 22650397Sobrien/* Given a type, perhaps copied for a typedef, 22750397Sobrien find the "original" version of it. */ 228169689Skanstatic tree 229132718Skanoriginal_type (tree t) 23050397Sobrien{ 231169689Skan int quals = cp_type_quals (t); 232169689Skan while (t != error_mark_node 233169689Skan && TYPE_NAME (t) != NULL_TREE) 23450397Sobrien { 23550397Sobrien tree x = TYPE_NAME (t); 23650397Sobrien if (TREE_CODE (x) != TYPE_DECL) 23750397Sobrien break; 23850397Sobrien x = DECL_ORIGINAL_TYPE (x); 23950397Sobrien if (x == NULL_TREE) 24050397Sobrien break; 24150397Sobrien t = x; 24250397Sobrien } 243169689Skan return cp_build_qualified_type (t, quals); 24450397Sobrien} 24550397Sobrien 24690075Sobrien/* T1 and T2 are arithmetic or enumeration types. Return the type 24790075Sobrien that will result from the "usual arithmetic conversions" on T1 and 24890075Sobrien T2 as described in [expr]. */ 24990075Sobrien 25090075Sobrientree 251132718Skantype_after_usual_arithmetic_conversions (tree t1, tree t2) 25290075Sobrien{ 25390075Sobrien enum tree_code code1 = TREE_CODE (t1); 25490075Sobrien enum tree_code code2 = TREE_CODE (t2); 25590075Sobrien tree attributes; 25690075Sobrien 25790075Sobrien /* FIXME: Attributes. */ 258169689Skan gcc_assert (ARITHMETIC_TYPE_P (t1) 259169689Skan || TREE_CODE (t1) == VECTOR_TYPE 260169689Skan || TREE_CODE (t1) == ENUMERAL_TYPE); 261169689Skan gcc_assert (ARITHMETIC_TYPE_P (t2) 262169689Skan || TREE_CODE (t2) == VECTOR_TYPE 263169689Skan || TREE_CODE (t2) == ENUMERAL_TYPE); 26490075Sobrien 26596263Sobrien /* In what follows, we slightly generalize the rules given in [expr] so 26696263Sobrien as to deal with `long long' and `complex'. First, merge the 26796263Sobrien attributes. */ 26890075Sobrien attributes = (*targetm.merge_type_attributes) (t1, t2); 26990075Sobrien 27096263Sobrien /* If one type is complex, form the common type of the non-complex 27196263Sobrien components, then make that complex. Use T1 or T2 if it is the 27296263Sobrien required type. */ 27396263Sobrien if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE) 27496263Sobrien { 27596263Sobrien tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1; 27696263Sobrien tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2; 27796263Sobrien tree subtype 27896263Sobrien = type_after_usual_arithmetic_conversions (subtype1, subtype2); 27996263Sobrien 28096263Sobrien if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype) 28196263Sobrien return build_type_attribute_variant (t1, attributes); 28296263Sobrien else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype) 28396263Sobrien return build_type_attribute_variant (t2, attributes); 28496263Sobrien else 28596263Sobrien return build_type_attribute_variant (build_complex_type (subtype), 28696263Sobrien attributes); 28796263Sobrien } 28896263Sobrien 289161651Skan if (code1 == VECTOR_TYPE) 290161651Skan { 291161651Skan /* When we get here we should have two vectors of the same size. 292161651Skan Just prefer the unsigned one if present. */ 293169689Skan if (TYPE_UNSIGNED (t1)) 294161651Skan return build_type_attribute_variant (t1, attributes); 295161651Skan else 296161651Skan return build_type_attribute_variant (t2, attributes); 297161651Skan } 298161651Skan 29990075Sobrien /* If only one is real, use it as the result. */ 30090075Sobrien if (code1 == REAL_TYPE && code2 != REAL_TYPE) 30190075Sobrien return build_type_attribute_variant (t1, attributes); 30290075Sobrien if (code2 == REAL_TYPE && code1 != REAL_TYPE) 30390075Sobrien return build_type_attribute_variant (t2, attributes); 30490075Sobrien 30590075Sobrien /* Perform the integral promotions. */ 30690075Sobrien if (code1 != REAL_TYPE) 30790075Sobrien { 30890075Sobrien t1 = type_promotes_to (t1); 30990075Sobrien t2 = type_promotes_to (t2); 31090075Sobrien } 31190075Sobrien 31290075Sobrien /* Both real or both integers; use the one with greater precision. */ 31390075Sobrien if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2)) 31490075Sobrien return build_type_attribute_variant (t1, attributes); 31590075Sobrien else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1)) 31690075Sobrien return build_type_attribute_variant (t2, attributes); 31790075Sobrien 31896263Sobrien /* The types are the same; no need to do anything fancy. */ 31996263Sobrien if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2)) 32096263Sobrien return build_type_attribute_variant (t1, attributes); 32196263Sobrien 32290075Sobrien if (code1 != REAL_TYPE) 32390075Sobrien { 32490075Sobrien /* If one is a sizetype, use it so size_binop doesn't blow up. */ 32590075Sobrien if (TYPE_IS_SIZETYPE (t1) > TYPE_IS_SIZETYPE (t2)) 32690075Sobrien return build_type_attribute_variant (t1, attributes); 32790075Sobrien if (TYPE_IS_SIZETYPE (t2) > TYPE_IS_SIZETYPE (t1)) 32890075Sobrien return build_type_attribute_variant (t2, attributes); 32990075Sobrien 33090075Sobrien /* If one is unsigned long long, then convert the other to unsigned 33190075Sobrien long long. */ 33290075Sobrien if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_unsigned_type_node) 33390075Sobrien || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_unsigned_type_node)) 33490075Sobrien return build_type_attribute_variant (long_long_unsigned_type_node, 33590075Sobrien attributes); 33690075Sobrien /* If one is a long long, and the other is an unsigned long, and 33790075Sobrien long long can represent all the values of an unsigned long, then 33890075Sobrien convert to a long long. Otherwise, convert to an unsigned long 33990075Sobrien long. Otherwise, if either operand is long long, convert the 34090075Sobrien other to long long. 341169689Skan 34290075Sobrien Since we're here, we know the TYPE_PRECISION is the same; 34390075Sobrien therefore converting to long long cannot represent all the values 34490075Sobrien of an unsigned long, so we choose unsigned long long in that 34590075Sobrien case. */ 34690075Sobrien if (same_type_p (TYPE_MAIN_VARIANT (t1), long_long_integer_type_node) 34790075Sobrien || same_type_p (TYPE_MAIN_VARIANT (t2), long_long_integer_type_node)) 34890075Sobrien { 349169689Skan tree t = ((TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2)) 350169689Skan ? long_long_unsigned_type_node 35190075Sobrien : long_long_integer_type_node); 35290075Sobrien return build_type_attribute_variant (t, attributes); 35390075Sobrien } 354169689Skan 35590075Sobrien /* Go through the same procedure, but for longs. */ 35690075Sobrien if (same_type_p (TYPE_MAIN_VARIANT (t1), long_unsigned_type_node) 35790075Sobrien || same_type_p (TYPE_MAIN_VARIANT (t2), long_unsigned_type_node)) 35890075Sobrien return build_type_attribute_variant (long_unsigned_type_node, 35990075Sobrien attributes); 36090075Sobrien if (same_type_p (TYPE_MAIN_VARIANT (t1), long_integer_type_node) 36190075Sobrien || same_type_p (TYPE_MAIN_VARIANT (t2), long_integer_type_node)) 36290075Sobrien { 363169689Skan tree t = ((TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2)) 36490075Sobrien ? long_unsigned_type_node : long_integer_type_node); 36590075Sobrien return build_type_attribute_variant (t, attributes); 36690075Sobrien } 36790075Sobrien /* Otherwise prefer the unsigned one. */ 368169689Skan if (TYPE_UNSIGNED (t1)) 36990075Sobrien return build_type_attribute_variant (t1, attributes); 37090075Sobrien else 37190075Sobrien return build_type_attribute_variant (t2, attributes); 37290075Sobrien } 37390075Sobrien else 37490075Sobrien { 37590075Sobrien if (same_type_p (TYPE_MAIN_VARIANT (t1), long_double_type_node) 37690075Sobrien || same_type_p (TYPE_MAIN_VARIANT (t2), long_double_type_node)) 37790075Sobrien return build_type_attribute_variant (long_double_type_node, 37890075Sobrien attributes); 37990075Sobrien if (same_type_p (TYPE_MAIN_VARIANT (t1), double_type_node) 38090075Sobrien || same_type_p (TYPE_MAIN_VARIANT (t2), double_type_node)) 38190075Sobrien return build_type_attribute_variant (double_type_node, 38290075Sobrien attributes); 38396263Sobrien if (same_type_p (TYPE_MAIN_VARIANT (t1), float_type_node) 38496263Sobrien || same_type_p (TYPE_MAIN_VARIANT (t2), float_type_node)) 38590075Sobrien return build_type_attribute_variant (float_type_node, 38690075Sobrien attributes); 387169689Skan 38896263Sobrien /* Two floating-point types whose TYPE_MAIN_VARIANTs are none of 389169689Skan the standard C++ floating-point types. Logic earlier in this 390169689Skan function has already eliminated the possibility that 391169689Skan TYPE_PRECISION (t2) != TYPE_PRECISION (t1), so there's no 392169689Skan compelling reason to choose one or the other. */ 39396263Sobrien return build_type_attribute_variant (t1, attributes); 39490075Sobrien } 39590075Sobrien} 39690075Sobrien 397132718Skan/* Subroutine of composite_pointer_type to implement the recursive 398132718Skan case. See that function for documentation fo the parameters. */ 399132718Skan 400132718Skanstatic tree 401132718Skancomposite_pointer_type_r (tree t1, tree t2, const char* location) 402132718Skan{ 403132718Skan tree pointee1; 404132718Skan tree pointee2; 405132718Skan tree result_type; 406132718Skan tree attributes; 407132718Skan 408132718Skan /* Determine the types pointed to by T1 and T2. */ 409132718Skan if (TREE_CODE (t1) == POINTER_TYPE) 410132718Skan { 411132718Skan pointee1 = TREE_TYPE (t1); 412132718Skan pointee2 = TREE_TYPE (t2); 413132718Skan } 414132718Skan else 415132718Skan { 416132718Skan pointee1 = TYPE_PTRMEM_POINTED_TO_TYPE (t1); 417132718Skan pointee2 = TYPE_PTRMEM_POINTED_TO_TYPE (t2); 418132718Skan } 419132718Skan 420132718Skan /* [expr.rel] 421132718Skan 422132718Skan Otherwise, the composite pointer type is a pointer type 423132718Skan similar (_conv.qual_) to the type of one of the operands, 424132718Skan with a cv-qualification signature (_conv.qual_) that is the 425132718Skan union of the cv-qualification signatures of the operand 426132718Skan types. */ 427132718Skan if (same_type_ignoring_top_level_qualifiers_p (pointee1, pointee2)) 428132718Skan result_type = pointee1; 429132718Skan else if ((TREE_CODE (pointee1) == POINTER_TYPE 430132718Skan && TREE_CODE (pointee2) == POINTER_TYPE) 431132718Skan || (TYPE_PTR_TO_MEMBER_P (pointee1) 432132718Skan && TYPE_PTR_TO_MEMBER_P (pointee2))) 433132718Skan result_type = composite_pointer_type_r (pointee1, pointee2, location); 434132718Skan else 435132718Skan { 436169689Skan pedwarn ("%s between distinct pointer types %qT and %qT " 437132718Skan "lacks a cast", 438132718Skan location, t1, t2); 439132718Skan result_type = void_type_node; 440132718Skan } 441132718Skan result_type = cp_build_qualified_type (result_type, 442132718Skan (cp_type_quals (pointee1) 443132718Skan | cp_type_quals (pointee2))); 444132718Skan /* If the original types were pointers to members, so is the 445132718Skan result. */ 446132718Skan if (TYPE_PTR_TO_MEMBER_P (t1)) 447132718Skan { 448132718Skan if (!same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1), 449132718Skan TYPE_PTRMEM_CLASS_TYPE (t2))) 450169689Skan pedwarn ("%s between distinct pointer types %qT and %qT " 451132718Skan "lacks a cast", 452132718Skan location, t1, t2); 453132718Skan result_type = build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1), 454132718Skan result_type); 455132718Skan } 456132718Skan else 457132718Skan result_type = build_pointer_type (result_type); 458132718Skan 459132718Skan /* Merge the attributes. */ 460132718Skan attributes = (*targetm.merge_type_attributes) (t1, t2); 461132718Skan return build_type_attribute_variant (result_type, attributes); 462132718Skan} 463132718Skan 46490075Sobrien/* Return the composite pointer type (see [expr.rel]) for T1 and T2. 46590075Sobrien ARG1 and ARG2 are the values with those types. The LOCATION is a 466169689Skan string describing the current location, in case an error occurs. 46790075Sobrien 468132718Skan This routine also implements the computation of a common type for 469132718Skan pointers-to-members as per [expr.eq]. */ 470132718Skan 471169689Skantree 472132718Skancomposite_pointer_type (tree t1, tree t2, tree arg1, tree arg2, 473132718Skan const char* location) 47490075Sobrien{ 475132718Skan tree class1; 476132718Skan tree class2; 47790075Sobrien 47890075Sobrien /* [expr.rel] 47990075Sobrien 48090075Sobrien If one operand is a null pointer constant, the composite pointer 48190075Sobrien type is the type of the other operand. */ 48290075Sobrien if (null_ptr_cst_p (arg1)) 48390075Sobrien return t2; 48490075Sobrien if (null_ptr_cst_p (arg2)) 48590075Sobrien return t1; 486169689Skan 48790075Sobrien /* We have: 48890075Sobrien 48990075Sobrien [expr.rel] 49090075Sobrien 49190075Sobrien If one of the operands has type "pointer to cv1 void*", then 49290075Sobrien the other has type "pointer to cv2T", and the composite pointer 49390075Sobrien type is "pointer to cv12 void", where cv12 is the union of cv1 49490075Sobrien and cv2. 49590075Sobrien 49690075Sobrien If either type is a pointer to void, make sure it is T1. */ 497132718Skan if (TREE_CODE (t2) == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (t2))) 49890075Sobrien { 49990075Sobrien tree t; 50090075Sobrien t = t1; 50190075Sobrien t1 = t2; 50290075Sobrien t2 = t; 50390075Sobrien } 504132718Skan 50590075Sobrien /* Now, if T1 is a pointer to void, merge the qualifiers. */ 506132718Skan if (TREE_CODE (t1) == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (t1))) 50790075Sobrien { 508132718Skan tree attributes; 509132718Skan tree result_type; 510132718Skan 51190075Sobrien if (pedantic && TYPE_PTRFN_P (t2)) 512169689Skan pedwarn ("ISO C++ forbids %s between pointer of type %<void *%> " 513169689Skan "and pointer-to-function", location); 514169689Skan result_type 515132718Skan = cp_build_qualified_type (void_type_node, 516132718Skan (cp_type_quals (TREE_TYPE (t1)) 517132718Skan | cp_type_quals (TREE_TYPE (t2)))); 51890075Sobrien result_type = build_pointer_type (result_type); 519132718Skan /* Merge the attributes. */ 520132718Skan attributes = (*targetm.merge_type_attributes) (t1, t2); 521132718Skan return build_type_attribute_variant (result_type, attributes); 52290075Sobrien } 523132718Skan 524169689Skan if (c_dialect_objc () && TREE_CODE (t1) == POINTER_TYPE 525169689Skan && TREE_CODE (t2) == POINTER_TYPE) 526169689Skan { 527169689Skan if (objc_compare_types (t1, t2, -3, NULL_TREE)) 528169689Skan return t1; 529169689Skan } 530169689Skan 531132718Skan /* [expr.eq] permits the application of a pointer conversion to 532132718Skan bring the pointers to a common type. */ 533132718Skan if (TREE_CODE (t1) == POINTER_TYPE && TREE_CODE (t2) == POINTER_TYPE 534132718Skan && CLASS_TYPE_P (TREE_TYPE (t1)) 535132718Skan && CLASS_TYPE_P (TREE_TYPE (t2)) 536132718Skan && !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (t1), 537132718Skan TREE_TYPE (t2))) 53890075Sobrien { 539132718Skan class1 = TREE_TYPE (t1); 540132718Skan class2 = TREE_TYPE (t2); 54190075Sobrien 542132718Skan if (DERIVED_FROM_P (class1, class2)) 543169689Skan t2 = (build_pointer_type 544132718Skan (cp_build_qualified_type (class1, TYPE_QUALS (class2)))); 545132718Skan else if (DERIVED_FROM_P (class2, class1)) 546169689Skan t1 = (build_pointer_type 547132718Skan (cp_build_qualified_type (class2, TYPE_QUALS (class1)))); 548132718Skan else 549132718Skan { 550169689Skan error ("%s between distinct pointer types %qT and %qT " 551132718Skan "lacks a cast", location, t1, t2); 552132718Skan return error_mark_node; 553132718Skan } 554132718Skan } 555132718Skan /* [expr.eq] permits the application of a pointer-to-member 556132718Skan conversion to change the class type of one of the types. */ 557132718Skan else if (TYPE_PTR_TO_MEMBER_P (t1) 558132718Skan && !same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1), 559132718Skan TYPE_PTRMEM_CLASS_TYPE (t2))) 560132718Skan { 561132718Skan class1 = TYPE_PTRMEM_CLASS_TYPE (t1); 562132718Skan class2 = TYPE_PTRMEM_CLASS_TYPE (t2); 56390075Sobrien 564132718Skan if (DERIVED_FROM_P (class1, class2)) 565132718Skan t1 = build_ptrmem_type (class2, TYPE_PTRMEM_POINTED_TO_TYPE (t1)); 566132718Skan else if (DERIVED_FROM_P (class2, class1)) 567132718Skan t2 = build_ptrmem_type (class1, TYPE_PTRMEM_POINTED_TO_TYPE (t2)); 56890075Sobrien else 56990075Sobrien { 570169689Skan error ("%s between distinct pointer-to-member types %qT and %qT " 571132718Skan "lacks a cast", location, t1, t2); 572132718Skan return error_mark_node; 57390075Sobrien } 57490075Sobrien } 57590075Sobrien 576132718Skan return composite_pointer_type_r (t1, t2, location); 57790075Sobrien} 57890075Sobrien 57996263Sobrien/* Return the merged type of two types. 58018334Speter We assume that comptypes has already been done and returned 1; 58118334Speter if that isn't so, this may crash. 58218334Speter 58396263Sobrien This just combines attributes and default arguments; any other 58496263Sobrien differences would cause the two types to compare unalike. */ 58518334Speter 58618334Spetertree 587132718Skanmerge_types (tree t1, tree t2) 58818334Speter{ 589132718Skan enum tree_code code1; 590132718Skan enum tree_code code2; 59118334Speter tree attributes; 59218334Speter 59318334Speter /* Save time if the two types are the same. */ 59450397Sobrien if (t1 == t2) 59550397Sobrien return t1; 59696263Sobrien if (original_type (t1) == original_type (t2)) 59750397Sobrien return t1; 59818334Speter 59918334Speter /* If one type is nonsense, use the other. */ 60018334Speter if (t1 == error_mark_node) 60118334Speter return t2; 60218334Speter if (t2 == error_mark_node) 60318334Speter return t1; 60418334Speter 60550397Sobrien /* Merge the attributes. */ 60690075Sobrien attributes = (*targetm.merge_type_attributes) (t1, t2); 60718334Speter 60850397Sobrien if (TYPE_PTRMEMFUNC_P (t1)) 60950397Sobrien t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1); 61050397Sobrien if (TYPE_PTRMEMFUNC_P (t2)) 61150397Sobrien t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2); 61250397Sobrien 61318334Speter code1 = TREE_CODE (t1); 61418334Speter code2 = TREE_CODE (t2); 61518334Speter 61618334Speter switch (code1) 61718334Speter { 61818334Speter case POINTER_TYPE: 61918334Speter case REFERENCE_TYPE: 62096263Sobrien /* For two pointers, do this recursively on the target type. */ 62118334Speter { 62296263Sobrien tree target = merge_types (TREE_TYPE (t1), TREE_TYPE (t2)); 62396263Sobrien int quals = cp_type_quals (t1); 62418334Speter 62518334Speter if (code1 == POINTER_TYPE) 62618334Speter t1 = build_pointer_type (target); 62718334Speter else 62818334Speter t1 = build_reference_type (target); 62918334Speter t1 = build_type_attribute_variant (t1, attributes); 63096263Sobrien t1 = cp_build_qualified_type (t1, quals); 63118334Speter 63218334Speter if (TREE_CODE (target) == METHOD_TYPE) 63318334Speter t1 = build_ptrmemfunc_type (t1); 63418334Speter 63518334Speter return t1; 63618334Speter } 63718334Speter 63896263Sobrien case OFFSET_TYPE: 63996263Sobrien { 640132718Skan int quals; 641132718Skan tree pointee; 642132718Skan quals = cp_type_quals (t1); 643132718Skan pointee = merge_types (TYPE_PTRMEM_POINTED_TO_TYPE (t1), 644132718Skan TYPE_PTRMEM_POINTED_TO_TYPE (t2)); 645132718Skan t1 = build_ptrmem_type (TYPE_PTRMEM_CLASS_TYPE (t1), 646132718Skan pointee); 647132718Skan t1 = cp_build_qualified_type (t1, quals); 64896263Sobrien break; 64996263Sobrien } 65096263Sobrien 65118334Speter case ARRAY_TYPE: 65218334Speter { 65396263Sobrien tree elt = merge_types (TREE_TYPE (t1), TREE_TYPE (t2)); 65418334Speter /* Save space: see if the result is identical to one of the args. */ 65518334Speter if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1)) 65618334Speter return build_type_attribute_variant (t1, attributes); 65718334Speter if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2)) 65818334Speter return build_type_attribute_variant (t2, attributes); 65918334Speter /* Merge the element types, and have a size if either arg has one. */ 66050397Sobrien t1 = build_cplus_array_type 66150397Sobrien (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2)); 66296263Sobrien break; 66318334Speter } 66418334Speter 66518334Speter case FUNCTION_TYPE: 66618334Speter /* Function types: prefer the one that specified arg types. 66718334Speter If both do, merge the arg types. Also merge the return types. */ 66818334Speter { 66996263Sobrien tree valtype = merge_types (TREE_TYPE (t1), TREE_TYPE (t2)); 67018334Speter tree p1 = TYPE_ARG_TYPES (t1); 67118334Speter tree p2 = TYPE_ARG_TYPES (t2); 67218334Speter tree rval, raises; 67318334Speter 67418334Speter /* Save space: see if the result is identical to one of the args. */ 67518334Speter if (valtype == TREE_TYPE (t1) && ! p2) 676132718Skan return cp_build_type_attribute_variant (t1, attributes); 67718334Speter if (valtype == TREE_TYPE (t2) && ! p1) 678132718Skan return cp_build_type_attribute_variant (t2, attributes); 67918334Speter 68018334Speter /* Simple way if one arg fails to specify argument types. */ 68118334Speter if (p1 == NULL_TREE || TREE_VALUE (p1) == void_type_node) 68218334Speter { 68318334Speter rval = build_function_type (valtype, p2); 68418334Speter if ((raises = TYPE_RAISES_EXCEPTIONS (t2))) 68518334Speter rval = build_exception_variant (rval, raises); 686132718Skan return cp_build_type_attribute_variant (rval, attributes); 68718334Speter } 68818334Speter raises = TYPE_RAISES_EXCEPTIONS (t1); 68918334Speter if (p2 == NULL_TREE || TREE_VALUE (p2) == void_type_node) 69018334Speter { 69118334Speter rval = build_function_type (valtype, p1); 69218334Speter if (raises) 69318334Speter rval = build_exception_variant (rval, raises); 694132718Skan return cp_build_type_attribute_variant (rval, attributes); 69518334Speter } 69618334Speter 69718334Speter rval = build_function_type (valtype, commonparms (p1, p2)); 69896263Sobrien t1 = build_exception_variant (rval, raises); 69996263Sobrien break; 70018334Speter } 70118334Speter 70296263Sobrien case METHOD_TYPE: 70396263Sobrien { 70496263Sobrien /* Get this value the long way, since TYPE_METHOD_BASETYPE 70596263Sobrien is just the main variant of this. */ 70696263Sobrien tree basetype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t2))); 70796263Sobrien tree raises = TYPE_RAISES_EXCEPTIONS (t1); 70896263Sobrien tree t3; 70918334Speter 71096263Sobrien /* If this was a member function type, get back to the 71196263Sobrien original type of type member function (i.e., without 71296263Sobrien the class instance variable up front. */ 71396263Sobrien t1 = build_function_type (TREE_TYPE (t1), 71496263Sobrien TREE_CHAIN (TYPE_ARG_TYPES (t1))); 71596263Sobrien t2 = build_function_type (TREE_TYPE (t2), 71696263Sobrien TREE_CHAIN (TYPE_ARG_TYPES (t2))); 71796263Sobrien t3 = merge_types (t1, t2); 718132718Skan t3 = build_method_type_directly (basetype, TREE_TYPE (t3), 719132718Skan TYPE_ARG_TYPES (t3)); 72096263Sobrien t1 = build_exception_variant (t3, raises); 72196263Sobrien break; 72296263Sobrien } 72318334Speter 724132718Skan case TYPENAME_TYPE: 725132718Skan /* There is no need to merge attributes into a TYPENAME_TYPE. 726132718Skan When the type is instantiated it will have whatever 727132718Skan attributes result from the instantiation. */ 728132718Skan return t1; 729132718Skan 73096263Sobrien default:; 73196263Sobrien } 732169689Skan 733169689Skan if (attribute_list_equal (TYPE_ATTRIBUTES (t1), attributes)) 734169689Skan return t1; 735169689Skan else if (attribute_list_equal (TYPE_ATTRIBUTES (t2), attributes)) 736169689Skan return t2; 737169689Skan else 738169689Skan return cp_build_type_attribute_variant (t1, attributes); 73996263Sobrien} 74018334Speter 74196263Sobrien/* Return the common type of two types. 74296263Sobrien We assume that comptypes has already been done and returned 1; 74396263Sobrien if that isn't so, this may crash. 74418334Speter 74596263Sobrien This is the type for the result of most arithmetic operations 74696263Sobrien if the operands have the given two types. */ 74718334Speter 74896263Sobrientree 749132718Skancommon_type (tree t1, tree t2) 75096263Sobrien{ 75196263Sobrien enum tree_code code1; 75296263Sobrien enum tree_code code2; 75318334Speter 75496263Sobrien /* If one type is nonsense, bail. */ 75596263Sobrien if (t1 == error_mark_node || t2 == error_mark_node) 75696263Sobrien return error_mark_node; 75718334Speter 75896263Sobrien code1 = TREE_CODE (t1); 75996263Sobrien code2 = TREE_CODE (t2); 76018334Speter 76196263Sobrien if ((ARITHMETIC_TYPE_P (t1) || code1 == ENUMERAL_TYPE 762171825Skan || code1 == VECTOR_TYPE) 76396263Sobrien && (ARITHMETIC_TYPE_P (t2) || code2 == ENUMERAL_TYPE 764171825Skan || code2 == VECTOR_TYPE)) 76596263Sobrien return type_after_usual_arithmetic_conversions (t1, t2); 76618334Speter 76796263Sobrien else if ((TYPE_PTR_P (t1) && TYPE_PTR_P (t2)) 76896263Sobrien || (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2)) 76996263Sobrien || (TYPE_PTRMEMFUNC_P (t1) && TYPE_PTRMEMFUNC_P (t2))) 77096263Sobrien return composite_pointer_type (t1, t2, error_mark_node, error_mark_node, 77196263Sobrien "conversion"); 77296263Sobrien else 773169689Skan gcc_unreachable (); 77418334Speter} 77518334Speter 77690075Sobrien/* Compare two exception specifier types for exactness or subsetness, if 777132718Skan allowed. Returns false for mismatch, true for match (same, or 778132718Skan derived and !exact). 779169689Skan 78090075Sobrien [except.spec] "If a class X ... objects of class X or any class publicly 781132718Skan and unambiguously derived from X. Similarly, if a pointer type Y * ... 78290075Sobrien exceptions of type Y * or that are pointers to any type publicly and 783132718Skan unambiguously derived from Y. Otherwise a function only allows exceptions 78490075Sobrien that have the same type ..." 78590075Sobrien This does not mention cv qualifiers and is different to what throw 78690075Sobrien [except.throw] and catch [except.catch] will do. They will ignore the 78790075Sobrien top level cv qualifiers, and allow qualifiers in the pointer to class 78890075Sobrien example. 789169689Skan 79090075Sobrien We implement the letter of the standard. */ 79150397Sobrien 792132718Skanstatic bool 793132718Skancomp_except_types (tree a, tree b, bool exact) 79490075Sobrien{ 79590075Sobrien if (same_type_p (a, b)) 796132718Skan return true; 79790075Sobrien else if (!exact) 79890075Sobrien { 79990075Sobrien if (cp_type_quals (a) || cp_type_quals (b)) 800169689Skan return false; 801169689Skan 80290075Sobrien if (TREE_CODE (a) == POINTER_TYPE 803169689Skan && TREE_CODE (b) == POINTER_TYPE) 804169689Skan { 805169689Skan a = TREE_TYPE (a); 806169689Skan b = TREE_TYPE (b); 807169689Skan if (cp_type_quals (a) || cp_type_quals (b)) 808169689Skan return false; 809169689Skan } 810169689Skan 81190075Sobrien if (TREE_CODE (a) != RECORD_TYPE 812169689Skan || TREE_CODE (b) != RECORD_TYPE) 813169689Skan return false; 814169689Skan 815169689Skan if (PUBLICLY_UNIQUELY_DERIVED_P (a, b)) 816169689Skan return true; 81790075Sobrien } 818132718Skan return false; 81990075Sobrien} 82090075Sobrien 821132718Skan/* Return true if TYPE1 and TYPE2 are equivalent exception specifiers. 822132718Skan If EXACT is false, T2 can be stricter than T1 (according to 15.4/7), 82390075Sobrien otherwise it must be exact. Exception lists are unordered, but 82490075Sobrien we've already filtered out duplicates. Most lists will be in order, 82590075Sobrien we should try to make use of that. */ 82690075Sobrien 827132718Skanbool 828132718Skancomp_except_specs (tree t1, tree t2, bool exact) 82918334Speter{ 83090075Sobrien tree probe; 83190075Sobrien tree base; 83290075Sobrien int length = 0; 83390075Sobrien 83490075Sobrien if (t1 == t2) 835132718Skan return true; 836169689Skan 837169689Skan if (t1 == NULL_TREE) /* T1 is ... */ 83890075Sobrien return t2 == NULL_TREE || !exact; 839169689Skan if (!TREE_VALUE (t1)) /* t1 is EMPTY */ 84090075Sobrien return t2 != NULL_TREE && !TREE_VALUE (t2); 841169689Skan if (t2 == NULL_TREE) /* T2 is ... */ 842132718Skan return false; 843117395Skan if (TREE_VALUE (t1) && !TREE_VALUE (t2)) /* T2 is EMPTY, T1 is not */ 84490075Sobrien return !exact; 845169689Skan 84690075Sobrien /* Neither set is ... or EMPTY, make sure each part of T2 is in T1. 84790075Sobrien Count how many we find, to determine exactness. For exact matching and 84890075Sobrien ordered T1, T2, this is an O(n) operation, otherwise its worst case is 84990075Sobrien O(nm). */ 85090075Sobrien for (base = t1; t2 != NULL_TREE; t2 = TREE_CHAIN (t2)) 85190075Sobrien { 85290075Sobrien for (probe = base; probe != NULL_TREE; probe = TREE_CHAIN (probe)) 853169689Skan { 854169689Skan tree a = TREE_VALUE (probe); 855169689Skan tree b = TREE_VALUE (t2); 856169689Skan 857169689Skan if (comp_except_types (a, b, exact)) 858169689Skan { 859169689Skan if (probe == base && exact) 860169689Skan base = TREE_CHAIN (probe); 861169689Skan length++; 862169689Skan break; 863169689Skan } 864169689Skan } 86590075Sobrien if (probe == NULL_TREE) 866169689Skan return false; 86790075Sobrien } 86890075Sobrien return !exact || base == NULL_TREE || length == list_length (t1); 86918334Speter} 87018334Speter 871132718Skan/* Compare the array types T1 and T2. ALLOW_REDECLARATION is true if 872132718Skan [] can match [size]. */ 87352284Sobrien 874132718Skanstatic bool 875132718Skancomp_array_types (tree t1, tree t2, bool allow_redeclaration) 87618334Speter{ 87752284Sobrien tree d1; 87852284Sobrien tree d2; 879132718Skan tree max1, max2; 88018334Speter 88152284Sobrien if (t1 == t2) 882132718Skan return true; 88352284Sobrien 88452284Sobrien /* The type of the array elements must be the same. */ 885132718Skan if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))) 886132718Skan return false; 88718334Speter 88852284Sobrien d1 = TYPE_DOMAIN (t1); 88952284Sobrien d2 = TYPE_DOMAIN (t2); 89052284Sobrien 89152284Sobrien if (d1 == d2) 892132718Skan return true; 89318334Speter 89452284Sobrien /* If one of the arrays is dimensionless, and the other has a 895117395Skan dimension, they are of different types. However, it is valid to 89652284Sobrien write: 89718334Speter 89852284Sobrien extern int a[]; 89952284Sobrien int a[3]; 90018334Speter 901169689Skan by [basic.link]: 90218334Speter 90352284Sobrien declarations for an array object can specify 90452284Sobrien array types that differ by the presence or absence of a major 90552284Sobrien array bound (_dcl.array_). */ 90652284Sobrien if (!d1 || !d2) 907132718Skan return allow_redeclaration; 90818334Speter 90952284Sobrien /* Check that the dimensions are the same. */ 91050397Sobrien 911132718Skan if (!cp_tree_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))) 912132718Skan return false; 913132718Skan max1 = TYPE_MAX_VALUE (d1); 914132718Skan max2 = TYPE_MAX_VALUE (d2); 915132718Skan if (processing_template_decl && !abi_version_at_least (2) 916132718Skan && !value_dependent_expression_p (max1) 917132718Skan && !value_dependent_expression_p (max2)) 918132718Skan { 919132718Skan /* With abi-1 we do not fold non-dependent array bounds, (and 920169689Skan consequently mangle them incorrectly). We must therefore 921169689Skan fold them here, to verify the domains have the same 922169689Skan value. */ 923132718Skan max1 = fold (max1); 924132718Skan max2 = fold (max2); 925132718Skan } 92652284Sobrien 927132718Skan if (!cp_tree_equal (max1, max2)) 928132718Skan return false; 92918334Speter 930132718Skan return true; 931132718Skan} 93252284Sobrien 933132718Skan/* Return true if T1 and T2 are related as allowed by STRICT. STRICT 934132718Skan is a bitwise-or of the COMPARE_* flags. */ 93552284Sobrien 936132718Skanbool 937132718Skancomptypes (tree t1, tree t2, int strict) 938132718Skan{ 93918334Speter if (t1 == t2) 940132718Skan return true; 94118334Speter 942132718Skan /* Suppress errors caused by previously reported errors. */ 943122180Skan if (t1 == error_mark_node || t2 == error_mark_node) 944132718Skan return false; 945169689Skan 946169689Skan gcc_assert (TYPE_P (t1) && TYPE_P (t2)); 947169689Skan 948132718Skan /* TYPENAME_TYPEs should be resolved if the qualifying scope is the 949132718Skan current instantiation. */ 950132718Skan if (TREE_CODE (t1) == TYPENAME_TYPE) 951132718Skan { 952132718Skan tree resolved = resolve_typename_type (t1, /*only_current_p=*/true); 95318334Speter 954132718Skan if (resolved != error_mark_node) 955132718Skan t1 = resolved; 956132718Skan } 957169689Skan 958132718Skan if (TREE_CODE (t2) == TYPENAME_TYPE) 959132718Skan { 960132718Skan tree resolved = resolve_typename_type (t2, /*only_current_p=*/true); 961132718Skan 962132718Skan if (resolved != error_mark_node) 963132718Skan t2 = resolved; 964132718Skan } 965132718Skan 966132718Skan /* If either type is the internal version of sizetype, use the 96790075Sobrien language version. */ 96890075Sobrien if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1) 969169689Skan && TYPE_ORIG_SIZE_TYPE (t1)) 970169689Skan t1 = TYPE_ORIG_SIZE_TYPE (t1); 97190075Sobrien 97290075Sobrien if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2) 973169689Skan && TYPE_ORIG_SIZE_TYPE (t2)) 974169689Skan t2 = TYPE_ORIG_SIZE_TYPE (t2); 97590075Sobrien 97650397Sobrien if (TYPE_PTRMEMFUNC_P (t1)) 97750397Sobrien t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1); 97850397Sobrien if (TYPE_PTRMEMFUNC_P (t2)) 97950397Sobrien t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2); 98050397Sobrien 98118334Speter /* Different classes of types can't be compatible. */ 98218334Speter if (TREE_CODE (t1) != TREE_CODE (t2)) 983132718Skan return false; 98418334Speter 985132718Skan /* Qualifiers must match. For array types, we will check when we 986132718Skan recur on the array element types. */ 987132718Skan if (TREE_CODE (t1) != ARRAY_TYPE 988132718Skan && TYPE_QUALS (t1) != TYPE_QUALS (t2)) 989132718Skan return false; 990132718Skan if (TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2)) 991132718Skan return false; 99218334Speter 99318334Speter /* Allow for two different type nodes which have essentially the same 99418334Speter definition. Note that we already checked for equality of the type 99550397Sobrien qualifiers (just above). */ 99618334Speter 997132718Skan if (TREE_CODE (t1) != ARRAY_TYPE 998132718Skan && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2)) 999132718Skan return true; 100018334Speter 1001169689Skan /* Compare the types. Break out if they could be the same. */ 100218334Speter switch (TREE_CODE (t1)) 100318334Speter { 100450397Sobrien case TEMPLATE_TEMPLATE_PARM: 100590075Sobrien case BOUND_TEMPLATE_TEMPLATE_PARM: 100650397Sobrien if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2) 100750397Sobrien || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2)) 1008132718Skan return false; 1009132718Skan if (!comp_template_parms 1010132718Skan (DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t1)), 1011132718Skan DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2)))) 1012132718Skan return false; 101390075Sobrien if (TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM) 1014169689Skan break; 101550397Sobrien /* Don't check inheritance. */ 101652284Sobrien strict = COMPARE_STRICT; 1017132718Skan /* Fall through. */ 101850397Sobrien 101918334Speter case RECORD_TYPE: 102018334Speter case UNION_TYPE: 102152284Sobrien if (TYPE_TEMPLATE_INFO (t1) && TYPE_TEMPLATE_INFO (t2) 102252284Sobrien && (TYPE_TI_TEMPLATE (t1) == TYPE_TI_TEMPLATE (t2) 1023132718Skan || TREE_CODE (t1) == BOUND_TEMPLATE_TEMPLATE_PARM) 1024132718Skan && comp_template_args (TYPE_TI_ARGS (t1), TYPE_TI_ARGS (t2))) 1025169689Skan break; 1026169689Skan 102752284Sobrien if ((strict & COMPARE_BASE) && DERIVED_FROM_P (t1, t2)) 1028169689Skan break; 1029132718Skan else if ((strict & COMPARE_DERIVED) && DERIVED_FROM_P (t2, t1)) 1030169689Skan break; 1031169689Skan 1032132718Skan return false; 103318334Speter 103418334Speter case OFFSET_TYPE: 1035132718Skan if (!comptypes (TYPE_OFFSET_BASETYPE (t1), TYPE_OFFSET_BASETYPE (t2), 1036132718Skan strict & ~COMPARE_REDECLARATION)) 1037132718Skan return false; 1038169689Skan if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))) 1039169689Skan return false; 1040169689Skan break; 104118334Speter 104218334Speter case POINTER_TYPE: 104318334Speter case REFERENCE_TYPE: 1044169689Skan if (TYPE_MODE (t1) != TYPE_MODE (t2) 1045169689Skan || TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2) 1046169689Skan || !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))) 1047169689Skan return false; 1048169689Skan break; 104918334Speter 105096263Sobrien case METHOD_TYPE: 105118334Speter case FUNCTION_TYPE: 1052132718Skan if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))) 1053132718Skan return false; 1054169689Skan if (!compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2))) 1055169689Skan return false; 1056169689Skan break; 105718334Speter 105818334Speter case ARRAY_TYPE: 1059132718Skan /* Target types must match incl. qualifiers. */ 1060169689Skan if (!comp_array_types (t1, t2, !!(strict & COMPARE_REDECLARATION))) 1061169689Skan return false; 1062169689Skan break; 106318334Speter 106418334Speter case TEMPLATE_TYPE_PARM: 1065169689Skan if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2) 1066169689Skan || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2)) 1067169689Skan return false; 1068169689Skan break; 106918334Speter 107050397Sobrien case TYPENAME_TYPE: 1071132718Skan if (!cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1), 1072132718Skan TYPENAME_TYPE_FULLNAME (t2))) 1073169689Skan return false; 1074169689Skan if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))) 1075169689Skan return false; 1076169689Skan break; 107750397Sobrien 107890075Sobrien case UNBOUND_CLASS_TEMPLATE: 1079132718Skan if (!cp_tree_equal (TYPE_IDENTIFIER (t1), TYPE_IDENTIFIER (t2))) 1080169689Skan return false; 1081169689Skan if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))) 1082169689Skan return false; 1083169689Skan break; 108490075Sobrien 108590075Sobrien case COMPLEX_TYPE: 1086169689Skan if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))) 1087169689Skan return false; 1088169689Skan break; 108990075Sobrien 1090169689Skan case VECTOR_TYPE: 1091169689Skan if (TYPE_VECTOR_SUBPARTS (t1) != TYPE_VECTOR_SUBPARTS (t2) 1092169689Skan || !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))) 1093169689Skan return false; 1094169689Skan break; 1095169689Skan 109650397Sobrien default: 1097169689Skan return false; 109818334Speter } 1099169689Skan 1100169689Skan /* If we get here, we know that from a target independent POV the 1101169689Skan types are the same. Make sure the target attributes are also 1102169689Skan the same. */ 1103169689Skan return targetm.comp_type_attributes (t1, t2); 110418334Speter} 110518334Speter 110652284Sobrien/* Returns 1 if TYPE1 is at least as qualified as TYPE2. */ 110752284Sobrien 1108132718Skanbool 1109132718Skanat_least_as_qualified_p (tree type1, tree type2) 111052284Sobrien{ 1111132718Skan int q1 = cp_type_quals (type1); 1112132718Skan int q2 = cp_type_quals (type2); 1113169689Skan 111452284Sobrien /* All qualifiers for TYPE2 must also appear in TYPE1. */ 1115132718Skan return (q1 & q2) == q2; 111652284Sobrien} 111752284Sobrien 111850397Sobrien/* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is 111950397Sobrien more cv-qualified that TYPE1, and 0 otherwise. */ 112050397Sobrien 112150397Sobrienint 1122132718Skancomp_cv_qualification (tree type1, tree type2) 112350397Sobrien{ 1124132718Skan int q1 = cp_type_quals (type1); 1125132718Skan int q2 = cp_type_quals (type2); 1126132718Skan 1127132718Skan if (q1 == q2) 112850397Sobrien return 0; 112950397Sobrien 1130132718Skan if ((q1 & q2) == q2) 113150397Sobrien return 1; 1132132718Skan else if ((q1 & q2) == q1) 113350397Sobrien return -1; 113450397Sobrien 113550397Sobrien return 0; 113650397Sobrien} 113750397Sobrien 113850397Sobrien/* Returns 1 if the cv-qualification signature of TYPE1 is a proper 113950397Sobrien subset of the cv-qualification signature of TYPE2, and the types 114050397Sobrien are similar. Returns -1 if the other way 'round, and 0 otherwise. */ 114150397Sobrien 114250397Sobrienint 1143132718Skancomp_cv_qual_signature (tree type1, tree type2) 114450397Sobrien{ 114550397Sobrien if (comp_ptr_ttypes_real (type2, type1, -1)) 114650397Sobrien return 1; 114750397Sobrien else if (comp_ptr_ttypes_real (type1, type2, -1)) 114850397Sobrien return -1; 114950397Sobrien else 115050397Sobrien return 0; 115150397Sobrien} 115250397Sobrien 115318334Speter/* If two types share a common base type, return that basetype. 115418334Speter If there is not a unique most-derived base type, this function 115518334Speter returns ERROR_MARK_NODE. */ 115650397Sobrien 115750397Sobrienstatic tree 1158132718Skancommon_base_type (tree tt1, tree tt2) 115918334Speter{ 116050397Sobrien tree best = NULL_TREE; 116118334Speter int i; 116218334Speter 116318334Speter /* If one is a baseclass of another, that's good enough. */ 116418334Speter if (UNIQUELY_DERIVED_FROM_P (tt1, tt2)) 116518334Speter return tt1; 116618334Speter if (UNIQUELY_DERIVED_FROM_P (tt2, tt1)) 116718334Speter return tt2; 116818334Speter 116918334Speter /* Otherwise, try to find a unique baseclass of TT1 117018334Speter that is shared by TT2, and follow that down. */ 1171169689Skan for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (tt1))-1; i >= 0; i--) 117218334Speter { 1173169689Skan tree basetype = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (tt1), i)); 117418334Speter tree trial = common_base_type (basetype, tt2); 1175169689Skan 117618334Speter if (trial) 117718334Speter { 117818334Speter if (trial == error_mark_node) 117918334Speter return trial; 118018334Speter if (best == NULL_TREE) 118118334Speter best = trial; 118218334Speter else if (best != trial) 118318334Speter return error_mark_node; 118418334Speter } 118518334Speter } 118618334Speter 118718334Speter /* Same for TT2. */ 1188169689Skan for (i = BINFO_N_BASE_BINFOS (TYPE_BINFO (tt2))-1; i >= 0; i--) 118918334Speter { 1190169689Skan tree basetype = BINFO_TYPE (BINFO_BASE_BINFO (TYPE_BINFO (tt2), i)); 119118334Speter tree trial = common_base_type (tt1, basetype); 1192169689Skan 119318334Speter if (trial) 119418334Speter { 119518334Speter if (trial == error_mark_node) 119618334Speter return trial; 119718334Speter if (best == NULL_TREE) 119818334Speter best = trial; 119918334Speter else if (best != trial) 120018334Speter return error_mark_node; 120118334Speter } 120218334Speter } 120318334Speter return best; 120418334Speter} 120518334Speter 120618334Speter/* Subroutines of `comptypes'. */ 120718334Speter 1208132718Skan/* Return true if two parameter type lists PARMS1 and PARMS2 are 120952284Sobrien equivalent in the sense that functions with those parameter types 121052284Sobrien can have equivalent types. The two lists must be equivalent, 1211132718Skan element by element. */ 121218334Speter 1213132718Skanbool 1214132718Skancompparms (tree parms1, tree parms2) 121518334Speter{ 1216132718Skan tree t1, t2; 121718334Speter 121818334Speter /* An unspecified parmlist matches any specified parmlist 121918334Speter whose argument types don't need default promotions. */ 122018334Speter 1221132718Skan for (t1 = parms1, t2 = parms2; 1222132718Skan t1 || t2; 1223132718Skan t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2)) 122418334Speter { 122518334Speter /* If one parmlist is shorter than the other, 122650397Sobrien they fail to match. */ 1227132718Skan if (!t1 || !t2) 1228132718Skan return false; 1229122180Skan if (!same_type_p (TREE_VALUE (t1), TREE_VALUE (t2))) 1230132718Skan return false; 123118334Speter } 1232132718Skan return true; 123318334Speter} 123418334Speter 1235132718Skan 1236132718Skan/* Process a sizeof or alignof expression where the operand is a 1237132718Skan type. */ 123850397Sobrien 123918334Spetertree 1240132718Skancxx_sizeof_or_alignof_type (tree type, enum tree_code op, bool complain) 124118334Speter{ 1242117395Skan tree value; 1243169689Skan bool dependent_p; 124418334Speter 1245169689Skan gcc_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR); 1246132718Skan if (type == error_mark_node) 1247132718Skan return error_mark_node; 1248132718Skan 1249132718Skan type = non_reference (type); 1250169689Skan if (TREE_CODE (type) == METHOD_TYPE) 125118334Speter { 1252117395Skan if (complain && (pedantic || warn_pointer_arith)) 1253169689Skan pedwarn ("invalid application of %qs to a member function", 1254169689Skan operator_name_info[(int) op].name); 1255117395Skan value = size_one_node; 125618334Speter } 125718334Speter 1258169689Skan dependent_p = dependent_type_p (type); 1259169689Skan if (!dependent_p) 1260169689Skan complete_type (type); 1261169689Skan if (dependent_p 1262169689Skan /* VLA types will have a non-constant size. In the body of an 1263169689Skan uninstantiated template, we don't need to try to compute the 1264169689Skan value, because the sizeof expression is not an integral 1265169689Skan constant expression in that case. And, if we do try to 1266169689Skan compute the value, we'll likely end up with SAVE_EXPRs, which 1267169689Skan the template substitution machinery does not expect to see. */ 1268169689Skan || (processing_template_decl 1269169689Skan && COMPLETE_TYPE_P (type) 1270169689Skan && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)) 1271169689Skan { 1272169689Skan value = build_min (op, size_type_node, type); 1273169689Skan TREE_READONLY (value) = 1; 1274169689Skan return value; 1275169689Skan } 1276169689Skan 1277169689Skan return c_sizeof_or_alignof_type (complete_type (type), 1278169689Skan op == SIZEOF_EXPR, 1279169689Skan complain); 128018334Speter} 128118334Speter 1282169689Skan/* Process a sizeof expression where the operand is an expression. */ 1283132718Skan 1284169689Skanstatic tree 1285169689Skancxx_sizeof_expr (tree e) 128650397Sobrien{ 1287132718Skan if (e == error_mark_node) 1288132718Skan return error_mark_node; 1289169689Skan 129050397Sobrien if (processing_template_decl) 1291132718Skan { 1292169689Skan e = build_min (SIZEOF_EXPR, size_type_node, e); 1293132718Skan TREE_SIDE_EFFECTS (e) = 0; 1294132718Skan TREE_READONLY (e) = 1; 1295169689Skan 1296132718Skan return e; 1297132718Skan } 1298169689Skan 129950397Sobrien if (TREE_CODE (e) == COMPONENT_REF 1300132718Skan && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL 130152284Sobrien && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1))) 130250397Sobrien { 1303169689Skan error ("invalid application of %<sizeof%> to a bit-field"); 1304132718Skan e = char_type_node; 130550397Sobrien } 1306132718Skan else if (is_overloaded_fn (e)) 1307132718Skan { 1308169689Skan pedwarn ("ISO C++ forbids applying %<sizeof%> to an expression of " 1309169689Skan "function type"); 1310132718Skan e = char_type_node; 1311132718Skan } 131252284Sobrien else if (type_unknown_p (e)) 131352284Sobrien { 1314117395Skan cxx_incomplete_type_error (e, TREE_TYPE (e)); 1315132718Skan e = char_type_node; 131652284Sobrien } 1317132718Skan else 1318132718Skan e = TREE_TYPE (e); 1319169689Skan 1320169689Skan return cxx_sizeof_or_alignof_type (e, SIZEOF_EXPR, true); 132150397Sobrien} 1322169689Skan 1323169689Skan/* Implement the __alignof keyword: Return the minimum required 1324169689Skan alignment of E, measured in bytes. For VAR_DECL's and 1325169689Skan FIELD_DECL's return DECL_ALIGN (which can be set from an 1326169689Skan "aligned" __attribute__ specification). */ 1327169689Skan 1328169689Skanstatic tree 1329169689Skancxx_alignof_expr (tree e) 1330169689Skan{ 1331169689Skan tree t; 1332169689Skan 1333169689Skan if (e == error_mark_node) 1334169689Skan return error_mark_node; 1335169689Skan 1336169689Skan if (processing_template_decl) 1337169689Skan { 1338169689Skan e = build_min (ALIGNOF_EXPR, size_type_node, e); 1339169689Skan TREE_SIDE_EFFECTS (e) = 0; 1340169689Skan TREE_READONLY (e) = 1; 1341169689Skan 1342169689Skan return e; 1343169689Skan } 1344169689Skan 1345169689Skan if (TREE_CODE (e) == VAR_DECL) 1346169689Skan t = size_int (DECL_ALIGN_UNIT (e)); 1347169689Skan else if (TREE_CODE (e) == COMPONENT_REF 1348169689Skan && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL 1349169689Skan && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1))) 1350169689Skan { 1351169689Skan error ("invalid application of %<__alignof%> to a bit-field"); 1352169689Skan t = size_one_node; 1353169689Skan } 1354169689Skan else if (TREE_CODE (e) == COMPONENT_REF 1355169689Skan && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL) 1356169689Skan t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (e, 1))); 1357169689Skan else if (is_overloaded_fn (e)) 1358169689Skan { 1359169689Skan pedwarn ("ISO C++ forbids applying %<__alignof%> to an expression of " 1360169689Skan "function type"); 1361169689Skan t = size_one_node; 1362169689Skan } 1363169689Skan else if (type_unknown_p (e)) 1364169689Skan { 1365169689Skan cxx_incomplete_type_error (e, TREE_TYPE (e)); 1366169689Skan t = size_one_node; 1367169689Skan } 1368169689Skan else 1369169689Skan return cxx_sizeof_or_alignof_type (TREE_TYPE (e), ALIGNOF_EXPR, true); 1370169689Skan 1371169689Skan return fold_convert (size_type_node, t); 1372169689Skan} 1373169689Skan 1374169689Skan/* Process a sizeof or alignof expression E with code OP where the operand 1375169689Skan is an expression. */ 1376169689Skan 1377169689Skantree 1378169689Skancxx_sizeof_or_alignof_expr (tree e, enum tree_code op) 1379169689Skan{ 1380169689Skan if (op == SIZEOF_EXPR) 1381169689Skan return cxx_sizeof_expr (e); 1382169689Skan else 1383169689Skan return cxx_alignof_expr (e); 1384169689Skan} 138518334Speter 1386132718Skan/* EXPR is being used in a context that is not a function call. 1387132718Skan Enforce: 138818334Speter 1389169689Skan [expr.ref] 139018334Speter 1391132718Skan The expression can be used only as the left-hand operand of a 1392169689Skan member function call. 1393132718Skan 1394132718Skan [expr.mptr.operator] 1395132718Skan 1396132718Skan If the result of .* or ->* is a function, then that result can be 1397169689Skan used only as the operand for the function call operator (). 1398132718Skan 1399132718Skan by issuing an error message if appropriate. Returns true iff EXPR 1400132718Skan violates these rules. */ 1401132718Skan 1402132718Skanbool 1403132718Skaninvalid_nonstatic_memfn_p (tree expr) 1404132718Skan{ 1405132718Skan if (TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE) 1406132718Skan { 1407132718Skan error ("invalid use of non-static member function"); 1408132718Skan return true; 1409132718Skan } 1410132718Skan return false; 1411132718Skan} 1412132718Skan 1413169689Skan/* If EXP is a reference to a bitfield, and the type of EXP does not 1414169689Skan match the declared type of the bitfield, return the declared type 1415169689Skan of the bitfield. Otherwise, return NULL_TREE. */ 1416169689Skan 1417169689Skantree 1418169689Skanis_bitfield_expr_with_lowered_type (tree exp) 1419169689Skan{ 1420169689Skan switch (TREE_CODE (exp)) 1421169689Skan { 1422169689Skan case COND_EXPR: 1423169689Skan if (!is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 1))) 1424169689Skan return NULL_TREE; 1425169689Skan return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 2)); 1426169689Skan 1427169689Skan case COMPOUND_EXPR: 1428169689Skan return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 1)); 1429169689Skan 1430169689Skan case MODIFY_EXPR: 1431169689Skan case SAVE_EXPR: 1432169689Skan return is_bitfield_expr_with_lowered_type (TREE_OPERAND (exp, 0)); 1433169689Skan 1434169689Skan case COMPONENT_REF: 1435169689Skan { 1436169689Skan tree field; 1437169689Skan 1438169689Skan field = TREE_OPERAND (exp, 1); 1439169689Skan if (TREE_CODE (field) != FIELD_DECL || !DECL_C_BIT_FIELD (field)) 1440169689Skan return NULL_TREE; 1441169689Skan if (same_type_ignoring_top_level_qualifiers_p 1442169689Skan (TREE_TYPE (exp), DECL_BIT_FIELD_TYPE (field))) 1443169689Skan return NULL_TREE; 1444169689Skan return DECL_BIT_FIELD_TYPE (field); 1445169689Skan } 1446169689Skan 1447169689Skan default: 1448169689Skan return NULL_TREE; 1449169689Skan } 1450169689Skan} 1451169689Skan 1452169689Skan/* Like is_bitfield_with_lowered_type, except that if EXP is not a 1453169689Skan bitfield with a lowered type, the type of EXP is returned, rather 1454169689Skan than NULL_TREE. */ 1455169689Skan 1456169689Skantree 1457169689Skanunlowered_expr_type (tree exp) 1458169689Skan{ 1459169689Skan tree type; 1460169689Skan 1461169689Skan type = is_bitfield_expr_with_lowered_type (exp); 1462169689Skan if (!type) 1463169689Skan type = TREE_TYPE (exp); 1464169689Skan 1465169689Skan return type; 1466169689Skan} 1467169689Skan 1468132718Skan/* Perform the conversions in [expr] that apply when an lvalue appears 1469132718Skan in an rvalue context: the lvalue-to-rvalue, array-to-pointer, and 1470169689Skan function-to-pointer conversions. In addition, manifest constants 1471169689Skan are replaced by their values, and bitfield references are converted 1472169689Skan to their declared types. 1473132718Skan 1474169689Skan Although the returned value is being used as an rvalue, this 1475169689Skan function does not wrap the returned expression in a 1476169689Skan NON_LVALUE_EXPR; the caller is expected to be mindful of the fact 1477169689Skan that the return value is no longer an lvalue. */ 1478132718Skan 147918334Spetertree 1480132718Skandecay_conversion (tree exp) 148118334Speter{ 1482132718Skan tree type; 1483132718Skan enum tree_code code; 148418334Speter 148552284Sobrien type = TREE_TYPE (exp); 148690075Sobrien if (type == error_mark_node) 148790075Sobrien return error_mark_node; 148890075Sobrien 148990075Sobrien if (type_unknown_p (exp)) 149090075Sobrien { 1491117395Skan cxx_incomplete_type_error (exp, TREE_TYPE (exp)); 149290075Sobrien return error_mark_node; 149390075Sobrien } 149418334Speter 1495169689Skan exp = decl_constant_value (exp); 1496169689Skan if (error_operand_p (exp)) 1497169689Skan return error_mark_node; 1498169689Skan 149918334Speter /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue. 150018334Speter Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */ 1501169689Skan code = TREE_CODE (type); 150218334Speter if (code == VOID_TYPE) 150318334Speter { 150418334Speter error ("void value not ignored as it ought to be"); 150518334Speter return error_mark_node; 150618334Speter } 1507132718Skan if (invalid_nonstatic_memfn_p (exp)) 1508132718Skan return error_mark_node; 150952284Sobrien if (code == FUNCTION_TYPE || is_overloaded_fn (exp)) 151052284Sobrien return build_unary_op (ADDR_EXPR, exp, 0); 151118334Speter if (code == ARRAY_TYPE) 151218334Speter { 1513132718Skan tree adr; 151418334Speter tree ptrtype; 151518334Speter 151618334Speter if (TREE_CODE (exp) == INDIRECT_REF) 1517169689Skan return build_nop (build_pointer_type (TREE_TYPE (type)), 1518132718Skan TREE_OPERAND (exp, 0)); 151918334Speter 152018334Speter if (TREE_CODE (exp) == COMPOUND_EXPR) 152118334Speter { 152218334Speter tree op1 = decay_conversion (TREE_OPERAND (exp, 1)); 1523169689Skan return build2 (COMPOUND_EXPR, TREE_TYPE (op1), 1524169689Skan TREE_OPERAND (exp, 0), op1); 152518334Speter } 152618334Speter 152718334Speter if (!lvalue_p (exp) 152818334Speter && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp))) 152918334Speter { 153018334Speter error ("invalid use of non-lvalue array"); 153118334Speter return error_mark_node; 153218334Speter } 153318334Speter 153452284Sobrien ptrtype = build_pointer_type (TREE_TYPE (type)); 153518334Speter 153618334Speter if (TREE_CODE (exp) == VAR_DECL) 153718334Speter { 1538117395Skan if (!cxx_mark_addressable (exp)) 153918334Speter return error_mark_node; 1540132718Skan adr = build_nop (ptrtype, build_address (exp)); 154118334Speter return adr; 154218334Speter } 154318334Speter /* This way is better for a COMPONENT_REF since it can 154418334Speter simplify the offset for a component. */ 154518334Speter adr = build_unary_op (ADDR_EXPR, exp, 1); 154650397Sobrien return cp_convert (ptrtype, adr); 154718334Speter } 154818334Speter 1549169689Skan /* If a bitfield is used in a context where integral promotion 1550169689Skan applies, then the caller is expected to have used 1551169689Skan default_conversion. That function promotes bitfields correctly 1552169689Skan before calling this function. At this point, if we have a 1553169689Skan bitfield referenced, we may assume that is not subject to 1554169689Skan promotion, and that, therefore, the type of the resulting rvalue 1555169689Skan is the declared type of the bitfield. */ 1556169689Skan exp = convert_bitfield_to_declared_type (exp); 155790075Sobrien 1558169689Skan /* We do not call rvalue() here because we do not want to wrap EXP 1559169689Skan in a NON_LVALUE_EXPR. */ 1560169689Skan 1561169689Skan /* [basic.lval] 1562169689Skan 1563169689Skan Non-class rvalues always have cv-unqualified types. */ 1564169689Skan type = TREE_TYPE (exp); 1565169689Skan if (!CLASS_TYPE_P (type) && cp_type_quals (type)) 1566169689Skan exp = build_nop (TYPE_MAIN_VARIANT (type), exp); 1567169689Skan 156818334Speter return exp; 156918334Speter} 157018334Speter 1571169689Skan/* Perform prepatory conversions, as part of the "usual arithmetic 1572169689Skan conversions". In particular, as per [expr]: 1573169689Skan 1574169689Skan Whenever an lvalue expression appears as an operand of an 1575169689Skan operator that expects the rvalue for that operand, the 1576169689Skan lvalue-to-rvalue, array-to-pointer, or function-to-pointer 1577169689Skan standard conversions are applied to convert the expression to an 1578169689Skan rvalue. 1579169689Skan 1580169689Skan In addition, we perform integral promotions here, as those are 1581169689Skan applied to both operands to a binary operator before determining 1582169689Skan what additional conversions should apply. */ 1583169689Skan 158418334Spetertree 1585132718Skandefault_conversion (tree exp) 158618334Speter{ 1587169689Skan /* Perform the integral promotions first so that bitfield 1588169689Skan expressions (which may promote to "int", even if the bitfield is 1589169689Skan declared "unsigned") are promoted correctly. */ 1590132718Skan if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (exp))) 1591132718Skan exp = perform_integral_promotions (exp); 1592169689Skan /* Perform the other conversions. */ 1593169689Skan exp = decay_conversion (exp); 159418334Speter 159518334Speter return exp; 159618334Speter} 159750397Sobrien 1598132718Skan/* EXPR is an expression with an integral or enumeration type. 1599132718Skan Perform the integral promotions in [conv.prom], and return the 1600132718Skan converted value. */ 1601132718Skan 1602132718Skantree 1603132718Skanperform_integral_promotions (tree expr) 1604132718Skan{ 1605132718Skan tree type; 1606132718Skan tree promoted_type; 1607132718Skan 1608169689Skan /* [conv.prom] 1609169689Skan 1610169689Skan If the bitfield has an enumerated type, it is treated as any 1611169689Skan other value of that type for promotion purposes. */ 1612169689Skan type = is_bitfield_expr_with_lowered_type (expr); 1613169689Skan if (!type || TREE_CODE (type) != ENUMERAL_TYPE) 1614169689Skan type = TREE_TYPE (expr); 1615169689Skan gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type)); 1616132718Skan promoted_type = type_promotes_to (type); 1617132718Skan if (type != promoted_type) 1618132718Skan expr = cp_convert (promoted_type, expr); 1619132718Skan return expr; 1620132718Skan} 1621132718Skan 162250397Sobrien/* Take the address of an inline function without setting TREE_ADDRESSABLE 162350397Sobrien or TREE_USED. */ 162450397Sobrien 162550397Sobrientree 1626132718Skaninline_conversion (tree exp) 162750397Sobrien{ 162850397Sobrien if (TREE_CODE (exp) == FUNCTION_DECL) 162952284Sobrien exp = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (exp)), exp); 163052284Sobrien 163152284Sobrien return exp; 163252284Sobrien} 163352284Sobrien 163452284Sobrien/* Returns nonzero iff exp is a STRING_CST or the result of applying 163552284Sobrien decay_conversion to one. */ 163652284Sobrien 163752284Sobrienint 1638132718Skanstring_conv_p (tree totype, tree exp, int warn) 163952284Sobrien{ 164052284Sobrien tree t; 164152284Sobrien 1642169689Skan if (TREE_CODE (totype) != POINTER_TYPE) 164352284Sobrien return 0; 164452284Sobrien 164552284Sobrien t = TREE_TYPE (totype); 164652284Sobrien if (!same_type_p (t, char_type_node) 164752284Sobrien && !same_type_p (t, wchar_type_node)) 164852284Sobrien return 0; 164952284Sobrien 165052284Sobrien if (TREE_CODE (exp) == STRING_CST) 165150397Sobrien { 165252284Sobrien /* Make sure that we don't try to convert between char and wchar_t. */ 165352284Sobrien if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp))), t)) 165452284Sobrien return 0; 165550397Sobrien } 165652284Sobrien else 165752284Sobrien { 165852284Sobrien /* Is this a string constant which has decayed to 'const char *'? */ 165952284Sobrien t = build_pointer_type (build_qualified_type (t, TYPE_QUAL_CONST)); 166052284Sobrien if (!same_type_p (TREE_TYPE (exp), t)) 166152284Sobrien return 0; 166252284Sobrien STRIP_NOPS (exp); 166352284Sobrien if (TREE_CODE (exp) != ADDR_EXPR 166452284Sobrien || TREE_CODE (TREE_OPERAND (exp, 0)) != STRING_CST) 166552284Sobrien return 0; 166652284Sobrien } 166752284Sobrien 166852284Sobrien /* This warning is not very useful, as it complains about printf. */ 1669169689Skan if (warn) 1670169689Skan warning (OPT_Wwrite_strings, 1671169689Skan "deprecated conversion from string constant to %qT", 1672169689Skan totype); 167352284Sobrien 167452284Sobrien return 1; 167550397Sobrien} 167618334Speter 167750397Sobrien/* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we 167850397Sobrien can, for example, use as an lvalue. This code used to be in 167950397Sobrien unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c' 168050397Sobrien expressions, where we're dealing with aggregates. But now it's again only 168150397Sobrien called from unary_complex_lvalue. The case (in particular) that led to 168250397Sobrien this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd 168350397Sobrien get it there. */ 168418334Speter 168550397Sobrienstatic tree 1686132718Skanrationalize_conditional_expr (enum tree_code code, tree t) 168750397Sobrien{ 168850397Sobrien /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that 168950397Sobrien the first operand is always the one to be used if both operands 169050397Sobrien are equal, so we know what conditional expression this used to be. */ 169150397Sobrien if (TREE_CODE (t) == MIN_EXPR || TREE_CODE (t) == MAX_EXPR) 169218334Speter { 1693169689Skan /* The following code is incorrect if either operand side-effects. */ 1694169689Skan gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0)) 1695169689Skan && !TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1))); 169650397Sobrien return 169750397Sobrien build_conditional_expr (build_x_binary_op ((TREE_CODE (t) == MIN_EXPR 169850397Sobrien ? LE_EXPR : GE_EXPR), 169950397Sobrien TREE_OPERAND (t, 0), 1700132718Skan TREE_OPERAND (t, 1), 1701132718Skan /*overloaded_p=*/NULL), 170250397Sobrien build_unary_op (code, TREE_OPERAND (t, 0), 0), 170350397Sobrien build_unary_op (code, TREE_OPERAND (t, 1), 0)); 170418334Speter } 170518334Speter 170650397Sobrien return 170750397Sobrien build_conditional_expr (TREE_OPERAND (t, 0), 170850397Sobrien build_unary_op (code, TREE_OPERAND (t, 1), 0), 170950397Sobrien build_unary_op (code, TREE_OPERAND (t, 2), 0)); 171050397Sobrien} 171118334Speter 171250397Sobrien/* Given the TYPE of an anonymous union field inside T, return the 171350397Sobrien FIELD_DECL for the field. If not found return NULL_TREE. Because 171450397Sobrien anonymous unions can nest, we must also search all anonymous unions 171550397Sobrien that are directly reachable. */ 171618334Speter 1717132718Skantree 1718132718Skanlookup_anon_field (tree t, tree type) 171950397Sobrien{ 172050397Sobrien tree field; 172118334Speter 172250397Sobrien for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field)) 172318334Speter { 172450397Sobrien if (TREE_STATIC (field)) 172550397Sobrien continue; 1726117395Skan if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field)) 172750397Sobrien continue; 172818334Speter 172950397Sobrien /* If we find it directly, return the field. */ 173050397Sobrien if (DECL_NAME (field) == NULL_TREE 173190075Sobrien && type == TYPE_MAIN_VARIANT (TREE_TYPE (field))) 173218334Speter { 173350397Sobrien return field; 173418334Speter } 173550397Sobrien 173650397Sobrien /* Otherwise, it could be nested, search harder. */ 173750397Sobrien if (DECL_NAME (field) == NULL_TREE 173890075Sobrien && ANON_AGGR_TYPE_P (TREE_TYPE (field))) 173918334Speter { 174050397Sobrien tree subfield = lookup_anon_field (TREE_TYPE (field), type); 174150397Sobrien if (subfield) 174250397Sobrien return subfield; 174318334Speter } 174418334Speter } 174550397Sobrien return NULL_TREE; 174618334Speter} 174718334Speter 1748117395Skan/* Build an expression representing OBJECT.MEMBER. OBJECT is an 1749117395Skan expression; MEMBER is a DECL or baselink. If ACCESS_PATH is 1750117395Skan non-NULL, it indicates the path to the base used to name MEMBER. 1751117395Skan If PRESERVE_REFERENCE is true, the expression returned will have 1752117395Skan REFERENCE_TYPE if the MEMBER does. Otherwise, the expression 1753169689Skan returned will have the type referred to by the reference. 175418334Speter 1755117395Skan This function does not perform access control; that is either done 1756117395Skan earlier by the parser when the name of MEMBER is resolved to MEMBER 1757117395Skan itself, or later when overload resolution selects one of the 1758117395Skan functions indicated by MEMBER. */ 1759117395Skan 176018334Spetertree 1761169689Skanbuild_class_member_access_expr (tree object, tree member, 1762117395Skan tree access_path, bool preserve_reference) 176318334Speter{ 1764117395Skan tree object_type; 1765117395Skan tree member_scope; 1766117395Skan tree result = NULL_TREE; 176718334Speter 1768169689Skan if (error_operand_p (object) || error_operand_p (member)) 176952284Sobrien return error_mark_node; 177050397Sobrien 1771169689Skan gcc_assert (DECL_P (member) || BASELINK_P (member)); 1772132718Skan 1773117395Skan /* [expr.ref] 177450397Sobrien 1775117395Skan The type of the first expression shall be "class object" (of a 1776117395Skan complete type). */ 1777117395Skan object_type = TREE_TYPE (object); 1778169689Skan if (!currently_open_class (object_type) 1779132718Skan && !complete_type_or_else (object_type, object)) 1780117395Skan return error_mark_node; 1781117395Skan if (!CLASS_TYPE_P (object_type)) 1782117395Skan { 1783169689Skan error ("request for member %qD in %qE, which is of non-class type %qT", 1784117395Skan member, object, object_type); 1785117395Skan return error_mark_node; 178618334Speter } 178718334Speter 1788117395Skan /* The standard does not seem to actually say that MEMBER must be a 1789117395Skan member of OBJECT_TYPE. However, that is clearly what is 1790117395Skan intended. */ 1791117395Skan if (DECL_P (member)) 179218334Speter { 1793117395Skan member_scope = DECL_CLASS_CONTEXT (member); 1794117395Skan mark_used (member); 1795117395Skan if (TREE_DEPRECATED (member)) 1796117395Skan warn_deprecated_use (member); 179718334Speter } 1798117395Skan else 1799117395Skan member_scope = BINFO_TYPE (BASELINK_BINFO (member)); 1800117395Skan /* If MEMBER is from an anonymous aggregate, MEMBER_SCOPE will 1801117395Skan presently be the anonymous union. Go outwards until we find a 1802117395Skan type related to OBJECT_TYPE. */ 1803117395Skan while (ANON_AGGR_TYPE_P (member_scope) 1804117395Skan && !same_type_ignoring_top_level_qualifiers_p (member_scope, 1805117395Skan object_type)) 1806117395Skan member_scope = TYPE_CONTEXT (member_scope); 1807117395Skan if (!member_scope || !DERIVED_FROM_P (member_scope, object_type)) 180850397Sobrien { 1809132718Skan if (TREE_CODE (member) == FIELD_DECL) 1810169689Skan error ("invalid use of nonstatic data member %qE", member); 1811132718Skan else 1812169689Skan error ("%qD is not a member of %qT", member, object_type); 1813117395Skan return error_mark_node; 181450397Sobrien } 181518334Speter 1816132718Skan /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into 1817132718Skan `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only an lvalue 1818132718Skan in the frontend; only _DECLs and _REFs are lvalues in the backend. */ 1819132718Skan { 1820132718Skan tree temp = unary_complex_lvalue (ADDR_EXPR, object); 1821132718Skan if (temp) 1822132718Skan object = build_indirect_ref (temp, NULL); 1823132718Skan } 1824132718Skan 1825117395Skan /* In [expr.ref], there is an explicit list of the valid choices for 1826117395Skan MEMBER. We check for each of those cases here. */ 1827117395Skan if (TREE_CODE (member) == VAR_DECL) 182818334Speter { 1829117395Skan /* A static data member. */ 1830117395Skan result = member; 1831117395Skan /* If OBJECT has side-effects, they are supposed to occur. */ 1832117395Skan if (TREE_SIDE_EFFECTS (object)) 1833169689Skan result = build2 (COMPOUND_EXPR, TREE_TYPE (result), object, result); 183418334Speter } 1835117395Skan else if (TREE_CODE (member) == FIELD_DECL) 183618334Speter { 1837117395Skan /* A non-static data member. */ 1838117395Skan bool null_object_p; 1839117395Skan int type_quals; 1840117395Skan tree member_type; 184118334Speter 1842117395Skan null_object_p = (TREE_CODE (object) == INDIRECT_REF 1843117395Skan && integer_zerop (TREE_OPERAND (object, 0))); 184418334Speter 1845117395Skan /* Convert OBJECT to the type of MEMBER. */ 1846117395Skan if (!same_type_p (TYPE_MAIN_VARIANT (object_type), 1847117395Skan TYPE_MAIN_VARIANT (member_scope))) 184818334Speter { 1849117395Skan tree binfo; 1850117395Skan base_kind kind; 1851117395Skan 1852117395Skan binfo = lookup_base (access_path ? access_path : object_type, 1853169689Skan member_scope, ba_unique, &kind); 1854117395Skan if (binfo == error_mark_node) 1855117395Skan return error_mark_node; 1856117395Skan 1857117395Skan /* It is invalid to try to get to a virtual base of a 1858117395Skan NULL object. The most common cause is invalid use of 1859117395Skan offsetof macro. */ 1860117395Skan if (null_object_p && kind == bk_via_virtual) 1861117395Skan { 1862169689Skan error ("invalid access to non-static data member %qD of " 1863169689Skan "NULL object", 1864117395Skan member); 1865169689Skan error ("(perhaps the %<offsetof%> macro was used incorrectly)"); 1866117395Skan return error_mark_node; 1867117395Skan } 1868117395Skan 1869117395Skan /* Convert to the base. */ 1870169689Skan object = build_base_path (PLUS_EXPR, object, binfo, 1871117395Skan /*nonnull=*/1); 1872117395Skan /* If we found the base successfully then we should be able 1873117395Skan to convert to it successfully. */ 1874169689Skan gcc_assert (object != error_mark_node); 187518334Speter } 1876117395Skan 1877117395Skan /* Complain about other invalid uses of offsetof, even though they will 1878117395Skan give the right answer. Note that we complain whether or not they 1879117395Skan actually used the offsetof macro, since there's no way to know at this 1880117395Skan point. So we just give a warning, instead of a pedwarn. */ 1881169689Skan /* Do not produce this warning for base class field references, because 1882169689Skan we know for a fact that didn't come from offsetof. This does occur 1883169689Skan in various testsuite cases where a null object is passed where a 1884169689Skan vtable access is required. */ 1885132718Skan if (null_object_p && warn_invalid_offsetof 1886169689Skan && CLASSTYPE_NON_POD_P (object_type) 1887169689Skan && !DECL_FIELD_IS_BASE (member) 1888169689Skan && !skip_evaluation) 188918334Speter { 1890169689Skan warning (0, "invalid access to non-static data member %qD of NULL object", 1891117395Skan member); 1892169689Skan warning (0, "(perhaps the %<offsetof%> macro was used incorrectly)"); 189318334Speter } 1894117395Skan 1895117395Skan /* If MEMBER is from an anonymous aggregate, we have converted 1896117395Skan OBJECT so that it refers to the class containing the 1897117395Skan anonymous union. Generate a reference to the anonymous union 1898117395Skan itself, and recur to find MEMBER. */ 1899117395Skan if (ANON_AGGR_TYPE_P (DECL_CONTEXT (member)) 1900117395Skan /* When this code is called from build_field_call, the 1901117395Skan object already has the type of the anonymous union. 1902117395Skan That is because the COMPONENT_REF was already 1903117395Skan constructed, and was then disassembled before calling 1904117395Skan build_field_call. After the function-call code is 1905117395Skan cleaned up, this waste can be eliminated. */ 1906169689Skan && (!same_type_ignoring_top_level_qualifiers_p 1907117395Skan (TREE_TYPE (object), DECL_CONTEXT (member)))) 1908117395Skan { 1909117395Skan tree anonymous_union; 1910117395Skan 1911117395Skan anonymous_union = lookup_anon_field (TREE_TYPE (object), 1912117395Skan DECL_CONTEXT (member)); 1913117395Skan object = build_class_member_access_expr (object, 1914117395Skan anonymous_union, 1915117395Skan /*access_path=*/NULL_TREE, 1916117395Skan preserve_reference); 1917117395Skan } 1918117395Skan 1919117395Skan /* Compute the type of the field, as described in [expr.ref]. */ 1920117395Skan type_quals = TYPE_UNQUALIFIED; 1921117395Skan member_type = TREE_TYPE (member); 1922117395Skan if (TREE_CODE (member_type) != REFERENCE_TYPE) 1923117395Skan { 1924169689Skan type_quals = (cp_type_quals (member_type) 1925117395Skan | cp_type_quals (object_type)); 1926169689Skan 1927117395Skan /* A field is const (volatile) if the enclosing object, or the 1928117395Skan field itself, is const (volatile). But, a mutable field is 1929117395Skan not const, even within a const object. */ 1930117395Skan if (DECL_MUTABLE_P (member)) 1931117395Skan type_quals &= ~TYPE_QUAL_CONST; 1932117395Skan member_type = cp_build_qualified_type (member_type, type_quals); 1933117395Skan } 1934117395Skan 1935169689Skan result = build3 (COMPONENT_REF, member_type, object, member, 1936169689Skan NULL_TREE); 1937169689Skan result = fold_if_not_in_template (result); 1938117395Skan 1939117395Skan /* Mark the expression const or volatile, as appropriate. Even 1940117395Skan though we've dealt with the type above, we still have to mark the 1941117395Skan expression itself. */ 1942117395Skan if (type_quals & TYPE_QUAL_CONST) 1943117395Skan TREE_READONLY (result) = 1; 1944169689Skan if (type_quals & TYPE_QUAL_VOLATILE) 1945117395Skan TREE_THIS_VOLATILE (result) = 1; 194618334Speter } 1947117395Skan else if (BASELINK_P (member)) 1948117395Skan { 1949117395Skan /* The member is a (possibly overloaded) member function. */ 1950117395Skan tree functions; 1951132718Skan tree type; 195218334Speter 1953117395Skan /* If the MEMBER is exactly one static member function, then we 1954117395Skan know the type of the expression. Otherwise, we must wait 1955117395Skan until overload resolution has been performed. */ 1956117395Skan functions = BASELINK_FUNCTIONS (member); 1957117395Skan if (TREE_CODE (functions) == FUNCTION_DECL 1958117395Skan && DECL_STATIC_FUNCTION_P (functions)) 1959132718Skan type = TREE_TYPE (functions); 1960117395Skan else 1961132718Skan type = unknown_type_node; 1962132718Skan /* Note that we do not convert OBJECT to the BASELINK_BINFO 1963132718Skan base. That will happen when the function is called. */ 1964169689Skan result = build3 (COMPONENT_REF, type, object, member, NULL_TREE); 1965117395Skan } 1966117395Skan else if (TREE_CODE (member) == CONST_DECL) 196750397Sobrien { 1968117395Skan /* The member is an enumerator. */ 1969117395Skan result = member; 1970117395Skan /* If OBJECT has side-effects, they are supposed to occur. */ 1971117395Skan if (TREE_SIDE_EFFECTS (object)) 1972169689Skan result = build2 (COMPOUND_EXPR, TREE_TYPE (result), 1973169689Skan object, result); 197450397Sobrien } 1975117395Skan else 197690075Sobrien { 1977169689Skan error ("invalid use of %qD", member); 197890075Sobrien return error_mark_node; 197990075Sobrien } 198018334Speter 1981117395Skan if (!preserve_reference) 1982117395Skan /* [expr.ref] 1983169689Skan 1984117395Skan If E2 is declared to have type "reference to T", then ... the 1985117395Skan type of E1.E2 is T. */ 1986117395Skan result = convert_from_reference (result); 198752284Sobrien 1988117395Skan return result; 1989117395Skan} 199018334Speter 1991132718Skan/* Return the destructor denoted by OBJECT.SCOPE::~DTOR_NAME, or, if 1992132718Skan SCOPE is NULL, by OBJECT.~DTOR_NAME. */ 1993132718Skan 1994132718Skanstatic tree 1995132718Skanlookup_destructor (tree object, tree scope, tree dtor_name) 1996132718Skan{ 1997132718Skan tree object_type = TREE_TYPE (object); 1998132718Skan tree dtor_type = TREE_OPERAND (dtor_name, 0); 1999132718Skan tree expr; 2000132718Skan 2001169689Skan if (scope && !check_dtor_name (scope, dtor_type)) 2002132718Skan { 2003169689Skan error ("qualified type %qT does not match destructor name ~%qT", 2004132718Skan scope, dtor_type); 2005132718Skan return error_mark_node; 2006132718Skan } 2007132718Skan if (!DERIVED_FROM_P (dtor_type, TYPE_MAIN_VARIANT (object_type))) 2008132718Skan { 2009169689Skan error ("the type being destroyed is %qT, but the destructor refers to %qT", 2010132718Skan TYPE_MAIN_VARIANT (object_type), dtor_type); 2011132718Skan return error_mark_node; 2012132718Skan } 2013132718Skan expr = lookup_member (dtor_type, complete_dtor_identifier, 2014132718Skan /*protect=*/1, /*want_type=*/false); 2015132718Skan expr = (adjust_result_of_qualified_name_lookup 2016132718Skan (expr, dtor_type, object_type)); 2017132718Skan return expr; 2018132718Skan} 2019132718Skan 2020169689Skan/* An expression of the form "A::template B" has been resolved to 2021169689Skan DECL. Issue a diagnostic if B is not a template or template 2022169689Skan specialization. */ 2023169689Skan 2024169689Skanvoid 2025169689Skancheck_template_keyword (tree decl) 2026169689Skan{ 2027169689Skan /* The standard says: 2028169689Skan 2029169689Skan [temp.names] 2030169689Skan 2031169689Skan If a name prefixed by the keyword template is not a member 2032169689Skan template, the program is ill-formed. 2033169689Skan 2034169689Skan DR 228 removed the restriction that the template be a member 2035169689Skan template. 2036169689Skan 2037169689Skan DR 96, if accepted would add the further restriction that explicit 2038169689Skan template arguments must be provided if the template keyword is 2039169689Skan used, but, as of 2005-10-16, that DR is still in "drafting". If 2040169689Skan this DR is accepted, then the semantic checks here can be 2041169689Skan simplified, as the entity named must in fact be a template 2042169689Skan specialization, rather than, as at present, a set of overloaded 2043169689Skan functions containing at least one template function. */ 2044169689Skan if (TREE_CODE (decl) != TEMPLATE_DECL 2045169689Skan && TREE_CODE (decl) != TEMPLATE_ID_EXPR) 2046169689Skan { 2047169689Skan if (!is_overloaded_fn (decl)) 2048169689Skan pedwarn ("%qD is not a template", decl); 2049169689Skan else 2050169689Skan { 2051169689Skan tree fns; 2052169689Skan fns = decl; 2053169689Skan if (BASELINK_P (fns)) 2054169689Skan fns = BASELINK_FUNCTIONS (fns); 2055169689Skan while (fns) 2056169689Skan { 2057169689Skan tree fn = OVL_CURRENT (fns); 2058169689Skan if (TREE_CODE (fn) == TEMPLATE_DECL 2059169689Skan || TREE_CODE (fn) == TEMPLATE_ID_EXPR) 2060169689Skan break; 2061169689Skan if (TREE_CODE (fn) == FUNCTION_DECL 2062169689Skan && DECL_USE_TEMPLATE (fn) 2063169689Skan && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (fn))) 2064169689Skan break; 2065169689Skan fns = OVL_NEXT (fns); 2066169689Skan } 2067169689Skan if (!fns) 2068169689Skan pedwarn ("%qD is not a template", decl); 2069169689Skan } 2070169689Skan } 2071169689Skan} 2072169689Skan 2073117395Skan/* This function is called by the parser to process a class member 2074117395Skan access expression of the form OBJECT.NAME. NAME is a node used by 2075117395Skan the parser to represent a name; it is not yet a DECL. It may, 2076117395Skan however, be a BASELINK where the BASELINK_FUNCTIONS is a 2077117395Skan TEMPLATE_ID_EXPR. Templates must be looked up by the parser, and 2078117395Skan there is no reason to do the lookup twice, so the parser keeps the 2079169689Skan BASELINK. TEMPLATE_P is true iff NAME was explicitly declared to 2080169689Skan be a template via the use of the "A::template B" syntax. */ 208118334Speter 2082117395Skantree 2083169689Skanfinish_class_member_access_expr (tree object, tree name, bool template_p) 2084117395Skan{ 2085132718Skan tree expr; 2086117395Skan tree object_type; 2087117395Skan tree member; 2088117395Skan tree access_path = NULL_TREE; 2089132718Skan tree orig_object = object; 2090132718Skan tree orig_name = name; 209118334Speter 2092117395Skan if (object == error_mark_node || name == error_mark_node) 2093117395Skan return error_mark_node; 209490075Sobrien 2095169689Skan /* If OBJECT is an ObjC class instance, we must obey ObjC access rules. */ 2096169689Skan if (!objc_is_public (object, name)) 2097169689Skan return error_mark_node; 2098169689Skan 2099132718Skan object_type = TREE_TYPE (object); 2100132718Skan 2101117395Skan if (processing_template_decl) 2102132718Skan { 2103132718Skan if (/* If OBJECT_TYPE is dependent, so is OBJECT.NAME. */ 2104132718Skan dependent_type_p (object_type) 2105132718Skan /* If NAME is just an IDENTIFIER_NODE, then the expression 2106132718Skan is dependent. */ 2107132718Skan || TREE_CODE (object) == IDENTIFIER_NODE 2108132718Skan /* If NAME is "f<args>", where either 'f' or 'args' is 2109132718Skan dependent, then the expression is dependent. */ 2110132718Skan || (TREE_CODE (name) == TEMPLATE_ID_EXPR 2111132718Skan && dependent_template_id_p (TREE_OPERAND (name, 0), 2112132718Skan TREE_OPERAND (name, 1))) 2113132718Skan /* If NAME is "T::X" where "T" is dependent, then the 2114132718Skan expression is dependent. */ 2115132718Skan || (TREE_CODE (name) == SCOPE_REF 2116132718Skan && TYPE_P (TREE_OPERAND (name, 0)) 2117132718Skan && dependent_type_p (TREE_OPERAND (name, 0)))) 2118169689Skan return build_min_nt (COMPONENT_REF, object, name, NULL_TREE); 2119132718Skan object = build_non_dependent_expr (object); 2120132718Skan } 212118334Speter 2122117395Skan /* [expr.ref] 212390075Sobrien 2124117395Skan The type of the first expression shall be "class object" (of a 2125117395Skan complete type). */ 2126169689Skan if (!currently_open_class (object_type) 2127132718Skan && !complete_type_or_else (object_type, object)) 2128117395Skan return error_mark_node; 2129117395Skan if (!CLASS_TYPE_P (object_type)) 2130117395Skan { 2131169689Skan error ("request for member %qD in %qE, which is of non-class type %qT", 2132117395Skan name, object, object_type); 2133117395Skan return error_mark_node; 2134117395Skan } 213596263Sobrien 2136117395Skan if (BASELINK_P (name)) 2137169689Skan /* A member function that has already been looked up. */ 2138169689Skan member = name; 2139117395Skan else 2140117395Skan { 2141117395Skan bool is_template_id = false; 2142117395Skan tree template_args = NULL_TREE; 2143132718Skan tree scope; 214450397Sobrien 2145117395Skan if (TREE_CODE (name) == TEMPLATE_ID_EXPR) 214650397Sobrien { 2147117395Skan is_template_id = true; 2148117395Skan template_args = TREE_OPERAND (name, 1); 2149117395Skan name = TREE_OPERAND (name, 0); 2150132718Skan 2151132718Skan if (TREE_CODE (name) == OVERLOAD) 2152132718Skan name = DECL_NAME (get_first_fn (name)); 2153132718Skan else if (DECL_P (name)) 2154132718Skan name = DECL_NAME (name); 2155117395Skan } 215696263Sobrien 2157117395Skan if (TREE_CODE (name) == SCOPE_REF) 2158117395Skan { 2159169689Skan /* A qualified name. The qualifying class or namespace `S' 2160169689Skan has already been looked up; it is either a TYPE or a 2161169689Skan NAMESPACE_DECL. */ 2162117395Skan scope = TREE_OPERAND (name, 0); 2163117395Skan name = TREE_OPERAND (name, 1); 2164117395Skan 2165117395Skan /* If SCOPE is a namespace, then the qualified name does not 2166117395Skan name a member of OBJECT_TYPE. */ 2167117395Skan if (TREE_CODE (scope) == NAMESPACE_DECL) 216850397Sobrien { 2169169689Skan error ("%<%D::%D%> is not a member of %qT", 2170117395Skan scope, name, object_type); 217150397Sobrien return error_mark_node; 217250397Sobrien } 2173117395Skan 2174169689Skan gcc_assert (CLASS_TYPE_P (scope)); 2175169689Skan gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE 2176169689Skan || TREE_CODE (name) == BIT_NOT_EXPR); 2177169689Skan 2178117395Skan /* Find the base of OBJECT_TYPE corresponding to SCOPE. */ 2179117395Skan access_path = lookup_base (object_type, scope, ba_check, NULL); 2180122180Skan if (access_path == error_mark_node) 218190075Sobrien return error_mark_node; 2182122180Skan if (!access_path) 2183122180Skan { 2184169689Skan error ("%qT is not a base of %qT", scope, object_type); 2185122180Skan return error_mark_node; 2186122180Skan } 218750397Sobrien } 2188132718Skan else 218950397Sobrien { 2190132718Skan scope = NULL_TREE; 2191132718Skan access_path = object_type; 219250397Sobrien } 2193132718Skan 2194132718Skan if (TREE_CODE (name) == BIT_NOT_EXPR) 2195132718Skan member = lookup_destructor (object, scope, name); 2196132718Skan else 2197117395Skan { 2198132718Skan /* Look up the member. */ 2199169689Skan member = lookup_member (access_path, name, /*protect=*/1, 2200132718Skan /*want_type=*/false); 2201117395Skan if (member == NULL_TREE) 2202117395Skan { 2203169689Skan error ("%qD has no member named %qE", object_type, name); 2204117395Skan return error_mark_node; 2205117395Skan } 2206132718Skan if (member == error_mark_node) 2207117395Skan return error_mark_node; 2208117395Skan } 2209169689Skan 2210117395Skan if (is_template_id) 2211117395Skan { 2212117395Skan tree template = member; 2213169689Skan 2214117395Skan if (BASELINK_P (template)) 2215132718Skan template = lookup_template_function (template, template_args); 2216117395Skan else 2217117395Skan { 2218169689Skan error ("%qD is not a member template function", name); 2219117395Skan return error_mark_node; 2220117395Skan } 2221117395Skan } 222218334Speter } 222350397Sobrien 2224132718Skan if (TREE_DEPRECATED (member)) 2225132718Skan warn_deprecated_use (member); 2226132718Skan 2227169689Skan if (template_p) 2228169689Skan check_template_keyword (member); 2229169689Skan 2230132718Skan expr = build_class_member_access_expr (object, member, access_path, 2231117395Skan /*preserve_reference=*/false); 2232132718Skan if (processing_template_decl && expr != error_mark_node) 2233169689Skan { 2234169689Skan if (BASELINK_P (member)) 2235169689Skan { 2236169689Skan if (TREE_CODE (orig_name) == SCOPE_REF) 2237169689Skan BASELINK_QUALIFIED_P (member) = 1; 2238169689Skan orig_name = member; 2239169689Skan } 2240169689Skan return build_min_non_dep (COMPONENT_REF, expr, 2241169689Skan orig_object, orig_name, 2242169689Skan NULL_TREE); 2243169689Skan } 2244169689Skan 2245132718Skan return expr; 224618334Speter} 224750397Sobrien 2248117395Skan/* Return an expression for the MEMBER_NAME field in the internal 2249117395Skan representation of PTRMEM, a pointer-to-member function. (Each 2250117395Skan pointer-to-member function type gets its own RECORD_TYPE so it is 2251117395Skan more convenient to access the fields by name than by FIELD_DECL.) 2252117395Skan This routine converts the NAME to a FIELD_DECL and then creates the 2253117395Skan node for the complete expression. */ 225450397Sobrien 225550397Sobrientree 2256117395Skanbuild_ptrmemfunc_access_expr (tree ptrmem, tree member_name) 225750397Sobrien{ 2258117395Skan tree ptrmem_type; 2259117395Skan tree member; 2260117395Skan tree member_type; 226150397Sobrien 2262117395Skan /* This code is a stripped down version of 2263117395Skan build_class_member_access_expr. It does not work to use that 2264117395Skan routine directly because it expects the object to be of class 2265117395Skan type. */ 2266117395Skan ptrmem_type = TREE_TYPE (ptrmem); 2267169689Skan gcc_assert (TYPE_PTRMEMFUNC_P (ptrmem_type)); 2268117395Skan member = lookup_member (ptrmem_type, member_name, /*protect=*/0, 2269132718Skan /*want_type=*/false); 2270117395Skan member_type = cp_build_qualified_type (TREE_TYPE (member), 2271117395Skan cp_type_quals (ptrmem_type)); 2272169689Skan return fold_build3 (COMPONENT_REF, member_type, 2273169689Skan ptrmem, member, NULL_TREE); 2274117395Skan} 227550397Sobrien 227618334Speter/* Given an expression PTR for a pointer, return an expression 227718334Speter for the value pointed to. 227818334Speter ERRORSTRING is the name of the operator to appear in error messages. 227918334Speter 228018334Speter This function may need to overload OPERATOR_FNNAME. 228118334Speter Must also handle REFERENCE_TYPEs for C++. */ 228218334Speter 228318334Spetertree 2284132718Skanbuild_x_indirect_ref (tree expr, const char *errorstring) 228518334Speter{ 2286132718Skan tree orig_expr = expr; 228750397Sobrien tree rval; 228850397Sobrien 228950397Sobrien if (processing_template_decl) 2290132718Skan { 2291132718Skan if (type_dependent_expression_p (expr)) 2292132718Skan return build_min_nt (INDIRECT_REF, expr); 2293132718Skan expr = build_non_dependent_expr (expr); 2294132718Skan } 229550397Sobrien 2296132718Skan rval = build_new_op (INDIRECT_REF, LOOKUP_NORMAL, expr, NULL_TREE, 2297132718Skan NULL_TREE, /*overloaded_p=*/NULL); 2298132718Skan if (!rval) 2299132718Skan rval = build_indirect_ref (expr, errorstring); 2300132718Skan 2301132718Skan if (processing_template_decl && rval != error_mark_node) 2302132718Skan return build_min_non_dep (INDIRECT_REF, rval, orig_expr); 2303132718Skan else 230418334Speter return rval; 230518334Speter} 230618334Speter 230718334Spetertree 2308132718Skanbuild_indirect_ref (tree ptr, const char *errorstring) 230918334Speter{ 2310132718Skan tree pointer, type; 231118334Speter 231250397Sobrien if (ptr == error_mark_node) 231350397Sobrien return error_mark_node; 231418334Speter 231552284Sobrien if (ptr == current_class_ptr) 231652284Sobrien return current_class_ref; 231752284Sobrien 231850397Sobrien pointer = (TREE_CODE (TREE_TYPE (ptr)) == REFERENCE_TYPE 2319132718Skan ? ptr : decay_conversion (ptr)); 232050397Sobrien type = TREE_TYPE (pointer); 232118334Speter 2322169689Skan if (POINTER_TYPE_P (type)) 232352284Sobrien { 232452284Sobrien /* [expr.unary.op] 2325169689Skan 232652284Sobrien If the type of the expression is "pointer to T," the type 2327169689Skan of the result is "T." 232818334Speter 2329169689Skan We must use the canonical variant because certain parts of 233052284Sobrien the back end, like fold, do pointer comparisons between 233152284Sobrien types. */ 233252284Sobrien tree t = canonical_type_variant (TREE_TYPE (type)); 233352284Sobrien 233490075Sobrien if (VOID_TYPE_P (t)) 2335169689Skan { 2336169689Skan /* A pointer to incomplete type (other than cv void) can be 2337169689Skan dereferenced [expr.unary.op]/1 */ 2338169689Skan error ("%qT is not a pointer-to-object type", type); 2339169689Skan return error_mark_node; 2340169689Skan } 234190075Sobrien else if (TREE_CODE (pointer) == ADDR_EXPR 2342117395Skan && same_type_p (t, TREE_TYPE (TREE_OPERAND (pointer, 0)))) 234352284Sobrien /* The POINTER was something like `&x'. We simplify `*&x' to 234452284Sobrien `x'. */ 234518334Speter return TREE_OPERAND (pointer, 0); 234618334Speter else 234718334Speter { 234852284Sobrien tree ref = build1 (INDIRECT_REF, t, pointer); 234918334Speter 235050397Sobrien /* We *must* set TREE_READONLY when dereferencing a pointer to const, 235150397Sobrien so that we get the proper error message if the result is used 235250397Sobrien to assign to. Also, &* is supposed to be a no-op. */ 235352284Sobrien TREE_READONLY (ref) = CP_TYPE_CONST_P (t); 235452284Sobrien TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t); 235550397Sobrien TREE_SIDE_EFFECTS (ref) 2356132718Skan = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (pointer)); 235718334Speter return ref; 235818334Speter } 235918334Speter } 236018334Speter /* `pointer' won't be an error_mark_node if we were given a 236118334Speter pointer to member, so it's cool to check for this here. */ 2362132718Skan else if (TYPE_PTR_TO_MEMBER_P (type)) 2363169689Skan error ("invalid use of %qs on pointer to member", errorstring); 236418334Speter else if (pointer != error_mark_node) 236518334Speter { 236618334Speter if (errorstring) 2367169689Skan error ("invalid type argument of %qs", errorstring); 236818334Speter else 236918334Speter error ("invalid type argument"); 237018334Speter } 237118334Speter return error_mark_node; 237218334Speter} 237318334Speter 237418334Speter/* This handles expressions of the form "a[i]", which denotes 237518334Speter an array reference. 237618334Speter 237718334Speter This is logically equivalent in C to *(a+i), but we may do it differently. 237818334Speter If A is a variable or a member, we generate a primitive ARRAY_REF. 237918334Speter This avoids forcing the array out of registers, and can work on 238018334Speter arrays that are not lvalues (for example, members of structures returned 238118334Speter by functions). 238218334Speter 238318334Speter If INDEX is of some user-defined type, it must be converted to 238418334Speter integer type. Otherwise, to make a compatible PLUS_EXPR, it 238518334Speter will inherit the type of the array, which will be some pointer type. */ 238618334Speter 238718334Spetertree 2388132718Skanbuild_array_ref (tree array, tree idx) 238918334Speter{ 239018334Speter if (idx == 0) 239118334Speter { 239218334Speter error ("subscript missing in array reference"); 239318334Speter return error_mark_node; 239418334Speter } 239518334Speter 239618334Speter if (TREE_TYPE (array) == error_mark_node 239718334Speter || TREE_TYPE (idx) == error_mark_node) 239818334Speter return error_mark_node; 239918334Speter 240090075Sobrien /* If ARRAY is a COMPOUND_EXPR or COND_EXPR, move our reference 240190075Sobrien inside it. */ 240290075Sobrien switch (TREE_CODE (array)) 240390075Sobrien { 240490075Sobrien case COMPOUND_EXPR: 240590075Sobrien { 240690075Sobrien tree value = build_array_ref (TREE_OPERAND (array, 1), idx); 2407169689Skan return build2 (COMPOUND_EXPR, TREE_TYPE (value), 2408169689Skan TREE_OPERAND (array, 0), value); 240990075Sobrien } 241090075Sobrien 241190075Sobrien case COND_EXPR: 241290075Sobrien return build_conditional_expr 241390075Sobrien (TREE_OPERAND (array, 0), 241490075Sobrien build_array_ref (TREE_OPERAND (array, 1), idx), 241590075Sobrien build_array_ref (TREE_OPERAND (array, 2), idx)); 241690075Sobrien 241790075Sobrien default: 241890075Sobrien break; 241990075Sobrien } 242090075Sobrien 2421169689Skan if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE) 242218334Speter { 242318334Speter tree rval, type; 242418334Speter 2425169689Skan warn_array_subscript_with_type_char (idx); 242618334Speter 2427132718Skan if (!INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (idx))) 242818334Speter { 242918334Speter error ("array subscript is not an integer"); 243018334Speter return error_mark_node; 243118334Speter } 243218334Speter 2433132718Skan /* Apply integral promotions *after* noticing character types. 2434132718Skan (It is unclear why we do these promotions -- the standard 2435169689Skan does not say that we should. In fact, the natural thing would 2436132718Skan seem to be to convert IDX to ptrdiff_t; we're performing 2437132718Skan pointer arithmetic.) */ 2438132718Skan idx = perform_integral_promotions (idx); 2439132718Skan 244018334Speter /* An array that is indexed by a non-constant 244118334Speter cannot be stored in a register; we must be able to do 244218334Speter address arithmetic on its address. 244318334Speter Likewise an array of elements of variable size. */ 244418334Speter if (TREE_CODE (idx) != INTEGER_CST 244590075Sobrien || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array))) 244650397Sobrien && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) 244750397Sobrien != INTEGER_CST))) 244818334Speter { 2449117395Skan if (!cxx_mark_addressable (array)) 245018334Speter return error_mark_node; 245118334Speter } 245290075Sobrien 245318334Speter /* An array that is indexed by a constant value which is not within 245418334Speter the array bounds cannot be stored in a register either; because we 245518334Speter would get a crash in store_bit_field/extract_bit_field when trying 245618334Speter to access a non-existent part of the register. */ 245718334Speter if (TREE_CODE (idx) == INTEGER_CST 2458169689Skan && TYPE_DOMAIN (TREE_TYPE (array)) 2459169689Skan && ! int_fits_type_p (idx, TYPE_DOMAIN (TREE_TYPE (array)))) 246018334Speter { 2461117395Skan if (!cxx_mark_addressable (array)) 246218334Speter return error_mark_node; 246318334Speter } 246418334Speter 246518334Speter if (pedantic && !lvalue_p (array)) 246690075Sobrien pedwarn ("ISO C++ forbids subscripting non-lvalue array"); 246718334Speter 246818334Speter /* Note in C++ it is valid to subscript a `register' array, since 246918334Speter it is valid to take the address of something with that 247018334Speter storage specification. */ 247118334Speter if (extra_warnings) 247218334Speter { 247318334Speter tree foo = array; 247418334Speter while (TREE_CODE (foo) == COMPONENT_REF) 247518334Speter foo = TREE_OPERAND (foo, 0); 247618334Speter if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo)) 2477169689Skan warning (OPT_Wextra, "subscripting array declared %<register%>"); 247818334Speter } 247918334Speter 248052284Sobrien type = TREE_TYPE (TREE_TYPE (array)); 2481169689Skan rval = build4 (ARRAY_REF, type, array, idx, NULL_TREE, NULL_TREE); 248218334Speter /* Array ref is const/volatile if the array elements are 248318334Speter or if the array is.. */ 248418334Speter TREE_READONLY (rval) 248552284Sobrien |= (CP_TYPE_CONST_P (type) | TREE_READONLY (array)); 248618334Speter TREE_SIDE_EFFECTS (rval) 248752284Sobrien |= (CP_TYPE_VOLATILE_P (type) | TREE_SIDE_EFFECTS (array)); 248818334Speter TREE_THIS_VOLATILE (rval) 248952284Sobrien |= (CP_TYPE_VOLATILE_P (type) | TREE_THIS_VOLATILE (array)); 2490169689Skan return require_complete_type (fold_if_not_in_template (rval)); 249118334Speter } 249218334Speter 249318334Speter { 249418334Speter tree ar = default_conversion (array); 249518334Speter tree ind = default_conversion (idx); 249618334Speter 249718334Speter /* Put the integer in IND to simplify error checking. */ 249818334Speter if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE) 249918334Speter { 250018334Speter tree temp = ar; 250118334Speter ar = ind; 250218334Speter ind = temp; 250318334Speter } 250418334Speter 250518334Speter if (ar == error_mark_node) 250618334Speter return ar; 250718334Speter 250818334Speter if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE) 250918334Speter { 251018334Speter error ("subscripted value is neither array nor pointer"); 251118334Speter return error_mark_node; 251218334Speter } 251318334Speter if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE) 251418334Speter { 251518334Speter error ("array subscript is not an integer"); 251618334Speter return error_mark_node; 251718334Speter } 251818334Speter 251990075Sobrien return build_indirect_ref (cp_build_binary_op (PLUS_EXPR, ar, ind), 252018334Speter "array indexing"); 252118334Speter } 252218334Speter} 252318334Speter 2524117395Skan/* Resolve a pointer to member function. INSTANCE is the object 2525117395Skan instance to use, if the member points to a virtual member. 252618334Speter 2527117395Skan This used to avoid checking for virtual functions if basetype 2528117395Skan has no virtual functions, according to an earlier ANSI draft. 2529117395Skan With the final ISO C++ rules, such an optimization is 2530117395Skan incorrect: A pointer to a derived member can be static_cast 2531117395Skan to pointer-to-base-member, as long as the dynamic object 2532117395Skan later has the right member. */ 253318334Speter 253418334Spetertree 2535132718Skanget_member_function_from_ptrfunc (tree *instance_ptrptr, tree function) 253618334Speter{ 253718334Speter if (TREE_CODE (function) == OFFSET_REF) 253890075Sobrien function = TREE_OPERAND (function, 1); 253918334Speter 254018334Speter if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function))) 254118334Speter { 2542117395Skan tree idx, delta, e1, e2, e3, vtbl, basetype; 2543117395Skan tree fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function)); 254418334Speter 254518334Speter tree instance_ptr = *instance_ptrptr; 2546117395Skan tree instance_save_expr = 0; 2547117395Skan if (instance_ptr == error_mark_node) 254890075Sobrien { 2549117395Skan if (TREE_CODE (function) == PTRMEM_CST) 2550117395Skan { 2551117395Skan /* Extracting the function address from a pmf is only 2552117395Skan allowed with -Wno-pmf-conversions. It only works for 2553117395Skan pmf constants. */ 2554117395Skan e1 = build_addr_func (PTRMEM_CST_MEMBER (function)); 2555117395Skan e1 = convert (fntype, e1); 2556117395Skan return e1; 2557117395Skan } 2558117395Skan else 2559117395Skan { 2560169689Skan error ("object missing in use of %qE", function); 2561117395Skan return error_mark_node; 2562117395Skan } 256390075Sobrien } 256490075Sobrien 256518334Speter if (TREE_SIDE_EFFECTS (instance_ptr)) 2566117395Skan instance_ptr = instance_save_expr = save_expr (instance_ptr); 256718334Speter 256818334Speter if (TREE_SIDE_EFFECTS (function)) 256918334Speter function = save_expr (function); 257018334Speter 2571117395Skan /* Start by extracting all the information from the PMF itself. */ 2572169689Skan e3 = pfn_from_ptrmemfunc (function); 2573117395Skan delta = build_ptrmemfunc_access_expr (function, delta_identifier); 2574117395Skan idx = build1 (NOP_EXPR, vtable_index_type, e3); 257590075Sobrien switch (TARGET_PTRMEMFUNC_VBIT_LOCATION) 257618334Speter { 257790075Sobrien case ptrmemfunc_vbit_in_pfn: 2578117395Skan e1 = cp_build_binary_op (BIT_AND_EXPR, idx, integer_one_node); 2579117395Skan idx = cp_build_binary_op (MINUS_EXPR, idx, integer_one_node); 258090075Sobrien break; 258118334Speter 258290075Sobrien case ptrmemfunc_vbit_in_delta: 2583117395Skan e1 = cp_build_binary_op (BIT_AND_EXPR, delta, integer_one_node); 2584117395Skan delta = cp_build_binary_op (RSHIFT_EXPR, delta, integer_one_node); 258590075Sobrien break; 258652284Sobrien 258790075Sobrien default: 2588169689Skan gcc_unreachable (); 258990075Sobrien } 259052284Sobrien 2591169689Skan /* Convert down to the right base before using the instance. A 2592169689Skan special case is that in a pointer to member of class C, C may 2593169689Skan be incomplete. In that case, the function will of course be 2594169689Skan a member of C, and no conversion is required. In fact, 2595169689Skan lookup_base will fail in that case, because incomplete 2596169689Skan classes do not have BINFOs. */ 2597117395Skan basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype)); 2598169689Skan if (!same_type_ignoring_top_level_qualifiers_p 2599169689Skan (basetype, TREE_TYPE (TREE_TYPE (instance_ptr)))) 2600169689Skan { 2601169689Skan basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)), 2602169689Skan basetype, ba_check, NULL); 2603169689Skan instance_ptr = build_base_path (PLUS_EXPR, instance_ptr, basetype, 2604169689Skan 1); 2605169689Skan if (instance_ptr == error_mark_node) 2606169689Skan return error_mark_node; 2607169689Skan } 2608117395Skan /* ...and then the delta in the PMF. */ 2609169689Skan instance_ptr = build2 (PLUS_EXPR, TREE_TYPE (instance_ptr), 2610169689Skan instance_ptr, delta); 2611117395Skan 2612117395Skan /* Hand back the adjusted 'this' argument to our caller. */ 2613117395Skan *instance_ptrptr = instance_ptr; 2614117395Skan 2615117395Skan /* Next extract the vtable pointer from the object. */ 2616117395Skan vtbl = build1 (NOP_EXPR, build_pointer_type (vtbl_ptr_type_node), 2617117395Skan instance_ptr); 261890075Sobrien vtbl = build_indirect_ref (vtbl, NULL); 261952284Sobrien 2620117395Skan /* Finally, extract the function pointer from the vtable. */ 2621169689Skan e2 = fold_build2 (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, idx); 2622117395Skan e2 = build_indirect_ref (e2, NULL); 2623117395Skan TREE_CONSTANT (e2) = 1; 2624169689Skan TREE_INVARIANT (e2) = 1; 2625117395Skan 262690075Sobrien /* When using function descriptors, the address of the 262790075Sobrien vtable entry is treated as a function pointer. */ 262890075Sobrien if (TARGET_VTABLE_USES_DESCRIPTORS) 262990075Sobrien e2 = build1 (NOP_EXPR, TREE_TYPE (e2), 263090075Sobrien build_unary_op (ADDR_EXPR, e2, /*noconvert=*/1)); 263152284Sobrien 263290075Sobrien TREE_TYPE (e2) = TREE_TYPE (e3); 263390075Sobrien e1 = build_conditional_expr (e1, e2, e3); 2634169689Skan 263590075Sobrien /* Make sure this doesn't get evaluated first inside one of the 263690075Sobrien branches of the COND_EXPR. */ 2637117395Skan if (instance_save_expr) 2638169689Skan e1 = build2 (COMPOUND_EXPR, TREE_TYPE (e1), 2639169689Skan instance_save_expr, e1); 264018334Speter 264150397Sobrien function = e1; 264218334Speter } 264318334Speter return function; 264418334Speter} 264518334Speter 264618334Spetertree 2647132718Skanbuild_function_call (tree function, tree params) 264818334Speter{ 2649132718Skan tree fntype, fndecl; 2650132718Skan tree coerced_params; 2651169689Skan tree name = NULL_TREE; 265218334Speter int is_method; 265390075Sobrien tree original = function; 265418334Speter 2655169689Skan /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF 2656169689Skan expressions, like those used for ObjC messenger dispatches. */ 2657169689Skan function = objc_rewrite_function_call (function, params); 2658169689Skan 265918334Speter /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue. 266018334Speter Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */ 266118334Speter if (TREE_CODE (function) == NOP_EXPR 266218334Speter && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0))) 266318334Speter function = TREE_OPERAND (function, 0); 266418334Speter 266518334Speter if (TREE_CODE (function) == FUNCTION_DECL) 266618334Speter { 266718334Speter name = DECL_NAME (function); 266818334Speter 266950397Sobrien mark_used (function); 267018334Speter fndecl = function; 267118334Speter 267218334Speter /* Convert anything with function type to a pointer-to-function. */ 267350397Sobrien if (pedantic && DECL_MAIN_P (function)) 2674169689Skan pedwarn ("ISO C++ forbids calling %<::main%> from within program"); 267518334Speter 267618334Speter /* Differs from default_conversion by not setting TREE_ADDRESSABLE 267718334Speter (because calling an inline function does not mean the function 267818334Speter needs to be separately compiled). */ 2679169689Skan 268018334Speter if (DECL_INLINE (function)) 268150397Sobrien function = inline_conversion (function); 268218334Speter else 268350397Sobrien function = build_addr_func (function); 268418334Speter } 268518334Speter else 268618334Speter { 268718334Speter fndecl = NULL_TREE; 268818334Speter 268950397Sobrien function = build_addr_func (function); 269018334Speter } 269118334Speter 269250397Sobrien if (function == error_mark_node) 269350397Sobrien return error_mark_node; 269450397Sobrien 269518334Speter fntype = TREE_TYPE (function); 269618334Speter 269718334Speter if (TYPE_PTRMEMFUNC_P (fntype)) 269818334Speter { 2699169689Skan error ("must use %<.*%> or %<->*%> to call pointer-to-member " 2700169689Skan "function in %<%E (...)%>", 2701169689Skan original); 270250397Sobrien return error_mark_node; 270318334Speter } 270418334Speter 270518334Speter is_method = (TREE_CODE (fntype) == POINTER_TYPE 270618334Speter && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE); 270718334Speter 270818334Speter if (!((TREE_CODE (fntype) == POINTER_TYPE 270918334Speter && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE) 271050397Sobrien || is_method 271150397Sobrien || TREE_CODE (function) == TEMPLATE_ID_EXPR)) 271218334Speter { 2713169689Skan error ("%qE cannot be used as a function", original); 271418334Speter return error_mark_node; 271518334Speter } 271618334Speter 271718334Speter /* fntype now gets the type of function pointed to. */ 271818334Speter fntype = TREE_TYPE (fntype); 271918334Speter 272018334Speter /* Convert the parameters to the types declared in the 272118334Speter function prototype, or apply default promotions. */ 272218334Speter 2723132718Skan coerced_params = convert_arguments (TYPE_ARG_TYPES (fntype), 2724132718Skan params, fndecl, LOOKUP_NORMAL); 272518334Speter if (coerced_params == error_mark_node) 2726132718Skan return error_mark_node; 272718334Speter 2728169689Skan /* Check for errors in format strings and inappropriately 2729169689Skan null parameters. */ 273018334Speter 2731169689Skan check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params, 2732169689Skan TYPE_ARG_TYPES (fntype)); 273318334Speter 2734169689Skan return build_cxx_call (function, coerced_params); 273518334Speter} 273618334Speter 273718334Speter/* Convert the actual parameter expressions in the list VALUES 273818334Speter to the types in the list TYPELIST. 273918334Speter If parmdecls is exhausted, or when an element has NULL as its type, 274018334Speter perform the default conversions. 274118334Speter 274218334Speter NAME is an IDENTIFIER_NODE or 0. It is used only for error messages. 274318334Speter 274418334Speter This is also where warnings about wrong number of args are generated. 2745169689Skan 274618334Speter Return a list of expressions for the parameters as converted. 274718334Speter 274818334Speter Both VALUES and the returned value are chains of TREE_LIST nodes 274918334Speter with the elements of the list in the TREE_VALUE slots of those nodes. 275018334Speter 275118334Speter In C++, unspecified trailing parameters can be filled in with their 275218334Speter default arguments, if such were specified. Do so here. */ 275318334Speter 2754169689Skanstatic tree 2755132718Skanconvert_arguments (tree typelist, tree values, tree fndecl, int flags) 275618334Speter{ 2757132718Skan tree typetail, valtail; 2758132718Skan tree result = NULL_TREE; 275952284Sobrien const char *called_thing = 0; 276018334Speter int i = 0; 276118334Speter 276250397Sobrien /* Argument passing is always copy-initialization. */ 276350397Sobrien flags |= LOOKUP_ONLYCONVERTING; 276450397Sobrien 276518334Speter if (fndecl) 276618334Speter { 276718334Speter if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE) 276818334Speter { 276918334Speter if (DECL_NAME (fndecl) == NULL_TREE 277018334Speter || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl))) 277118334Speter called_thing = "constructor"; 277218334Speter else 277318334Speter called_thing = "member function"; 277418334Speter } 277518334Speter else 277618334Speter called_thing = "function"; 277718334Speter } 277818334Speter 277918334Speter for (valtail = values, typetail = typelist; 278018334Speter valtail; 278118334Speter valtail = TREE_CHAIN (valtail), i++) 278218334Speter { 2783132718Skan tree type = typetail ? TREE_VALUE (typetail) : 0; 2784132718Skan tree val = TREE_VALUE (valtail); 278518334Speter 2786169689Skan if (val == error_mark_node || type == error_mark_node) 278718334Speter return error_mark_node; 278818334Speter 278918334Speter if (type == void_type_node) 279018334Speter { 279118334Speter if (fndecl) 279218334Speter { 2793169689Skan error ("too many arguments to %s %q+#D", called_thing, fndecl); 279418334Speter error ("at this point in file"); 279518334Speter } 279618334Speter else 279718334Speter error ("too many arguments to function"); 279818334Speter /* In case anybody wants to know if this argument 279918334Speter list is valid. */ 280018334Speter if (result) 280118334Speter TREE_TYPE (tree_last (result)) = error_mark_node; 280218334Speter break; 280318334Speter } 280418334Speter 280518334Speter /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue. 280618334Speter Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */ 280718334Speter if (TREE_CODE (val) == NOP_EXPR 280818334Speter && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)) 280918334Speter && (type == 0 || TREE_CODE (type) != REFERENCE_TYPE)) 281018334Speter val = TREE_OPERAND (val, 0); 281118334Speter 281218334Speter if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE) 281318334Speter { 281418334Speter if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE 281518334Speter || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE 281618334Speter || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE) 2817132718Skan val = decay_conversion (val); 281818334Speter } 281918334Speter 282018334Speter if (val == error_mark_node) 282118334Speter return error_mark_node; 282218334Speter 282318334Speter if (type != 0) 282418334Speter { 282518334Speter /* Formal parm type is specified by a function prototype. */ 282618334Speter tree parmval; 282718334Speter 282890075Sobrien if (!COMPLETE_TYPE_P (complete_type (type))) 282918334Speter { 2830132718Skan if (fndecl) 2831169689Skan error ("parameter %P of %qD has incomplete type %qT", 2832132718Skan i, fndecl, type); 2833132718Skan else 2834169689Skan error ("parameter %P has incomplete type %qT", i, type); 2835132718Skan parmval = error_mark_node; 283618334Speter } 283718334Speter else 283818334Speter { 283950397Sobrien parmval = convert_for_initialization 284052284Sobrien (NULL_TREE, type, val, flags, 284150397Sobrien "argument passing", fndecl, i); 2842117395Skan parmval = convert_for_arg_passing (type, parmval); 284318334Speter } 284418334Speter 284518334Speter if (parmval == error_mark_node) 284618334Speter return error_mark_node; 284718334Speter 284890075Sobrien result = tree_cons (NULL_TREE, parmval, result); 284918334Speter } 285018334Speter else 285118334Speter { 285290075Sobrien if (fndecl && DECL_BUILT_IN (fndecl) 285390075Sobrien && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CONSTANT_P) 285490075Sobrien /* Don't do ellipsis conversion for __built_in_constant_p 285590075Sobrien as this will result in spurious warnings for non-POD 285690075Sobrien types. */ 285790075Sobrien val = require_complete_type (val); 285890075Sobrien else 285990075Sobrien val = convert_arg_to_ellipsis (val); 286090075Sobrien 286190075Sobrien result = tree_cons (NULL_TREE, val, result); 286218334Speter } 286318334Speter 286418334Speter if (typetail) 286518334Speter typetail = TREE_CHAIN (typetail); 286618334Speter } 286718334Speter 286818334Speter if (typetail != 0 && typetail != void_list_node) 286918334Speter { 2870132718Skan /* See if there are default arguments that can be used. */ 2871169689Skan if (TREE_PURPOSE (typetail) 2872132718Skan && TREE_CODE (TREE_PURPOSE (typetail)) != DEFAULT_ARG) 287318334Speter { 287418334Speter for (; typetail != void_list_node; ++i) 287518334Speter { 2876169689Skan tree parmval 2877169689Skan = convert_default_arg (TREE_VALUE (typetail), 2878169689Skan TREE_PURPOSE (typetail), 287990075Sobrien fndecl, i); 288018334Speter 288118334Speter if (parmval == error_mark_node) 288218334Speter return error_mark_node; 288318334Speter 288490075Sobrien result = tree_cons (0, parmval, result); 288518334Speter typetail = TREE_CHAIN (typetail); 288618334Speter /* ends with `...'. */ 288718334Speter if (typetail == NULL_TREE) 288818334Speter break; 288918334Speter } 289018334Speter } 289118334Speter else 289218334Speter { 289318334Speter if (fndecl) 289418334Speter { 2895169689Skan error ("too few arguments to %s %q+#D", called_thing, fndecl); 289618334Speter error ("at this point in file"); 289718334Speter } 289818334Speter else 289918334Speter error ("too few arguments to function"); 2900169689Skan return error_mark_node; 290118334Speter } 290218334Speter } 290318334Speter 290418334Speter return nreverse (result); 290518334Speter} 290618334Speter 290718334Speter/* Build a binary-operation expression, after performing default 290818334Speter conversions on the operands. CODE is the kind of expression to build. */ 290918334Speter 291018334Spetertree 2911169689Skanbuild_x_binary_op (enum tree_code code, tree arg1, tree arg2, 2912132718Skan bool *overloaded_p) 291318334Speter{ 2914132718Skan tree orig_arg1; 2915132718Skan tree orig_arg2; 2916132718Skan tree expr; 2917132718Skan 2918132718Skan orig_arg1 = arg1; 2919132718Skan orig_arg2 = arg2; 2920132718Skan 292150397Sobrien if (processing_template_decl) 2922132718Skan { 2923132718Skan if (type_dependent_expression_p (arg1) 2924132718Skan || type_dependent_expression_p (arg2)) 2925132718Skan return build_min_nt (code, arg1, arg2); 2926132718Skan arg1 = build_non_dependent_expr (arg1); 2927132718Skan arg2 = build_non_dependent_expr (arg2); 2928132718Skan } 292950397Sobrien 2930132718Skan if (code == DOTSTAR_EXPR) 2931132718Skan expr = build_m_component_ref (arg1, arg2); 2932132718Skan else 2933169689Skan expr = build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE, 2934132718Skan overloaded_p); 2935132718Skan 2936132718Skan if (processing_template_decl && expr != error_mark_node) 2937132718Skan return build_min_non_dep (code, expr, orig_arg1, orig_arg2); 2938169689Skan 2939132718Skan return expr; 294018334Speter} 294118334Speter 294218334Speter/* Build a binary-operation expression without default conversions. 294318334Speter CODE is the kind of expression to build. 294418334Speter This function differs from `build' in several ways: 294518334Speter the data type of the result is computed and recorded in it, 294618334Speter warnings are generated if arg data types are invalid, 294718334Speter special handling for addition and subtraction of pointers is known, 294818334Speter and some optimization is done (operations on narrow ints 294918334Speter are done in the narrower type when that gives the same result). 295018334Speter Constant folding is also done before the result is returned. 295118334Speter 295218334Speter Note that the operands will never have enumeral types 295318334Speter because either they have just had the default conversions performed 295418334Speter or they have both just been converted to some other type in which 295518334Speter the arithmetic is to be done. 295618334Speter 295718334Speter C++: must do special pointer arithmetic when implementing 295818334Speter multiple inheritance, and deal with pointer to member functions. */ 295918334Speter 296018334Spetertree 2961132718Skanbuild_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, 2962132718Skan int convert_p ATTRIBUTE_UNUSED) 296318334Speter{ 296418334Speter tree op0, op1; 2965132718Skan enum tree_code code0, code1; 296618334Speter tree type0, type1; 2967169689Skan const char *invalid_op_diag; 296818334Speter 296918334Speter /* Expression code to give to the expression when it is built. 297018334Speter Normally this is CODE, which is what the caller asked for, 297118334Speter but in some special cases we change it. */ 2972132718Skan enum tree_code resultcode = code; 297318334Speter 297418334Speter /* Data type in which the computation is to be performed. 297518334Speter In the simplest cases this is the common type of the arguments. */ 2976132718Skan tree result_type = NULL; 297718334Speter 297818334Speter /* Nonzero means operands have already been type-converted 297918334Speter in whatever way is necessary. 298018334Speter Zero means they need to be converted to RESULT_TYPE. */ 298118334Speter int converted = 0; 298218334Speter 298318334Speter /* Nonzero means create the expression with this type, rather than 298418334Speter RESULT_TYPE. */ 298518334Speter tree build_type = 0; 298618334Speter 298718334Speter /* Nonzero means after finally constructing the expression 298818334Speter convert it to this type. */ 298918334Speter tree final_type = 0; 299018334Speter 2991169689Skan tree result; 2992169689Skan 299318334Speter /* Nonzero if this is an operation like MIN or MAX which can 299418334Speter safely be computed in short if both args are promoted shorts. 299518334Speter Also implies COMMON. 299618334Speter -1 indicates a bitwise operation; this makes a difference 299718334Speter in the exact conditions for when it is safe to do the operation 299818334Speter in a narrower mode. */ 299918334Speter int shorten = 0; 300018334Speter 300118334Speter /* Nonzero if this is a comparison operation; 300218334Speter if both args are promoted shorts, compare the original shorts. 300318334Speter Also implies COMMON. */ 300418334Speter int short_compare = 0; 300518334Speter 300618334Speter /* Nonzero if this is a right-shift operation, which can be computed on the 300718334Speter original short and then promoted if the operand is a promoted short. */ 300818334Speter int short_shift = 0; 300918334Speter 301018334Speter /* Nonzero means set RESULT_TYPE to the common type of the args. */ 301118334Speter int common = 0; 301218334Speter 3013169689Skan /* True if both operands have arithmetic type. */ 3014169689Skan bool arithmetic_types_p; 3015169689Skan 301618334Speter /* Apply default conversions. */ 301790075Sobrien op0 = orig_op0; 301890075Sobrien op1 = orig_op1; 3019169689Skan 302018334Speter if (code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR 302118334Speter || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR 302218334Speter || code == TRUTH_XOR_EXPR) 302318334Speter { 302490075Sobrien if (!really_overloaded_fn (op0)) 302590075Sobrien op0 = decay_conversion (op0); 302690075Sobrien if (!really_overloaded_fn (op1)) 302790075Sobrien op1 = decay_conversion (op1); 302818334Speter } 302918334Speter else 303018334Speter { 303190075Sobrien if (!really_overloaded_fn (op0)) 303290075Sobrien op0 = default_conversion (op0); 303390075Sobrien if (!really_overloaded_fn (op1)) 303490075Sobrien op1 = default_conversion (op1); 303518334Speter } 303618334Speter 303752284Sobrien /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */ 303852284Sobrien STRIP_TYPE_NOPS (op0); 303952284Sobrien STRIP_TYPE_NOPS (op1); 304052284Sobrien 304152284Sobrien /* DTRT if one side is an overloaded function, but complain about it. */ 304252284Sobrien if (type_unknown_p (op0)) 304352284Sobrien { 304496263Sobrien tree t = instantiate_type (TREE_TYPE (op1), op0, tf_none); 304552284Sobrien if (t != error_mark_node) 304652284Sobrien { 3047169689Skan pedwarn ("assuming cast to type %qT from overloaded function", 3048169689Skan TREE_TYPE (t)); 304952284Sobrien op0 = t; 305052284Sobrien } 305152284Sobrien } 305252284Sobrien if (type_unknown_p (op1)) 305352284Sobrien { 305496263Sobrien tree t = instantiate_type (TREE_TYPE (op0), op1, tf_none); 305552284Sobrien if (t != error_mark_node) 305652284Sobrien { 3057169689Skan pedwarn ("assuming cast to type %qT from overloaded function", 3058169689Skan TREE_TYPE (t)); 305952284Sobrien op1 = t; 306052284Sobrien } 306152284Sobrien } 306252284Sobrien 306318334Speter type0 = TREE_TYPE (op0); 306418334Speter type1 = TREE_TYPE (op1); 306518334Speter 306618334Speter /* The expression codes of the data types of the arguments tell us 306718334Speter whether the arguments are integers, floating, pointers, etc. */ 306818334Speter code0 = TREE_CODE (type0); 306918334Speter code1 = TREE_CODE (type1); 307018334Speter 307118334Speter /* If an error was already reported for one of the arguments, 307218334Speter avoid reporting another error. */ 307318334Speter 307418334Speter if (code0 == ERROR_MARK || code1 == ERROR_MARK) 307518334Speter return error_mark_node; 307618334Speter 3077169689Skan if ((invalid_op_diag 3078169689Skan = targetm.invalid_binary_op (code, type0, type1))) 3079169689Skan { 3080169689Skan error (invalid_op_diag); 3081169689Skan return error_mark_node; 3082169689Skan } 3083169689Skan 308418334Speter switch (code) 308518334Speter { 308618334Speter case MINUS_EXPR: 308718334Speter /* Subtraction of two similar pointers. 308818334Speter We must subtract them as integers, then divide by object size. */ 308918334Speter if (code0 == POINTER_TYPE && code1 == POINTER_TYPE 3090132718Skan && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (type0), 3091132718Skan TREE_TYPE (type1))) 309250397Sobrien return pointer_diff (op0, op1, common_type (type0, type1)); 3093169689Skan /* In all other cases except pointer - int, the usual arithmetic 3094169689Skan rules aply. */ 3095169689Skan else if (!(code0 == POINTER_TYPE && code1 == INTEGER_TYPE)) 3096169689Skan { 3097169689Skan common = 1; 3098169689Skan break; 3099169689Skan } 3100169689Skan /* The pointer - int case is just like pointer + int; fall 3101169689Skan through. */ 3102169689Skan case PLUS_EXPR: 3103169689Skan if ((code0 == POINTER_TYPE || code1 == POINTER_TYPE) 3104169689Skan && (code0 == INTEGER_TYPE || code1 == INTEGER_TYPE)) 3105169689Skan { 3106169689Skan tree ptr_operand; 3107169689Skan tree int_operand; 3108169689Skan ptr_operand = ((code0 == POINTER_TYPE) ? op0 : op1); 3109169689Skan int_operand = ((code0 == INTEGER_TYPE) ? op0 : op1); 3110169689Skan if (processing_template_decl) 3111169689Skan { 3112169689Skan result_type = TREE_TYPE (ptr_operand); 3113169689Skan break; 3114169689Skan } 3115169689Skan return cp_pointer_int_sum (code, 3116169689Skan ptr_operand, 3117169689Skan int_operand); 3118169689Skan } 3119169689Skan common = 1; 312018334Speter break; 312118334Speter 312218334Speter case MULT_EXPR: 312318334Speter common = 1; 312418334Speter break; 312518334Speter 312618334Speter case TRUNC_DIV_EXPR: 312718334Speter case CEIL_DIV_EXPR: 312818334Speter case FLOOR_DIV_EXPR: 312918334Speter case ROUND_DIV_EXPR: 313018334Speter case EXACT_DIV_EXPR: 313150397Sobrien if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE 3132161651Skan || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE) 313350397Sobrien && (code1 == INTEGER_TYPE || code1 == REAL_TYPE 3134161651Skan || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)) 313518334Speter { 3136169689Skan enum tree_code tcode0 = code0, tcode1 = code1; 3137169689Skan 313818334Speter if (TREE_CODE (op1) == INTEGER_CST && integer_zerop (op1)) 3139169689Skan warning (OPT_Wdiv_by_zero, "division by zero in %<%E / 0%>", op0); 314018334Speter else if (TREE_CODE (op1) == REAL_CST && real_zerop (op1)) 3141169689Skan warning (OPT_Wdiv_by_zero, "division by zero in %<%E / 0.%>", op0); 3142169689Skan 3143169689Skan if (tcode0 == COMPLEX_TYPE || tcode0 == VECTOR_TYPE) 3144169689Skan tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0))); 3145169689Skan if (tcode1 == COMPLEX_TYPE || tcode1 == VECTOR_TYPE) 3146169689Skan tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1))); 3147169689Skan 3148169689Skan if (!(tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE)) 314918334Speter resultcode = RDIV_EXPR; 315018334Speter else 315118334Speter /* When dividing two signed integers, we have to promote to int. 315218334Speter unless we divide by a constant != -1. Note that default 315318334Speter conversion will have been performed on the operands at this 315418334Speter point, so we have to dig out the original type to find out if 315518334Speter it was unsigned. */ 315618334Speter shorten = ((TREE_CODE (op0) == NOP_EXPR 3157169689Skan && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0)))) 315818334Speter || (TREE_CODE (op1) == INTEGER_CST 315990075Sobrien && ! integer_all_onesp (op1))); 316090075Sobrien 316118334Speter common = 1; 316218334Speter } 316318334Speter break; 316418334Speter 316518334Speter case BIT_AND_EXPR: 316618334Speter case BIT_IOR_EXPR: 316718334Speter case BIT_XOR_EXPR: 3168161651Skan if ((code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 3169161651Skan || (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)) 317018334Speter shorten = -1; 317118334Speter break; 317218334Speter 317318334Speter case TRUNC_MOD_EXPR: 317418334Speter case FLOOR_MOD_EXPR: 317518334Speter if (code1 == INTEGER_TYPE && integer_zerop (op1)) 3176169689Skan warning (OPT_Wdiv_by_zero, "division by zero in %<%E %% 0%>", op0); 317718334Speter else if (code1 == REAL_TYPE && real_zerop (op1)) 3178169689Skan warning (OPT_Wdiv_by_zero, "division by zero in %<%E %% 0.%>", op0); 3179169689Skan 318018334Speter if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 318118334Speter { 318218334Speter /* Although it would be tempting to shorten always here, that loses 318318334Speter on some targets, since the modulo instruction is undefined if the 318418334Speter quotient can't be represented in the computation mode. We shorten 318518334Speter only if unsigned or if dividing by something we know != -1. */ 318618334Speter shorten = ((TREE_CODE (op0) == NOP_EXPR 3187169689Skan && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0)))) 318818334Speter || (TREE_CODE (op1) == INTEGER_CST 318990075Sobrien && ! integer_all_onesp (op1))); 319018334Speter common = 1; 319118334Speter } 319218334Speter break; 319318334Speter 319418334Speter case TRUTH_ANDIF_EXPR: 319518334Speter case TRUTH_ORIF_EXPR: 319618334Speter case TRUTH_AND_EXPR: 319718334Speter case TRUTH_OR_EXPR: 319818334Speter result_type = boolean_type_node; 319918334Speter break; 320018334Speter 320118334Speter /* Shift operations: result has same type as first operand; 320218334Speter always convert second operand to int. 320318334Speter Also set SHORT_SHIFT if shifting rightward. */ 320418334Speter 320518334Speter case RSHIFT_EXPR: 320618334Speter if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 320718334Speter { 320818334Speter result_type = type0; 320918334Speter if (TREE_CODE (op1) == INTEGER_CST) 321018334Speter { 321118334Speter if (tree_int_cst_lt (op1, integer_zero_node)) 3212169689Skan warning (0, "right shift count is negative"); 321318334Speter else 321418334Speter { 321590075Sobrien if (! integer_zerop (op1)) 321618334Speter short_shift = 1; 321790075Sobrien if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) 3218169689Skan warning (0, "right shift count >= width of type"); 321918334Speter } 322018334Speter } 322118334Speter /* Convert the shift-count to an integer, regardless of 322218334Speter size of value being shifted. */ 322318334Speter if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) 322450397Sobrien op1 = cp_convert (integer_type_node, op1); 322518334Speter /* Avoid converting op1 to result_type later. */ 322618334Speter converted = 1; 322718334Speter } 322818334Speter break; 322918334Speter 323018334Speter case LSHIFT_EXPR: 323118334Speter if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 323218334Speter { 323318334Speter result_type = type0; 323418334Speter if (TREE_CODE (op1) == INTEGER_CST) 323518334Speter { 323618334Speter if (tree_int_cst_lt (op1, integer_zero_node)) 3237169689Skan warning (0, "left shift count is negative"); 323890075Sobrien else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) 3239169689Skan warning (0, "left shift count >= width of type"); 324018334Speter } 324118334Speter /* Convert the shift-count to an integer, regardless of 324218334Speter size of value being shifted. */ 324318334Speter if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) 324450397Sobrien op1 = cp_convert (integer_type_node, op1); 324518334Speter /* Avoid converting op1 to result_type later. */ 324618334Speter converted = 1; 324718334Speter } 324818334Speter break; 324918334Speter 325018334Speter case RROTATE_EXPR: 325118334Speter case LROTATE_EXPR: 325218334Speter if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 325318334Speter { 325418334Speter result_type = type0; 325518334Speter if (TREE_CODE (op1) == INTEGER_CST) 325618334Speter { 325718334Speter if (tree_int_cst_lt (op1, integer_zero_node)) 3258169689Skan warning (0, "%s rotate count is negative", 325918334Speter (code == LROTATE_EXPR) ? "left" : "right"); 326090075Sobrien else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) 3261169689Skan warning (0, "%s rotate count >= width of type", 326218334Speter (code == LROTATE_EXPR) ? "left" : "right"); 326318334Speter } 326418334Speter /* Convert the shift-count to an integer, regardless of 326518334Speter size of value being shifted. */ 326618334Speter if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) 326750397Sobrien op1 = cp_convert (integer_type_node, op1); 326818334Speter } 326918334Speter break; 327018334Speter 327118334Speter case EQ_EXPR: 327218334Speter case NE_EXPR: 3273169689Skan if (code0 == REAL_TYPE || code1 == REAL_TYPE) 3274169689Skan warning (OPT_Wfloat_equal, 3275169689Skan "comparing floating point with == or != is unsafe"); 3276169689Skan if ((TREE_CODE (orig_op0) == STRING_CST && !integer_zerop (op1)) 3277169689Skan || (TREE_CODE (orig_op1) == STRING_CST && !integer_zerop (op0))) 3278169689Skan warning (OPT_Waddress, 3279169689Skan "comparison with string literal results in unspecified behaviour"); 328090075Sobrien 3281169689Skan build_type = boolean_type_node; 328250397Sobrien if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE 328350397Sobrien || code0 == COMPLEX_TYPE) 328450397Sobrien && (code1 == INTEGER_TYPE || code1 == REAL_TYPE 328550397Sobrien || code1 == COMPLEX_TYPE)) 328618334Speter short_compare = 1; 3287132718Skan else if ((code0 == POINTER_TYPE && code1 == POINTER_TYPE) 3288132718Skan || (TYPE_PTRMEM_P (type0) && TYPE_PTRMEM_P (type1))) 328990075Sobrien result_type = composite_pointer_type (type0, type1, op0, op1, 329090075Sobrien "comparison"); 3291132718Skan else if ((code0 == POINTER_TYPE || TYPE_PTRMEM_P (type0)) 3292132718Skan && null_ptr_cst_p (op1)) 329318334Speter result_type = type0; 3294132718Skan else if ((code1 == POINTER_TYPE || TYPE_PTRMEM_P (type1)) 3295132718Skan && null_ptr_cst_p (op0)) 329618334Speter result_type = type1; 329718334Speter else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 329818334Speter { 329918334Speter result_type = type0; 330090075Sobrien error ("ISO C++ forbids comparison between pointer and integer"); 330118334Speter } 330218334Speter else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) 330318334Speter { 330418334Speter result_type = type1; 330590075Sobrien error ("ISO C++ forbids comparison between pointer and integer"); 330618334Speter } 330790075Sobrien else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p (op1)) 330818334Speter { 3309117395Skan op0 = build_ptrmemfunc_access_expr (op0, pfn_identifier); 331090075Sobrien op1 = cp_convert (TREE_TYPE (op0), integer_zero_node); 331118334Speter result_type = TREE_TYPE (op0); 331218334Speter } 331390075Sobrien else if (TYPE_PTRMEMFUNC_P (type1) && null_ptr_cst_p (op0)) 331490075Sobrien return cp_build_binary_op (code, op1, op0); 331518334Speter else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1) 331652284Sobrien && same_type_p (type0, type1)) 331718334Speter { 331890075Sobrien /* E will be the final comparison. */ 331990075Sobrien tree e; 332090075Sobrien /* E1 and E2 are for scratch. */ 332190075Sobrien tree e1; 332290075Sobrien tree e2; 332390075Sobrien tree pfn0; 332490075Sobrien tree pfn1; 332590075Sobrien tree delta0; 332690075Sobrien tree delta1; 332718334Speter 332890075Sobrien if (TREE_SIDE_EFFECTS (op0)) 332990075Sobrien op0 = save_expr (op0); 333090075Sobrien if (TREE_SIDE_EFFECTS (op1)) 333190075Sobrien op1 = save_expr (op1); 333218334Speter 333390075Sobrien /* We generate: 333490075Sobrien 3335169689Skan (op0.pfn == op1.pfn 333690075Sobrien && (!op0.pfn || op0.delta == op1.delta)) 3337169689Skan 333890075Sobrien The reason for the `!op0.pfn' bit is that a NULL 333990075Sobrien pointer-to-member is any member with a zero PFN; the 334090075Sobrien DELTA field is unspecified. */ 334190075Sobrien pfn0 = pfn_from_ptrmemfunc (op0); 334290075Sobrien pfn1 = pfn_from_ptrmemfunc (op1); 3343117395Skan delta0 = build_ptrmemfunc_access_expr (op0, 3344117395Skan delta_identifier); 3345117395Skan delta1 = build_ptrmemfunc_access_expr (op1, 3346117395Skan delta_identifier); 334790075Sobrien e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1); 3348169689Skan e2 = cp_build_binary_op (EQ_EXPR, 334990075Sobrien pfn0, 335090075Sobrien cp_convert (TREE_TYPE (pfn0), 335190075Sobrien integer_zero_node)); 335290075Sobrien e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2); 3353169689Skan e2 = build2 (EQ_EXPR, boolean_type_node, pfn0, pfn1); 335490075Sobrien e = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1); 335518334Speter if (code == EQ_EXPR) 335690075Sobrien return e; 335790075Sobrien return cp_build_binary_op (EQ_EXPR, e, integer_zero_node); 335818334Speter } 3359169689Skan else 3360169689Skan { 3361169689Skan gcc_assert (!TYPE_PTRMEMFUNC_P (type0) 3362169689Skan || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0), 3363169689Skan type1)); 3364169689Skan gcc_assert (!TYPE_PTRMEMFUNC_P (type1) 3365169689Skan || !same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type1), 3366169689Skan type0)); 3367169689Skan } 3368169689Skan 336918334Speter break; 337018334Speter 337118334Speter case MAX_EXPR: 337218334Speter case MIN_EXPR: 337318334Speter if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE) 337418334Speter && (code1 == INTEGER_TYPE || code1 == REAL_TYPE)) 337518334Speter shorten = 1; 337618334Speter else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) 337790075Sobrien result_type = composite_pointer_type (type0, type1, op0, op1, 337890075Sobrien "comparison"); 337918334Speter break; 338018334Speter 338118334Speter case LE_EXPR: 338218334Speter case GE_EXPR: 338318334Speter case LT_EXPR: 338418334Speter case GT_EXPR: 3385169689Skan if (TREE_CODE (orig_op0) == STRING_CST 3386169689Skan || TREE_CODE (orig_op1) == STRING_CST) 3387169689Skan warning (OPT_Waddress, 3388169689Skan "comparison with string literal results in unspecified behaviour"); 3389169689Skan 339018334Speter build_type = boolean_type_node; 339118334Speter if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE) 339218334Speter && (code1 == INTEGER_TYPE || code1 == REAL_TYPE)) 339318334Speter short_compare = 1; 339418334Speter else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) 339590075Sobrien result_type = composite_pointer_type (type0, type1, op0, op1, 339690075Sobrien "comparison"); 339718334Speter else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST 339818334Speter && integer_zerop (op1)) 339918334Speter result_type = type0; 340018334Speter else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST 340118334Speter && integer_zerop (op0)) 340218334Speter result_type = type1; 340318334Speter else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 340418334Speter { 340518334Speter result_type = type0; 340690075Sobrien pedwarn ("ISO C++ forbids comparison between pointer and integer"); 340718334Speter } 340818334Speter else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) 340918334Speter { 341018334Speter result_type = type1; 341190075Sobrien pedwarn ("ISO C++ forbids comparison between pointer and integer"); 341218334Speter } 341318334Speter break; 341450397Sobrien 341590075Sobrien case UNORDERED_EXPR: 341690075Sobrien case ORDERED_EXPR: 341790075Sobrien case UNLT_EXPR: 341890075Sobrien case UNLE_EXPR: 341990075Sobrien case UNGT_EXPR: 342090075Sobrien case UNGE_EXPR: 342190075Sobrien case UNEQ_EXPR: 342290075Sobrien build_type = integer_type_node; 342390075Sobrien if (code0 != REAL_TYPE || code1 != REAL_TYPE) 342490075Sobrien { 342590075Sobrien error ("unordered comparison on non-floating point argument"); 342690075Sobrien return error_mark_node; 342790075Sobrien } 342890075Sobrien common = 1; 342990075Sobrien break; 343090075Sobrien 343150397Sobrien default: 343250397Sobrien break; 343318334Speter } 343418334Speter 3435161651Skan if (((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE) 3436169689Skan && (code1 == INTEGER_TYPE || code1 == REAL_TYPE 3437169689Skan || code1 == COMPLEX_TYPE))) 3438169689Skan arithmetic_types_p = 1; 3439169689Skan else 344018334Speter { 3441169689Skan arithmetic_types_p = 0; 3442169689Skan /* Vector arithmetic is only allowed when both sides are vectors. */ 3443169689Skan if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE) 3444169689Skan { 3445169689Skan if (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1)) 3446169689Skan || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0), 3447169689Skan TREE_TYPE (type1))) 3448169689Skan { 3449169689Skan binary_op_error (code); 3450169689Skan return error_mark_node; 3451169689Skan } 3452169689Skan arithmetic_types_p = 1; 3453169689Skan } 3454169689Skan } 3455169689Skan /* Determine the RESULT_TYPE, if it is not already known. */ 3456169689Skan if (!result_type 3457169689Skan && arithmetic_types_p 3458169689Skan && (shorten || common || short_compare)) 3459169689Skan result_type = common_type (type0, type1); 346050397Sobrien 3461169689Skan if (!result_type) 3462169689Skan { 3463169689Skan error ("invalid operands of types %qT and %qT to binary %qO", 3464169689Skan TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code); 3465169689Skan return error_mark_node; 3466169689Skan } 3467161651Skan 3468169689Skan /* If we're in a template, the only thing we need to know is the 3469169689Skan RESULT_TYPE. */ 3470169689Skan if (processing_template_decl) 3471169689Skan return build2 (resultcode, 3472169689Skan build_type ? build_type : result_type, 3473169689Skan op0, op1); 347418334Speter 3475169689Skan if (arithmetic_types_p) 3476169689Skan { 3477169689Skan int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE); 3478169689Skan 347918334Speter /* For certain operations (which identify themselves by shorten != 0) 348018334Speter if both args were extended from the same smaller type, 348118334Speter do the arithmetic in that type and then extend. 348218334Speter 348318334Speter shorten !=0 and !=1 indicates a bitwise operation. 348418334Speter For them, this optimization is safe only if 348518334Speter both args are zero-extended or both are sign-extended. 348618334Speter Otherwise, we might change the result. 348718334Speter Eg, (short)-1 | (unsigned short)-1 is (int)-1 348818334Speter but calculated in (unsigned short) it would be (unsigned short)-1. */ 348918334Speter 349050397Sobrien if (shorten && none_complex) 349118334Speter { 349218334Speter int unsigned0, unsigned1; 349318334Speter tree arg0 = get_narrower (op0, &unsigned0); 349418334Speter tree arg1 = get_narrower (op1, &unsigned1); 349518334Speter /* UNS is 1 if the operation to be done is an unsigned one. */ 3496169689Skan int uns = TYPE_UNSIGNED (result_type); 349718334Speter tree type; 349818334Speter 349918334Speter final_type = result_type; 350018334Speter 350118334Speter /* Handle the case that OP0 does not *contain* a conversion 350218334Speter but it *requires* conversion to FINAL_TYPE. */ 350318334Speter 350418334Speter if (op0 == arg0 && TREE_TYPE (op0) != final_type) 3505169689Skan unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0)); 350618334Speter if (op1 == arg1 && TREE_TYPE (op1) != final_type) 3507169689Skan unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1)); 350818334Speter 350918334Speter /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */ 351018334Speter 351118334Speter /* For bitwise operations, signedness of nominal type 351218334Speter does not matter. Consider only how operands were extended. */ 351318334Speter if (shorten == -1) 351418334Speter uns = unsigned0; 351518334Speter 351618334Speter /* Note that in all three cases below we refrain from optimizing 351718334Speter an unsigned operation on sign-extended args. 351818334Speter That would not be valid. */ 351918334Speter 352018334Speter /* Both args variable: if both extended in same way 352118334Speter from same width, do it in that width. 352218334Speter Do it unsigned if args were zero-extended. */ 352318334Speter if ((TYPE_PRECISION (TREE_TYPE (arg0)) 352418334Speter < TYPE_PRECISION (result_type)) 352518334Speter && (TYPE_PRECISION (TREE_TYPE (arg1)) 352618334Speter == TYPE_PRECISION (TREE_TYPE (arg0))) 352718334Speter && unsigned0 == unsigned1 352818334Speter && (unsigned0 || !uns)) 3529117395Skan result_type = c_common_signed_or_unsigned_type 3530117395Skan (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1))); 353118334Speter else if (TREE_CODE (arg0) == INTEGER_CST 353218334Speter && (unsigned1 || !uns) 353318334Speter && (TYPE_PRECISION (TREE_TYPE (arg1)) 353418334Speter < TYPE_PRECISION (result_type)) 3535117395Skan && (type = c_common_signed_or_unsigned_type 3536117395Skan (unsigned1, TREE_TYPE (arg1)), 353718334Speter int_fits_type_p (arg0, type))) 353818334Speter result_type = type; 353918334Speter else if (TREE_CODE (arg1) == INTEGER_CST 354018334Speter && (unsigned0 || !uns) 354118334Speter && (TYPE_PRECISION (TREE_TYPE (arg0)) 354218334Speter < TYPE_PRECISION (result_type)) 3543117395Skan && (type = c_common_signed_or_unsigned_type 3544117395Skan (unsigned0, TREE_TYPE (arg0)), 354518334Speter int_fits_type_p (arg1, type))) 354618334Speter result_type = type; 354718334Speter } 354818334Speter 354918334Speter /* Shifts can be shortened if shifting right. */ 355018334Speter 355118334Speter if (short_shift) 355218334Speter { 355318334Speter int unsigned_arg; 355418334Speter tree arg0 = get_narrower (op0, &unsigned_arg); 355518334Speter 355618334Speter final_type = result_type; 355718334Speter 355818334Speter if (arg0 == op0 && final_type == TREE_TYPE (op0)) 3559169689Skan unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0)); 356018334Speter 356118334Speter if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type) 356218334Speter /* We can shorten only if the shift count is less than the 356318334Speter number of bits in the smaller type size. */ 356490075Sobrien && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0 356518334Speter /* If arg is sign-extended and then unsigned-shifted, 356618334Speter we can simulate this with a signed shift in arg's type 356718334Speter only if the extended result is at least twice as wide 356818334Speter as the arg. Otherwise, the shift could use up all the 356918334Speter ones made by sign-extension and bring in zeros. 357018334Speter We can't optimize that case at all, but in most machines 357118334Speter it never happens because available widths are 2**N. */ 3572169689Skan && (!TYPE_UNSIGNED (final_type) 357318334Speter || unsigned_arg 357450397Sobrien || (((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0))) 357518334Speter <= TYPE_PRECISION (result_type)))) 357618334Speter { 357718334Speter /* Do an unsigned shift if the operand was zero-extended. */ 357818334Speter result_type 3579117395Skan = c_common_signed_or_unsigned_type (unsigned_arg, 3580117395Skan TREE_TYPE (arg0)); 358118334Speter /* Convert value-to-be-shifted to that type. */ 358218334Speter if (TREE_TYPE (op0) != result_type) 358350397Sobrien op0 = cp_convert (result_type, op0); 358418334Speter converted = 1; 358518334Speter } 358618334Speter } 358718334Speter 358818334Speter /* Comparison operations are shortened too but differently. 358918334Speter They identify themselves by setting short_compare = 1. */ 359018334Speter 359118334Speter if (short_compare) 359218334Speter { 359318334Speter /* Don't write &op0, etc., because that would prevent op0 359418334Speter from being kept in a register. 359518334Speter Instead, make copies of the our local variables and 359618334Speter pass the copies by reference, then copy them back afterward. */ 359718334Speter tree xop0 = op0, xop1 = op1, xresult_type = result_type; 359818334Speter enum tree_code xresultcode = resultcode; 3599169689Skan tree val 360018334Speter = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode); 360118334Speter if (val != 0) 360250397Sobrien return cp_convert (boolean_type_node, val); 360318334Speter op0 = xop0, op1 = xop1; 360418334Speter converted = 1; 360518334Speter resultcode = xresultcode; 360618334Speter } 360718334Speter 360890075Sobrien if ((short_compare || code == MIN_EXPR || code == MAX_EXPR) 3609132718Skan && warn_sign_compare 3610132718Skan /* Do not warn until the template is instantiated; we cannot 3611132718Skan bound the ranges of the arguments until that point. */ 3612132718Skan && !processing_template_decl) 361318334Speter { 3614169689Skan int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0)); 3615169689Skan int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1)); 361618334Speter 361718334Speter int unsignedp0, unsignedp1; 361818334Speter tree primop0 = get_narrower (op0, &unsignedp0); 361918334Speter tree primop1 = get_narrower (op1, &unsignedp1); 362018334Speter 362150397Sobrien /* Check for comparison of different enum types. */ 3622169689Skan if (TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE 3623169689Skan && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE 362450397Sobrien && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0)) 3625169689Skan != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1))) 362650397Sobrien { 3627169689Skan warning (0, "comparison between types %q#T and %q#T", 3628169689Skan TREE_TYPE (orig_op0), TREE_TYPE (orig_op1)); 362950397Sobrien } 363050397Sobrien 363118334Speter /* Give warnings for comparisons between signed and unsigned 363218334Speter quantities that may fail. */ 363318334Speter /* Do the checking based on the original operand trees, so that 363418334Speter casts will be considered, but default promotions won't be. */ 363518334Speter 363618334Speter /* Do not warn if the comparison is being done in a signed type, 363718334Speter since the signed type will only be chosen if it can represent 363818334Speter all the values of the unsigned type. */ 3639169689Skan if (!TYPE_UNSIGNED (result_type)) 364018334Speter /* OK */; 364118334Speter /* Do not warn if both operands are unsigned. */ 364218334Speter else if (op0_signed == op1_signed) 364318334Speter /* OK */; 364418334Speter /* Do not warn if the signed quantity is an unsuffixed 364518334Speter integer literal (or some static constant expression 364690075Sobrien involving such literals or a conditional expression 364718334Speter involving such literals) and it is non-negative. */ 364890075Sobrien else if ((op0_signed && tree_expr_nonnegative_p (orig_op0)) 364990075Sobrien || (op1_signed && tree_expr_nonnegative_p (orig_op1))) 365018334Speter /* OK */; 365118334Speter /* Do not warn if the comparison is an equality operation, 365218334Speter the unsigned quantity is an integral constant and it does 365318334Speter not use the most significant bit of result_type. */ 365418334Speter else if ((resultcode == EQ_EXPR || resultcode == NE_EXPR) 365518334Speter && ((op0_signed && TREE_CODE (orig_op1) == INTEGER_CST 3656117395Skan && int_fits_type_p (orig_op1, c_common_signed_type 3657117395Skan (result_type))) 365818334Speter || (op1_signed && TREE_CODE (orig_op0) == INTEGER_CST 3659117395Skan && int_fits_type_p (orig_op0, c_common_signed_type 3660117395Skan (result_type))))) 366118334Speter /* OK */; 366218334Speter else 3663169689Skan warning (0, "comparison between signed and unsigned integer expressions"); 366418334Speter 366518334Speter /* Warn if two unsigned values are being compared in a size 366618334Speter larger than their original size, and one (and only one) is the 366718334Speter result of a `~' operator. This comparison will always fail. 366818334Speter 366918334Speter Also warn if one operand is a constant, and the constant does not 367018334Speter have all bits set that are set in the ~ operand when it is 367118334Speter extended. */ 367218334Speter 367350397Sobrien if ((TREE_CODE (primop0) == BIT_NOT_EXPR) 367450397Sobrien ^ (TREE_CODE (primop1) == BIT_NOT_EXPR)) 367518334Speter { 367618334Speter if (TREE_CODE (primop0) == BIT_NOT_EXPR) 367718334Speter primop0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0); 367818334Speter if (TREE_CODE (primop1) == BIT_NOT_EXPR) 367918334Speter primop1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1); 3680169689Skan 368190075Sobrien if (host_integerp (primop0, 0) || host_integerp (primop1, 0)) 368218334Speter { 368318334Speter tree primop; 368418334Speter HOST_WIDE_INT constant, mask; 368518334Speter int unsignedp; 368690075Sobrien unsigned int bits; 368718334Speter 368890075Sobrien if (host_integerp (primop0, 0)) 368918334Speter { 369018334Speter primop = primop1; 369118334Speter unsignedp = unsignedp1; 369290075Sobrien constant = tree_low_cst (primop0, 0); 369318334Speter } 369418334Speter else 369518334Speter { 369618334Speter primop = primop0; 369718334Speter unsignedp = unsignedp0; 369890075Sobrien constant = tree_low_cst (primop1, 0); 369918334Speter } 370018334Speter 370118334Speter bits = TYPE_PRECISION (TREE_TYPE (primop)); 370218334Speter if (bits < TYPE_PRECISION (result_type) 370318334Speter && bits < HOST_BITS_PER_LONG && unsignedp) 370418334Speter { 370518334Speter mask = (~ (HOST_WIDE_INT) 0) << bits; 370618334Speter if ((mask & constant) != mask) 3707169689Skan warning (0, "comparison of promoted ~unsigned with constant"); 370818334Speter } 370918334Speter } 371018334Speter else if (unsignedp0 && unsignedp1 371118334Speter && (TYPE_PRECISION (TREE_TYPE (primop0)) 371218334Speter < TYPE_PRECISION (result_type)) 371318334Speter && (TYPE_PRECISION (TREE_TYPE (primop1)) 371418334Speter < TYPE_PRECISION (result_type))) 3715169689Skan warning (0, "comparison of promoted ~unsigned with unsigned"); 371618334Speter } 371718334Speter } 371818334Speter } 371918334Speter 3720169689Skan /* If CONVERTED is zero, both args will be converted to type RESULT_TYPE. 372118334Speter Then the expression will be built. 372218334Speter It will be given type FINAL_TYPE if that is nonzero; 372318334Speter otherwise, it will be given type RESULT_TYPE. */ 372418334Speter 3725117395Skan /* Issue warnings about peculiar, but valid, uses of NULL. */ 372652284Sobrien if (/* It's reasonable to use pointer values as operands of && 372752284Sobrien and ||, so NULL is no exception. */ 372852284Sobrien !(code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR) 372952284Sobrien && (/* If OP0 is NULL and OP1 is not a pointer, or vice versa. */ 373052284Sobrien (orig_op0 == null_node 373152284Sobrien && TREE_CODE (TREE_TYPE (op1)) != POINTER_TYPE) 373252284Sobrien /* Or vice versa. */ 373352284Sobrien || (orig_op1 == null_node 373452284Sobrien && TREE_CODE (TREE_TYPE (op0)) != POINTER_TYPE) 373552284Sobrien /* Or, both are NULL and the operation was not a comparison. */ 3736169689Skan || (orig_op0 == null_node && orig_op1 == null_node 373752284Sobrien && code != EQ_EXPR && code != NE_EXPR))) 373852284Sobrien /* Some sort of arithmetic operation involving NULL was 373952284Sobrien performed. Note that pointer-difference and pointer-addition 374052284Sobrien have already been handled above, and so we don't end up here in 374152284Sobrien that case. */ 3742169689Skan warning (0, "NULL used in arithmetic"); 374352284Sobrien 374418334Speter if (! converted) 374518334Speter { 374618334Speter if (TREE_TYPE (op0) != result_type) 3747169689Skan op0 = cp_convert (result_type, op0); 374818334Speter if (TREE_TYPE (op1) != result_type) 3749169689Skan op1 = cp_convert (result_type, op1); 375052284Sobrien 375152284Sobrien if (op0 == error_mark_node || op1 == error_mark_node) 375252284Sobrien return error_mark_node; 375318334Speter } 375418334Speter 375518334Speter if (build_type == NULL_TREE) 375618334Speter build_type = result_type; 375718334Speter 3758169689Skan result = build2 (resultcode, build_type, op0, op1); 3759169689Skan result = fold_if_not_in_template (result); 3760169689Skan if (final_type != 0) 3761169689Skan result = cp_convert (final_type, result); 3762169689Skan return result; 376318334Speter} 376418334Speter 376518334Speter/* Return a tree for the sum or difference (RESULTCODE says which) 376618334Speter of pointer PTROP and integer INTOP. */ 376718334Speter 376818334Speterstatic tree 3769132718Skancp_pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop) 377018334Speter{ 377196263Sobrien tree res_type = TREE_TYPE (ptrop); 377218334Speter 377396263Sobrien /* pointer_int_sum() uses size_in_bytes() on the TREE_TYPE(res_type) 377496263Sobrien in certain circumstance (when it's valid to do so). So we need 377596263Sobrien to make sure it's complete. We don't need to check here, if we 377696263Sobrien can actually complete it at all, as those checks will be done in 377796263Sobrien pointer_int_sum() anyway. */ 377896263Sobrien complete_type (TREE_TYPE (res_type)); 377918334Speter 3780169689Skan return pointer_int_sum (resultcode, ptrop, 3781169689Skan fold_if_not_in_template (intop)); 378218334Speter} 378318334Speter 378418334Speter/* Return a tree for the difference of pointers OP0 and OP1. 378518334Speter The resulting tree has type int. */ 378618334Speter 378718334Speterstatic tree 3788132718Skanpointer_diff (tree op0, tree op1, tree ptrtype) 378918334Speter{ 3790169689Skan tree result; 379118334Speter tree restype = ptrdiff_type_node; 379250397Sobrien tree target_type = TREE_TYPE (ptrtype); 379318334Speter 379452284Sobrien if (!complete_type_or_else (target_type, NULL_TREE)) 379550397Sobrien return error_mark_node; 379650397Sobrien 379750397Sobrien if (pedantic || warn_pointer_arith) 379818334Speter { 379918334Speter if (TREE_CODE (target_type) == VOID_TYPE) 3800169689Skan pedwarn ("ISO C++ forbids using pointer of type %<void *%> in subtraction"); 380118334Speter if (TREE_CODE (target_type) == FUNCTION_TYPE) 380290075Sobrien pedwarn ("ISO C++ forbids using pointer to a function in subtraction"); 380318334Speter if (TREE_CODE (target_type) == METHOD_TYPE) 380490075Sobrien pedwarn ("ISO C++ forbids using pointer to a method in subtraction"); 380518334Speter } 380618334Speter 380718334Speter /* First do the subtraction as integers; 380818334Speter then drop through to build the divide operator. */ 380918334Speter 3810169689Skan op0 = cp_build_binary_op (MINUS_EXPR, 381190075Sobrien cp_convert (restype, op0), 381290075Sobrien cp_convert (restype, op1)); 381318334Speter 381418334Speter /* This generates an error if op1 is a pointer to an incomplete type. */ 381590075Sobrien if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1)))) 381690075Sobrien error ("invalid use of a pointer to an incomplete type in pointer arithmetic"); 381718334Speter 3818169689Skan op1 = (TYPE_PTROB_P (ptrtype) 3819132718Skan ? size_in_bytes (target_type) 3820132718Skan : integer_one_node); 382118334Speter 382218334Speter /* Do the division. */ 382318334Speter 3824169689Skan result = build2 (EXACT_DIV_EXPR, restype, op0, cp_convert (restype, op1)); 3825169689Skan return fold_if_not_in_template (result); 382618334Speter} 382718334Speter 382818334Speter/* Construct and perhaps optimize a tree representation 382918334Speter for a unary operation. CODE, a tree_code, specifies the operation 383018334Speter and XARG is the operand. */ 383118334Speter 383218334Spetertree 3833132718Skanbuild_x_unary_op (enum tree_code code, tree xarg) 383418334Speter{ 3835132718Skan tree orig_expr = xarg; 383690075Sobrien tree exp; 383790075Sobrien int ptrmem = 0; 3838169689Skan 383950397Sobrien if (processing_template_decl) 3840132718Skan { 3841132718Skan if (type_dependent_expression_p (xarg)) 3842132718Skan return build_min_nt (code, xarg, NULL_TREE); 3843146895Skan 3844132718Skan xarg = build_non_dependent_expr (xarg); 3845132718Skan } 384650397Sobrien 3847132718Skan exp = NULL_TREE; 3848132718Skan 3849132718Skan /* [expr.unary.op] says: 3850132718Skan 3851132718Skan The address of an object of incomplete type can be taken. 3852132718Skan 3853132718Skan (And is just the ordinary address operator, not an overloaded 3854132718Skan "operator &".) However, if the type is a template 3855132718Skan specialization, we must complete the type at this point so that 3856132718Skan an overloaded "operator &" will be available if required. */ 385718334Speter if (code == ADDR_EXPR 385850397Sobrien && TREE_CODE (xarg) != TEMPLATE_ID_EXPR 3859132718Skan && ((CLASS_TYPE_P (TREE_TYPE (xarg)) 3860132718Skan && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (xarg)))) 386118334Speter || (TREE_CODE (xarg) == OFFSET_REF))) 3862132718Skan /* Don't look for a function. */; 386318334Speter else 3864132718Skan exp = build_new_op (code, LOOKUP_NORMAL, xarg, NULL_TREE, NULL_TREE, 3865132718Skan /*overloaded_p=*/NULL); 3866132718Skan if (!exp && code == ADDR_EXPR) 386718334Speter { 3868107590Sobrien /* A pointer to member-function can be formed only by saying 3869107590Sobrien &X::mf. */ 3870107590Sobrien if (!flag_ms_extensions && TREE_CODE (TREE_TYPE (xarg)) == METHOD_TYPE 3871107590Sobrien && (TREE_CODE (xarg) != OFFSET_REF || !PTRMEM_OK_P (xarg))) 3872107590Sobrien { 3873169689Skan if (TREE_CODE (xarg) != OFFSET_REF 3874169689Skan || !TYPE_P (TREE_OPERAND (xarg, 0))) 3875107590Sobrien { 3876169689Skan error ("invalid use of %qE to form a pointer-to-member-function", 3877107590Sobrien xarg); 3878169689Skan if (TREE_CODE (xarg) != OFFSET_REF) 3879169689Skan inform (" a qualified-id is required"); 3880107590Sobrien return error_mark_node; 3881107590Sobrien } 3882107590Sobrien else 3883107590Sobrien { 3884169689Skan error ("parentheses around %qE cannot be used to form a" 3885169689Skan " pointer-to-member-function", 3886107590Sobrien xarg); 3887107590Sobrien PTRMEM_OK_P (xarg) = 1; 3888107590Sobrien } 3889107590Sobrien } 3890169689Skan 389190075Sobrien if (TREE_CODE (xarg) == OFFSET_REF) 3892169689Skan { 3893169689Skan ptrmem = PTRMEM_OK_P (xarg); 3894169689Skan 3895169689Skan if (!ptrmem && !flag_ms_extensions 3896169689Skan && TREE_CODE (TREE_TYPE (TREE_OPERAND (xarg, 1))) == METHOD_TYPE) 389790075Sobrien { 389890075Sobrien /* A single non-static member, make sure we don't allow a 3899169689Skan pointer-to-member. */ 3900169689Skan xarg = build2 (OFFSET_REF, TREE_TYPE (xarg), 3901169689Skan TREE_OPERAND (xarg, 0), 3902169689Skan ovl_cons (TREE_OPERAND (xarg, 1), NULL_TREE)); 390390075Sobrien PTRMEM_OK_P (xarg) = ptrmem; 3904169689Skan } 3905169689Skan } 390690075Sobrien else if (TREE_CODE (xarg) == TARGET_EXPR) 3907169689Skan warning (0, "taking address of temporary"); 3908132718Skan exp = build_unary_op (ADDR_EXPR, xarg, 0); 390950397Sobrien } 391050397Sobrien 3911132718Skan if (processing_template_decl && exp != error_mark_node) 3912146895Skan exp = build_min_non_dep (code, exp, orig_expr, 3913146895Skan /*For {PRE,POST}{INC,DEC}REMENT_EXPR*/NULL_TREE); 3914146895Skan if (TREE_CODE (exp) == ADDR_EXPR) 3915146895Skan PTRMEM_OK_P (exp) = ptrmem; 391690075Sobrien return exp; 391718334Speter} 391818334Speter 3919117395Skan/* Like c_common_truthvalue_conversion, but handle pointer-to-member 3920117395Skan constants, where a null value is represented by an INTEGER_CST of 3921117395Skan -1. */ 392290075Sobrien 392390075Sobrientree 3924132718Skancp_truthvalue_conversion (tree expr) 392590075Sobrien{ 392690075Sobrien tree type = TREE_TYPE (expr); 392790075Sobrien if (TYPE_PTRMEM_P (type)) 392890075Sobrien return build_binary_op (NE_EXPR, expr, integer_zero_node, 1); 392990075Sobrien else 3930117395Skan return c_common_truthvalue_conversion (expr); 393190075Sobrien} 393290075Sobrien 393390075Sobrien/* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */ 3934169689Skan 393518334Spetertree 3936132718Skancondition_conversion (tree expr) 393718334Speter{ 393850397Sobrien tree t; 393950397Sobrien if (processing_template_decl) 394050397Sobrien return expr; 394190075Sobrien t = perform_implicit_conversion (boolean_type_node, expr); 3942169689Skan t = fold_build_cleanup_point_expr (boolean_type_node, t); 394318334Speter return t; 394418334Speter} 3945169689Skan 3946117395Skan/* Return an ADDR_EXPR giving the address of T. This function 3947117395Skan attempts no optimizations or simplifications; it is a low-level 3948117395Skan primitive. */ 3949117395Skan 3950117395Skantree 3951117395Skanbuild_address (tree t) 3952117395Skan{ 3953117395Skan tree addr; 3954117395Skan 3955117395Skan if (error_operand_p (t) || !cxx_mark_addressable (t)) 3956117395Skan return error_mark_node; 3957117395Skan 3958132718Skan addr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (t)), t); 3959117395Skan 3960117395Skan return addr; 3961117395Skan} 3962117395Skan 3963117395Skan/* Return a NOP_EXPR converting EXPR to TYPE. */ 3964117395Skan 3965117395Skantree 3966117395Skanbuild_nop (tree type, tree expr) 3967117395Skan{ 3968117395Skan if (type == error_mark_node || error_operand_p (expr)) 3969117395Skan return expr; 3970169689Skan return build1 (NOP_EXPR, type, expr); 3971117395Skan} 3972117395Skan 397318334Speter/* C++: Must handle pointers to members. 397418334Speter 397518334Speter Perhaps type instantiation should be extended to handle conversion 397618334Speter from aggregates to types we don't yet know we want? (Or are those 397718334Speter cases typically errors which should be reported?) 397818334Speter 397918334Speter NOCONVERT nonzero suppresses the default promotions 398018334Speter (such as from short to int). */ 398150397Sobrien 398218334Spetertree 3983132718Skanbuild_unary_op (enum tree_code code, tree xarg, int noconvert) 398418334Speter{ 398518334Speter /* No default_conversion here. It causes trouble for ADDR_EXPR. */ 3986132718Skan tree arg = xarg; 3987132718Skan tree argtype = 0; 398852284Sobrien const char *errstring = NULL; 398918334Speter tree val; 3990169689Skan const char *invalid_op_diag; 399118334Speter 399218334Speter if (arg == error_mark_node) 399318334Speter return error_mark_node; 399418334Speter 3995169689Skan if ((invalid_op_diag 3996169689Skan = targetm.invalid_unary_op ((code == UNARY_PLUS_EXPR 3997169689Skan ? CONVERT_EXPR 3998169689Skan : code), 3999169689Skan TREE_TYPE (xarg)))) 4000169689Skan { 4001169689Skan error (invalid_op_diag); 4002169689Skan return error_mark_node; 4003169689Skan } 4004169689Skan 400518334Speter switch (code) 400618334Speter { 4007169689Skan case UNARY_PLUS_EXPR: 4008169689Skan case NEGATE_EXPR: 4009169689Skan { 4010169689Skan int flags = WANT_ARITH | WANT_ENUM; 4011169689Skan /* Unary plus (but not unary minus) is allowed on pointers. */ 4012169689Skan if (code == UNARY_PLUS_EXPR) 4013169689Skan flags |= WANT_POINTER; 4014169689Skan arg = build_expr_type_conversion (flags, arg, true); 4015169689Skan if (!arg) 4016169689Skan errstring = (code == NEGATE_EXPR 4017169689Skan ? "wrong type argument to unary minus" 4018169689Skan : "wrong type argument to unary plus"); 4019169689Skan else 4020169689Skan { 4021169689Skan if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg))) 4022169689Skan arg = perform_integral_promotions (arg); 402318334Speter 4024169689Skan /* Make sure the result is not an lvalue: a unary plus or minus 4025169689Skan expression is always a rvalue. */ 4026169689Skan arg = rvalue (arg); 4027169689Skan } 4028169689Skan } 402918334Speter break; 403018334Speter 403118334Speter case BIT_NOT_EXPR: 403250397Sobrien if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) 403350397Sobrien { 403450397Sobrien code = CONJ_EXPR; 403550397Sobrien if (!noconvert) 403650397Sobrien arg = default_conversion (arg); 403750397Sobrien } 4038169689Skan else if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM 4039169689Skan | WANT_VECTOR, 4040132718Skan arg, true))) 404118334Speter errstring = "wrong type argument to bit-complement"; 4042169689Skan else if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg))) 4043132718Skan arg = perform_integral_promotions (arg); 404418334Speter break; 404518334Speter 404618334Speter case ABS_EXPR: 4047132718Skan if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true))) 404818334Speter errstring = "wrong type argument to abs"; 404918334Speter else if (!noconvert) 405018334Speter arg = default_conversion (arg); 405118334Speter break; 405218334Speter 405350397Sobrien case CONJ_EXPR: 405450397Sobrien /* Conjugating a real value is a no-op, but allow it anyway. */ 4055132718Skan if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true))) 405650397Sobrien errstring = "wrong type argument to conjugation"; 405750397Sobrien else if (!noconvert) 405850397Sobrien arg = default_conversion (arg); 405950397Sobrien break; 406050397Sobrien 406118334Speter case TRUTH_NOT_EXPR: 4062132718Skan arg = perform_implicit_conversion (boolean_type_node, arg); 406318334Speter val = invert_truthvalue (arg); 406418334Speter if (arg != error_mark_node) 406518334Speter return val; 406618334Speter errstring = "in argument to unary !"; 406718334Speter break; 406818334Speter 406918334Speter case NOP_EXPR: 407018334Speter break; 4071169689Skan 407250397Sobrien case REALPART_EXPR: 407350397Sobrien if (TREE_CODE (arg) == COMPLEX_CST) 407450397Sobrien return TREE_REALPART (arg); 407550397Sobrien else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) 4076169689Skan { 4077169689Skan arg = build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg); 4078169689Skan return fold_if_not_in_template (arg); 4079169689Skan } 408050397Sobrien else 408150397Sobrien return arg; 408250397Sobrien 408350397Sobrien case IMAGPART_EXPR: 408450397Sobrien if (TREE_CODE (arg) == COMPLEX_CST) 408550397Sobrien return TREE_IMAGPART (arg); 408650397Sobrien else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) 4087169689Skan { 4088169689Skan arg = build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg); 4089169689Skan return fold_if_not_in_template (arg); 4090169689Skan } 409150397Sobrien else 409250397Sobrien return cp_convert (TREE_TYPE (arg), integer_zero_node); 4093169689Skan 409418334Speter case PREINCREMENT_EXPR: 409518334Speter case POSTINCREMENT_EXPR: 409618334Speter case PREDECREMENT_EXPR: 409718334Speter case POSTDECREMENT_EXPR: 409818334Speter /* Handle complex lvalues (when permitted) 409918334Speter by reduction to simpler cases. */ 410018334Speter 410118334Speter val = unary_complex_lvalue (code, arg); 410218334Speter if (val != 0) 410318334Speter return val; 410418334Speter 410550397Sobrien /* Increment or decrement the real part of the value, 410650397Sobrien and don't change the imaginary part. */ 410750397Sobrien if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) 410850397Sobrien { 410950397Sobrien tree real, imag; 411050397Sobrien 411150397Sobrien arg = stabilize_reference (arg); 411250397Sobrien real = build_unary_op (REALPART_EXPR, arg, 1); 411350397Sobrien imag = build_unary_op (IMAGPART_EXPR, arg, 1); 4114169689Skan return build2 (COMPLEX_EXPR, TREE_TYPE (arg), 4115169689Skan build_unary_op (code, real, 1), imag); 411650397Sobrien } 411750397Sobrien 411818334Speter /* Report invalid types. */ 411918334Speter 412018334Speter if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_POINTER, 4121132718Skan arg, true))) 412218334Speter { 412318334Speter if (code == PREINCREMENT_EXPR) 412418334Speter errstring ="no pre-increment operator for type"; 412518334Speter else if (code == POSTINCREMENT_EXPR) 412618334Speter errstring ="no post-increment operator for type"; 412718334Speter else if (code == PREDECREMENT_EXPR) 412818334Speter errstring ="no pre-decrement operator for type"; 412918334Speter else 413018334Speter errstring ="no post-decrement operator for type"; 413118334Speter break; 413218334Speter } 413318334Speter 413418334Speter /* Report something read-only. */ 413518334Speter 413652284Sobrien if (CP_TYPE_CONST_P (TREE_TYPE (arg)) 413718334Speter || TREE_READONLY (arg)) 413818334Speter readonly_error (arg, ((code == PREINCREMENT_EXPR 413918334Speter || code == POSTINCREMENT_EXPR) 414018334Speter ? "increment" : "decrement"), 414118334Speter 0); 414218334Speter 414318334Speter { 4144132718Skan tree inc; 4145169689Skan tree declared_type; 414618334Speter tree result_type = TREE_TYPE (arg); 414718334Speter 4148169689Skan declared_type = unlowered_expr_type (arg); 4149169689Skan 415018334Speter arg = get_unwidened (arg, 0); 415118334Speter argtype = TREE_TYPE (arg); 415218334Speter 415318334Speter /* ARM $5.2.5 last annotation says this should be forbidden. */ 415418334Speter if (TREE_CODE (argtype) == ENUMERAL_TYPE) 415590075Sobrien pedwarn ("ISO C++ forbids %sing an enum", 415618334Speter (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 415718334Speter ? "increment" : "decrement"); 4158169689Skan 415918334Speter /* Compute the increment. */ 416018334Speter 416118334Speter if (TREE_CODE (argtype) == POINTER_TYPE) 416218334Speter { 416390075Sobrien tree type = complete_type (TREE_TYPE (argtype)); 4164169689Skan 416590075Sobrien if (!COMPLETE_OR_VOID_TYPE_P (type)) 4166169689Skan error ("cannot %s a pointer to incomplete type %qT", 4167169689Skan ((code == PREINCREMENT_EXPR 4168169689Skan || code == POSTINCREMENT_EXPR) 4169169689Skan ? "increment" : "decrement"), TREE_TYPE (argtype)); 417050397Sobrien else if ((pedantic || warn_pointer_arith) 4171132718Skan && !TYPE_PTROB_P (argtype)) 4172169689Skan pedwarn ("ISO C++ forbids %sing a pointer of type %qT", 4173169689Skan ((code == PREINCREMENT_EXPR 4174169689Skan || code == POSTINCREMENT_EXPR) 4175169689Skan ? "increment" : "decrement"), argtype); 4176117395Skan inc = cxx_sizeof_nowarn (TREE_TYPE (argtype)); 417718334Speter } 417818334Speter else 417918334Speter inc = integer_one_node; 418018334Speter 418150397Sobrien inc = cp_convert (argtype, inc); 418218334Speter 418318334Speter /* Handle incrementing a cast-expression. */ 418418334Speter 418518334Speter switch (TREE_CODE (arg)) 418618334Speter { 418718334Speter case NOP_EXPR: 418818334Speter case CONVERT_EXPR: 418918334Speter case FLOAT_EXPR: 419018334Speter case FIX_TRUNC_EXPR: 419118334Speter case FIX_FLOOR_EXPR: 419218334Speter case FIX_ROUND_EXPR: 419318334Speter case FIX_CEIL_EXPR: 419418334Speter { 419550397Sobrien tree incremented, modify, value, compound; 419618334Speter if (! lvalue_p (arg) && pedantic) 419718334Speter pedwarn ("cast to non-reference type used as lvalue"); 419818334Speter arg = stabilize_reference (arg); 419918334Speter if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR) 420018334Speter value = arg; 420118334Speter else 420218334Speter value = save_expr (arg); 4203169689Skan incremented = build2 (((code == PREINCREMENT_EXPR 4204169689Skan || code == POSTINCREMENT_EXPR) 4205169689Skan ? PLUS_EXPR : MINUS_EXPR), 4206169689Skan argtype, value, inc); 420750397Sobrien 420818334Speter modify = build_modify_expr (arg, NOP_EXPR, incremented); 4209169689Skan compound = build2 (COMPOUND_EXPR, TREE_TYPE (arg), 4210169689Skan modify, value); 421150397Sobrien 421250397Sobrien /* Eliminate warning about unused result of + or -. */ 4213169689Skan TREE_NO_WARNING (compound) = 1; 421450397Sobrien return compound; 421518334Speter } 421650397Sobrien 421750397Sobrien default: 421850397Sobrien break; 421918334Speter } 422018334Speter 422118334Speter /* Complain about anything else that is not a true lvalue. */ 422218334Speter if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR 422318334Speter || code == POSTINCREMENT_EXPR) 4224169689Skan ? lv_increment : lv_decrement))) 422518334Speter return error_mark_node; 422618334Speter 422718334Speter /* Forbid using -- on `bool'. */ 4228169689Skan if (same_type_p (declared_type, boolean_type_node)) 422918334Speter { 423018334Speter if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR) 423118334Speter { 4232169689Skan error ("invalid use of %<--%> on bool variable %qD", arg); 423318334Speter return error_mark_node; 423418334Speter } 423590075Sobrien val = boolean_increment (code, arg); 423618334Speter } 423718334Speter else 4238169689Skan val = build2 (code, TREE_TYPE (arg), arg, inc); 423918334Speter 424018334Speter TREE_SIDE_EFFECTS (val) = 1; 424150397Sobrien return cp_convert (result_type, val); 424218334Speter } 424318334Speter 424418334Speter case ADDR_EXPR: 424518334Speter /* Note that this operation never does default_conversion 424618334Speter regardless of NOCONVERT. */ 424718334Speter 424852284Sobrien argtype = lvalue_type (arg); 4249132718Skan 4250132718Skan if (TREE_CODE (arg) == OFFSET_REF) 4251132718Skan goto offset_ref; 4252132718Skan 425318334Speter if (TREE_CODE (argtype) == REFERENCE_TYPE) 425418334Speter { 4255169689Skan tree type = build_pointer_type (TREE_TYPE (argtype)); 4256169689Skan arg = build1 (CONVERT_EXPR, type, arg); 425718334Speter return arg; 425818334Speter } 425950397Sobrien else if (pedantic && DECL_MAIN_P (arg)) 426018334Speter /* ARM $3.4 */ 4261169689Skan pedwarn ("ISO C++ forbids taking address of function %<::main%>"); 426218334Speter 426318334Speter /* Let &* cancel out to simplify resulting code. */ 426418334Speter if (TREE_CODE (arg) == INDIRECT_REF) 426518334Speter { 426650397Sobrien /* We don't need to have `current_class_ptr' wrapped in a 426718334Speter NON_LVALUE_EXPR node. */ 426850397Sobrien if (arg == current_class_ref) 426950397Sobrien return current_class_ptr; 427018334Speter 427118334Speter arg = TREE_OPERAND (arg, 0); 427218334Speter if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE) 427318334Speter { 4274169689Skan tree type = build_pointer_type (TREE_TYPE (TREE_TYPE (arg))); 4275169689Skan arg = build1 (CONVERT_EXPR, type, arg); 427618334Speter } 4277169689Skan else 427818334Speter /* Don't let this be an lvalue. */ 4279169689Skan arg = rvalue (arg); 428018334Speter return arg; 428118334Speter } 428218334Speter 428318334Speter /* Uninstantiated types are all functions. Taking the 428418334Speter address of a function is a no-op, so just return the 428518334Speter argument. */ 428618334Speter 4287169689Skan gcc_assert (TREE_CODE (arg) != IDENTIFIER_NODE 4288169689Skan || !IDENTIFIER_OPNAME_P (arg)); 428918334Speter 429052284Sobrien if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg) 4291117395Skan && !really_overloaded_fn (TREE_OPERAND (arg, 1))) 4292169689Skan { 429352284Sobrien /* They're trying to take the address of a unique non-static 429490075Sobrien member function. This is ill-formed (except in MS-land), 429590075Sobrien but let's try to DTRT. 429690075Sobrien Note: We only handle unique functions here because we don't 429790075Sobrien want to complain if there's a static overload; non-unique 429890075Sobrien cases will be handled by instantiate_type. But we need to 429990075Sobrien handle this case here to allow casts on the resulting PMF. 430090075Sobrien We could defer this in non-MS mode, but it's easier to give 430190075Sobrien a useful error here. */ 430218334Speter 4303132718Skan /* Inside constant member functions, the `this' pointer 4304132718Skan contains an extra const qualifier. TYPE_MAIN_VARIANT 4305132718Skan is used here to remove this const from the diagnostics 4306132718Skan and the created OFFSET_REF. */ 4307132718Skan tree base = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg, 0))); 4308169689Skan tree fn = get_first_fn (TREE_OPERAND (arg, 1)); 4309169689Skan mark_used (fn); 431050397Sobrien 431190075Sobrien if (! flag_ms_extensions) 431290075Sobrien { 4313169689Skan tree name = DECL_NAME (fn); 431490075Sobrien if (current_class_type 431590075Sobrien && TREE_OPERAND (arg, 0) == current_class_ref) 431690075Sobrien /* An expression like &memfn. */ 4317132718Skan pedwarn ("ISO C++ forbids taking the address of an unqualified" 4318132718Skan " or parenthesized non-static member function to form" 4319169689Skan " a pointer to member function. Say %<&%T::%D%>", 4320132718Skan base, name); 432190075Sobrien else 4322132718Skan pedwarn ("ISO C++ forbids taking the address of a bound member" 4323132718Skan " function to form a pointer to member function." 4324169689Skan " Say %<&%T::%D%>", 4325132718Skan base, name); 432690075Sobrien } 4327169689Skan arg = build_offset_ref (base, fn, /*address_p=*/true); 4328169689Skan } 4329132718Skan 4330169689Skan offset_ref: 433152284Sobrien if (type_unknown_p (arg)) 433252284Sobrien return build1 (ADDR_EXPR, unknown_type_node, arg); 4333169689Skan 433418334Speter /* Handle complex lvalues (when permitted) 433518334Speter by reduction to simpler cases. */ 433618334Speter val = unary_complex_lvalue (code, arg); 433718334Speter if (val != 0) 433818334Speter return val; 433918334Speter 434018334Speter switch (TREE_CODE (arg)) 434118334Speter { 434218334Speter case NOP_EXPR: 434318334Speter case CONVERT_EXPR: 434418334Speter case FLOAT_EXPR: 434518334Speter case FIX_TRUNC_EXPR: 434618334Speter case FIX_FLOOR_EXPR: 434718334Speter case FIX_ROUND_EXPR: 434818334Speter case FIX_CEIL_EXPR: 434918334Speter if (! lvalue_p (arg) && pedantic) 435090075Sobrien pedwarn ("ISO C++ forbids taking the address of a cast to a non-lvalue expression"); 435150397Sobrien break; 4352132718Skan 4353169689Skan case BASELINK: 4354169689Skan arg = BASELINK_FUNCTIONS (arg); 4355169689Skan /* Fall through. */ 4356169689Skan 4357132718Skan case OVERLOAD: 4358132718Skan arg = OVL_CURRENT (arg); 4359132718Skan break; 4360132718Skan 4361169689Skan case OFFSET_REF: 4362169689Skan /* Turn a reference to a non-static data member into a 4363169689Skan pointer-to-member. */ 4364169689Skan { 4365169689Skan tree type; 4366169689Skan tree t; 4367169689Skan 4368169689Skan if (!PTRMEM_OK_P (arg)) 4369169689Skan return build_unary_op (code, arg, 0); 4370169689Skan 4371169689Skan t = TREE_OPERAND (arg, 1); 4372169689Skan if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE) 4373169689Skan { 4374169689Skan error ("cannot create pointer to reference member %qD", t); 4375169689Skan return error_mark_node; 4376169689Skan } 4377169689Skan 4378169689Skan type = build_ptrmem_type (context_for_name_lookup (t), 4379169689Skan TREE_TYPE (t)); 4380169689Skan t = make_ptrmem_cst (type, TREE_OPERAND (arg, 1)); 4381169689Skan return t; 4382169689Skan } 4383169689Skan 438450397Sobrien default: 438550397Sobrien break; 438618334Speter } 438718334Speter 438818334Speter /* Anything not already handled and not a true memory reference 438918334Speter is an error. */ 4390169689Skan if (TREE_CODE (argtype) != FUNCTION_TYPE 4391169689Skan && TREE_CODE (argtype) != METHOD_TYPE 4392169689Skan && TREE_CODE (arg) != OFFSET_REF 4393169689Skan && !lvalue_or_else (arg, lv_addressof)) 439418334Speter return error_mark_node; 439518334Speter 439652284Sobrien if (argtype != error_mark_node) 439752284Sobrien argtype = build_pointer_type (argtype); 439818334Speter 4399169689Skan /* In a template, we are processing a non-dependent expression 4400169689Skan so we can just form an ADDR_EXPR with the correct type. */ 4401169689Skan if (processing_template_decl) 4402169689Skan { 4403169689Skan val = build_address (arg); 4404169689Skan if (TREE_CODE (arg) == OFFSET_REF) 4405169689Skan PTRMEM_OK_P (val) = PTRMEM_OK_P (arg); 4406169689Skan return val; 4407169689Skan } 440818334Speter 4409169689Skan if (TREE_CODE (arg) != COMPONENT_REF) 4410169689Skan { 4411169689Skan val = build_address (arg); 4412169689Skan if (TREE_CODE (arg) == OFFSET_REF) 4413169689Skan PTRMEM_OK_P (val) = PTRMEM_OK_P (arg); 4414169689Skan } 4415169689Skan else if (TREE_CODE (TREE_OPERAND (arg, 1)) == BASELINK) 4416169689Skan { 4417169689Skan tree fn = BASELINK_FUNCTIONS (TREE_OPERAND (arg, 1)); 4418132718Skan 4419169689Skan /* We can only get here with a single static member 4420169689Skan function. */ 4421169689Skan gcc_assert (TREE_CODE (fn) == FUNCTION_DECL 4422169689Skan && DECL_STATIC_FUNCTION_P (fn)); 4423169689Skan mark_used (fn); 4424169689Skan val = build_address (fn); 4425169689Skan if (TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0))) 4426169689Skan /* Do not lose object's side effects. */ 4427169689Skan val = build2 (COMPOUND_EXPR, TREE_TYPE (val), 4428169689Skan TREE_OPERAND (arg, 0), val); 4429169689Skan } 4430169689Skan else if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1))) 4431169689Skan { 4432169689Skan error ("attempt to take address of bit-field structure member %qD", 4433169689Skan TREE_OPERAND (arg, 1)); 4434169689Skan return error_mark_node; 4435169689Skan } 4436169689Skan else 4437169689Skan { 4438169689Skan tree object = TREE_OPERAND (arg, 0); 4439169689Skan tree field = TREE_OPERAND (arg, 1); 4440169689Skan gcc_assert (same_type_ignoring_top_level_qualifiers_p 4441169689Skan (TREE_TYPE (object), decl_type_context (field))); 4442169689Skan val = build_address (arg); 4443169689Skan } 444418334Speter 4445169689Skan if (TREE_CODE (argtype) == POINTER_TYPE 4446169689Skan && TREE_CODE (TREE_TYPE (argtype)) == METHOD_TYPE) 4447169689Skan { 4448169689Skan build_ptrmemfunc_type (argtype); 4449169689Skan val = build_ptrmemfunc (argtype, val, 0, 4450169689Skan /*c_cast_p=*/false); 4451169689Skan } 445250397Sobrien 4453169689Skan return val; 445450397Sobrien 445550397Sobrien default: 445650397Sobrien break; 445718334Speter } 445818334Speter 445918334Speter if (!errstring) 446018334Speter { 446118334Speter if (argtype == 0) 446218334Speter argtype = TREE_TYPE (arg); 4463169689Skan return fold_if_not_in_template (build1 (code, argtype, arg)); 446418334Speter } 446518334Speter 446690075Sobrien error ("%s", errstring); 446718334Speter return error_mark_node; 446818334Speter} 446918334Speter 447018334Speter/* Apply unary lvalue-demanding operator CODE to the expression ARG 447118334Speter for certain kinds of expressions which are not really lvalues 447218334Speter but which we can accept as lvalues. 447318334Speter 4474146895Skan If ARG is not a kind of expression we can handle, return 4475146895Skan NULL_TREE. */ 4476169689Skan 447718334Spetertree 4478132718Skanunary_complex_lvalue (enum tree_code code, tree arg) 447918334Speter{ 4480169689Skan /* Inside a template, making these kinds of adjustments is 4481169689Skan pointless; we are only concerned with the type of the 4482169689Skan expression. */ 4483169689Skan if (processing_template_decl) 4484169689Skan return NULL_TREE; 4485169689Skan 448618334Speter /* Handle (a, b) used as an "lvalue". */ 448718334Speter if (TREE_CODE (arg) == COMPOUND_EXPR) 448818334Speter { 448918334Speter tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0); 4490169689Skan return build2 (COMPOUND_EXPR, TREE_TYPE (real_result), 4491169689Skan TREE_OPERAND (arg, 0), real_result); 449218334Speter } 449318334Speter 449418334Speter /* Handle (a ? b : c) used as an "lvalue". */ 449550397Sobrien if (TREE_CODE (arg) == COND_EXPR 449650397Sobrien || TREE_CODE (arg) == MIN_EXPR || TREE_CODE (arg) == MAX_EXPR) 449718334Speter return rationalize_conditional_expr (code, arg); 449818334Speter 449990075Sobrien /* Handle (a = b), (++a), and (--a) used as an "lvalue". */ 450018334Speter if (TREE_CODE (arg) == MODIFY_EXPR 450118334Speter || TREE_CODE (arg) == PREINCREMENT_EXPR 450218334Speter || TREE_CODE (arg) == PREDECREMENT_EXPR) 450390075Sobrien { 450490075Sobrien tree lvalue = TREE_OPERAND (arg, 0); 450590075Sobrien if (TREE_SIDE_EFFECTS (lvalue)) 450690075Sobrien { 450790075Sobrien lvalue = stabilize_reference (lvalue); 4508169689Skan arg = build2 (TREE_CODE (arg), TREE_TYPE (arg), 4509169689Skan lvalue, TREE_OPERAND (arg, 1)); 451090075Sobrien } 451190075Sobrien return unary_complex_lvalue 4512169689Skan (code, build2 (COMPOUND_EXPR, TREE_TYPE (lvalue), arg, lvalue)); 451390075Sobrien } 451418334Speter 451518334Speter if (code != ADDR_EXPR) 4516169689Skan return NULL_TREE; 451718334Speter 451818334Speter /* Handle (a = b) used as an "lvalue" for `&'. */ 451918334Speter if (TREE_CODE (arg) == MODIFY_EXPR 452018334Speter || TREE_CODE (arg) == INIT_EXPR) 452118334Speter { 452218334Speter tree real_result = build_unary_op (code, TREE_OPERAND (arg, 0), 0); 4523169689Skan arg = build2 (COMPOUND_EXPR, TREE_TYPE (real_result), 4524169689Skan arg, real_result); 4525169689Skan TREE_NO_WARNING (arg) = 1; 452650397Sobrien return arg; 452718334Speter } 452818334Speter 452918334Speter if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE 453018334Speter || TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE 4531132718Skan || TREE_CODE (arg) == OFFSET_REF) 4532169689Skan return NULL_TREE; 453318334Speter 453418334Speter /* We permit compiler to make function calls returning 453518334Speter objects of aggregate type look like lvalues. */ 453618334Speter { 453718334Speter tree targ = arg; 453818334Speter 453918334Speter if (TREE_CODE (targ) == SAVE_EXPR) 454018334Speter targ = TREE_OPERAND (targ, 0); 454118334Speter 454218334Speter if (TREE_CODE (targ) == CALL_EXPR && IS_AGGR_TYPE (TREE_TYPE (targ))) 454318334Speter { 454418334Speter if (TREE_CODE (arg) == SAVE_EXPR) 454518334Speter targ = arg; 454618334Speter else 454750397Sobrien targ = build_cplus_new (TREE_TYPE (arg), arg); 454818334Speter return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (arg)), targ); 454918334Speter } 455018334Speter 455118334Speter if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == INDIRECT_REF) 4552169689Skan return build3 (SAVE_EXPR, build_pointer_type (TREE_TYPE (arg)), 455318334Speter TREE_OPERAND (targ, 0), current_function_decl, NULL); 455418334Speter } 455518334Speter 455618334Speter /* Don't let anything else be handled specially. */ 4557169689Skan return NULL_TREE; 455818334Speter} 455918334Speter 456018334Speter/* Mark EXP saying that we need to be able to take the 456118334Speter address of it; it should not be allocated in a register. 4562117395Skan Value is true if successful. 456318334Speter 456450397Sobrien C++: we do not allow `current_class_ptr' to be addressable. */ 456518334Speter 4566117395Skanbool 4567132718Skancxx_mark_addressable (tree exp) 456818334Speter{ 4569132718Skan tree x = exp; 457018334Speter 457118334Speter while (1) 457218334Speter switch (TREE_CODE (x)) 457318334Speter { 457418334Speter case ADDR_EXPR: 457518334Speter case COMPONENT_REF: 457618334Speter case ARRAY_REF: 457750397Sobrien case REALPART_EXPR: 457850397Sobrien case IMAGPART_EXPR: 457918334Speter x = TREE_OPERAND (x, 0); 458018334Speter break; 458118334Speter 458218334Speter case PARM_DECL: 458350397Sobrien if (x == current_class_ptr) 458418334Speter { 4585169689Skan error ("cannot take the address of %<this%>, which is an rvalue expression"); 4586132718Skan TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later. */ 4587117395Skan return true; 458818334Speter } 4589132718Skan /* Fall through. */ 4590102780Skan 459118334Speter case VAR_DECL: 459218334Speter /* Caller should not be trying to mark initialized 459318334Speter constant fields addressable. */ 4594169689Skan gcc_assert (DECL_LANG_SPECIFIC (x) == 0 4595169689Skan || DECL_IN_AGGR_P (x) == 0 4596169689Skan || TREE_STATIC (x) 4597169689Skan || DECL_EXTERNAL (x)); 4598132718Skan /* Fall through. */ 459918334Speter 460018334Speter case CONST_DECL: 460118334Speter case RESULT_DECL: 460250397Sobrien if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x) 4603169689Skan && !DECL_ARTIFICIAL (x)) 4604169689Skan { 4605169689Skan if (TREE_CODE (x) == VAR_DECL && DECL_HARD_REGISTER (x)) 4606169689Skan { 4607169689Skan error 4608169689Skan ("address of explicit register variable %qD requested", x); 4609169689Skan return false; 4610169689Skan } 4611169689Skan else if (extra_warnings) 4612169689Skan warning 4613169689Skan (OPT_Wextra, "address requested for %qD, which is declared %<register%>", x); 4614169689Skan } 461518334Speter TREE_ADDRESSABLE (x) = 1; 4616117395Skan return true; 461718334Speter 461818334Speter case FUNCTION_DECL: 461918334Speter TREE_ADDRESSABLE (x) = 1; 4620117395Skan return true; 462118334Speter 462250397Sobrien case CONSTRUCTOR: 462350397Sobrien TREE_ADDRESSABLE (x) = 1; 4624117395Skan return true; 462550397Sobrien 462650397Sobrien case TARGET_EXPR: 462750397Sobrien TREE_ADDRESSABLE (x) = 1; 4628117395Skan cxx_mark_addressable (TREE_OPERAND (x, 0)); 4629117395Skan return true; 463050397Sobrien 463118334Speter default: 4632117395Skan return true; 463318334Speter } 463418334Speter} 463518334Speter 463618334Speter/* Build and return a conditional expression IFEXP ? OP1 : OP2. */ 463718334Speter 463818334Spetertree 4639132718Skanbuild_x_conditional_expr (tree ifexp, tree op1, tree op2) 464018334Speter{ 4641132718Skan tree orig_ifexp = ifexp; 4642132718Skan tree orig_op1 = op1; 4643132718Skan tree orig_op2 = op2; 4644132718Skan tree expr; 4645132718Skan 464650397Sobrien if (processing_template_decl) 4647132718Skan { 4648132718Skan /* The standard says that the expression is type-dependent if 4649132718Skan IFEXP is type-dependent, even though the eventual type of the 4650132718Skan expression doesn't dependent on IFEXP. */ 4651132718Skan if (type_dependent_expression_p (ifexp) 4652132718Skan /* As a GNU extension, the middle operand may be omitted. */ 4653132718Skan || (op1 && type_dependent_expression_p (op1)) 4654132718Skan || type_dependent_expression_p (op2)) 4655132718Skan return build_min_nt (COND_EXPR, ifexp, op1, op2); 4656132718Skan ifexp = build_non_dependent_expr (ifexp); 4657132718Skan if (op1) 4658132718Skan op1 = build_non_dependent_expr (op1); 4659132718Skan op2 = build_non_dependent_expr (op2); 4660132718Skan } 466118334Speter 4662132718Skan expr = build_conditional_expr (ifexp, op1, op2); 4663132718Skan if (processing_template_decl && expr != error_mark_node) 4664169689Skan return build_min_non_dep (COND_EXPR, expr, 4665132718Skan orig_ifexp, orig_op1, orig_op2); 4666132718Skan return expr; 466718334Speter} 466818334Speter 4669132718Skan/* Given a list of expressions, return a compound expression 4670132718Skan that performs them all and returns the value of the last of them. */ 467150397Sobrien 4672132718Skantree build_x_compound_expr_from_list (tree list, const char *msg) 4673132718Skan{ 4674132718Skan tree expr = TREE_VALUE (list); 4675169689Skan 4676132718Skan if (TREE_CHAIN (list)) 4677132718Skan { 4678132718Skan if (msg) 4679132718Skan pedwarn ("%s expression list treated as compound expression", msg); 4680132718Skan 4681132718Skan for (list = TREE_CHAIN (list); list; list = TREE_CHAIN (list)) 4682132718Skan expr = build_x_compound_expr (expr, TREE_VALUE (list)); 4683132718Skan } 4684169689Skan 4685132718Skan return expr; 4686132718Skan} 4687132718Skan 4688132718Skan/* Handle overloading of the ',' operator when needed. */ 4689132718Skan 469018334Spetertree 4691132718Skanbuild_x_compound_expr (tree op1, tree op2) 469218334Speter{ 469318334Speter tree result; 4694132718Skan tree orig_op1 = op1; 4695132718Skan tree orig_op2 = op2; 469618334Speter 469750397Sobrien if (processing_template_decl) 469818334Speter { 4699132718Skan if (type_dependent_expression_p (op1) 4700132718Skan || type_dependent_expression_p (op2)) 4701132718Skan return build_min_nt (COMPOUND_EXPR, op1, op2); 4702132718Skan op1 = build_non_dependent_expr (op1); 4703132718Skan op2 = build_non_dependent_expr (op2); 470418334Speter } 470518334Speter 4706132718Skan result = build_new_op (COMPOUND_EXPR, LOOKUP_NORMAL, op1, op2, NULL_TREE, 4707132718Skan /*overloaded_p=*/NULL); 4708132718Skan if (!result) 4709132718Skan result = build_compound_expr (op1, op2); 4710132718Skan 4711132718Skan if (processing_template_decl && result != error_mark_node) 4712132718Skan return build_min_non_dep (COMPOUND_EXPR, result, orig_op1, orig_op2); 4713169689Skan 4714132718Skan return result; 471518334Speter} 471618334Speter 4717132718Skan/* Build a compound expression. */ 471818334Speter 471918334Spetertree 4720132718Skanbuild_compound_expr (tree lhs, tree rhs) 472118334Speter{ 4722132718Skan lhs = convert_to_void (lhs, "left-hand operand of comma"); 4723169689Skan 4724132718Skan if (lhs == error_mark_node || rhs == error_mark_node) 4725132718Skan return error_mark_node; 4726169689Skan 4727132718Skan if (TREE_CODE (rhs) == TARGET_EXPR) 472818334Speter { 4729132718Skan /* If the rhs is a TARGET_EXPR, then build the compound 4730169689Skan expression inside the target_expr's initializer. This 4731132718Skan helps the compiler to eliminate unnecessary temporaries. */ 4732132718Skan tree init = TREE_OPERAND (rhs, 1); 4733169689Skan 4734169689Skan init = build2 (COMPOUND_EXPR, TREE_TYPE (init), lhs, init); 4735132718Skan TREE_OPERAND (rhs, 1) = init; 4736169689Skan 4737132718Skan return rhs; 473818334Speter } 4739169689Skan 4740169689Skan return build2 (COMPOUND_EXPR, TREE_TYPE (rhs), lhs, rhs); 474118334Speter} 474218334Speter 4743169689Skan/* Issue a diagnostic message if casting from SRC_TYPE to DEST_TYPE 4744169689Skan casts away constness. DIAG_FN gives the function to call if we 4745169689Skan need to issue a diagnostic; if it is NULL, no diagnostic will be 4746169689Skan issued. DESCRIPTION explains what operation is taking place. */ 4747117395Skan 4748117395Skanstatic void 4749132718Skancheck_for_casting_away_constness (tree src_type, tree dest_type, 4750169689Skan void (*diag_fn)(const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2), 4751132718Skan const char *description) 4752117395Skan{ 4753169689Skan if (diag_fn && casts_away_constness (src_type, dest_type)) 4754169689Skan diag_fn ("%s from type %qT to type %qT casts away constness", 4755169689Skan description, src_type, dest_type); 4756117395Skan} 4757117395Skan 4758169689Skan/* Convert EXPR (an expression with pointer-to-member type) to TYPE 4759169689Skan (another pointer-to-member type in the same hierarchy) and return 4760169689Skan the converted expression. If ALLOW_INVERSE_P is permitted, a 4761169689Skan pointer-to-derived may be converted to pointer-to-base; otherwise, 4762169689Skan only the other direction is permitted. If C_CAST_P is true, this 4763169689Skan conversion is taking place as part of a C-style cast. */ 4764117395Skan 476550397Sobrientree 4766169689Skanconvert_ptrmem (tree type, tree expr, bool allow_inverse_p, 4767169689Skan bool c_cast_p) 476818334Speter{ 4769169689Skan if (TYPE_PTRMEM_P (type)) 4770169689Skan { 4771169689Skan tree delta; 477218334Speter 4773169689Skan if (TREE_CODE (expr) == PTRMEM_CST) 4774169689Skan expr = cplus_expand_constant (expr); 4775169689Skan delta = get_delta_difference (TYPE_PTRMEM_CLASS_TYPE (TREE_TYPE (expr)), 4776169689Skan TYPE_PTRMEM_CLASS_TYPE (type), 4777169689Skan allow_inverse_p, 4778169689Skan c_cast_p); 4779169689Skan if (!integer_zerop (delta)) 4780169689Skan expr = cp_build_binary_op (PLUS_EXPR, 4781169689Skan build_nop (ptrdiff_type_node, expr), 4782169689Skan delta); 4783169689Skan return build_nop (type, expr); 4784169689Skan } 4785169689Skan else 4786169689Skan return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 4787169689Skan allow_inverse_p, c_cast_p); 4788169689Skan} 478918334Speter 4790169689Skan/* If EXPR is an INTEGER_CST and ORIG is an arithmetic constant, return 4791169689Skan a version of EXPR that has TREE_OVERFLOW and/or TREE_CONSTANT_OVERFLOW 4792169689Skan set iff they are set in ORIG. Otherwise, return EXPR unchanged. */ 4793169689Skan 4794169689Skanstatic tree 4795169689Skanignore_overflows (tree expr, tree orig) 4796169689Skan{ 4797169689Skan if (TREE_CODE (expr) == INTEGER_CST 4798169689Skan && CONSTANT_CLASS_P (orig) 4799169689Skan && TREE_CODE (orig) != STRING_CST 4800169689Skan && (TREE_OVERFLOW (expr) != TREE_OVERFLOW (orig) 4801169689Skan || TREE_CONSTANT_OVERFLOW (expr) 4802169689Skan != TREE_CONSTANT_OVERFLOW (orig))) 480318334Speter { 4804169689Skan if (!TREE_OVERFLOW (orig) && !TREE_CONSTANT_OVERFLOW (orig)) 4805169689Skan /* Ensure constant sharing. */ 4806169689Skan expr = build_int_cst_wide (TREE_TYPE (expr), 4807169689Skan TREE_INT_CST_LOW (expr), 4808169689Skan TREE_INT_CST_HIGH (expr)); 4809169689Skan else 4810169689Skan { 4811169689Skan /* Avoid clobbering a shared constant. */ 4812169689Skan expr = copy_node (expr); 4813169689Skan TREE_OVERFLOW (expr) = TREE_OVERFLOW (orig); 4814169689Skan TREE_CONSTANT_OVERFLOW (expr) 4815169689Skan = TREE_CONSTANT_OVERFLOW (orig); 4816169689Skan } 481718334Speter } 4818169689Skan return expr; 4819169689Skan} 482050397Sobrien 4821169689Skan/* Perform a static_cast from EXPR to TYPE. When C_CAST_P is true, 4822169689Skan this static_cast is being attempted as one of the possible casts 4823169689Skan allowed by a C-style cast. (In that case, accessibility of base 4824169689Skan classes is not considered, and it is OK to cast away 4825169689Skan constness.) Return the result of the cast. *VALID_P is set to 4826169689Skan indicate whether or not the cast was valid. */ 482750397Sobrien 4828169689Skanstatic tree 4829169689Skanbuild_static_cast_1 (tree type, tree expr, bool c_cast_p, 4830169689Skan bool *valid_p) 4831169689Skan{ 4832169689Skan tree intype; 4833169689Skan tree result; 4834169689Skan tree orig; 4835169689Skan void (*diag_fn)(const char*, ...) ATTRIBUTE_GCC_CXXDIAG(1,2); 4836169689Skan const char *desc; 4837169689Skan 4838169689Skan /* Assume the cast is valid. */ 4839169689Skan *valid_p = true; 4840169689Skan 4841117395Skan intype = TREE_TYPE (expr); 4842117395Skan 4843169689Skan /* Save casted types in the function's used types hash table. */ 4844169689Skan used_types_insert (type); 4845169689Skan 4846169689Skan /* Determine what to do when casting away constness. */ 4847169689Skan if (c_cast_p) 4848169689Skan { 4849169689Skan /* C-style casts are allowed to cast away constness. With 4850169689Skan WARN_CAST_QUAL, we still want to issue a warning. */ 4851169689Skan diag_fn = warn_cast_qual ? warning0 : NULL; 4852169689Skan desc = "cast"; 4853169689Skan } 4854169689Skan else 4855169689Skan { 4856169689Skan /* A static_cast may not cast away constness. */ 4857169689Skan diag_fn = error; 4858169689Skan desc = "static_cast"; 4859169689Skan } 4860169689Skan 4861117395Skan /* [expr.static.cast] 4862117395Skan 4863117395Skan An lvalue of type "cv1 B", where B is a class type, can be cast 4864117395Skan to type "reference to cv2 D", where D is a class derived (clause 4865117395Skan _class.derived_) from B, if a valid standard conversion from 4866117395Skan "pointer to D" to "pointer to B" exists (_conv.ptr_), cv2 is the 4867117395Skan same cv-qualification as, or greater cv-qualification than, cv1, 4868117395Skan and B is not a virtual base class of D. */ 4869117395Skan /* We check this case before checking the validity of "TYPE t = 4870117395Skan EXPR;" below because for this case: 4871117395Skan 4872117395Skan struct B {}; 4873117395Skan struct D : public B { D(const B&); }; 4874117395Skan extern B& b; 4875117395Skan void f() { static_cast<const D&>(b); } 4876117395Skan 4877117395Skan we want to avoid constructing a new D. The standard is not 4878117395Skan completely clear about this issue, but our interpretation is 4879117395Skan consistent with other compilers. */ 4880117395Skan if (TREE_CODE (type) == REFERENCE_TYPE 4881117395Skan && CLASS_TYPE_P (TREE_TYPE (type)) 4882117395Skan && CLASS_TYPE_P (intype) 4883132718Skan && real_lvalue_p (expr) 4884117395Skan && DERIVED_FROM_P (intype, TREE_TYPE (type)) 4885117395Skan && can_convert (build_pointer_type (TYPE_MAIN_VARIANT (intype)), 4886169689Skan build_pointer_type (TYPE_MAIN_VARIANT 4887117395Skan (TREE_TYPE (type)))) 4888169689Skan && (c_cast_p 4889169689Skan || at_least_as_qualified_p (TREE_TYPE (type), intype))) 489090075Sobrien { 4891169689Skan tree base; 4892169689Skan 4893122180Skan /* There is a standard conversion from "D*" to "B*" even if "B" 4894169689Skan is ambiguous or inaccessible. If this is really a 4895169689Skan static_cast, then we check both for inaccessibility and 4896169689Skan ambiguity. However, if this is a static_cast being performed 4897169689Skan because the user wrote a C-style cast, then accessibility is 4898169689Skan not considered. */ 4899169689Skan base = lookup_base (TREE_TYPE (type), intype, 4900169689Skan c_cast_p ? ba_unique : ba_check, 4901169689Skan NULL); 4902117395Skan 4903122180Skan /* Convert from "B*" to "D*". This function will check that "B" 4904122180Skan is not a virtual base of "D". */ 4905169689Skan expr = build_base_path (MINUS_EXPR, build_address (expr), 4906117395Skan base, /*nonnull=*/false); 4907117395Skan /* Convert the pointer to a reference -- but then remember that 4908117395Skan there are no expressions with reference type in C++. */ 4909117395Skan return convert_from_reference (build_nop (type, expr)); 491090075Sobrien } 491150397Sobrien 4912169689Skan orig = expr; 4913169689Skan 4914117395Skan /* [expr.static.cast] 491550397Sobrien 4916117395Skan An expression e can be explicitly converted to a type T using a 4917117395Skan static_cast of the form static_cast<T>(e) if the declaration T 4918117395Skan t(e);" is well-formed, for some invented temporary variable 4919117395Skan t. */ 4920169689Skan result = perform_direct_initialization_if_possible (type, expr, 4921169689Skan c_cast_p); 4922117395Skan if (result) 4923132718Skan { 4924132718Skan result = convert_from_reference (result); 4925169689Skan 4926169689Skan /* Ignore any integer overflow caused by the cast. */ 4927169689Skan result = ignore_overflows (result, orig); 4928169689Skan 4929132718Skan /* [expr.static.cast] 4930132718Skan 4931169689Skan If T is a reference type, the result is an lvalue; otherwise, 4932132718Skan the result is an rvalue. */ 4933169689Skan if (TREE_CODE (type) != REFERENCE_TYPE) 4934169689Skan result = rvalue (result); 4935132718Skan return result; 4936132718Skan } 4937169689Skan 4938117395Skan /* [expr.static.cast] 493950397Sobrien 4940117395Skan Any expression can be explicitly converted to type cv void. */ 4941117395Skan if (TREE_CODE (type) == VOID_TYPE) 4942117395Skan return convert_to_void (expr, /*implicit=*/NULL); 494350397Sobrien 4944117395Skan /* [expr.static.cast] 4945117395Skan 4946117395Skan The inverse of any standard conversion sequence (clause _conv_), 4947117395Skan other than the lvalue-to-rvalue (_conv.lval_), array-to-pointer 4948117395Skan (_conv.array_), function-to-pointer (_conv.func_), and boolean 4949117395Skan (_conv.bool_) conversions, can be performed explicitly using 4950117395Skan static_cast subject to the restriction that the explicit 4951117395Skan conversion does not cast away constness (_expr.const.cast_), and 4952117395Skan the following additional rules for specific cases: */ 4953117395Skan /* For reference, the conversions not excluded are: integral 4954117395Skan promotions, floating point promotion, integral conversions, 4955117395Skan floating point conversions, floating-integral conversions, 4956117395Skan pointer conversions, and pointer to member conversions. */ 4957169689Skan /* DR 128 4958117395Skan 4959169689Skan A value of integral _or enumeration_ type can be explicitly 4960169689Skan converted to an enumeration type. */ 4961169689Skan /* The effect of all that is that any conversion between any two 4962169689Skan types which are integral, floating, or enumeration types can be 4963169689Skan performed. */ 4964169689Skan if ((INTEGRAL_TYPE_P (type) || SCALAR_FLOAT_TYPE_P (type)) 4965169689Skan && (INTEGRAL_TYPE_P (intype) || SCALAR_FLOAT_TYPE_P (intype))) 4966169689Skan { 4967169689Skan expr = ocp_convert (type, expr, CONV_C_CAST, LOOKUP_NORMAL); 4968169689Skan 4969169689Skan /* Ignore any integer overflow caused by the cast. */ 4970169689Skan expr = ignore_overflows (expr, orig); 4971169689Skan return expr; 4972169689Skan } 4973169689Skan 4974117395Skan if (TYPE_PTR_P (type) && TYPE_PTR_P (intype) 4975117395Skan && CLASS_TYPE_P (TREE_TYPE (type)) 4976117395Skan && CLASS_TYPE_P (TREE_TYPE (intype)) 4977169689Skan && can_convert (build_pointer_type (TYPE_MAIN_VARIANT 4978169689Skan (TREE_TYPE (intype))), 4979169689Skan build_pointer_type (TYPE_MAIN_VARIANT 4980117395Skan (TREE_TYPE (type))))) 498118334Speter { 4982117395Skan tree base; 4983117395Skan 4984169689Skan if (!c_cast_p) 4985169689Skan check_for_casting_away_constness (intype, type, diag_fn, desc); 4986169689Skan base = lookup_base (TREE_TYPE (type), TREE_TYPE (intype), 4987169689Skan c_cast_p ? ba_unique : ba_check, 4988132718Skan NULL); 4989117395Skan return build_base_path (MINUS_EXPR, expr, base, /*nonnull=*/false); 499018334Speter } 4991169689Skan 4992117395Skan if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype)) 4993117395Skan || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype))) 499496263Sobrien { 4995117395Skan tree c1; 4996117395Skan tree c2; 4997117395Skan tree t1; 4998117395Skan tree t2; 4999117395Skan 5000117395Skan c1 = TYPE_PTRMEM_CLASS_TYPE (intype); 5001117395Skan c2 = TYPE_PTRMEM_CLASS_TYPE (type); 5002117395Skan 5003117395Skan if (TYPE_PTRMEM_P (type)) 5004117395Skan { 5005169689Skan t1 = (build_ptrmem_type 5006117395Skan (c1, 5007117395Skan TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (intype)))); 5008169689Skan t2 = (build_ptrmem_type 5009117395Skan (c2, 5010117395Skan TYPE_MAIN_VARIANT (TYPE_PTRMEM_POINTED_TO_TYPE (type)))); 5011117395Skan } 5012117395Skan else 5013117395Skan { 5014117395Skan t1 = intype; 5015117395Skan t2 = type; 5016117395Skan } 5017117395Skan if (can_convert (t1, t2)) 5018117395Skan { 5019169689Skan if (!c_cast_p) 5020169689Skan check_for_casting_away_constness (intype, type, diag_fn, 5021169689Skan desc); 5022169689Skan return convert_ptrmem (type, expr, /*allow_inverse_p=*/1, 5023169689Skan c_cast_p); 5024117395Skan } 502596263Sobrien } 5026169689Skan 502790075Sobrien /* [expr.static.cast] 502890075Sobrien 5029117395Skan An rvalue of type "pointer to cv void" can be explicitly 5030117395Skan converted to a pointer to object type. A value of type pointer 5031117395Skan to object converted to "pointer to cv void" and back to the 5032117395Skan original pointer type will have its original value. */ 5033169689Skan if (TREE_CODE (intype) == POINTER_TYPE 5034117395Skan && VOID_TYPE_P (TREE_TYPE (intype)) 5035117395Skan && TYPE_PTROB_P (type)) 503690075Sobrien { 5037169689Skan if (!c_cast_p) 5038169689Skan check_for_casting_away_constness (intype, type, diag_fn, desc); 5039117395Skan return build_nop (type, expr); 504090075Sobrien } 504190075Sobrien 5042169689Skan *valid_p = false; 504350397Sobrien return error_mark_node; 504418334Speter} 504518334Speter 5046169689Skan/* Return an expression representing static_cast<TYPE>(EXPR). */ 5047169689Skan 504850397Sobrientree 5049169689Skanbuild_static_cast (tree type, tree expr) 505018334Speter{ 5051169689Skan tree result; 5052169689Skan bool valid_p; 505318334Speter 505418334Speter if (type == error_mark_node || expr == error_mark_node) 505518334Speter return error_mark_node; 505618334Speter 505750397Sobrien if (processing_template_decl) 505818334Speter { 5059169689Skan expr = build_min (STATIC_CAST_EXPR, type, expr); 5060169689Skan /* We don't know if it will or will not have side effects. */ 5061169689Skan TREE_SIDE_EFFECTS (expr) = 1; 5062169689Skan return convert_from_reference (expr); 506318334Speter } 506450397Sobrien 5065169689Skan /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue. 5066169689Skan Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */ 5067169689Skan if (TREE_CODE (type) != REFERENCE_TYPE 5068169689Skan && TREE_CODE (expr) == NOP_EXPR 5069169689Skan && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0))) 5070169689Skan expr = TREE_OPERAND (expr, 0); 5071169689Skan 5072169689Skan result = build_static_cast_1 (type, expr, /*c_cast_p=*/false, &valid_p); 5073169689Skan if (valid_p) 5074169689Skan return result; 5075169689Skan 5076169689Skan error ("invalid static_cast from type %qT to type %qT", 5077169689Skan TREE_TYPE (expr), type); 5078169689Skan return error_mark_node; 5079169689Skan} 5080169689Skan 5081169689Skan/* EXPR is an expression with member function or pointer-to-member 5082169689Skan function type. TYPE is a pointer type. Converting EXPR to TYPE is 5083169689Skan not permitted by ISO C++, but we accept it in some modes. If we 5084169689Skan are not in one of those modes, issue a diagnostic. Return the 5085169689Skan converted expression. */ 5086169689Skan 5087169689Skantree 5088169689Skanconvert_member_func_to_ptr (tree type, tree expr) 5089169689Skan{ 5090169689Skan tree intype; 5091169689Skan tree decl; 5092169689Skan 5093169689Skan intype = TREE_TYPE (expr); 5094169689Skan gcc_assert (TYPE_PTRMEMFUNC_P (intype) 5095169689Skan || TREE_CODE (intype) == METHOD_TYPE); 5096169689Skan 5097169689Skan if (pedantic || warn_pmf2ptr) 5098169689Skan pedwarn ("converting from %qT to %qT", intype, type); 5099169689Skan 5100169689Skan if (TREE_CODE (intype) == METHOD_TYPE) 5101169689Skan expr = build_addr_func (expr); 5102169689Skan else if (TREE_CODE (expr) == PTRMEM_CST) 5103169689Skan expr = build_address (PTRMEM_CST_MEMBER (expr)); 5104169689Skan else 510518334Speter { 5106169689Skan decl = maybe_dummy_object (TYPE_PTRMEM_CLASS_TYPE (intype), 0); 5107169689Skan decl = build_address (decl); 5108169689Skan expr = get_member_function_from_ptrfunc (&decl, expr); 510918334Speter } 511050397Sobrien 5111169689Skan return build_nop (type, expr); 5112169689Skan} 5113169689Skan 5114169689Skan/* Return a representation for a reinterpret_cast from EXPR to TYPE. 5115169689Skan If C_CAST_P is true, this reinterpret cast is being done as part of 5116169689Skan a C-style cast. If VALID_P is non-NULL, *VALID_P is set to 5117169689Skan indicate whether or not reinterpret_cast was valid. */ 5118169689Skan 5119169689Skanstatic tree 5120169689Skanbuild_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p, 5121169689Skan bool *valid_p) 5122169689Skan{ 5123169689Skan tree intype; 5124169689Skan 5125169689Skan /* Assume the cast is invalid. */ 5126169689Skan if (valid_p) 5127169689Skan *valid_p = true; 5128169689Skan 5129169689Skan if (type == error_mark_node || error_operand_p (expr)) 5130169689Skan return error_mark_node; 5131169689Skan 513250397Sobrien intype = TREE_TYPE (expr); 513350397Sobrien 5134169689Skan /* Save casted types in the function's used types hash table. */ 5135169689Skan used_types_insert (type); 5136169689Skan 5137169689Skan /* [expr.reinterpret.cast] 5138169689Skan An lvalue expression of type T1 can be cast to the type 5139169689Skan "reference to T2" if an expression of type "pointer to T1" can be 5140169689Skan explicitly converted to the type "pointer to T2" using a 5141169689Skan reinterpret_cast. */ 514218334Speter if (TREE_CODE (type) == REFERENCE_TYPE) 514318334Speter { 514450397Sobrien if (! real_lvalue_p (expr)) 514550397Sobrien { 5146169689Skan error ("invalid cast of an rvalue expression of type " 5147169689Skan "%qT to type %qT", 5148169689Skan intype, type); 514950397Sobrien return error_mark_node; 515050397Sobrien } 5151169689Skan 5152169689Skan /* Warn about a reinterpret_cast from "A*" to "B&" if "A" and 5153169689Skan "B" are related class types; the reinterpret_cast does not 5154169689Skan adjust the pointer. */ 5155169689Skan if (TYPE_PTR_P (intype) 5156169689Skan && (comptypes (TREE_TYPE (intype), TREE_TYPE (type), 5157169689Skan COMPARE_BASE | COMPARE_DERIVED))) 5158169689Skan warning (0, "casting %qT to %qT does not dereference pointer", 5159169689Skan intype, type); 5160169689Skan 516150397Sobrien expr = build_unary_op (ADDR_EXPR, expr, 0); 516250397Sobrien if (expr != error_mark_node) 5163169689Skan expr = build_reinterpret_cast_1 5164169689Skan (build_pointer_type (TREE_TYPE (type)), expr, c_cast_p, 5165169689Skan valid_p); 516650397Sobrien if (expr != error_mark_node) 516750397Sobrien expr = build_indirect_ref (expr, 0); 516850397Sobrien return expr; 516918334Speter } 517050397Sobrien 5171169689Skan /* As a G++ extension, we consider conversions from member 5172169689Skan functions, and pointers to member functions to 5173169689Skan pointer-to-function and pointer-to-void types. If 5174169689Skan -Wno-pmf-conversions has not been specified, 5175169689Skan convert_member_func_to_ptr will issue an error message. */ 5176169689Skan if ((TYPE_PTRMEMFUNC_P (intype) 5177169689Skan || TREE_CODE (intype) == METHOD_TYPE) 5178169689Skan && TYPE_PTR_P (type) 5179169689Skan && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE 5180169689Skan || VOID_TYPE_P (TREE_TYPE (type)))) 5181169689Skan return convert_member_func_to_ptr (type, expr); 5182169689Skan 5183169689Skan /* If the cast is not to a reference type, the lvalue-to-rvalue, 5184169689Skan array-to-pointer, and function-to-pointer conversions are 5185169689Skan performed. */ 5186169689Skan expr = decay_conversion (expr); 5187169689Skan 5188169689Skan /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue. 5189169689Skan Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */ 5190169689Skan if (TREE_CODE (expr) == NOP_EXPR 5191169689Skan && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0))) 5192169689Skan expr = TREE_OPERAND (expr, 0); 5193169689Skan 5194169689Skan if (error_operand_p (expr)) 5195169689Skan return error_mark_node; 5196169689Skan 5197169689Skan intype = TREE_TYPE (expr); 5198169689Skan 5199169689Skan /* [expr.reinterpret.cast] 5200169689Skan A pointer can be converted to any integral type large enough to 5201169689Skan hold it. */ 5202169689Skan if (CP_INTEGRAL_TYPE_P (type) && TYPE_PTR_P (intype)) 520350397Sobrien { 520450397Sobrien if (TYPE_PRECISION (type) < TYPE_PRECISION (intype)) 5205169689Skan pedwarn ("cast from %qT to %qT loses precision", 5206169689Skan intype, type); 520750397Sobrien } 5208169689Skan /* [expr.reinterpret.cast] 5209169689Skan A value of integral or enumeration type can be explicitly 5210169689Skan converted to a pointer. */ 5211169689Skan else if (TYPE_PTR_P (type) && INTEGRAL_OR_ENUMERATION_TYPE_P (intype)) 5212169689Skan /* OK */ 5213169689Skan ; 521450397Sobrien else if ((TYPE_PTRFN_P (type) && TYPE_PTRFN_P (intype)) 521550397Sobrien || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype))) 5216169689Skan return fold_if_not_in_template (build_nop (type, expr)); 521750397Sobrien else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype)) 521850397Sobrien || (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype))) 521950397Sobrien { 5220169689Skan tree sexpr = expr; 5221169689Skan 5222169689Skan if (!c_cast_p) 5223169689Skan check_for_casting_away_constness (intype, type, error, 5224169689Skan "reinterpret_cast"); 5225169689Skan /* Warn about possible alignment problems. */ 5226169689Skan if (STRICT_ALIGNMENT && warn_cast_align 5227169689Skan && !VOID_TYPE_P (type) 5228169689Skan && TREE_CODE (TREE_TYPE (intype)) != FUNCTION_TYPE 5229169689Skan && COMPLETE_TYPE_P (TREE_TYPE (type)) 5230169689Skan && COMPLETE_TYPE_P (TREE_TYPE (intype)) 5231169689Skan && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (intype))) 5232169689Skan warning (0, "cast from %qT to %qT increases required alignment of " 5233169689Skan "target type", 5234169689Skan intype, type); 5235169689Skan 5236169689Skan /* We need to strip nops here, because the frontend likes to 5237169689Skan create (int *)&a for array-to-pointer decay, instead of &a[0]. */ 5238169689Skan STRIP_NOPS (sexpr); 5239169689Skan strict_aliasing_warning (intype, type, sexpr); 5240169689Skan 5241169689Skan return fold_if_not_in_template (build_nop (type, expr)); 524250397Sobrien } 524350397Sobrien else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype)) 524452284Sobrien || (TYPE_PTRFN_P (intype) && TYPE_PTROBV_P (type))) 524550397Sobrien { 5246169689Skan if (pedantic) 5247169689Skan /* Only issue a warning, as we have always supported this 5248169689Skan where possible, and it is necessary in some cases. DR 195 5249169689Skan addresses this issue, but as of 2004/10/26 is still in 5250169689Skan drafting. */ 5251169689Skan warning (0, "ISO C++ forbids casting between pointer-to-function and pointer-to-object"); 5252169689Skan return fold_if_not_in_template (build_nop (type, expr)); 525350397Sobrien } 5254169689Skan else if (TREE_CODE (type) == VECTOR_TYPE) 5255169689Skan return fold_if_not_in_template (convert_to_vector (type, expr)); 5256169689Skan else if (TREE_CODE (intype) == VECTOR_TYPE && INTEGRAL_TYPE_P (type)) 5257169689Skan return fold_if_not_in_template (convert_to_integer (type, expr)); 525818334Speter else 525918334Speter { 5260169689Skan if (valid_p) 5261169689Skan *valid_p = false; 5262169689Skan error ("invalid cast from type %qT to type %qT", intype, type); 526350397Sobrien return error_mark_node; 526450397Sobrien } 5265169689Skan 526650397Sobrien return cp_convert (type, expr); 526750397Sobrien} 526818334Speter 526950397Sobrientree 5270169689Skanbuild_reinterpret_cast (tree type, tree expr) 527150397Sobrien{ 5272169689Skan if (type == error_mark_node || expr == error_mark_node) 527350397Sobrien return error_mark_node; 527450397Sobrien 527550397Sobrien if (processing_template_decl) 527650397Sobrien { 5277169689Skan tree t = build_min (REINTERPRET_CAST_EXPR, type, expr); 5278169689Skan 5279132718Skan if (!TREE_SIDE_EFFECTS (t) 5280132718Skan && type_dependent_expression_p (expr)) 5281132718Skan /* There might turn out to be side effects inside expr. */ 5282132718Skan TREE_SIDE_EFFECTS (t) = 1; 5283169689Skan return convert_from_reference (t); 528418334Speter } 528518334Speter 5286169689Skan return build_reinterpret_cast_1 (type, expr, /*c_cast_p=*/false, 5287169689Skan /*valid_p=*/NULL); 5288169689Skan} 5289169689Skan 5290169689Skan/* Perform a const_cast from EXPR to TYPE. If the cast is valid, 5291169689Skan return an appropriate expression. Otherwise, return 5292169689Skan error_mark_node. If the cast is not valid, and COMPLAIN is true, 5293169689Skan then a diagnostic will be issued. If VALID_P is non-NULL, we are 5294169689Skan performing a C-style cast, its value upon return will indicate 5295169689Skan whether or not the conversion succeeded. */ 5296169689Skan 5297169689Skanstatic tree 5298169689Skanbuild_const_cast_1 (tree dst_type, tree expr, bool complain, 5299169689Skan bool *valid_p) 5300169689Skan{ 5301169689Skan tree src_type; 5302169689Skan tree reference_type; 5303169689Skan 5304169689Skan /* Callers are responsible for handling error_mark_node as a 5305169689Skan destination type. */ 5306169689Skan gcc_assert (dst_type != error_mark_node); 5307169689Skan /* In a template, callers should be building syntactic 5308169689Skan representations of casts, not using this machinery. */ 5309169689Skan gcc_assert (!processing_template_decl); 5310169689Skan 5311169689Skan /* Assume the conversion is invalid. */ 5312169689Skan if (valid_p) 5313169689Skan *valid_p = false; 5314169689Skan 5315169689Skan if (!POINTER_TYPE_P (dst_type) && !TYPE_PTRMEM_P (dst_type)) 531652284Sobrien { 5317169689Skan if (complain) 5318169689Skan error ("invalid use of const_cast with type %qT, " 5319169689Skan "which is not a pointer, " 5320169689Skan "reference, nor a pointer-to-data-member type", dst_type); 532152284Sobrien return error_mark_node; 532252284Sobrien } 532352284Sobrien 5324169689Skan if (TREE_CODE (TREE_TYPE (dst_type)) == FUNCTION_TYPE) 532518334Speter { 5326169689Skan if (complain) 5327169689Skan error ("invalid use of const_cast with type %qT, which is a pointer " 5328169689Skan "or reference to a function type", dst_type); 5329169689Skan return error_mark_node; 533050397Sobrien } 533150397Sobrien 5332169689Skan /* Save casted types in the function's used types hash table. */ 5333169689Skan used_types_insert (dst_type); 5334169689Skan 5335169689Skan src_type = TREE_TYPE (expr); 5336169689Skan /* Expressions do not really have reference types. */ 5337169689Skan if (TREE_CODE (src_type) == REFERENCE_TYPE) 5338169689Skan src_type = TREE_TYPE (src_type); 5339169689Skan 5340169689Skan /* [expr.const.cast] 5341169689Skan 5342169689Skan An lvalue of type T1 can be explicitly converted to an lvalue of 5343169689Skan type T2 using the cast const_cast<T2&> (where T1 and T2 are object 5344169689Skan types) if a pointer to T1 can be explicitly converted to the type 5345169689Skan pointer to T2 using a const_cast. */ 5346169689Skan if (TREE_CODE (dst_type) == REFERENCE_TYPE) 534750397Sobrien { 5348169689Skan reference_type = dst_type; 534950397Sobrien if (! real_lvalue_p (expr)) 535018334Speter { 5351169689Skan if (complain) 5352169689Skan error ("invalid const_cast of an rvalue of type %qT to type %qT", 5353169689Skan src_type, dst_type); 535418334Speter return error_mark_node; 535518334Speter } 5356169689Skan dst_type = build_pointer_type (TREE_TYPE (dst_type)); 5357169689Skan src_type = build_pointer_type (src_type); 5358169689Skan } 5359169689Skan else 5360169689Skan { 5361169689Skan reference_type = NULL_TREE; 5362169689Skan /* If the destination type is not a reference type, the 5363169689Skan lvalue-to-rvalue, array-to-pointer, and function-to-pointer 5364169689Skan conversions are performed. */ 5365169689Skan src_type = type_decays_to (src_type); 5366169689Skan if (src_type == error_mark_node) 5367169689Skan return error_mark_node; 5368169689Skan } 536918334Speter 5370169689Skan if ((TYPE_PTR_P (src_type) || TYPE_PTRMEM_P (src_type)) 5371169689Skan && comp_ptr_ttypes_const (dst_type, src_type)) 5372169689Skan { 5373169689Skan if (valid_p) 537450397Sobrien { 5375169689Skan *valid_p = true; 5376169689Skan /* This cast is actually a C-style cast. Issue a warning if 5377169689Skan the user is making a potentially unsafe cast. */ 5378169689Skan if (warn_cast_qual) 5379169689Skan check_for_casting_away_constness (src_type, dst_type, 5380169689Skan warning0, 5381169689Skan "cast"); 5382169689Skan } 5383169689Skan if (reference_type) 5384169689Skan { 538550397Sobrien expr = build_unary_op (ADDR_EXPR, expr, 0); 5386169689Skan expr = build_nop (reference_type, expr); 538750397Sobrien return convert_from_reference (expr); 538850397Sobrien } 5389169689Skan else 5390169689Skan { 5391169689Skan expr = decay_conversion (expr); 5392169689Skan /* build_c_cast puts on a NOP_EXPR to make the result not an 5393169689Skan lvalue. Strip such NOP_EXPRs if VALUE is being used in 5394169689Skan non-lvalue context. */ 5395169689Skan if (TREE_CODE (expr) == NOP_EXPR 5396169689Skan && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0))) 5397169689Skan expr = TREE_OPERAND (expr, 0); 5398169689Skan return build_nop (dst_type, expr); 5399169689Skan } 540018334Speter } 540118334Speter 5402169689Skan if (complain) 5403169689Skan error ("invalid const_cast from type %qT to type %qT", 5404169689Skan src_type, dst_type); 540550397Sobrien return error_mark_node; 540618334Speter} 540718334Speter 5408169689Skantree 5409169689Skanbuild_const_cast (tree type, tree expr) 5410169689Skan{ 5411169689Skan if (type == error_mark_node || error_operand_p (expr)) 5412169689Skan return error_mark_node; 541318334Speter 5414169689Skan if (processing_template_decl) 5415169689Skan { 5416169689Skan tree t = build_min (CONST_CAST_EXPR, type, expr); 541718334Speter 5418169689Skan if (!TREE_SIDE_EFFECTS (t) 5419169689Skan && type_dependent_expression_p (expr)) 5420169689Skan /* There might turn out to be side effects inside expr. */ 5421169689Skan TREE_SIDE_EFFECTS (t) = 1; 5422169689Skan return convert_from_reference (t); 5423169689Skan } 5424169689Skan 5425169689Skan return build_const_cast_1 (type, expr, /*complain=*/true, 5426169689Skan /*valid_p=*/NULL); 5427169689Skan} 5428169689Skan 5429169689Skan/* Build an expression representing an explicit C-style cast to type 5430169689Skan TYPE of expression EXPR. */ 5431169689Skan 543218334Spetertree 5433132718Skanbuild_c_cast (tree type, tree expr) 543418334Speter{ 5435132718Skan tree value = expr; 5436169689Skan tree result; 5437169689Skan bool valid_p; 543818334Speter 5439169689Skan if (type == error_mark_node || error_operand_p (expr)) 544018334Speter return error_mark_node; 544118334Speter 544290075Sobrien if (processing_template_decl) 544390075Sobrien { 544490075Sobrien tree t = build_min (CAST_EXPR, type, 544590075Sobrien tree_cons (NULL_TREE, value, NULL_TREE)); 5446132718Skan /* We don't know if it will or will not have side effects. */ 5447132718Skan TREE_SIDE_EFFECTS (t) = 1; 5448169689Skan return convert_from_reference (t); 544990075Sobrien } 545090075Sobrien 5451169689Skan /* Casts to a (pointer to a) specific ObjC class (or 'id' or 5452169689Skan 'Class') should always be retained, because this information aids 5453169689Skan in method lookup. */ 5454169689Skan if (objc_is_object_ptr (type) 5455169689Skan && objc_is_object_ptr (TREE_TYPE (expr))) 5456169689Skan return build_nop (type, expr); 5457169689Skan 545818334Speter /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue. 545918334Speter Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */ 546018334Speter if (TREE_CODE (type) != REFERENCE_TYPE 546118334Speter && TREE_CODE (value) == NOP_EXPR 546218334Speter && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0))) 546318334Speter value = TREE_OPERAND (value, 0); 546418334Speter 546518334Speter if (TREE_CODE (type) == ARRAY_TYPE) 546618334Speter { 546718334Speter /* Allow casting from T1* to T2[] because Cfront allows it. 546890075Sobrien NIHCL uses it. It is not valid ISO C++ however. */ 546918334Speter if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE) 547018334Speter { 5471169689Skan pedwarn ("ISO C++ forbids casting to an array type %qT", type); 547218334Speter type = build_pointer_type (TREE_TYPE (type)); 547318334Speter } 547418334Speter else 547518334Speter { 5476169689Skan error ("ISO C++ forbids casting to an array type %qT", type); 547718334Speter return error_mark_node; 547818334Speter } 547918334Speter } 548018334Speter 548118334Speter if (TREE_CODE (type) == FUNCTION_TYPE 548218334Speter || TREE_CODE (type) == METHOD_TYPE) 548318334Speter { 5484169689Skan error ("invalid cast to function type %qT", type); 548518334Speter return error_mark_node; 548618334Speter } 548718334Speter 5488169689Skan /* A C-style cast can be a const_cast. */ 5489169689Skan result = build_const_cast_1 (type, value, /*complain=*/false, 5490169689Skan &valid_p); 5491169689Skan if (valid_p) 5492169689Skan return result; 5493117395Skan 5494169689Skan /* Or a static cast. */ 5495169689Skan result = build_static_cast_1 (type, value, /*c_cast_p=*/true, 5496169689Skan &valid_p); 5497169689Skan /* Or a reinterpret_cast. */ 5498169689Skan if (!valid_p) 5499169689Skan result = build_reinterpret_cast_1 (type, value, /*c_cast_p=*/true, 5500169689Skan &valid_p); 5501169689Skan /* The static_cast or reinterpret_cast may be followed by a 5502169689Skan const_cast. */ 5503169689Skan if (valid_p 5504169689Skan /* A valid cast may result in errors if, for example, a 5505169689Skan conversion to am ambiguous base class is required. */ 5506169689Skan && !error_operand_p (result)) 550718334Speter { 5508169689Skan tree result_type; 550918334Speter 5510169689Skan /* Non-class rvalues always have cv-unqualified type. */ 5511169689Skan if (!CLASS_TYPE_P (type)) 5512169689Skan type = TYPE_MAIN_VARIANT (type); 5513169689Skan result_type = TREE_TYPE (result); 5514169689Skan if (!CLASS_TYPE_P (result_type)) 5515169689Skan result_type = TYPE_MAIN_VARIANT (result_type); 5516169689Skan /* If the type of RESULT does not match TYPE, perform a 5517169689Skan const_cast to make it match. If the static_cast or 5518169689Skan reinterpret_cast succeeded, we will differ by at most 5519169689Skan cv-qualification, so the follow-on const_cast is guaranteed 5520169689Skan to succeed. */ 5521169689Skan if (!same_type_p (non_reference (type), non_reference (result_type))) 552252284Sobrien { 5523169689Skan result = build_const_cast_1 (type, result, false, &valid_p); 5524169689Skan gcc_assert (valid_p); 552518334Speter } 5526169689Skan return result; 552718334Speter } 552818334Speter 5529169689Skan return error_mark_node; 553018334Speter} 553118334Speter 553218334Speter/* Build an assignment expression of lvalue LHS from value RHS. 553318334Speter MODIFYCODE is the code for a binary operator that we use 553418334Speter to combine the old value of LHS with RHS to get the new value. 553518334Speter Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. 553618334Speter 553750397Sobrien C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */ 553818334Speter 553918334Spetertree 5540132718Skanbuild_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) 554118334Speter{ 5542132718Skan tree result; 554318334Speter tree newrhs = rhs; 554418334Speter tree lhstype = TREE_TYPE (lhs); 554518334Speter tree olhstype = lhstype; 5546132718Skan tree olhs = NULL_TREE; 5547169689Skan bool plain_assign = (modifycode == NOP_EXPR); 554818334Speter 554918334Speter /* Avoid duplicate error messages from operands that had errors. */ 5550169689Skan if (error_operand_p (lhs) || error_operand_p (rhs)) 555118334Speter return error_mark_node; 555218334Speter 555318334Speter /* Handle control structure constructs used as "lvalues". */ 555418334Speter switch (TREE_CODE (lhs)) 555518334Speter { 5556132718Skan /* Handle --foo = 5; as these are valid constructs in C++. */ 555718334Speter case PREDECREMENT_EXPR: 555818334Speter case PREINCREMENT_EXPR: 555918334Speter if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0))) 5560169689Skan lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs), 5561169689Skan stabilize_reference (TREE_OPERAND (lhs, 0)), 5562169689Skan TREE_OPERAND (lhs, 1)); 5563169689Skan return build2 (COMPOUND_EXPR, lhstype, 5564169689Skan lhs, 5565169689Skan build_modify_expr (TREE_OPERAND (lhs, 0), 5566169689Skan modifycode, rhs)); 556718334Speter 556818334Speter /* Handle (a, b) used as an "lvalue". */ 556918334Speter case COMPOUND_EXPR: 557018334Speter newrhs = build_modify_expr (TREE_OPERAND (lhs, 1), 557118334Speter modifycode, rhs); 557250397Sobrien if (newrhs == error_mark_node) 557318334Speter return error_mark_node; 5574169689Skan return build2 (COMPOUND_EXPR, lhstype, 5575169689Skan TREE_OPERAND (lhs, 0), newrhs); 557618334Speter 557718334Speter case MODIFY_EXPR: 5578122180Skan if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0))) 5579169689Skan lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs), 5580169689Skan stabilize_reference (TREE_OPERAND (lhs, 0)), 5581169689Skan TREE_OPERAND (lhs, 1)); 558218334Speter newrhs = build_modify_expr (TREE_OPERAND (lhs, 0), modifycode, rhs); 558350397Sobrien if (newrhs == error_mark_node) 558418334Speter return error_mark_node; 5585169689Skan return build2 (COMPOUND_EXPR, lhstype, lhs, newrhs); 558618334Speter 5587169689Skan case MIN_EXPR: 5588169689Skan case MAX_EXPR: 5589169689Skan /* MIN_EXPR and MAX_EXPR are currently only permitted as lvalues, 5590169689Skan when neither operand has side-effects. */ 5591169689Skan if (!lvalue_or_else (lhs, lv_assign)) 5592169689Skan return error_mark_node; 5593169689Skan 5594169689Skan gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)) 5595169689Skan && !TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 1))); 5596169689Skan 5597169689Skan lhs = build3 (COND_EXPR, TREE_TYPE (lhs), 5598169689Skan build2 (TREE_CODE (lhs) == MIN_EXPR ? LE_EXPR : GE_EXPR, 5599169689Skan boolean_type_node, 5600169689Skan TREE_OPERAND (lhs, 0), 5601169689Skan TREE_OPERAND (lhs, 1)), 5602169689Skan TREE_OPERAND (lhs, 0), 5603169689Skan TREE_OPERAND (lhs, 1)); 5604169689Skan /* Fall through. */ 5605169689Skan 560618334Speter /* Handle (a ? b : c) used as an "lvalue". */ 560718334Speter case COND_EXPR: 560818334Speter { 560918334Speter /* Produce (a ? (b = rhs) : (c = rhs)) 561018334Speter except that the RHS goes through a save-expr 561118334Speter so the code to compute it is only emitted once. */ 561290075Sobrien tree cond; 5613117395Skan tree preeval = NULL_TREE; 561490075Sobrien 5615169689Skan if (VOID_TYPE_P (TREE_TYPE (rhs))) 5616169689Skan { 5617169689Skan error ("void value not ignored as it ought to be"); 5618169689Skan return error_mark_node; 5619169689Skan } 5620169689Skan 5621117395Skan rhs = stabilize_expr (rhs, &preeval); 5622169689Skan 562390075Sobrien /* Check this here to avoid odd errors when trying to convert 562490075Sobrien a throw to the type of the COND_EXPR. */ 5625169689Skan if (!lvalue_or_else (lhs, lv_assign)) 562690075Sobrien return error_mark_node; 562790075Sobrien 562890075Sobrien cond = build_conditional_expr 562990075Sobrien (TREE_OPERAND (lhs, 0), 5630169689Skan build_modify_expr (TREE_OPERAND (lhs, 1), 563190075Sobrien modifycode, rhs), 5632169689Skan build_modify_expr (TREE_OPERAND (lhs, 2), 563390075Sobrien modifycode, rhs)); 563490075Sobrien 563550397Sobrien if (cond == error_mark_node) 563618334Speter return cond; 563718334Speter /* Make sure the code to compute the rhs comes out 563818334Speter before the split. */ 5639132718Skan if (preeval) 5640169689Skan cond = build2 (COMPOUND_EXPR, TREE_TYPE (lhs), preeval, cond); 5641132718Skan return cond; 564218334Speter } 5643169689Skan 564450397Sobrien default: 564550397Sobrien break; 564618334Speter } 564718334Speter 564818334Speter if (modifycode == INIT_EXPR) 564918334Speter { 565090075Sobrien if (TREE_CODE (rhs) == CONSTRUCTOR) 565118334Speter { 5652122180Skan if (! same_type_p (TREE_TYPE (rhs), lhstype)) 5653122180Skan /* Call convert to generate an error; see PR 11063. */ 5654122180Skan rhs = convert (lhstype, rhs); 5655169689Skan result = build2 (INIT_EXPR, lhstype, lhs, rhs); 565690075Sobrien TREE_SIDE_EFFECTS (result) = 1; 565718334Speter return result; 565818334Speter } 565990075Sobrien else if (! IS_AGGR_TYPE (lhstype)) 5660132718Skan /* Do the default thing. */; 566118334Speter else 566218334Speter { 5663117395Skan result = build_special_member_call (lhs, complete_ctor_identifier, 5664117395Skan build_tree_list (NULL_TREE, rhs), 5665169689Skan lhstype, LOOKUP_NORMAL); 566618334Speter if (result == NULL_TREE) 566718334Speter return error_mark_node; 566818334Speter return result; 566918334Speter } 567018334Speter } 567118334Speter else 567218334Speter { 567390075Sobrien lhs = require_complete_type (lhs); 567490075Sobrien if (lhs == error_mark_node) 567590075Sobrien return error_mark_node; 567690075Sobrien 567790075Sobrien if (modifycode == NOP_EXPR) 567890075Sobrien { 567990075Sobrien /* `operator=' is not an inheritable operator. */ 568090075Sobrien if (! IS_AGGR_TYPE (lhstype)) 5681132718Skan /* Do the default thing. */; 568290075Sobrien else 568390075Sobrien { 5684132718Skan result = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL, 5685132718Skan lhs, rhs, make_node (NOP_EXPR), 5686132718Skan /*overloaded_p=*/NULL); 568790075Sobrien if (result == NULL_TREE) 568890075Sobrien return error_mark_node; 568990075Sobrien return result; 569090075Sobrien } 569190075Sobrien lhstype = olhstype; 569290075Sobrien } 569390075Sobrien else 569490075Sobrien { 569590075Sobrien /* A binary op has been requested. Combine the old LHS 5696169689Skan value with the RHS producing the value we should actually 5697169689Skan store into the LHS. */ 569890075Sobrien 5699169689Skan gcc_assert (!PROMOTES_TO_AGGR_TYPE (lhstype, REFERENCE_TYPE)); 570090075Sobrien lhs = stabilize_reference (lhs); 570190075Sobrien newrhs = cp_build_binary_op (modifycode, lhs, rhs); 570290075Sobrien if (newrhs == error_mark_node) 570390075Sobrien { 5704169689Skan error (" in evaluation of %<%Q(%#T, %#T)%>", modifycode, 570590075Sobrien TREE_TYPE (lhs), TREE_TYPE (rhs)); 570690075Sobrien return error_mark_node; 570790075Sobrien } 5708169689Skan 570990075Sobrien /* Now it looks like a plain assignment. */ 571090075Sobrien modifycode = NOP_EXPR; 571190075Sobrien } 5712169689Skan gcc_assert (TREE_CODE (lhstype) != REFERENCE_TYPE); 5713169689Skan gcc_assert (TREE_CODE (TREE_TYPE (newrhs)) != REFERENCE_TYPE); 571418334Speter } 571518334Speter 5716169689Skan /* The left-hand side must be an lvalue. */ 5717169689Skan if (!lvalue_or_else (lhs, lv_assign)) 571818334Speter return error_mark_node; 571918334Speter 572090075Sobrien /* Warn about modifying something that is `const'. Don't warn if 572190075Sobrien this is initialization. */ 572218334Speter if (modifycode != INIT_EXPR 572352284Sobrien && (TREE_READONLY (lhs) || CP_TYPE_CONST_P (lhstype) 572452284Sobrien /* Functions are not modifiable, even though they are 572552284Sobrien lvalues. */ 572652284Sobrien || TREE_CODE (TREE_TYPE (lhs)) == FUNCTION_TYPE 572790075Sobrien || TREE_CODE (TREE_TYPE (lhs)) == METHOD_TYPE 572890075Sobrien /* If it's an aggregate and any field is const, then it is 572990075Sobrien effectively const. */ 5730132718Skan || (CLASS_TYPE_P (lhstype) 573190075Sobrien && C_TYPE_FIELDS_READONLY (lhstype)))) 573218334Speter readonly_error (lhs, "assignment", 0); 573318334Speter 573490075Sobrien /* If storing into a structure or union member, it has probably been 573590075Sobrien given type `int'. Compute the type that would go with the actual 573690075Sobrien amount of storage the member occupies. */ 573718334Speter 573818334Speter if (TREE_CODE (lhs) == COMPONENT_REF 573918334Speter && (TREE_CODE (lhstype) == INTEGER_TYPE 574018334Speter || TREE_CODE (lhstype) == REAL_TYPE 574118334Speter || TREE_CODE (lhstype) == ENUMERAL_TYPE)) 574218334Speter { 574318334Speter lhstype = TREE_TYPE (get_unwidened (lhs, 0)); 574418334Speter 574518334Speter /* If storing in a field that is in actuality a short or narrower 574618334Speter than one, we must store in the field in its actual type. */ 574718334Speter 574818334Speter if (lhstype != TREE_TYPE (lhs)) 574918334Speter { 5750132718Skan /* Avoid warnings converting integral types back into enums for 5751132718Skan enum bit fields. */ 5752132718Skan if (TREE_CODE (lhstype) == INTEGER_TYPE 5753132718Skan && TREE_CODE (olhstype) == ENUMERAL_TYPE) 5754132718Skan { 5755132718Skan if (TREE_SIDE_EFFECTS (lhs)) 5756132718Skan lhs = stabilize_reference (lhs); 5757132718Skan olhs = lhs; 5758132718Skan } 575918334Speter lhs = copy_node (lhs); 576018334Speter TREE_TYPE (lhs) = lhstype; 576118334Speter } 576218334Speter } 576318334Speter 576418334Speter /* Convert new value to destination type. */ 576518334Speter 576618334Speter if (TREE_CODE (lhstype) == ARRAY_TYPE) 576718334Speter { 576818334Speter int from_array; 5769169689Skan 577096263Sobrien if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype), 577196263Sobrien TYPE_MAIN_VARIANT (TREE_TYPE (rhs)))) 577218334Speter { 5773169689Skan error ("incompatible types in assignment of %qT to %qT", 577496263Sobrien TREE_TYPE (rhs), lhstype); 577518334Speter return error_mark_node; 577618334Speter } 577718334Speter 577818334Speter /* Allow array assignment in compiler-generated code. */ 577996263Sobrien if (! DECL_ARTIFICIAL (current_function_decl)) 5780169689Skan { 5781169689Skan /* This routine is used for both initialization and assignment. 5782169689Skan Make sure the diagnostic message differentiates the context. */ 5783169689Skan if (modifycode == INIT_EXPR) 5784169689Skan error ("array used as initializer"); 5785169689Skan else 5786169689Skan error ("invalid array assignment"); 5787169689Skan return error_mark_node; 5788169689Skan } 578918334Speter 579018334Speter from_array = TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE 5791169689Skan ? 1 + (modifycode != INIT_EXPR): 0; 5792169689Skan return build_vec_init (lhs, NULL_TREE, newrhs, 5793169689Skan /*explicit_default_init_p=*/false, 5794169689Skan from_array); 579518334Speter } 579618334Speter 579718334Speter if (modifycode == INIT_EXPR) 579890075Sobrien newrhs = convert_for_initialization (lhs, lhstype, newrhs, LOOKUP_NORMAL, 579990075Sobrien "initialization", NULL_TREE, 0); 580018334Speter else 580118334Speter { 580250397Sobrien /* Avoid warnings on enum bit fields. */ 580318334Speter if (TREE_CODE (olhstype) == ENUMERAL_TYPE 580418334Speter && TREE_CODE (lhstype) == INTEGER_TYPE) 580518334Speter { 580618334Speter newrhs = convert_for_assignment (olhstype, newrhs, "assignment", 580718334Speter NULL_TREE, 0); 580818334Speter newrhs = convert_force (lhstype, newrhs, 0); 580918334Speter } 581018334Speter else 581118334Speter newrhs = convert_for_assignment (lhstype, newrhs, "assignment", 581218334Speter NULL_TREE, 0); 581318334Speter if (TREE_CODE (newrhs) == CALL_EXPR 581418334Speter && TYPE_NEEDS_CONSTRUCTING (lhstype)) 581550397Sobrien newrhs = build_cplus_new (lhstype, newrhs); 581618334Speter 581718334Speter /* Can't initialize directly from a TARGET_EXPR, since that would 581818334Speter cause the lhs to be constructed twice, and possibly result in 581918334Speter accidental self-initialization. So we force the TARGET_EXPR to be 582050397Sobrien expanded without a target. */ 582118334Speter if (TREE_CODE (newrhs) == TARGET_EXPR) 5822169689Skan newrhs = build2 (COMPOUND_EXPR, TREE_TYPE (newrhs), newrhs, 5823169689Skan TREE_OPERAND (newrhs, 0)); 582418334Speter } 582518334Speter 582650397Sobrien if (newrhs == error_mark_node) 582718334Speter return error_mark_node; 582818334Speter 5829169689Skan if (c_dialect_objc () && flag_objc_gc) 5830169689Skan { 5831169689Skan result = objc_generate_write_barrier (lhs, modifycode, newrhs); 583218334Speter 5833169689Skan if (result) 5834169689Skan return result; 5835169689Skan } 5836169689Skan 5837169689Skan result = build2 (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR, 5838169689Skan lhstype, lhs, newrhs); 5839169689Skan 584018334Speter TREE_SIDE_EFFECTS (result) = 1; 5841169689Skan if (!plain_assign) 5842169689Skan TREE_NO_WARNING (result) = 1; 584318334Speter 584418334Speter /* If we got the LHS in a different type for storing in, 584518334Speter convert the result back to the nominal type of LHS 584618334Speter so that the value we return always has the same type 584718334Speter as the LHS argument. */ 584818334Speter 584918334Speter if (olhstype == TREE_TYPE (result)) 585018334Speter return result; 5851132718Skan if (olhs) 585218334Speter { 5853169689Skan result = build2 (COMPOUND_EXPR, olhstype, result, olhs); 5854169689Skan TREE_NO_WARNING (result) = 1; 585518334Speter return result; 585618334Speter } 585718334Speter return convert_for_assignment (olhstype, result, "assignment", 585818334Speter NULL_TREE, 0); 585918334Speter} 586018334Speter 586150397Sobrientree 5862132718Skanbuild_x_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) 586350397Sobrien{ 586450397Sobrien if (processing_template_decl) 586550397Sobrien return build_min_nt (MODOP_EXPR, lhs, 586650397Sobrien build_min_nt (modifycode, NULL_TREE, NULL_TREE), rhs); 586718334Speter 586850397Sobrien if (modifycode != NOP_EXPR) 586950397Sobrien { 5870132718Skan tree rval = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs, 5871132718Skan make_node (modifycode), 5872132718Skan /*overloaded_p=*/NULL); 587350397Sobrien if (rval) 5874169689Skan { 5875169689Skan TREE_NO_WARNING (rval) = 1; 5876169689Skan return rval; 5877169689Skan } 587850397Sobrien } 587950397Sobrien return build_modify_expr (lhs, modifycode, rhs); 588050397Sobrien} 588150397Sobrien 588218334Speter 588318334Speter/* Get difference in deltas for different pointer to member function 5884132718Skan types. Returns an integer constant of type PTRDIFF_TYPE_NODE. If 5885169689Skan the conversion is invalid, the constant is zero. If 5886169689Skan ALLOW_INVERSE_P is true, then allow reverse conversions as well. 5887169689Skan If C_CAST_P is true this conversion is taking place as part of a 5888169689Skan C-style cast. 588950397Sobrien 589052284Sobrien Note that the naming of FROM and TO is kind of backwards; the return 589152284Sobrien value is what we add to a TO in order to get a FROM. They are named 589252284Sobrien this way because we call this function to find out how to convert from 589352284Sobrien a pointer to member of FROM to a pointer to member of TO. */ 589452284Sobrien 589518334Speterstatic tree 5896169689Skanget_delta_difference (tree from, tree to, 5897169689Skan bool allow_inverse_p, 5898169689Skan bool c_cast_p) 589918334Speter{ 590018334Speter tree binfo; 590190075Sobrien base_kind kind; 5902169689Skan tree result; 5903169689Skan 5904169689Skan /* Assume no conversion is required. */ 5905169689Skan result = integer_zero_node; 5906169689Skan binfo = lookup_base (to, from, c_cast_p ? ba_unique : ba_check, &kind); 590790075Sobrien if (kind == bk_inaccessible || kind == bk_ambig) 5908169689Skan error (" in pointer to member function conversion"); 5909169689Skan else if (binfo) 591018334Speter { 5911169689Skan if (kind != bk_via_virtual) 5912169689Skan result = BINFO_OFFSET (binfo); 5913169689Skan else 5914169689Skan { 5915169689Skan tree virt_binfo = binfo_from_vbase (binfo); 5916169689Skan 5917169689Skan /* This is a reinterpret cast, we choose to do nothing. */ 5918169689Skan if (allow_inverse_p) 5919169689Skan warning (0, "pointer to member cast via virtual base %qT", 5920169689Skan BINFO_TYPE (virt_binfo)); 5921169689Skan else 5922169689Skan error ("pointer to member conversion via virtual base %qT", 5923169689Skan BINFO_TYPE (virt_binfo)); 5924169689Skan } 592518334Speter } 5926169689Skan else if (same_type_ignoring_top_level_qualifiers_p (from, to)) 5927169689Skan /* Pointer to member of incomplete class is permitted*/; 5928169689Skan else if (!allow_inverse_p) 592918334Speter { 5930169689Skan error_not_base_type (from, to); 5931169689Skan error (" in pointer to member conversion"); 5932169689Skan } 5933169689Skan else 5934169689Skan { 5935169689Skan binfo = lookup_base (from, to, c_cast_p ? ba_unique : ba_check, &kind); 5936169689Skan if (binfo) 593718334Speter { 5938169689Skan if (kind != bk_via_virtual) 5939169689Skan result = size_diffop (size_zero_node, BINFO_OFFSET (binfo)); 5940169689Skan else 5941169689Skan { 5942169689Skan /* This is a reinterpret cast, we choose to do nothing. */ 5943169689Skan tree virt_binfo = binfo_from_vbase (binfo); 5944169689Skan 5945169689Skan warning (0, "pointer to member cast via virtual base %qT", 5946169689Skan BINFO_TYPE (virt_binfo)); 5947169689Skan } 594818334Speter } 594918334Speter } 595050397Sobrien 5951169689Skan return fold_if_not_in_template (convert_to_integer (ptrdiff_type_node, 5952169689Skan result)); 595318334Speter} 595418334Speter 595590075Sobrien/* Return a constructor for the pointer-to-member-function TYPE using 595690075Sobrien the other components as specified. */ 595790075Sobrien 595852284Sobrientree 5959132718Skanbuild_ptrmemfunc1 (tree type, tree delta, tree pfn) 596050397Sobrien{ 596190075Sobrien tree u = NULL_TREE; 596290075Sobrien tree delta_field; 596390075Sobrien tree pfn_field; 5964169689Skan VEC(constructor_elt, gc) *v; 596550397Sobrien 596690075Sobrien /* Pull the FIELD_DECLs out of the type. */ 596790075Sobrien pfn_field = TYPE_FIELDS (type); 596890075Sobrien delta_field = TREE_CHAIN (pfn_field); 596950397Sobrien 597090075Sobrien /* Make sure DELTA has the type we want. */ 597150397Sobrien delta = convert_and_check (delta_type_node, delta); 597250397Sobrien 597390075Sobrien /* Finish creating the initializer. */ 5974169689Skan v = VEC_alloc(constructor_elt, gc, 2); 5975169689Skan CONSTRUCTOR_APPEND_ELT(v, pfn_field, pfn); 5976169689Skan CONSTRUCTOR_APPEND_ELT(v, delta_field, delta); 5977169689Skan u = build_constructor (type, v); 5978169689Skan TREE_CONSTANT (u) = TREE_CONSTANT (pfn) & TREE_CONSTANT (delta); 5979169689Skan TREE_INVARIANT (u) = TREE_INVARIANT (pfn) & TREE_INVARIANT (delta); 598090075Sobrien TREE_STATIC (u) = (TREE_CONSTANT (u) 598190075Sobrien && (initializer_constant_valid_p (pfn, TREE_TYPE (pfn)) 598290075Sobrien != NULL_TREE) 5983169689Skan && (initializer_constant_valid_p (delta, TREE_TYPE (delta)) 598490075Sobrien != NULL_TREE)); 598550397Sobrien return u; 598650397Sobrien} 598750397Sobrien 598818334Speter/* Build a constructor for a pointer to member function. It can be 598918334Speter used to initialize global variables, local variable, or used 599018334Speter as a value in expressions. TYPE is the POINTER to METHOD_TYPE we 599118334Speter want to be. 599218334Speter 5993117395Skan If FORCE is nonzero, then force this conversion, even if 599418334Speter we would rather not do it. Usually set when using an explicit 5995169689Skan cast. A C-style cast is being processed iff C_CAST_P is true. 599618334Speter 599718334Speter Return error_mark_node, if something goes wrong. */ 599818334Speter 599918334Spetertree 6000169689Skanbuild_ptrmemfunc (tree type, tree pfn, int force, bool c_cast_p) 600118334Speter{ 600252284Sobrien tree fn; 6003117395Skan tree pfn_type; 6004117395Skan tree to_type; 600590075Sobrien 6006117395Skan if (error_operand_p (pfn)) 6007117395Skan return error_mark_node; 6008117395Skan 6009117395Skan pfn_type = TREE_TYPE (pfn); 6010117395Skan to_type = build_ptrmemfunc_type (type); 6011117395Skan 601250397Sobrien /* Handle multiple conversions of pointer to member functions. */ 6013117395Skan if (TYPE_PTRMEMFUNC_P (pfn_type)) 601418334Speter { 601590075Sobrien tree delta = NULL_TREE; 601652284Sobrien tree npfn = NULL_TREE; 601790075Sobrien tree n; 601850397Sobrien 6019169689Skan if (!force 6020169689Skan && !can_convert_arg (to_type, TREE_TYPE (pfn), pfn, LOOKUP_NORMAL)) 6021169689Skan error ("invalid conversion to type %qT from type %qT", 6022169689Skan to_type, pfn_type); 602318334Speter 602490075Sobrien n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type), 602590075Sobrien TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type), 6026169689Skan force, 6027169689Skan c_cast_p); 602818334Speter 602990075Sobrien /* We don't have to do any conversion to convert a 603090075Sobrien pointer-to-member to its own type. But, we don't want to 603190075Sobrien just return a PTRMEM_CST if there's an explicit cast; that 603290075Sobrien cast should make the expression an invalid template argument. */ 603390075Sobrien if (TREE_CODE (pfn) != PTRMEM_CST) 603452284Sobrien { 603590075Sobrien if (same_type_p (to_type, pfn_type)) 603690075Sobrien return pfn; 603790075Sobrien else if (integer_zerop (n)) 603890075Sobrien return build_reinterpret_cast (to_type, pfn); 603990075Sobrien } 604018334Speter 604190075Sobrien if (TREE_SIDE_EFFECTS (pfn)) 604290075Sobrien pfn = save_expr (pfn); 604390075Sobrien 604490075Sobrien /* Obtain the function pointer and the current DELTA. */ 604590075Sobrien if (TREE_CODE (pfn) == PTRMEM_CST) 604690075Sobrien expand_ptrmemfunc_cst (pfn, &delta, &npfn); 604752284Sobrien else 604852284Sobrien { 6049117395Skan npfn = build_ptrmemfunc_access_expr (pfn, pfn_identifier); 6050117395Skan delta = build_ptrmemfunc_access_expr (pfn, delta_identifier); 605152284Sobrien } 605252284Sobrien 605390075Sobrien /* Just adjust the DELTA field. */ 6054169689Skan gcc_assert (same_type_ignoring_top_level_qualifiers_p 6055169689Skan (TREE_TYPE (delta), ptrdiff_type_node)); 605690075Sobrien if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta) 605790075Sobrien n = cp_build_binary_op (LSHIFT_EXPR, n, integer_one_node); 605890075Sobrien delta = cp_build_binary_op (PLUS_EXPR, delta, n); 605990075Sobrien return build_ptrmemfunc1 (to_type, delta, npfn); 606018334Speter } 606118334Speter 606250397Sobrien /* Handle null pointer to member function conversions. */ 606318334Speter if (integer_zerop (pfn)) 606418334Speter { 606550397Sobrien pfn = build_c_cast (type, integer_zero_node); 606690075Sobrien return build_ptrmemfunc1 (to_type, 6067169689Skan integer_zero_node, 606890075Sobrien pfn); 606918334Speter } 607018334Speter 607152284Sobrien if (type_unknown_p (pfn)) 6072169689Skan return instantiate_type (type, pfn, tf_warning_or_error); 607318334Speter 607452284Sobrien fn = TREE_OPERAND (pfn, 0); 6075169689Skan gcc_assert (TREE_CODE (fn) == FUNCTION_DECL 6076169689Skan /* In a template, we will have preserved the 6077169689Skan OFFSET_REF. */ 6078169689Skan || (processing_template_decl && TREE_CODE (fn) == OFFSET_REF)); 607990075Sobrien return make_ptrmem_cst (to_type, fn); 608052284Sobrien} 608150397Sobrien 608252284Sobrien/* Return the DELTA, IDX, PFN, and DELTA2 values for the PTRMEM_CST 608390075Sobrien given by CST. 608418334Speter 608590075Sobrien ??? There is no consistency as to the types returned for the above 6086169689Skan values. Some code acts as if it were a sizetype and some as if it were 608790075Sobrien integer_type_node. */ 608890075Sobrien 608952284Sobrienvoid 6090132718Skanexpand_ptrmemfunc_cst (tree cst, tree *delta, tree *pfn) 609152284Sobrien{ 609252284Sobrien tree type = TREE_TYPE (cst); 609352284Sobrien tree fn = PTRMEM_CST_MEMBER (cst); 609452284Sobrien tree ptr_class, fn_class; 609518334Speter 6096169689Skan gcc_assert (TREE_CODE (fn) == FUNCTION_DECL); 609752284Sobrien 609852284Sobrien /* The class that the function belongs to. */ 609990075Sobrien fn_class = DECL_CONTEXT (fn); 610052284Sobrien 610152284Sobrien /* The class that we're creating a pointer to member of. */ 610252284Sobrien ptr_class = TYPE_PTRMEMFUNC_OBJECT_TYPE (type); 610352284Sobrien 610452284Sobrien /* First, calculate the adjustment to the function's class. */ 6105169689Skan *delta = get_delta_difference (fn_class, ptr_class, /*force=*/0, 6106169689Skan /*c_cast_p=*/0); 610752284Sobrien 610852284Sobrien if (!DECL_VIRTUAL_P (fn)) 610990075Sobrien *pfn = convert (TYPE_PTRMEMFUNC_FN_TYPE (type), build_addr_func (fn)); 611018334Speter else 611118334Speter { 611252284Sobrien /* If we're dealing with a virtual function, we have to adjust 'this' 6113169689Skan again, to point to the base which provides the vtable entry for 6114169689Skan fn; the call will do the opposite adjustment. */ 6115117395Skan tree orig_class = DECL_CONTEXT (fn); 611652284Sobrien tree binfo = binfo_or_else (orig_class, fn_class); 6117169689Skan *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta), 6118169689Skan *delta, BINFO_OFFSET (binfo)); 6119169689Skan *delta = fold_if_not_in_template (*delta); 612018334Speter 612190075Sobrien /* We set PFN to the vtable offset at which the function can be 612290075Sobrien found, plus one (unless ptrmemfunc_vbit_in_delta, in which 612390075Sobrien case delta is shifted left, and then incremented). */ 612490075Sobrien *pfn = DECL_VINDEX (fn); 6125169689Skan *pfn = build2 (MULT_EXPR, integer_type_node, *pfn, 6126169689Skan TYPE_SIZE_UNIT (vtable_entry_type)); 6127169689Skan *pfn = fold_if_not_in_template (*pfn); 612852284Sobrien 612990075Sobrien switch (TARGET_PTRMEMFUNC_VBIT_LOCATION) 613090075Sobrien { 613190075Sobrien case ptrmemfunc_vbit_in_pfn: 6132169689Skan *pfn = build2 (PLUS_EXPR, integer_type_node, *pfn, 6133169689Skan integer_one_node); 6134169689Skan *pfn = fold_if_not_in_template (*pfn); 613590075Sobrien break; 613690075Sobrien 613790075Sobrien case ptrmemfunc_vbit_in_delta: 6138169689Skan *delta = build2 (LSHIFT_EXPR, TREE_TYPE (*delta), 6139169689Skan *delta, integer_one_node); 6140169689Skan *delta = fold_if_not_in_template (*delta); 6141169689Skan *delta = build2 (PLUS_EXPR, TREE_TYPE (*delta), 6142169689Skan *delta, integer_one_node); 6143169689Skan *delta = fold_if_not_in_template (*delta); 614490075Sobrien break; 614590075Sobrien 614690075Sobrien default: 6147169689Skan gcc_unreachable (); 614890075Sobrien } 614990075Sobrien 6150169689Skan *pfn = build_nop (TYPE_PTRMEMFUNC_FN_TYPE (type), *pfn); 6151169689Skan *pfn = fold_if_not_in_template (*pfn); 615218334Speter } 615352284Sobrien} 615418334Speter 615590075Sobrien/* Return an expression for PFN from the pointer-to-member function 615652284Sobrien given by T. */ 615752284Sobrien 6158169689Skanstatic tree 6159132718Skanpfn_from_ptrmemfunc (tree t) 616052284Sobrien{ 616152284Sobrien if (TREE_CODE (t) == PTRMEM_CST) 616252284Sobrien { 616352284Sobrien tree delta; 616452284Sobrien tree pfn; 6165169689Skan 616690075Sobrien expand_ptrmemfunc_cst (t, &delta, &pfn); 616790075Sobrien if (pfn) 616890075Sobrien return pfn; 616952284Sobrien } 617052284Sobrien 6171117395Skan return build_ptrmemfunc_access_expr (t, pfn_identifier); 617218334Speter} 617318334Speter 617490075Sobrien/* Convert value RHS to type TYPE as preparation for an assignment to 617590075Sobrien an lvalue of type TYPE. ERRTYPE is a string to use in error 617690075Sobrien messages: "assignment", "return", etc. If FNDECL is non-NULL, we 617790075Sobrien are doing the conversion in order to pass the PARMNUMth argument of 617890075Sobrien FNDECL. */ 617918334Speter 618018334Speterstatic tree 6181132718Skanconvert_for_assignment (tree type, tree rhs, 6182132718Skan const char *errtype, tree fndecl, int parmnum) 618318334Speter{ 6184132718Skan tree rhstype; 6185132718Skan enum tree_code coder; 618618334Speter 618718334Speter /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ 618818334Speter if (TREE_CODE (rhs) == NON_LVALUE_EXPR) 618918334Speter rhs = TREE_OPERAND (rhs, 0); 619018334Speter 619190075Sobrien rhstype = TREE_TYPE (rhs); 619290075Sobrien coder = TREE_CODE (rhstype); 619390075Sobrien 6194132718Skan if (TREE_CODE (type) == VECTOR_TYPE && coder == VECTOR_TYPE 6195169689Skan && vector_types_convertible_p (type, rhstype)) 6196132718Skan return convert (type, rhs); 6197132718Skan 619890075Sobrien if (rhs == error_mark_node || rhstype == error_mark_node) 619918334Speter return error_mark_node; 620050397Sobrien if (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node) 620118334Speter return error_mark_node; 620218334Speter 620390075Sobrien /* The RHS of an assignment cannot have void type. */ 620418334Speter if (coder == VOID_TYPE) 620518334Speter { 620618334Speter error ("void value not ignored as it ought to be"); 620718334Speter return error_mark_node; 620818334Speter } 620918334Speter 621090075Sobrien /* Simplify the RHS if possible. */ 621190075Sobrien if (TREE_CODE (rhs) == CONST_DECL) 621290075Sobrien rhs = DECL_INITIAL (rhs); 621318334Speter 6214169689Skan if (c_dialect_objc ()) 6215169689Skan { 6216169689Skan int parmno; 6217169689Skan tree rname = fndecl; 6218110611Skan 6219169689Skan if (!strcmp (errtype, "assignment")) 6220169689Skan parmno = -1; 6221169689Skan else if (!strcmp (errtype, "initialization")) 6222169689Skan parmno = -2; 6223169689Skan else 6224169689Skan { 6225169689Skan tree selector = objc_message_selector (); 6226169689Skan 6227169689Skan parmno = parmnum; 6228169689Skan 6229169689Skan if (selector && parmno > 1) 6230169689Skan { 6231169689Skan rname = selector; 6232169689Skan parmno -= 1; 6233169689Skan } 6234169689Skan } 6235169689Skan 6236169689Skan if (objc_compare_types (type, rhstype, parmno, rname)) 6237169689Skan return convert (type, rhs); 6238169689Skan } 6239169689Skan 624090075Sobrien /* [expr.ass] 624118334Speter 624290075Sobrien The expression is implicitly converted (clause _conv_) to the 624390075Sobrien cv-unqualified type of the left operand. 624418334Speter 624590075Sobrien We allow bad conversions here because by the time we get to this point 624690075Sobrien we are committed to doing the conversion. If we end up doing a bad 624790075Sobrien conversion, convert_like will complain. */ 624890075Sobrien if (!can_convert_arg_bad (type, rhstype, rhs)) 624990075Sobrien { 625090075Sobrien /* When -Wno-pmf-conversions is use, we just silently allow 625190075Sobrien conversions from pointers-to-members to plain pointers. If 625290075Sobrien the conversion doesn't work, cp_convert will complain. */ 6253169689Skan if (!warn_pmf2ptr 6254169689Skan && TYPE_PTR_P (type) 625590075Sobrien && TYPE_PTRMEMFUNC_P (rhstype)) 625690075Sobrien rhs = cp_convert (strip_top_quals (type), rhs); 625718334Speter else 625818334Speter { 625990075Sobrien /* If the right-hand side has unknown type, then it is an 626090075Sobrien overloaded function. Call instantiate_type to get error 626190075Sobrien messages. */ 626290075Sobrien if (rhstype == unknown_type_node) 6263169689Skan instantiate_type (type, rhs, tf_warning_or_error); 626490075Sobrien else if (fndecl) 6265169689Skan error ("cannot convert %qT to %qT for argument %qP to %qD", 6266169689Skan rhstype, type, parmnum, fndecl); 626718334Speter else 6268169689Skan error ("cannot convert %qT to %qT in %s", rhstype, type, errtype); 626990075Sobrien return error_mark_node; 627018334Speter } 627118334Speter } 6272169689Skan if (warn_missing_format_attribute) 6273169689Skan { 6274169689Skan const enum tree_code codel = TREE_CODE (type); 6275169689Skan if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE) 6276169689Skan && coder == codel 6277169689Skan && check_missing_format_attribute (type, rhstype)) 6278169689Skan warning (OPT_Wmissing_format_attribute, 6279169689Skan "%s might be a candidate for a format attribute", 6280169689Skan errtype); 6281169689Skan } 6282169689Skan 628390075Sobrien return perform_implicit_conversion (strip_top_quals (type), rhs); 628418334Speter} 628518334Speter 628652284Sobrien/* Convert RHS to be of type TYPE. 6287117395Skan If EXP is nonzero, it is the target of the initialization. 628818334Speter ERRTYPE is a string to use in error messages. 628918334Speter 629018334Speter Two major differences between the behavior of 629118334Speter `convert_for_assignment' and `convert_for_initialization' 629218334Speter are that references are bashed in the former, while 629318334Speter copied in the latter, and aggregates are assigned in 629418334Speter the former (operator=) while initialized in the 629518334Speter latter (X(X&)). 629618334Speter 629718334Speter If using constructor make sure no conversion operator exists, if one does 629818334Speter exist, an ambiguity exists. 629918334Speter 630018334Speter If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything. */ 630150397Sobrien 630218334Spetertree 6303132718Skanconvert_for_initialization (tree exp, tree type, tree rhs, int flags, 6304132718Skan const char *errtype, tree fndecl, int parmnum) 630518334Speter{ 6306132718Skan enum tree_code codel = TREE_CODE (type); 6307132718Skan tree rhstype; 6308132718Skan enum tree_code coder; 630918334Speter 631018334Speter /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue. 631118334Speter Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */ 631218334Speter if (TREE_CODE (rhs) == NOP_EXPR 631318334Speter && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0)) 631418334Speter && codel != REFERENCE_TYPE) 631518334Speter rhs = TREE_OPERAND (rhs, 0); 631618334Speter 6317169689Skan if (type == error_mark_node 6318169689Skan || rhs == error_mark_node 631918334Speter || (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node)) 632018334Speter return error_mark_node; 632118334Speter 632218334Speter if ((TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE 632318334Speter && TREE_CODE (type) != ARRAY_TYPE 632418334Speter && (TREE_CODE (type) != REFERENCE_TYPE 632518334Speter || TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE)) 632652284Sobrien || (TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE 632752284Sobrien && (TREE_CODE (type) != REFERENCE_TYPE 632852284Sobrien || TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)) 632918334Speter || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE) 6330132718Skan rhs = decay_conversion (rhs); 633118334Speter 633218334Speter rhstype = TREE_TYPE (rhs); 633318334Speter coder = TREE_CODE (rhstype); 633418334Speter 633518334Speter if (coder == ERROR_MARK) 633618334Speter return error_mark_node; 633718334Speter 633818334Speter /* We accept references to incomplete types, so we can 633918334Speter return here before checking if RHS is of complete type. */ 6340169689Skan 634118334Speter if (codel == REFERENCE_TYPE) 634218334Speter { 634318334Speter /* This should eventually happen in convert_arguments. */ 634450397Sobrien int savew = 0, savee = 0; 634518334Speter 634618334Speter if (fndecl) 634718334Speter savew = warningcount, savee = errorcount; 6348122180Skan rhs = initialize_reference (type, rhs, /*decl=*/NULL_TREE, 6349122180Skan /*cleanup=*/NULL); 635018334Speter if (fndecl) 635118334Speter { 635218334Speter if (warningcount > savew) 6353169689Skan warning (0, "in passing argument %P of %q+D", parmnum, fndecl); 635418334Speter else if (errorcount > savee) 6355169689Skan error ("in passing argument %P of %q+D", parmnum, fndecl); 635618334Speter } 635718334Speter return rhs; 6358169689Skan } 635918334Speter 636052284Sobrien if (exp != 0) 636152284Sobrien exp = require_complete_type (exp); 636218334Speter if (exp == error_mark_node) 636318334Speter return error_mark_node; 636418334Speter 6365132718Skan rhstype = non_reference (rhstype); 636618334Speter 636750397Sobrien type = complete_type (type); 636850397Sobrien 636950397Sobrien if (IS_AGGR_TYPE (type)) 637050397Sobrien return ocp_convert (type, rhs, CONV_IMPLICIT|CONV_FORCE_TEMP, flags); 637118334Speter 637218334Speter return convert_for_assignment (type, rhs, errtype, fndecl, parmnum); 637318334Speter} 637418334Speter 637590075Sobrien/* If RETVAL is the address of, or a reference to, a local variable or 6376132718Skan temporary give an appropriate warning. */ 637718334Speter 637890075Sobrienstatic void 6379132718Skanmaybe_warn_about_returning_address_of_local (tree retval) 638018334Speter{ 638190075Sobrien tree valtype = TREE_TYPE (DECL_RESULT (current_function_decl)); 638290075Sobrien tree whats_returned = retval; 638318334Speter 638490075Sobrien for (;;) 638518334Speter { 638690075Sobrien if (TREE_CODE (whats_returned) == COMPOUND_EXPR) 638790075Sobrien whats_returned = TREE_OPERAND (whats_returned, 1); 638890075Sobrien else if (TREE_CODE (whats_returned) == CONVERT_EXPR 638990075Sobrien || TREE_CODE (whats_returned) == NON_LVALUE_EXPR 639090075Sobrien || TREE_CODE (whats_returned) == NOP_EXPR) 639190075Sobrien whats_returned = TREE_OPERAND (whats_returned, 0); 639290075Sobrien else 639390075Sobrien break; 639418334Speter } 639518334Speter 639690075Sobrien if (TREE_CODE (whats_returned) != ADDR_EXPR) 639790075Sobrien return; 6398169689Skan whats_returned = TREE_OPERAND (whats_returned, 0); 639990075Sobrien 640090075Sobrien if (TREE_CODE (valtype) == REFERENCE_TYPE) 640150397Sobrien { 640290075Sobrien if (TREE_CODE (whats_returned) == AGGR_INIT_EXPR 640390075Sobrien || TREE_CODE (whats_returned) == TARGET_EXPR) 640490075Sobrien { 6405169689Skan warning (0, "returning reference to temporary"); 640690075Sobrien return; 640790075Sobrien } 6408169689Skan if (TREE_CODE (whats_returned) == VAR_DECL 640990075Sobrien && DECL_NAME (whats_returned) 641090075Sobrien && TEMP_NAME_P (DECL_NAME (whats_returned))) 641190075Sobrien { 6412169689Skan warning (0, "reference to non-lvalue returned"); 641390075Sobrien return; 641490075Sobrien } 641550397Sobrien } 641650397Sobrien 6417169689Skan while (TREE_CODE (whats_returned) == COMPONENT_REF 6418169689Skan || TREE_CODE (whats_returned) == ARRAY_REF) 6419169689Skan whats_returned = TREE_OPERAND (whats_returned, 0); 6420169689Skan 6421169689Skan if (DECL_P (whats_returned) 642290075Sobrien && DECL_NAME (whats_returned) 642390075Sobrien && DECL_FUNCTION_SCOPE_P (whats_returned) 642490075Sobrien && !(TREE_STATIC (whats_returned) 642590075Sobrien || TREE_PUBLIC (whats_returned))) 642650397Sobrien { 642790075Sobrien if (TREE_CODE (valtype) == REFERENCE_TYPE) 6428169689Skan warning (0, "reference to local variable %q+D returned", 6429169689Skan whats_returned); 643090075Sobrien else 6431169689Skan warning (0, "address of local variable %q+D returned", 6432169689Skan whats_returned); 643350397Sobrien return; 643450397Sobrien } 643590075Sobrien} 643650397Sobrien 6437117395Skan/* Check that returning RETVAL from the current function is valid. 643890075Sobrien Return an expression explicitly showing all conversions required to 643990075Sobrien change RETVAL into the function return type, and to assign it to 6440169689Skan the DECL_RESULT for the function. Set *NO_WARNING to true if 6441169689Skan code reaches end of non-void function warning shouldn't be issued 6442169689Skan on this RETURN_EXPR. */ 644318334Speter 644490075Sobrientree 6445169689Skancheck_return_expr (tree retval, bool *no_warning) 644690075Sobrien{ 644790075Sobrien tree result; 644890075Sobrien /* The type actually returned by the function, after any 644990075Sobrien promotions. */ 645090075Sobrien tree valtype; 645190075Sobrien int fn_returns_value_p; 645218334Speter 6453169689Skan *no_warning = false; 6454169689Skan 645590075Sobrien /* A `volatile' function is one that isn't supposed to return, ever. 645690075Sobrien (This is a G++ extension, used to get better code for functions 645790075Sobrien that call the `volatile' function.) */ 645890075Sobrien if (TREE_THIS_VOLATILE (current_function_decl)) 6459169689Skan warning (0, "function declared %<noreturn%> has a %<return%> statement"); 646018334Speter 646190075Sobrien /* Check for various simple errors. */ 646290075Sobrien if (DECL_DESTRUCTOR_P (current_function_decl)) 646390075Sobrien { 646490075Sobrien if (retval) 646590075Sobrien error ("returning a value from a destructor"); 646690075Sobrien return NULL_TREE; 646718334Speter } 646850397Sobrien else if (DECL_CONSTRUCTOR_P (current_function_decl)) 646918334Speter { 647090075Sobrien if (in_function_try_handler) 647190075Sobrien /* If a return statement appears in a handler of the 6472117395Skan function-try-block of a constructor, the program is ill-formed. */ 647390075Sobrien error ("cannot return from a handler of a function-try-block of a constructor"); 647490075Sobrien else if (retval) 647590075Sobrien /* You can't return a value from a constructor. */ 647650397Sobrien error ("returning a value from a constructor"); 647790075Sobrien return NULL_TREE; 647818334Speter } 647918334Speter 6480132718Skan if (processing_template_decl) 6481132718Skan { 6482132718Skan current_function_returns_value = 1; 6483132718Skan return retval; 6484132718Skan } 6485169689Skan 648690075Sobrien /* When no explicit return-value is given in a function with a named 648790075Sobrien return value, the named return value is used. */ 648890075Sobrien result = DECL_RESULT (current_function_decl); 648990075Sobrien valtype = TREE_TYPE (result); 6490169689Skan gcc_assert (valtype != NULL_TREE); 649190075Sobrien fn_returns_value_p = !VOID_TYPE_P (valtype); 649290075Sobrien if (!retval && DECL_NAME (result) && fn_returns_value_p) 649390075Sobrien retval = result; 649490075Sobrien 649590075Sobrien /* Check for a return statement with no return value in a function 649690075Sobrien that's supposed to return a value. */ 649790075Sobrien if (!retval && fn_returns_value_p) 649890075Sobrien { 6499169689Skan pedwarn ("return-statement with no value, in function returning %qT", 6500132718Skan valtype); 650190075Sobrien /* Clear this, so finish_function won't say that we reach the 650290075Sobrien end of a non-void function (which we don't, we gave a 650390075Sobrien return!). */ 650490075Sobrien current_function_returns_null = 0; 6505169689Skan /* And signal caller that TREE_NO_WARNING should be set on the 6506169689Skan RETURN_EXPR to avoid control reaches end of non-void function 6507169689Skan warnings in tree-cfg.c. */ 6508169689Skan *no_warning = true; 650990075Sobrien } 651090075Sobrien /* Check for a return statement with a value in a function that 651190075Sobrien isn't supposed to return a value. */ 651290075Sobrien else if (retval && !fn_returns_value_p) 6513169689Skan { 651490075Sobrien if (VOID_TYPE_P (TREE_TYPE (retval))) 651590075Sobrien /* You can return a `void' value from a function of `void' 651690075Sobrien type. In that case, we have to evaluate the expression for 651790075Sobrien its side-effects. */ 651890075Sobrien finish_expr_stmt (retval); 651990075Sobrien else 6520132718Skan pedwarn ("return-statement with a value, in function " 6521169689Skan "returning 'void'"); 652290075Sobrien 652390075Sobrien current_function_returns_null = 1; 652490075Sobrien 652590075Sobrien /* There's really no value to return, after all. */ 652690075Sobrien return NULL_TREE; 652790075Sobrien } 652890075Sobrien else if (!retval) 652990075Sobrien /* Remember that this function can sometimes return without a 653090075Sobrien value. */ 653190075Sobrien current_function_returns_null = 1; 653290075Sobrien else 653390075Sobrien /* Remember that this function did return a value. */ 653490075Sobrien current_function_returns_value = 1; 653590075Sobrien 6536161651Skan /* Check for erroneous operands -- but after giving ourselves a 6537161651Skan chance to provide an error about returning a value from a void 6538161651Skan function. */ 6539161651Skan if (error_operand_p (retval)) 6540161651Skan { 6541161651Skan current_function_return_value = error_mark_node; 6542161651Skan return error_mark_node; 6543161651Skan } 6544161651Skan 654590075Sobrien /* Only operator new(...) throw(), can return NULL [expr.new/13]. */ 654690075Sobrien if ((DECL_OVERLOADED_OPERATOR_P (current_function_decl) == NEW_EXPR 654790075Sobrien || DECL_OVERLOADED_OPERATOR_P (current_function_decl) == VEC_NEW_EXPR) 654890075Sobrien && !TYPE_NOTHROW_P (TREE_TYPE (current_function_decl)) 654990075Sobrien && ! flag_check_new 655090075Sobrien && null_ptr_cst_p (retval)) 6551169689Skan warning (0, "%<operator new%> must not return NULL unless it is " 6552169689Skan "declared %<throw()%> (or -fcheck-new is in effect)"); 655390075Sobrien 655450397Sobrien /* Effective C++ rule 15. See also start_function. */ 655550397Sobrien if (warn_ecpp 6556169689Skan && DECL_NAME (current_function_decl) == ansi_assopname(NOP_EXPR)) 6557169689Skan { 6558169689Skan bool warn = true; 655950397Sobrien 6560169689Skan /* The function return type must be a reference to the current 6561169689Skan class. */ 6562169689Skan if (TREE_CODE (valtype) == REFERENCE_TYPE 6563169689Skan && same_type_ignoring_top_level_qualifiers_p 6564169689Skan (TREE_TYPE (valtype), TREE_TYPE (current_class_ref))) 6565169689Skan { 6566169689Skan /* Returning '*this' is obviously OK. */ 6567169689Skan if (retval == current_class_ref) 6568169689Skan warn = false; 6569169689Skan /* If we are calling a function whose return type is the same of 6570169689Skan the current class reference, it is ok. */ 6571169689Skan else if (TREE_CODE (retval) == INDIRECT_REF 6572169689Skan && TREE_CODE (TREE_OPERAND (retval, 0)) == CALL_EXPR) 6573169689Skan warn = false; 6574169689Skan } 6575169689Skan 6576169689Skan if (warn) 6577169689Skan warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>"); 6578169689Skan } 6579169689Skan 658090075Sobrien /* The fabled Named Return Value optimization, as per [class.copy]/15: 658190075Sobrien 658290075Sobrien [...] For a function with a class return type, if the expression 658390075Sobrien in the return statement is the name of a local object, and the cv- 658490075Sobrien unqualified type of the local object is the same as the function 658590075Sobrien return type, an implementation is permitted to omit creating the tem- 658690075Sobrien porary object to hold the function return value [...] 658790075Sobrien 658890075Sobrien So, if this is a value-returning function that always returns the same 658990075Sobrien local variable, remember it. 659090075Sobrien 659190075Sobrien It might be nice to be more flexible, and choose the first suitable 659290075Sobrien variable even if the function sometimes returns something else, but 659390075Sobrien then we run the risk of clobbering the variable we chose if the other 659490075Sobrien returned expression uses the chosen variable somehow. And people expect 659590075Sobrien this restriction, anyway. (jason 2000-11-19) 659690075Sobrien 6597169689Skan See finish_function and finalize_nrv for the rest of this optimization. */ 659890075Sobrien 659990075Sobrien if (fn_returns_value_p && flag_elide_constructors) 660018334Speter { 660190075Sobrien if (retval != NULL_TREE 660290075Sobrien && (current_function_return_value == NULL_TREE 660390075Sobrien || current_function_return_value == retval) 660490075Sobrien && TREE_CODE (retval) == VAR_DECL 660590075Sobrien && DECL_CONTEXT (retval) == current_function_decl 660690075Sobrien && ! TREE_STATIC (retval) 6607220150Smm && ! DECL_ANON_UNION_VAR_P (retval) 660890075Sobrien && (DECL_ALIGN (retval) 660990075Sobrien >= DECL_ALIGN (DECL_RESULT (current_function_decl))) 661090075Sobrien && same_type_p ((TYPE_MAIN_VARIANT 661190075Sobrien (TREE_TYPE (retval))), 661290075Sobrien (TYPE_MAIN_VARIANT 661390075Sobrien (TREE_TYPE (TREE_TYPE (current_function_decl)))))) 661490075Sobrien current_function_return_value = retval; 661590075Sobrien else 661690075Sobrien current_function_return_value = error_mark_node; 661718334Speter } 661818334Speter 661990075Sobrien /* We don't need to do any conversions when there's nothing being 662090075Sobrien returned. */ 6621161651Skan if (!retval) 6622161651Skan return NULL_TREE; 662390075Sobrien 662490075Sobrien /* Do any required conversions. */ 662590075Sobrien if (retval == result || DECL_CONSTRUCTOR_P (current_function_decl)) 662690075Sobrien /* No conversions are required. */ 662790075Sobrien ; 662818334Speter else 662918334Speter { 663090075Sobrien /* The type the function is declared to return. */ 663150397Sobrien tree functype = TREE_TYPE (TREE_TYPE (current_function_decl)); 663250397Sobrien 6633169689Skan /* The functype's return type will have been set to void, if it 6634169689Skan was an incomplete type. Just treat this as 'return;' */ 6635169689Skan if (VOID_TYPE_P (functype)) 6636169689Skan return error_mark_node; 6637169689Skan 663850397Sobrien /* First convert the value to the function's return type, then 663950397Sobrien to the type of return value's location to handle the 6640169689Skan case that functype is smaller than the valtype. */ 664150397Sobrien retval = convert_for_initialization 664250397Sobrien (NULL_TREE, functype, retval, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING, 664350397Sobrien "return", NULL_TREE, 0); 664450397Sobrien retval = convert (valtype, retval); 664550397Sobrien 664690075Sobrien /* If the conversion failed, treat this just like `return;'. */ 664750397Sobrien if (retval == error_mark_node) 664890075Sobrien return retval; 664950397Sobrien /* We can't initialize a register from a AGGR_INIT_EXPR. */ 665050397Sobrien else if (! current_function_returns_struct 665150397Sobrien && TREE_CODE (retval) == TARGET_EXPR 665250397Sobrien && TREE_CODE (TREE_OPERAND (retval, 1)) == AGGR_INIT_EXPR) 6653169689Skan retval = build2 (COMPOUND_EXPR, TREE_TYPE (retval), retval, 6654169689Skan TREE_OPERAND (retval, 0)); 665590075Sobrien else 665690075Sobrien maybe_warn_about_returning_address_of_local (retval); 665718334Speter } 6658169689Skan 665990075Sobrien /* Actually copy the value returned into the appropriate location. */ 666050397Sobrien if (retval && retval != result) 6661169689Skan retval = build2 (INIT_EXPR, TREE_TYPE (result), result, retval); 666218334Speter 666390075Sobrien return retval; 666490075Sobrien} 666518334Speter 666618334Speter 6667117395Skan/* Returns nonzero if the pointer-type FROM can be converted to the 666850397Sobrien pointer-type TO via a qualification conversion. If CONSTP is -1, 6669117395Skan then we return nonzero if the pointers are similar, and the 667050397Sobrien cv-qualification signature of FROM is a proper subset of that of TO. 667150397Sobrien 667250397Sobrien If CONSTP is positive, then all outer pointers have been 667350397Sobrien const-qualified. */ 667450397Sobrien 667550397Sobrienstatic int 6676132718Skancomp_ptr_ttypes_real (tree to, tree from, int constp) 667718334Speter{ 6678132718Skan bool to_more_cv_qualified = false; 667950397Sobrien 668018334Speter for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from)) 668118334Speter { 668218334Speter if (TREE_CODE (to) != TREE_CODE (from)) 668318334Speter return 0; 668418334Speter 668550397Sobrien if (TREE_CODE (from) == OFFSET_TYPE 6686132718Skan && !same_type_p (TYPE_OFFSET_BASETYPE (from), 6687132718Skan TYPE_OFFSET_BASETYPE (to))) 6688132718Skan return 0; 668950397Sobrien 669018334Speter /* Const and volatile mean something different for function types, 669118334Speter so the usual checks are not appropriate. */ 669218334Speter if (TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE) 669318334Speter { 6694169689Skan /* In Objective-C++, some types may have been 'volatilized' by 6695169689Skan the compiler for EH; when comparing them here, the volatile 6696169689Skan qualification must be ignored. */ 6697169689Skan bool objc_quals_match = objc_type_quals_match (to, from); 6698169689Skan 6699169689Skan if (!at_least_as_qualified_p (to, from) && !objc_quals_match) 670018334Speter return 0; 670118334Speter 6702169689Skan if (!at_least_as_qualified_p (from, to) && !objc_quals_match) 670350397Sobrien { 670450397Sobrien if (constp == 0) 670550397Sobrien return 0; 6706132718Skan to_more_cv_qualified = true; 670750397Sobrien } 670850397Sobrien 670950397Sobrien if (constp > 0) 671050397Sobrien constp &= TYPE_READONLY (to); 671118334Speter } 671218334Speter 6713132718Skan if (TREE_CODE (to) != POINTER_TYPE && !TYPE_PTRMEM_P (to)) 6714132718Skan return ((constp >= 0 || to_more_cv_qualified) 6715132718Skan && same_type_ignoring_top_level_qualifiers_p (to, from)); 671618334Speter } 671718334Speter} 671818334Speter 6719132718Skan/* When comparing, say, char ** to char const **, this function takes 6720132718Skan the 'char *' and 'char const *'. Do not pass non-pointer/reference 6721132718Skan types to this function. */ 672250397Sobrien 672318334Speterint 6724132718Skancomp_ptr_ttypes (tree to, tree from) 672518334Speter{ 672618334Speter return comp_ptr_ttypes_real (to, from, 1); 672718334Speter} 672850397Sobrien 672950397Sobrien/* Returns 1 if to and from are (possibly multi-level) pointers to the same 673050397Sobrien type or inheritance-related types, regardless of cv-quals. */ 673150397Sobrien 673250397Sobrienint 6733132718Skanptr_reasonably_similar (tree to, tree from) 673450397Sobrien{ 673550397Sobrien for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from)) 673650397Sobrien { 673790075Sobrien /* Any target type is similar enough to void. */ 673890075Sobrien if (TREE_CODE (to) == VOID_TYPE 673990075Sobrien || TREE_CODE (from) == VOID_TYPE) 674090075Sobrien return 1; 674190075Sobrien 674250397Sobrien if (TREE_CODE (to) != TREE_CODE (from)) 674350397Sobrien return 0; 674450397Sobrien 674550397Sobrien if (TREE_CODE (from) == OFFSET_TYPE 674650397Sobrien && comptypes (TYPE_OFFSET_BASETYPE (to), 6747169689Skan TYPE_OFFSET_BASETYPE (from), 6748132718Skan COMPARE_BASE | COMPARE_DERIVED)) 674950397Sobrien continue; 675050397Sobrien 6751169689Skan if (TREE_CODE (to) == VECTOR_TYPE 6752169689Skan && vector_types_convertible_p (to, from)) 6753169689Skan return 1; 6754169689Skan 675590075Sobrien if (TREE_CODE (to) == INTEGER_TYPE 675690075Sobrien && TYPE_PRECISION (to) == TYPE_PRECISION (from)) 675790075Sobrien return 1; 675890075Sobrien 675990075Sobrien if (TREE_CODE (to) == FUNCTION_TYPE) 676090075Sobrien return 1; 676190075Sobrien 676250397Sobrien if (TREE_CODE (to) != POINTER_TYPE) 676350397Sobrien return comptypes 6764169689Skan (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from), 6765132718Skan COMPARE_BASE | COMPARE_DERIVED); 676650397Sobrien } 676750397Sobrien} 676850397Sobrien 6769169689Skan/* Return true if TO and FROM (both of which are POINTER_TYPEs or 6770169689Skan pointer-to-member types) are the same, ignoring cv-qualification at 6771169689Skan all levels. */ 677250397Sobrien 6773169689Skanbool 6774132718Skancomp_ptr_ttypes_const (tree to, tree from) 677550397Sobrien{ 677650397Sobrien for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from)) 677750397Sobrien { 677850397Sobrien if (TREE_CODE (to) != TREE_CODE (from)) 6779169689Skan return false; 678050397Sobrien 678150397Sobrien if (TREE_CODE (from) == OFFSET_TYPE 678252284Sobrien && same_type_p (TYPE_OFFSET_BASETYPE (from), 678352284Sobrien TYPE_OFFSET_BASETYPE (to))) 678450397Sobrien continue; 678550397Sobrien 678650397Sobrien if (TREE_CODE (to) != POINTER_TYPE) 678790075Sobrien return same_type_ignoring_top_level_qualifiers_p (to, from); 678850397Sobrien } 678950397Sobrien} 679050397Sobrien 679190075Sobrien/* Returns the type qualifiers for this type, including the qualifiers on the 679290075Sobrien elements for an array type. */ 679352284Sobrien 679452284Sobrienint 6795132718Skancp_type_quals (tree type) 679652284Sobrien{ 679790075Sobrien type = strip_array_types (type); 6798117395Skan if (type == error_mark_node) 6799117395Skan return TYPE_UNQUALIFIED; 680052284Sobrien return TYPE_QUALS (type); 680152284Sobrien} 680252284Sobrien 6803169689Skan/* Returns nonzero if the TYPE is const from a C++ perspective: look inside 6804169689Skan arrays. */ 6805169689Skan 6806169689Skanbool 6807169689Skancp_type_readonly (tree type) 6808169689Skan{ 6809169689Skan type = strip_array_types (type); 6810169689Skan return TYPE_READONLY (type); 6811169689Skan} 6812169689Skan 6813132718Skan/* Returns nonzero if the TYPE contains a mutable member. */ 681452284Sobrien 6815132718Skanbool 6816132718Skancp_has_mutable_p (tree type) 681752284Sobrien{ 681890075Sobrien type = strip_array_types (type); 681952284Sobrien 682052284Sobrien return CLASS_TYPE_P (type) && CLASSTYPE_HAS_MUTABLE (type); 682152284Sobrien} 682290075Sobrien 6823169689Skan/* Apply the TYPE_QUALS to the new DECL. */ 6824169689Skanvoid 6825169689Skancp_apply_type_quals_to_decl (int type_quals, tree decl) 6826169689Skan{ 6827169689Skan tree type = TREE_TYPE (decl); 6828169689Skan 6829169689Skan if (type == error_mark_node) 6830169689Skan return; 6831169689Skan 6832169689Skan if (TREE_CODE (type) == FUNCTION_TYPE 6833169689Skan && type_quals != TYPE_UNQUALIFIED) 6834169689Skan { 6835169689Skan /* This was an error in C++98 (cv-qualifiers cannot be added to 6836169689Skan a function type), but DR 295 makes the code well-formed by 6837169689Skan dropping the extra qualifiers. */ 6838169689Skan if (pedantic) 6839169689Skan { 6840169689Skan tree bad_type = build_qualified_type (type, type_quals); 6841169689Skan pedwarn ("ignoring %qV qualifiers added to function type %qT", 6842169689Skan bad_type, type); 6843169689Skan } 6844169689Skan 6845169689Skan TREE_TYPE (decl) = TYPE_MAIN_VARIANT (type); 6846169689Skan return; 6847169689Skan } 6848169689Skan 6849169689Skan /* Avoid setting TREE_READONLY incorrectly. */ 6850169689Skan if (/* If the object has a constructor, the constructor may modify 6851169689Skan the object. */ 6852169689Skan TYPE_NEEDS_CONSTRUCTING (type) 6853169689Skan /* If the type isn't complete, we don't know yet if it will need 6854169689Skan constructing. */ 6855169689Skan || !COMPLETE_TYPE_P (type) 6856169689Skan /* If the type has a mutable component, that component might be 6857169689Skan modified. */ 6858169689Skan || TYPE_HAS_MUTABLE_P (type)) 6859169689Skan type_quals &= ~TYPE_QUAL_CONST; 6860169689Skan 6861169689Skan c_apply_type_quals_to_decl (type_quals, decl); 6862169689Skan} 6863169689Skan 686490075Sobrien/* Subroutine of casts_away_constness. Make T1 and T2 point at 6865169689Skan exemplar types such that casting T1 to T2 is casting away constness 686690075Sobrien if and only if there is no implicit conversion from T1 to T2. */ 686790075Sobrien 686890075Sobrienstatic void 6869132718Skancasts_away_constness_r (tree *t1, tree *t2) 687090075Sobrien{ 687190075Sobrien int quals1; 687290075Sobrien int quals2; 687390075Sobrien 687490075Sobrien /* [expr.const.cast] 687590075Sobrien 687690075Sobrien For multi-level pointer to members and multi-level mixed pointers 687790075Sobrien and pointers to members (conv.qual), the "member" aspect of a 687890075Sobrien pointer to member level is ignored when determining if a const 687990075Sobrien cv-qualifier has been cast away. */ 688090075Sobrien /* [expr.const.cast] 688190075Sobrien 688290075Sobrien For two pointer types: 688390075Sobrien 6884169689Skan X1 is T1cv1,1 * ... cv1,N * where T1 is not a pointer type 6885169689Skan X2 is T2cv2,1 * ... cv2,M * where T2 is not a pointer type 6886169689Skan K is min(N,M) 688790075Sobrien 688890075Sobrien casting from X1 to X2 casts away constness if, for a non-pointer 688990075Sobrien type T there does not exist an implicit conversion (clause 689090075Sobrien _conv_) from: 689190075Sobrien 6892169689Skan Tcv1,(N-K+1) * cv1,(N-K+2) * ... cv1,N * 6893169689Skan 689490075Sobrien to 689590075Sobrien 6896169689Skan Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *. */ 6897161651Skan if ((!TYPE_PTR_P (*t1) && !TYPE_PTRMEM_P (*t1)) 6898161651Skan || (!TYPE_PTR_P (*t2) && !TYPE_PTRMEM_P (*t2))) 689990075Sobrien { 690090075Sobrien *t1 = cp_build_qualified_type (void_type_node, 690190075Sobrien cp_type_quals (*t1)); 690290075Sobrien *t2 = cp_build_qualified_type (void_type_node, 690390075Sobrien cp_type_quals (*t2)); 690490075Sobrien return; 690590075Sobrien } 6906169689Skan 690790075Sobrien quals1 = cp_type_quals (*t1); 690890075Sobrien quals2 = cp_type_quals (*t2); 6909161651Skan 6910161651Skan if (TYPE_PTRMEM_P (*t1)) 6911161651Skan *t1 = TYPE_PTRMEM_POINTED_TO_TYPE (*t1); 6912161651Skan else 6913161651Skan *t1 = TREE_TYPE (*t1); 6914161651Skan if (TYPE_PTRMEM_P (*t2)) 6915161651Skan *t2 = TYPE_PTRMEM_POINTED_TO_TYPE (*t2); 6916161651Skan else 6917161651Skan *t2 = TREE_TYPE (*t2); 6918161651Skan 691990075Sobrien casts_away_constness_r (t1, t2); 692090075Sobrien *t1 = build_pointer_type (*t1); 692190075Sobrien *t2 = build_pointer_type (*t2); 692290075Sobrien *t1 = cp_build_qualified_type (*t1, quals1); 692390075Sobrien *t2 = cp_build_qualified_type (*t2, quals2); 692490075Sobrien} 692590075Sobrien 6926117395Skan/* Returns nonzero if casting from TYPE1 to TYPE2 casts away 692790075Sobrien constness. */ 692890075Sobrien 6929132718Skanstatic bool 6930132718Skancasts_away_constness (tree t1, tree t2) 693190075Sobrien{ 693290075Sobrien if (TREE_CODE (t2) == REFERENCE_TYPE) 693390075Sobrien { 693490075Sobrien /* [expr.const.cast] 6935169689Skan 693690075Sobrien Casting from an lvalue of type T1 to an lvalue of type T2 693790075Sobrien using a reference cast casts away constness if a cast from an 693890075Sobrien rvalue of type "pointer to T1" to the type "pointer to T2" 693990075Sobrien casts away constness. */ 6940132718Skan t1 = (TREE_CODE (t1) == REFERENCE_TYPE ? TREE_TYPE (t1) : t1); 694190075Sobrien return casts_away_constness (build_pointer_type (t1), 694290075Sobrien build_pointer_type (TREE_TYPE (t2))); 694390075Sobrien } 694490075Sobrien 694590075Sobrien if (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2)) 694690075Sobrien /* [expr.const.cast] 6947169689Skan 694890075Sobrien Casting from an rvalue of type "pointer to data member of X 694990075Sobrien of type T1" to the type "pointer to data member of Y of type 695090075Sobrien T2" casts away constness if a cast from an rvalue of type 695190075Sobrien "pointer to T1" to the type "pointer to T2" casts away 695290075Sobrien constness. */ 695390075Sobrien return casts_away_constness 6954132718Skan (build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t1)), 6955132718Skan build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (t2))); 695690075Sobrien 695790075Sobrien /* Casting away constness is only something that makes sense for 695890075Sobrien pointer or reference types. */ 6959169689Skan if (TREE_CODE (t1) != POINTER_TYPE 696090075Sobrien || TREE_CODE (t2) != POINTER_TYPE) 6961132718Skan return false; 696290075Sobrien 696390075Sobrien /* Top-level qualifiers don't matter. */ 696490075Sobrien t1 = TYPE_MAIN_VARIANT (t1); 696590075Sobrien t2 = TYPE_MAIN_VARIANT (t2); 696690075Sobrien casts_away_constness_r (&t1, &t2); 696790075Sobrien if (!can_convert (t2, t1)) 6968132718Skan return true; 696990075Sobrien 6970132718Skan return false; 697190075Sobrien} 697290075Sobrien 6973132718Skan/* If T is a REFERENCE_TYPE return the type to which T refers. 6974132718Skan Otherwise, return T itself. */ 697590075Sobrien 6976132718Skantree 6977132718Skannon_reference (tree t) 697890075Sobrien{ 6979132718Skan if (TREE_CODE (t) == REFERENCE_TYPE) 6980132718Skan t = TREE_TYPE (t); 6981132718Skan return t; 698290075Sobrien} 6983169689Skan 6984169689Skan 6985169689Skan/* Return nonzero if REF is an lvalue valid for this language; 6986169689Skan otherwise, print an error message and return zero. USE says 6987169689Skan how the lvalue is being used and so selects the error message. */ 6988169689Skan 6989169689Skanint 6990169689Skanlvalue_or_else (tree ref, enum lvalue_use use) 6991169689Skan{ 6992169689Skan int win = lvalue_p (ref); 6993169689Skan 6994169689Skan if (!win) 6995169689Skan lvalue_error (use); 6996169689Skan 6997169689Skan return win; 6998169689Skan} 6999