diff options
Diffstat (limited to 'gcc/cp/typeck.c')
| -rwxr-xr-x | gcc/cp/typeck.c | 7495 |
1 files changed, 0 insertions, 7495 deletions
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c deleted file mode 100755 index 58c19a4..0000000 --- a/gcc/cp/typeck.c +++ /dev/null @@ -1,7495 +0,0 @@ -/* Build expressions with type checking for C++ compiler. - Copyright (C) 1987, 88, 89, 92-98, 1999 Free Software Foundation, Inc. - Hacked by Michael Tiemann (tiemann@cygnus.com) - -This file is part of GNU CC. - -GNU CC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) -any later version. - -GNU CC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with GNU CC; see the file COPYING. If not, write to -the Free Software Foundation, 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. */ - - -/* This file is part of the C++ front end. - It contains routines to build C++ expressions given their operands, - including computing the types of the result, C and C++ specific error - checks, and some optimization. - - There are also routines to build RETURN_STMT nodes and CASE_STMT nodes, - and to process initializations in declarations (since they work - like a strange sort of assignment). */ - -#include "config.h" -#include "system.h" -#include "tree.h" -#include "rtl.h" -#include "cp-tree.h" -#include "flags.h" -#include "output.h" -#include "expr.h" -#include "toplev.h" - -extern void compiler_error (); - -static tree convert_for_assignment PROTO((tree, tree, char*, tree, - int)); -static tree pointer_int_sum PROTO((enum tree_code, tree, tree)); -static tree rationalize_conditional_expr PROTO((enum tree_code, tree)); -static int comp_target_parms PROTO((tree, tree, int)); -static int comp_ptr_ttypes_real PROTO((tree, tree, int)); -static int comp_ptr_ttypes_const PROTO((tree, tree)); -static int comp_ptr_ttypes_reinterpret PROTO((tree, tree)); -static int comp_array_types PROTO((int (*) (tree, tree, int), tree, - tree, int)); -static tree build_ptrmemfunc1 PROTO((tree, tree, tree, tree, tree)); -static tree common_base_type PROTO((tree, tree)); -#if 0 -static tree convert_sequence PROTO((tree, tree)); -#endif -static tree lookup_anon_field PROTO((tree, tree)); -static tree pointer_diff PROTO((tree, tree, tree)); -static tree qualify_type PROTO((tree, tree)); -static tree get_delta_difference PROTO((tree, tree, int)); - -/* Return the target type of TYPE, which meas return T for: - T*, T&, T[], T (...), and otherwise, just T. */ - -tree -target_type (type) - tree type; -{ - if (TREE_CODE (type) == REFERENCE_TYPE) - type = TREE_TYPE (type); - while (TREE_CODE (type) == POINTER_TYPE - || TREE_CODE (type) == ARRAY_TYPE - || TREE_CODE (type) == FUNCTION_TYPE - || TREE_CODE (type) == METHOD_TYPE - || TREE_CODE (type) == OFFSET_TYPE) - type = TREE_TYPE (type); - return type; -} - -/* Do `exp = require_complete_type (exp);' to make sure exp - does not have an incomplete type. (That includes void types.) - Returns the error_mark_node if the VALUE does not have - complete type when this function returns. */ - -tree -require_complete_type (value) - tree value; -{ - tree type; - - if (processing_template_decl) - return value; - - if (TREE_CODE (value) == OVERLOAD) - type = unknown_type_node; - else - type = TREE_TYPE (value); - - /* First, detect a valid value with a complete type. */ - if (TYPE_SIZE (type) != 0 - && type != void_type_node - && ! (TYPE_LANG_SPECIFIC (type) - && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type)) - && TYPE_SIZE (SIGNATURE_TYPE (type)) == 0)) - return value; - - /* If we see X::Y, we build an OFFSET_TYPE which has - not been laid out. Try to avoid an error by interpreting - it as this->X::Y, if reasonable. */ - if (TREE_CODE (value) == OFFSET_REF - && current_class_ref != 0 - && TREE_OPERAND (value, 0) == current_class_ref) - { - tree base, member = TREE_OPERAND (value, 1); - tree basetype = TYPE_OFFSET_BASETYPE (type); - my_friendly_assert (TREE_CODE (member) == FIELD_DECL, 305); - base = convert_pointer_to (basetype, current_class_ptr); - value = build (COMPONENT_REF, TREE_TYPE (member), - build_indirect_ref (base, NULL_PTR), member); - return require_complete_type (value); - } - - if (complete_type_or_else (type)) - return value; - else - return error_mark_node; -} - -/* Try to complete TYPE, if it is incomplete. For example, if TYPE is - a template instantiation, do the instantiation. Returns TYPE, - whether or not it could be completed, unless something goes - horribly wrong, in which case the error_mark_node is returned. */ - -tree -complete_type (type) - tree type; -{ - if (type == NULL_TREE) - /* Rather than crash, we return something sure to cause an error - at some point. */ - return error_mark_node; - - if (type == error_mark_node || TYPE_SIZE (type) != NULL_TREE) - ; - else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type)) - { - tree t = complete_type (TREE_TYPE (type)); - if (TYPE_SIZE (t) != NULL_TREE && ! processing_template_decl) - layout_type (type); - TYPE_NEEDS_CONSTRUCTING (type) - = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t)); - TYPE_NEEDS_DESTRUCTOR (type) - = TYPE_NEEDS_DESTRUCTOR (TYPE_MAIN_VARIANT (t)); - } - else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INSTANTIATION (type)) - instantiate_class_template (TYPE_MAIN_VARIANT (type)); - - return type; -} - -/* Like complete_type, but issue an error if the TYPE cannot be - completed. Returns NULL_TREE if the type cannot be made - complete. */ - -tree -complete_type_or_else (type) - tree type; -{ - type = complete_type (type); - if (type == error_mark_node) - /* We already issued an error. */ - return NULL_TREE; - else if (!TYPE_SIZE (type)) - { - incomplete_type_error (NULL_TREE, type); - return NULL_TREE; - } - else - return type; -} - -/* Return truthvalue of whether type of EXP is instantiated. */ - -int -type_unknown_p (exp) - tree exp; -{ - return (TREE_CODE (exp) == OVERLOAD - || TREE_CODE (exp) == TREE_LIST - || TREE_TYPE (exp) == unknown_type_node - || (TREE_CODE (TREE_TYPE (exp)) == OFFSET_TYPE - && TREE_TYPE (TREE_TYPE (exp)) == unknown_type_node)); -} - -/* Return truthvalue of whether T is function (or pfn) type. */ - -int -fntype_p (t) - tree t; -{ - return (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE - || (TREE_CODE (t) == POINTER_TYPE - && (TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE - || TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))); -} - -/* Return a variant of TYPE which has all the type qualifiers of LIKE - as well as those of TYPE. */ - -static tree -qualify_type (type, like) - tree type, like; -{ - /* @@ Must do member pointers here. */ - return cp_build_qualified_type (type, (CP_TYPE_QUALS (type) - | CP_TYPE_QUALS (like))); -} - -/* Return the common type of two parameter lists. - We assume that comptypes has already been done and returned 1; - if that isn't so, this may crash. - - As an optimization, free the space we allocate if the parameter - lists are already common. */ - -tree -commonparms (p1, p2) - tree p1, p2; -{ - tree oldargs = p1, newargs, n; - int i, len; - int any_change = 0; - char *first_obj = (char *) oballoc (0); - - len = list_length (p1); - newargs = tree_last (p1); - - if (newargs == void_list_node) - i = 1; - else - { - i = 0; - newargs = 0; - } - - for (; i < len; i++) - newargs = tree_cons (NULL_TREE, NULL_TREE, newargs); - - n = newargs; - - for (i = 0; p1; - p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n), i++) - { - if (TREE_PURPOSE (p1) && !TREE_PURPOSE (p2)) - { - TREE_PURPOSE (n) = TREE_PURPOSE (p1); - any_change = 1; - } - else if (! TREE_PURPOSE (p1)) - { - if (TREE_PURPOSE (p2)) - { - TREE_PURPOSE (n) = TREE_PURPOSE (p2); - any_change = 1; - } - } - else - { - if (1 != simple_cst_equal (TREE_PURPOSE (p1), TREE_PURPOSE (p2))) - any_change = 1; - TREE_PURPOSE (n) = TREE_PURPOSE (p2); - } - if (TREE_VALUE (p1) != TREE_VALUE (p2)) - { - any_change = 1; - TREE_VALUE (n) = common_type (TREE_VALUE (p1), TREE_VALUE (p2)); - } - else - TREE_VALUE (n) = TREE_VALUE (p1); - } - if (! any_change) - { - obfree (first_obj); - return oldargs; - } - - return newargs; -} - -/* Given a type, perhaps copied for a typedef, - find the "original" version of it. */ -tree -original_type (t) - tree t; -{ - while (TYPE_NAME (t) != NULL_TREE) - { - tree x = TYPE_NAME (t); - if (TREE_CODE (x) != TYPE_DECL) - break; - x = DECL_ORIGINAL_TYPE (x); - if (x == NULL_TREE) - break; - t = x; - } - return t; -} - -/* Return the common type of two types. - We assume that comptypes has already been done and returned 1; - if that isn't so, this may crash. - - This is the type for the result of most arithmetic operations - if the operands have the given two types. - - We do not deal with enumeral types here because they have already been - converted to integer types. */ - -tree -common_type (t1, t2) - tree t1, t2; -{ - register enum tree_code code1; - register enum tree_code code2; - tree attributes; - - /* Save time if the two types are the same. */ - if (t1 == t2) - return t1; - t1 = original_type (t1); - t2 = original_type (t2); - if (t1 == t2) - return t1; - - /* If one type is nonsense, use the other. */ - if (t1 == error_mark_node) - return t2; - if (t2 == error_mark_node) - return t1; - - /* Merge the attributes. */ - attributes = merge_machine_type_attributes (t1, t2); - - { register tree a1, a2; - a1 = TYPE_ATTRIBUTES (t1); - a2 = TYPE_ATTRIBUTES (t2); - - /* Either one unset? Take the set one. */ - - if (!(attributes = a1)) - attributes = a2; - - /* One that completely contains the other? Take it. */ - - else if (a2 && !attribute_list_contained (a1, a2)) - { - if (attribute_list_contained (a2, a1)) - attributes = a2; - else - { - /* Pick the longest list, and hang on the other list. */ - /* ??? For the moment we punt on the issue of attrs with args. */ - - if (list_length (a1) < list_length (a2)) - attributes = a2, a2 = a1; - - for (; a2; a2 = TREE_CHAIN (a2)) - if (lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)), - attributes) == NULL_TREE) - { - a1 = copy_node (a2); - TREE_CHAIN (a1) = attributes; - attributes = a1; - } - } - } - } - - /* Treat an enum type as the unsigned integer type of the same width. */ - - if (TREE_CODE (t1) == ENUMERAL_TYPE) - t1 = type_for_size (TYPE_PRECISION (t1), 1); - if (TREE_CODE (t2) == ENUMERAL_TYPE) - t2 = type_for_size (TYPE_PRECISION (t2), 1); - - if (TYPE_PTRMEMFUNC_P (t1)) - t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1); - if (TYPE_PTRMEMFUNC_P (t2)) - t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2); - - code1 = TREE_CODE (t1); - code2 = TREE_CODE (t2); - - /* If one type is complex, form the common type of the non-complex - components, then make that complex. Use T1 or T2 if it is the - required type. */ - if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE) - { - tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1; - tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2; - tree subtype = common_type (subtype1, subtype2); - - if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype) - return build_type_attribute_variant (t1, attributes); - else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype) - return build_type_attribute_variant (t2, attributes); - else - return build_type_attribute_variant (build_complex_type (subtype), - attributes); - } - - switch (code1) - { - case INTEGER_TYPE: - case REAL_TYPE: - /* If only one is real, use it as the result. */ - - if (code1 == REAL_TYPE && code2 != REAL_TYPE) - return build_type_attribute_variant (t1, attributes); - - if (code2 == REAL_TYPE && code1 != REAL_TYPE) - return build_type_attribute_variant (t2, attributes); - - /* Both real or both integers; use the one with greater precision. */ - - if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2)) - return build_type_attribute_variant (t1, attributes); - else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1)) - return build_type_attribute_variant (t2, attributes); - - /* Same precision. Prefer longs to ints even when same size. */ - - if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node - || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node) - return build_type_attribute_variant (long_unsigned_type_node, - attributes); - - if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node - || TYPE_MAIN_VARIANT (t2) == long_integer_type_node) - { - /* But preserve unsignedness from the other type, - since long cannot hold all the values of an unsigned int. */ - if (TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2)) - t1 = long_unsigned_type_node; - else - t1 = long_integer_type_node; - return build_type_attribute_variant (t1, attributes); - } - - if (TYPE_MAIN_VARIANT (t1) == long_double_type_node - || TYPE_MAIN_VARIANT (t2) == long_double_type_node) - return build_type_attribute_variant (long_double_type_node, - attributes); - - /* Otherwise prefer the unsigned one. */ - - if (TREE_UNSIGNED (t1)) - return build_type_attribute_variant (t1, attributes); - else - return build_type_attribute_variant (t2, attributes); - - case POINTER_TYPE: - case REFERENCE_TYPE: - /* For two pointers, do this recursively on the target type, - and combine the qualifiers of the two types' targets. */ - /* This code was turned off; I don't know why. - But ANSI C++ specifies doing this with the qualifiers. - So I turned it on again. */ - { - tree tt1 = TYPE_MAIN_VARIANT (TREE_TYPE (t1)); - tree tt2 = TYPE_MAIN_VARIANT (TREE_TYPE (t2)); - int type_quals = (CP_TYPE_QUALS (TREE_TYPE (t1)) - | CP_TYPE_QUALS (TREE_TYPE (t2))); - tree target; - - if (tt1 == tt2) - target = tt1; - else if (tt1 == void_type_node || tt2 == void_type_node) - target = void_type_node; - else if (tt1 == unknown_type_node) - target = tt2; - else if (tt2 == unknown_type_node) - target = tt1; - else - target = common_type (tt1, tt2); - - target = cp_build_qualified_type (target, type_quals); - if (code1 == POINTER_TYPE) - t1 = build_pointer_type (target); - else - t1 = build_reference_type (target); - t1 = build_type_attribute_variant (t1, attributes); - - if (TREE_CODE (target) == METHOD_TYPE) - t1 = build_ptrmemfunc_type (t1); - - return t1; - } - - case ARRAY_TYPE: - { - tree elt = common_type (TREE_TYPE (t1), TREE_TYPE (t2)); - /* Save space: see if the result is identical to one of the args. */ - if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1)) - return build_type_attribute_variant (t1, attributes); - if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2)) - return build_type_attribute_variant (t2, attributes); - /* Merge the element types, and have a size if either arg has one. */ - t1 = build_cplus_array_type - (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2)); - return build_type_attribute_variant (t1, attributes); - } - - case FUNCTION_TYPE: - /* Function types: prefer the one that specified arg types. - If both do, merge the arg types. Also merge the return types. */ - { - tree valtype = common_type (TREE_TYPE (t1), TREE_TYPE (t2)); - tree p1 = TYPE_ARG_TYPES (t1); - tree p2 = TYPE_ARG_TYPES (t2); - tree rval, raises; - - /* Save space: see if the result is identical to one of the args. */ - if (valtype == TREE_TYPE (t1) && ! p2) - return build_type_attribute_variant (t1, attributes); - if (valtype == TREE_TYPE (t2) && ! p1) - return build_type_attribute_variant (t2, attributes); - - /* Simple way if one arg fails to specify argument types. */ - if (p1 == NULL_TREE || TREE_VALUE (p1) == void_type_node) - { - rval = build_function_type (valtype, p2); - if ((raises = TYPE_RAISES_EXCEPTIONS (t2))) - rval = build_exception_variant (rval, raises); - return build_type_attribute_variant (rval, attributes); - } - raises = TYPE_RAISES_EXCEPTIONS (t1); - if (p2 == NULL_TREE || TREE_VALUE (p2) == void_type_node) - { - rval = build_function_type (valtype, p1); - if (raises) - rval = build_exception_variant (rval, raises); - return build_type_attribute_variant (rval, attributes); - } - - rval = build_function_type (valtype, commonparms (p1, p2)); - rval = build_exception_variant (rval, raises); - return build_type_attribute_variant (rval, attributes); - } - - case RECORD_TYPE: - case UNION_TYPE: - t1 = TYPE_MAIN_VARIANT (t1); - t2 = TYPE_MAIN_VARIANT (t2); - - if (DERIVED_FROM_P (t1, t2) && binfo_or_else (t1, t2)) - return build_type_attribute_variant (t1, attributes); - else if (binfo_or_else (t2, t1)) - return build_type_attribute_variant (t2, attributes); - else - { - compiler_error ("common_type called with uncommon aggregate types"); - return error_mark_node; - } - - case METHOD_TYPE: - if (TREE_CODE (TREE_TYPE (t1)) == TREE_CODE (TREE_TYPE (t2))) - { - /* Get this value the long way, since TYPE_METHOD_BASETYPE - is just the main variant of this. */ - tree basetype; - tree raises, t3; - - tree b1 = TYPE_OFFSET_BASETYPE (t1); - tree b2 = TYPE_OFFSET_BASETYPE (t2); - - if (same_type_p (b1, b2) - || (DERIVED_FROM_P (b1, b2) && binfo_or_else (b1, b2))) - basetype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t2))); - else - { - if (binfo_or_else (b2, b1) == NULL_TREE) - compiler_error ("common_type called with uncommon method types"); - basetype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t1))); - } - - raises = TYPE_RAISES_EXCEPTIONS (t1); - - /* If this was a member function type, get back to the - original type of type member function (i.e., without - the class instance variable up front. */ - t1 = build_function_type (TREE_TYPE (t1), - TREE_CHAIN (TYPE_ARG_TYPES (t1))); - t2 = build_function_type (TREE_TYPE (t2), - TREE_CHAIN (TYPE_ARG_TYPES (t2))); - t3 = common_type (t1, t2); - t3 = build_cplus_method_type (basetype, TREE_TYPE (t3), - TYPE_ARG_TYPES (t3)); - t1 = build_exception_variant (t3, raises); - } - else - compiler_error ("common_type called with uncommon method types"); - - return build_type_attribute_variant (t1, attributes); - - case OFFSET_TYPE: - if (TREE_TYPE (t1) == TREE_TYPE (t2)) - { - tree b1 = TYPE_OFFSET_BASETYPE (t1); - tree b2 = TYPE_OFFSET_BASETYPE (t2); - - if (same_type_p (b1, b2) - || (DERIVED_FROM_P (b1, b2) && binfo_or_else (b1, b2))) - return build_type_attribute_variant (t2, attributes); - else if (binfo_or_else (b2, b1)) - return build_type_attribute_variant (t1, attributes); - } - compiler_error ("common_type called with uncommon member types"); - - default: - return build_type_attribute_variant (t1, attributes); - } -} - -/* Return 1 if TYPE1 and TYPE2 raise the same exceptions. */ - -int -compexcepttypes (t1, t2) - tree t1, t2; -{ - return TYPE_RAISES_EXCEPTIONS (t1) == TYPE_RAISES_EXCEPTIONS (t2); -} - -/* Compare the array types T1 and T2, using CMP as the type comparison - function for the element types. STRICT is as for comptypes. */ - -static int -comp_array_types (cmp, t1, t2, strict) - register int (*cmp) PROTO((tree, tree, int)); - tree t1, t2; - int strict; -{ - tree d1; - tree d2; - - if (t1 == t2) - return 1; - - /* The type of the array elements must be the same. */ - if (!(TREE_TYPE (t1) == TREE_TYPE (t2) - || (*cmp) (TREE_TYPE (t1), TREE_TYPE (t2), - strict & ~COMPARE_REDECLARATION))) - return 0; - - d1 = TYPE_DOMAIN (t1); - d2 = TYPE_DOMAIN (t2); - - if (d1 == d2) - return 1; - - /* If one of the arrays is dimensionless, and the other has a - dimension, they are of different types. However, it is legal to - write: - - extern int a[]; - int a[3]; - - by [basic.link]: - - declarations for an array object can specify - array types that differ by the presence or absence of a major - array bound (_dcl.array_). */ - if (!d1 || !d2) - return strict & COMPARE_REDECLARATION; - - /* Check that the dimensions are the same. */ - return (cp_tree_equal (TYPE_MIN_VALUE (d1), - TYPE_MIN_VALUE (d2)) - && cp_tree_equal (TYPE_MAX_VALUE (d1), - TYPE_MAX_VALUE (d2))); -} - -/* Return 1 if TYPE1 and TYPE2 are compatible types for assignment - or various other operations. STRICT is a bitwise-or of the - COMPARE_* flags. */ - -int -comptypes (type1, type2, strict) - tree type1, type2; - int strict; -{ - register tree t1 = type1; - register tree t2 = type2; - int attrval, val; - int orig_strict = strict; - - /* The special exemption for redeclaring array types without an - array bound only applies at the top level: - - extern int (*i)[]; - int (*i)[8]; - - is not legal, for example. */ - strict &= ~COMPARE_REDECLARATION; - - /* Suppress errors caused by previously reported errors */ - if (t1 == t2) - return 1; - - /* This should never happen. */ - my_friendly_assert (t1 != error_mark_node, 307); - - if (t2 == error_mark_node) - return 0; - - if (strict & COMPARE_RELAXED) - { - /* Treat an enum type as the unsigned integer type of the same width. */ - - if (TREE_CODE (t1) == ENUMERAL_TYPE) - t1 = type_for_size (TYPE_PRECISION (t1), 1); - if (TREE_CODE (t2) == ENUMERAL_TYPE) - t2 = type_for_size (TYPE_PRECISION (t2), 1); - - if (t1 == t2) - return 1; - } - - if (TYPE_PTRMEMFUNC_P (t1)) - t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1); - if (TYPE_PTRMEMFUNC_P (t2)) - t2 = TYPE_PTRMEMFUNC_FN_TYPE (t2); - - /* Different classes of types can't be compatible. */ - if (TREE_CODE (t1) != TREE_CODE (t2)) - return 0; - - /* Qualifiers must match. */ - if (CP_TYPE_QUALS (t1) != CP_TYPE_QUALS (t2)) - return 0; - if (strict == COMPARE_STRICT - && TYPE_FOR_JAVA (t1) != TYPE_FOR_JAVA (t2)) - return 0; - - /* Allow for two different type nodes which have essentially the same - definition. Note that we already checked for equality of the type - qualifiers (just above). */ - - if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2)) - return 1; - - /* ??? COMP_TYPE_ATTRIBUTES is currently useless for variables as each - attribute is its own main variant (`val' will remain 0). */ -#ifndef COMP_TYPE_ATTRIBUTES -#define COMP_TYPE_ATTRIBUTES(t1,t2) 1 -#endif - - /* 1 if no need for warning yet, 2 if warning cause has been seen. */ - if (! (attrval = COMP_TYPE_ATTRIBUTES (t1, t2))) - return 0; - - /* 1 if no need for warning yet, 2 if warning cause has been seen. */ - val = 0; - - switch (TREE_CODE (t1)) - { - case TEMPLATE_TEMPLATE_PARM: - if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2) - || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2)) - return 0; - if (! comp_template_parms (DECL_TEMPLATE_PARMS (TYPE_NAME (t1)), - DECL_TEMPLATE_PARMS (TYPE_NAME (t2)))) - return 0; - if (!TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t1) - && ! TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)) - return 1; - /* Don't check inheritance. */ - strict = COMPARE_STRICT; - /* fall through */ - - case RECORD_TYPE: - case UNION_TYPE: - if (TYPE_TEMPLATE_INFO (t1) && TYPE_TEMPLATE_INFO (t2) - && (TYPE_TI_TEMPLATE (t1) == TYPE_TI_TEMPLATE (t2) - || TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM)) - val = comp_template_args (TYPE_TI_ARGS (t1), - TYPE_TI_ARGS (t2)); - look_hard: - if ((strict & COMPARE_BASE) && DERIVED_FROM_P (t1, t2)) - { - val = 1; - break; - } - if ((strict & COMPARE_RELAXED) && DERIVED_FROM_P (t2, t1)) - { - val = 1; - break; - } - break; - - case OFFSET_TYPE: - val = (comptypes (build_pointer_type (TYPE_OFFSET_BASETYPE (t1)), - build_pointer_type (TYPE_OFFSET_BASETYPE (t2)), strict) - && comptypes (TREE_TYPE (t1), TREE_TYPE (t2), strict)); - break; - - case METHOD_TYPE: - if (! compexcepttypes (t1, t2)) - return 0; - - /* This case is anti-symmetrical! - One can pass a base member (or member function) - to something expecting a derived member (or member function), - but not vice-versa! */ - - val = (comptypes (TREE_TYPE (t1), TREE_TYPE (t2), strict) - && compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2))); - break; - - case POINTER_TYPE: - case REFERENCE_TYPE: - t1 = TREE_TYPE (t1); - t2 = TREE_TYPE (t2); - /* first, check whether the referred types match with the - required level of strictness */ - val = comptypes (t1, t2, strict); - if (val) - break; - if (TREE_CODE (t1) == RECORD_TYPE - && TREE_CODE (t2) == RECORD_TYPE) - goto look_hard; - break; - - case FUNCTION_TYPE: - if (! compexcepttypes (t1, t2)) - return 0; - - val = ((TREE_TYPE (t1) == TREE_TYPE (t2) - || comptypes (TREE_TYPE (t1), TREE_TYPE (t2), strict)) - && compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2))); - break; - - case ARRAY_TYPE: - /* Target types must match incl. qualifiers. We use ORIG_STRICT - here since this is the one place where - COMPARE_REDECLARATION should be used. */ - val = comp_array_types (comptypes, t1, t2, orig_strict); - break; - - case TEMPLATE_TYPE_PARM: - return TEMPLATE_TYPE_IDX (t1) == TEMPLATE_TYPE_IDX (t2) - && TEMPLATE_TYPE_LEVEL (t1) == TEMPLATE_TYPE_LEVEL (t2); - - case TYPENAME_TYPE: - if (TYPE_IDENTIFIER (t1) != TYPE_IDENTIFIER (t2)) - return 0; - return same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)); - - default: - break; - } - return attrval == 2 && val == 1 ? 2 : val; -} - -/* Subroutine of comp_target-types. Make sure that the cv-quals change - only in the same direction as the target type. */ - -static int -comp_cv_target_types (ttl, ttr, nptrs) - tree ttl, ttr; - int nptrs; -{ - int t; - - if (!at_least_as_qualified_p (ttl, ttr) - && !at_least_as_qualified_p (ttr, ttl)) - /* The qualifications are incomparable. */ - return 0; - - if (TYPE_MAIN_VARIANT (ttl) == TYPE_MAIN_VARIANT (ttr)) - return more_qualified_p (ttr, ttl) ? -1 : 1; - - t = comp_target_types (ttl, ttr, nptrs); - if ((t == 1 && at_least_as_qualified_p (ttl, ttr)) - || (t == -1 && at_least_as_qualified_p (ttr, ttl))) - return t; - - return 0; -} - -/* Return 1 or -1 if TTL and TTR are pointers to types that are equivalent, - ignoring their qualifiers, 0 if not. Return 1 means that TTR can be - converted to TTL. Return -1 means that TTL can be converted to TTR but - not vice versa. - - NPTRS is the number of pointers we can strip off and keep cool. - This is used to permit (for aggr A, aggr B) A, B* to convert to A*, - but to not permit B** to convert to A**. - - This should go away. Callers should use can_convert or something - similar instead. (jason 17 Apr 1997) */ - -int -comp_target_types (ttl, ttr, nptrs) - tree ttl, ttr; - int nptrs; -{ - ttl = TYPE_MAIN_VARIANT (ttl); - ttr = TYPE_MAIN_VARIANT (ttr); - if (ttl == ttr) - return 1; - - if (TREE_CODE (ttr) != TREE_CODE (ttl)) - return 0; - - if ((TREE_CODE (ttr) == POINTER_TYPE - || TREE_CODE (ttr) == REFERENCE_TYPE) - /* If we get a pointer with nptrs == 0, we don't allow any tweaking - of the type pointed to. This is necessary for reference init - semantics. We won't get here from a previous call with nptrs == 1; - for multi-level pointers we end up in comp_ptr_ttypes. */ - && nptrs > 0) - { - int is_ptr = TREE_CODE (ttr) == POINTER_TYPE; - - ttl = TREE_TYPE (ttl); - ttr = TREE_TYPE (ttr); - - if (is_ptr) - { - if (TREE_CODE (ttl) == UNKNOWN_TYPE - || TREE_CODE (ttr) == UNKNOWN_TYPE) - return 1; - else if (TREE_CODE (ttl) == VOID_TYPE - && TREE_CODE (ttr) != FUNCTION_TYPE - && TREE_CODE (ttr) != METHOD_TYPE - && TREE_CODE (ttr) != OFFSET_TYPE) - return 1; - else if (TREE_CODE (ttr) == VOID_TYPE - && TREE_CODE (ttl) != FUNCTION_TYPE - && TREE_CODE (ttl) != METHOD_TYPE - && TREE_CODE (ttl) != OFFSET_TYPE) - return -1; - else if (TREE_CODE (ttl) == POINTER_TYPE - || TREE_CODE (ttl) == ARRAY_TYPE) - { - if (comp_ptr_ttypes (ttl, ttr)) - return 1; - else if (comp_ptr_ttypes (ttr, ttl)) - return -1; - return 0; - } - } - - /* Const and volatile mean something different for function types, - so the usual checks are not appropriate. */ - if (TREE_CODE (ttl) == FUNCTION_TYPE || TREE_CODE (ttl) == METHOD_TYPE) - return comp_target_types (ttl, ttr, nptrs - 1); - - return comp_cv_target_types (ttl, ttr, nptrs - 1); - } - - if (TREE_CODE (ttr) == ARRAY_TYPE) - return comp_array_types (comp_target_types, ttl, ttr, COMPARE_STRICT); - else if (TREE_CODE (ttr) == FUNCTION_TYPE || TREE_CODE (ttr) == METHOD_TYPE) - { - tree argsl, argsr; - int saw_contra = 0; - - if (pedantic) - { - if (!same_type_p (TREE_TYPE (ttl), TREE_TYPE (ttr))) - return 0; - } - else - { - switch (comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), -1)) - { - case 0: - return 0; - case -1: - saw_contra = 1; - } - } - - argsl = TYPE_ARG_TYPES (ttl); - argsr = TYPE_ARG_TYPES (ttr); - - /* Compare 'this' here, not in comp_target_parms. */ - if (TREE_CODE (ttr) == METHOD_TYPE) - { - tree tl = TYPE_METHOD_BASETYPE (ttl); - tree tr = TYPE_METHOD_BASETYPE (ttr); - - if (!same_or_base_type_p (tr, tl)) - { - if (same_or_base_type_p (tl, tr)) - saw_contra = 1; - else - return 0; - } - - argsl = TREE_CHAIN (argsl); - argsr = TREE_CHAIN (argsr); - } - - switch (comp_target_parms (argsl, argsr, 1)) - { - case 0: - return 0; - case -1: - saw_contra = 1; - } - - return saw_contra ? -1 : 1; - } - /* for C++ */ - else if (TREE_CODE (ttr) == OFFSET_TYPE) - { - int base; - - /* Contravariance: we can assign a pointer to base member to a pointer - to derived member. Note difference from simple pointer case, where - we can pass a pointer to derived to a pointer to base. */ - if (same_or_base_type_p (TYPE_OFFSET_BASETYPE (ttr), - TYPE_OFFSET_BASETYPE (ttl))) - base = 1; - else if (same_or_base_type_p (TYPE_OFFSET_BASETYPE (ttl), - TYPE_OFFSET_BASETYPE (ttr))) - { - tree tmp = ttl; - ttl = ttr; - ttr = tmp; - base = -1; - } - else - return 0; - - ttl = TREE_TYPE (ttl); - ttr = TREE_TYPE (ttr); - - if (TREE_CODE (ttl) == POINTER_TYPE - || TREE_CODE (ttl) == ARRAY_TYPE) - { - if (comp_ptr_ttypes (ttl, ttr)) - return base; - return 0; - } - else - { - if (comp_cv_target_types (ttl, ttr, nptrs) == 1) - return base; - return 0; - } - } - else if (IS_AGGR_TYPE (ttl)) - { - if (nptrs < 0) - return 0; - if (same_or_base_type_p (build_pointer_type (ttl), - build_pointer_type (ttr))) - return 1; - if (same_or_base_type_p (build_pointer_type (ttr), - build_pointer_type (ttl))) - return -1; - return 0; - } - - return 0; -} - -/* Returns 1 if TYPE1 is at least as qualified as TYPE2. */ - -int -at_least_as_qualified_p (type1, type2) - tree type1; - tree type2; -{ - /* All qualifiers for TYPE2 must also appear in TYPE1. */ - return ((CP_TYPE_QUALS (type1) & CP_TYPE_QUALS (type2)) - == CP_TYPE_QUALS (type2)); -} - -/* Returns 1 if TYPE1 is more qualified than TYPE2. */ - -int -more_qualified_p (type1, type2) - tree type1; - tree type2; -{ - return (CP_TYPE_QUALS (type1) != CP_TYPE_QUALS (type2) - && at_least_as_qualified_p (type1, type2)); -} - -/* Returns 1 if TYPE1 is more cv-qualified than TYPE2, -1 if TYPE2 is - more cv-qualified that TYPE1, and 0 otherwise. */ - -int -comp_cv_qualification (type1, type2) - tree type1; - tree type2; -{ - if (CP_TYPE_QUALS (type1) == CP_TYPE_QUALS (type2)) - return 0; - - if (at_least_as_qualified_p (type1, type2)) - return 1; - - else if (at_least_as_qualified_p (type2, type1)) - return -1; - - return 0; -} - -/* Returns 1 if the cv-qualification signature of TYPE1 is a proper - subset of the cv-qualification signature of TYPE2, and the types - are similar. Returns -1 if the other way 'round, and 0 otherwise. */ - -int -comp_cv_qual_signature (type1, type2) - tree type1; - tree type2; -{ - if (comp_ptr_ttypes_real (type2, type1, -1)) - return 1; - else if (comp_ptr_ttypes_real (type1, type2, -1)) - return -1; - else - return 0; -} - -/* If two types share a common base type, return that basetype. - If there is not a unique most-derived base type, this function - returns ERROR_MARK_NODE. */ - -static tree -common_base_type (tt1, tt2) - tree tt1, tt2; -{ - tree best = NULL_TREE; - int i; - - /* If one is a baseclass of another, that's good enough. */ - if (UNIQUELY_DERIVED_FROM_P (tt1, tt2)) - return tt1; - if (UNIQUELY_DERIVED_FROM_P (tt2, tt1)) - return tt2; - - /* Otherwise, try to find a unique baseclass of TT1 - that is shared by TT2, and follow that down. */ - for (i = CLASSTYPE_N_BASECLASSES (tt1)-1; i >= 0; i--) - { - tree basetype = TYPE_BINFO_BASETYPE (tt1, i); - tree trial = common_base_type (basetype, tt2); - if (trial) - { - if (trial == error_mark_node) - return trial; - if (best == NULL_TREE) - best = trial; - else if (best != trial) - return error_mark_node; - } - } - - /* Same for TT2. */ - for (i = CLASSTYPE_N_BASECLASSES (tt2)-1; i >= 0; i--) - { - tree basetype = TYPE_BINFO_BASETYPE (tt2, i); - tree trial = common_base_type (tt1, basetype); - if (trial) - { - if (trial == error_mark_node) - return trial; - if (best == NULL_TREE) - best = trial; - else if (best != trial) - return error_mark_node; - } - } - return best; -} - -/* Subroutines of `comptypes'. */ - -/* Return 1 if two parameter type lists PARMS1 and PARMS2 - are equivalent in the sense that functions with those parameter types - can have equivalent types. - If either list is empty, we win. - Otherwise, the two lists must be equivalent, element by element. - - C++: See comment above about TYPE1, TYPE2. - - STRICT is no longer used. */ - -int -compparms (parms1, parms2) - tree parms1, parms2; -{ - register tree t1 = parms1, t2 = parms2; - - /* An unspecified parmlist matches any specified parmlist - whose argument types don't need default promotions. */ - - while (1) - { - if (t1 == 0 && t2 == 0) - return 1; - /* If one parmlist is shorter than the other, - they fail to match. */ - if (t1 == 0 || t2 == 0) - return 0; - if (!same_type_p (TREE_VALUE (t2), TREE_VALUE (t1))) - return 0; - - t1 = TREE_CHAIN (t1); - t2 = TREE_CHAIN (t2); - } -} - -/* This really wants return whether or not parameter type lists - would make their owning functions assignment compatible or not. - - The return value is like for comp_target_types. - - This should go away, possibly with the exception of the empty parmlist - conversion; there are no conversions between function types in C++. - (jason 17 Apr 1997) */ - -static int -comp_target_parms (parms1, parms2, strict) - tree parms1, parms2; - int strict; -{ - register tree t1 = parms1, t2 = parms2; - int warn_contravariance = 0; - - /* In C, an unspecified parmlist matches any specified parmlist - whose argument types don't need default promotions. This is not - true for C++, but let's do it anyway for unfixed headers. */ - - if (t1 == 0 && t2 != 0) - { - cp_pedwarn ("ANSI C++ prohibits conversion from `(%#T)' to `(...)'", - parms2); - return self_promoting_args_p (t2); - } - if (t2 == 0) - return self_promoting_args_p (t1); - - for (; t1 || t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2)) - { - tree p1, p2; - - /* If one parmlist is shorter than the other, - they fail to match, unless STRICT is <= 0. */ - if (t1 == 0 || t2 == 0) - { - if (strict > 0) - return 0; - if (strict < 0) - return 1 + warn_contravariance; - return ((t1 && TREE_PURPOSE (t1)) + warn_contravariance); - } - p1 = TREE_VALUE (t1); - p2 = TREE_VALUE (t2); - if (same_type_p (p1, p2)) - continue; - - if (pedantic) - return 0; - - if ((TREE_CODE (p1) == POINTER_TYPE && TREE_CODE (p2) == POINTER_TYPE) - || (TREE_CODE (p1) == REFERENCE_TYPE - && TREE_CODE (p2) == REFERENCE_TYPE)) - { - if (strict <= 0 - && (TYPE_MAIN_VARIANT (TREE_TYPE (p1)) - == TYPE_MAIN_VARIANT (TREE_TYPE (p2)))) - continue; - - /* The following is wrong for contravariance, - but many programs depend on it. */ - if (TREE_TYPE (p1) == void_type_node) - continue; - if (TREE_TYPE (p2) == void_type_node) - { - warn_contravariance = 1; - continue; - } - if (IS_AGGR_TYPE (TREE_TYPE (p1)) - && !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (p1)), - TYPE_MAIN_VARIANT (TREE_TYPE (p2)))) - return 0; - } - /* Note backwards order due to contravariance. */ - if (comp_target_types (p2, p1, 1) <= 0) - { - if (comp_target_types (p1, p2, 1) > 0) - { - warn_contravariance = 1; - continue; - } - if (strict != 0) - return 0; - } - } - return warn_contravariance ? -1 : 1; -} - -/* Return 1 if PARMS specifies a fixed number of parameters - and none of their types is affected by default promotions. */ - -int -self_promoting_args_p (parms) - tree parms; -{ - register tree t; - for (t = parms; t; t = TREE_CHAIN (t)) - { - register tree type = TREE_VALUE (t); - - if (TREE_CHAIN (t) == 0 && type != void_type_node) - return 0; - - if (type == 0) - return 0; - - if (TYPE_MAIN_VARIANT (type) == float_type_node) - return 0; - - if (C_PROMOTING_INTEGER_TYPE_P (type)) - return 0; - } - return 1; -} - -/* Return an unsigned type the same as TYPE in other respects. - - C++: must make these work for type variants as well. */ - -tree -unsigned_type (type) - tree type; -{ - tree type1 = TYPE_MAIN_VARIANT (type); - if (type1 == signed_char_type_node || type1 == char_type_node) - return unsigned_char_type_node; - if (type1 == integer_type_node) - return unsigned_type_node; - if (type1 == short_integer_type_node) - return short_unsigned_type_node; - if (type1 == long_integer_type_node) - return long_unsigned_type_node; - if (type1 == long_long_integer_type_node) - return long_long_unsigned_type_node; -#if HOST_BITS_PER_WIDE_INT >= 64 - if (type1 == intTI_type_node) - return unsigned_intTI_type_node; -#endif - if (type1 == intDI_type_node) - return unsigned_intDI_type_node; - if (type1 == intSI_type_node) - return unsigned_intSI_type_node; - if (type1 == intHI_type_node) - return unsigned_intHI_type_node; - if (type1 == intQI_type_node) - return unsigned_intQI_type_node; - - return signed_or_unsigned_type (1, type); -} - -/* Return a signed type the same as TYPE in other respects. */ - -tree -signed_type (type) - tree type; -{ - tree type1 = TYPE_MAIN_VARIANT (type); - if (type1 == unsigned_char_type_node || type1 == char_type_node) - return signed_char_type_node; - if (type1 == unsigned_type_node) - return integer_type_node; - if (type1 == short_unsigned_type_node) - return short_integer_type_node; - if (type1 == long_unsigned_type_node) - return long_integer_type_node; - if (type1 == long_long_unsigned_type_node) - return long_long_integer_type_node; -#if HOST_BITS_PER_WIDE_INT >= 64 - if (type1 == unsigned_intTI_type_node) - return intTI_type_node; -#endif - if (type1 == unsigned_intDI_type_node) - return intDI_type_node; - if (type1 == unsigned_intSI_type_node) - return intSI_type_node; - if (type1 == unsigned_intHI_type_node) - return intHI_type_node; - if (type1 == unsigned_intQI_type_node) - return intQI_type_node; - - return signed_or_unsigned_type (0, type); -} - -/* Return a type the same as TYPE except unsigned or - signed according to UNSIGNEDP. */ - -tree -signed_or_unsigned_type (unsignedp, type) - int unsignedp; - tree type; -{ - if (! INTEGRAL_TYPE_P (type) - || TREE_UNSIGNED (type) == unsignedp) - return type; - - if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node)) - return unsignedp ? unsigned_char_type_node : signed_char_type_node; - if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)) - return unsignedp ? unsigned_type_node : integer_type_node; - if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node)) - return unsignedp ? short_unsigned_type_node : short_integer_type_node; - if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node)) - return unsignedp ? long_unsigned_type_node : long_integer_type_node; - if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node)) - return (unsignedp ? long_long_unsigned_type_node - : long_long_integer_type_node); - return type; -} - -/* Compute the value of the `sizeof' operator. */ - -tree -c_sizeof (type) - tree type; -{ - enum tree_code code = TREE_CODE (type); - tree t; - - if (processing_template_decl) - return build_min (SIZEOF_EXPR, sizetype, type); - - if (code == FUNCTION_TYPE) - { - if (pedantic || warn_pointer_arith) - pedwarn ("ANSI C++ forbids taking the sizeof a function type"); - return size_int (1); - } - if (code == METHOD_TYPE) - { - if (pedantic || warn_pointer_arith) - pedwarn ("ANSI C++ forbids taking the sizeof a method type"); - return size_int (1); - } - if (code == VOID_TYPE) - { - if (pedantic || warn_pointer_arith) - pedwarn ("ANSI C++ forbids taking the sizeof a void type"); - return size_int (1); - } - if (code == ERROR_MARK) - return size_int (1); - - /* ARM $5.3.2: ``When applied to a reference, the result is the size of the - referenced object.'' */ - if (code == REFERENCE_TYPE) - type = TREE_TYPE (type); - - /* We couldn't find anything in the ARM or the draft standard that says, - one way or the other, if doing sizeof on something that doesn't have - an object associated with it is correct or incorrect. For example, if - you declare `struct S { char str[16]; };', and in your program do - a `sizeof (S::str)', should we flag that as an error or should we give - the size of it? Since it seems like a reasonable thing to do, we'll go - with giving the value. */ - if (code == OFFSET_TYPE) - type = TREE_TYPE (type); - - /* @@ This also produces an error for a signature ref. - In that case we should be able to do better. */ - if (IS_SIGNATURE (type)) - { - error ("`sizeof' applied to a signature type"); - return size_int (0); - } - - if (TYPE_SIZE (complete_type (type)) == 0) - { - cp_error ("`sizeof' applied to incomplete type `%T'", type); - return size_int (0); - } - - /* Convert in case a char is more than one unit. */ - t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type), - size_int (TYPE_PRECISION (char_type_node))); - t = convert (sizetype, t); - /* size_binop does not put the constant in range, so do it now. */ - if (TREE_CODE (t) == INTEGER_CST && force_fit_type (t, 0)) - TREE_CONSTANT_OVERFLOW (t) = TREE_OVERFLOW (t) = 1; - return t; -} - -tree -expr_sizeof (e) - tree e; -{ - if (processing_template_decl) - return build_min (SIZEOF_EXPR, sizetype, e); - - if (TREE_CODE (e) == COMPONENT_REF - && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1))) - error ("sizeof applied to a bit-field"); - /* ANSI says arrays and functions are converted inside comma. - But we can't really convert them in build_compound_expr - because that would break commas in lvalues. - So do the conversion here if operand was a comma. */ - if (TREE_CODE (e) == COMPOUND_EXPR - && (TREE_CODE (TREE_TYPE (e)) == ARRAY_TYPE - || TREE_CODE (TREE_TYPE (e)) == FUNCTION_TYPE)) - e = default_conversion (e); - else if (is_overloaded_fn (e)) - { - pedwarn ("ANSI C++ forbids taking the sizeof a function type"); - return size_int (1); - } - - return c_sizeof (TREE_TYPE (e)); -} - -tree -c_sizeof_nowarn (type) - tree type; -{ - enum tree_code code = TREE_CODE (type); - tree t; - - if (code == FUNCTION_TYPE - || code == METHOD_TYPE - || code == VOID_TYPE - || code == ERROR_MARK) - return size_int (1); - if (code == REFERENCE_TYPE) - type = TREE_TYPE (type); - - if (TYPE_SIZE (type) == 0) - return size_int (0); - - /* Convert in case a char is more than one unit. */ - t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type), - size_int (TYPE_PRECISION (char_type_node))); - t = convert (sizetype, t); - force_fit_type (t, 0); - return t; -} - -/* Implement the __alignof keyword: Return the minimum required - alignment of TYPE, measured in bytes. */ - -tree -c_alignof (type) - tree type; -{ - enum tree_code code = TREE_CODE (type); - tree t; - - if (processing_template_decl) - return build_min (ALIGNOF_EXPR, sizetype, type); - - if (code == FUNCTION_TYPE || code == METHOD_TYPE) - return size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT); - - if (code == VOID_TYPE || code == ERROR_MARK) - return size_int (1); - - /* C++: this is really correct! */ - if (code == REFERENCE_TYPE) - type = TREE_TYPE (type); - - /* @@ This also produces an error for a signature ref. - In that case we should be able to do better. */ - if (IS_SIGNATURE (type)) - { - error ("`__alignof' applied to a signature type"); - return size_int (1); - } - - t = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT); - force_fit_type (t, 0); - return t; -} - -/* Perform default promotions for C data used in expressions. - Arrays and functions are converted to pointers; - enumeral types or short or char, to int. - In addition, manifest constants symbols are replaced by their values. - - C++: this will automatically bash references to their target type. */ - -tree -decay_conversion (exp) - tree exp; -{ - register tree type = TREE_TYPE (exp); - register enum tree_code code = TREE_CODE (type); - - if (code == OFFSET_TYPE) - { - if (TREE_CODE (exp) == OFFSET_REF) - return decay_conversion (resolve_offset_ref (exp)); - - type = TREE_TYPE (type); - code = TREE_CODE (type); - - if (type == unknown_type_node) - { - cp_pedwarn ("assuming & on overloaded member function"); - return build_unary_op (ADDR_EXPR, exp, 0); - } - } - - if (code == REFERENCE_TYPE) - { - exp = convert_from_reference (exp); - type = TREE_TYPE (exp); - code = TREE_CODE (type); - } - - /* Constants can be used directly unless they're not loadable. */ - if (TREE_CODE (exp) == CONST_DECL) - exp = DECL_INITIAL (exp); - /* Replace a nonvolatile const static variable with its value. */ - else if (TREE_READONLY_DECL_P (exp)) - { - exp = decl_constant_value (exp); - type = TREE_TYPE (exp); - } - - /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue. - Leave such NOP_EXPRs, since RHS is being used in non-lvalue context. */ - - if (code == VOID_TYPE) - { - error ("void value not ignored as it ought to be"); - return error_mark_node; - } - if (code == METHOD_TYPE) - { - cp_pedwarn ("assuming & on `%E'", exp); - return build_unary_op (ADDR_EXPR, exp, 0); - } - if (code == FUNCTION_TYPE || is_overloaded_fn (exp)) - { - return build_unary_op (ADDR_EXPR, exp, 0); - } - if (code == ARRAY_TYPE) - { - register tree adr; - tree ptrtype; - - if (TREE_CODE (exp) == INDIRECT_REF) - { - /* Stripping away the INDIRECT_REF is not the right - thing to do for references... */ - tree inner = TREE_OPERAND (exp, 0); - if (TREE_CODE (TREE_TYPE (inner)) == REFERENCE_TYPE) - { - inner = build1 (CONVERT_EXPR, - build_pointer_type (TREE_TYPE - (TREE_TYPE (inner))), - inner); - TREE_CONSTANT (inner) = TREE_CONSTANT (TREE_OPERAND (inner, 0)); - } - return cp_convert (build_pointer_type (TREE_TYPE (type)), inner); - } - - if (TREE_CODE (exp) == COMPOUND_EXPR) - { - tree op1 = decay_conversion (TREE_OPERAND (exp, 1)); - return build (COMPOUND_EXPR, TREE_TYPE (op1), - TREE_OPERAND (exp, 0), op1); - } - - if (!lvalue_p (exp) - && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp))) - { - error ("invalid use of non-lvalue array"); - return error_mark_node; - } - - ptrtype = build_pointer_type (TREE_TYPE (type)); - - if (TREE_CODE (exp) == VAR_DECL) - { - /* ??? This is not really quite correct - in that the type of the operand of ADDR_EXPR - is not the target type of the type of the ADDR_EXPR itself. - Question is, can this lossage be avoided? */ - adr = build1 (ADDR_EXPR, ptrtype, exp); - if (mark_addressable (exp) == 0) - return error_mark_node; - TREE_CONSTANT (adr) = staticp (exp); - TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */ - return adr; - } - /* This way is better for a COMPONENT_REF since it can - simplify the offset for a component. */ - adr = build_unary_op (ADDR_EXPR, exp, 1); - return cp_convert (ptrtype, adr); - } - - return exp; -} - -tree -default_conversion (exp) - tree exp; -{ - tree type; - enum tree_code code; - - exp = decay_conversion (exp); - - type = TREE_TYPE (exp); - code = TREE_CODE (type); - - if (INTEGRAL_CODE_P (code)) - { - tree t = type_promotes_to (type); - if (t != type) - return cp_convert (t, exp); - } - - return exp; -} - -/* Take the address of an inline function without setting TREE_ADDRESSABLE - or TREE_USED. */ - -tree -inline_conversion (exp) - tree exp; -{ - if (TREE_CODE (exp) == FUNCTION_DECL) - exp = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (exp)), exp); - - return exp; -} - -/* Returns nonzero iff exp is a STRING_CST or the result of applying - decay_conversion to one. */ - -int -string_conv_p (totype, exp, warn) - tree totype, exp; - int warn; -{ - tree t; - - if (! flag_const_strings || TREE_CODE (totype) != POINTER_TYPE) - return 0; - - t = TREE_TYPE (totype); - if (!same_type_p (t, char_type_node) - && !same_type_p (t, wchar_type_node)) - return 0; - - if (TREE_CODE (exp) == STRING_CST) - { - /* Make sure that we don't try to convert between char and wchar_t. */ - if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (exp))) != t) - return 0; - } - else - { - /* Is this a string constant which has decayed to 'const char *'? */ - t = build_pointer_type (build_qualified_type (t, TYPE_QUAL_CONST)); - if (!same_type_p (TREE_TYPE (exp), t)) - return 0; - STRIP_NOPS (exp); - if (TREE_CODE (exp) != ADDR_EXPR - || TREE_CODE (TREE_OPERAND (exp, 0)) != STRING_CST) - return 0; - } - - /* This warning is not very useful, as it complains about printf. */ - if (warn && warn_write_strings) - cp_warning ("deprecated conversion from string constant to `%T'", totype); - - return 1; -} - -tree -build_object_ref (datum, basetype, field) - tree datum, basetype, field; -{ - tree dtype; - if (datum == error_mark_node) - return error_mark_node; - - dtype = TREE_TYPE (datum); - if (TREE_CODE (dtype) == REFERENCE_TYPE) - dtype = TREE_TYPE (dtype); - if (! IS_AGGR_TYPE_CODE (TREE_CODE (dtype))) - { - cp_error ("request for member `%T::%D' in expression of non-aggregate type `%T'", - basetype, field, dtype); - return error_mark_node; - } - else if (IS_SIGNATURE (basetype)) - { - warning ("signature name in scope resolution ignored"); - return build_component_ref (datum, field, NULL_TREE, 1); - } - else if (is_aggr_type (basetype, 1)) - { - tree binfo = binfo_or_else (basetype, dtype); - if (binfo) - return build_x_component_ref (build_scoped_ref (datum, basetype), - field, binfo, 1); - } - return error_mark_node; -} - -/* Like `build_component_ref, but uses an already found field, and converts - from a reference. Must compute access for current_class_ref. - Otherwise, ok. */ - -tree -build_component_ref_1 (datum, field, protect) - tree datum, field; - int protect; -{ - return convert_from_reference - (build_component_ref (datum, field, NULL_TREE, protect)); -} - -/* Given a COND_EXPR, MIN_EXPR, or MAX_EXPR in T, return it in a form that we - can, for example, use as an lvalue. This code used to be in - unary_complex_lvalue, but we needed it to deal with `a = (d == c) ? b : c' - expressions, where we're dealing with aggregates. But now it's again only - called from unary_complex_lvalue. The case (in particular) that led to - this was with CODE == ADDR_EXPR, since it's not an lvalue when we'd - get it there. */ - -static tree -rationalize_conditional_expr (code, t) - enum tree_code code; - tree t; -{ - /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that - the first operand is always the one to be used if both operands - are equal, so we know what conditional expression this used to be. */ - if (TREE_CODE (t) == MIN_EXPR || TREE_CODE (t) == MAX_EXPR) - { - return - build_conditional_expr (build_x_binary_op ((TREE_CODE (t) == MIN_EXPR - ? LE_EXPR : GE_EXPR), - TREE_OPERAND (t, 0), - TREE_OPERAND (t, 1)), - build_unary_op (code, TREE_OPERAND (t, 0), 0), - build_unary_op (code, TREE_OPERAND (t, 1), 0)); - } - - return - build_conditional_expr (TREE_OPERAND (t, 0), - build_unary_op (code, TREE_OPERAND (t, 1), 0), - build_unary_op (code, TREE_OPERAND (t, 2), 0)); -} - -/* Given the TYPE of an anonymous union field inside T, return the - FIELD_DECL for the field. If not found return NULL_TREE. Because - anonymous unions can nest, we must also search all anonymous unions - that are directly reachable. */ - -static tree -lookup_anon_field (t, type) - tree t, type; -{ - tree field; - - for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field)) - { - if (TREE_STATIC (field)) - continue; - if (TREE_CODE (field) != FIELD_DECL) - continue; - - /* If we find it directly, return the field. */ - if (DECL_NAME (field) == NULL_TREE - && type == TREE_TYPE (field)) - { - return field; - } - - /* Otherwise, it could be nested, search harder. */ - if (DECL_NAME (field) == NULL_TREE - && TREE_CODE (TREE_TYPE (field)) == UNION_TYPE) - { - tree subfield = lookup_anon_field (TREE_TYPE (field), type); - if (subfield) - return subfield; - } - } - return NULL_TREE; -} - -/* Build a COMPONENT_REF for a given DATUM, and it's member COMPONENT. - COMPONENT can be an IDENTIFIER_NODE that is the name of the member - that we are interested in, or it can be a FIELD_DECL. */ - -tree -build_component_ref (datum, component, basetype_path, protect) - tree datum, component, basetype_path; - int protect; -{ - register tree basetype; - register enum tree_code code; - register tree field = NULL; - register tree ref; - tree field_type; - int type_quals; - - if (processing_template_decl) - return build_min_nt (COMPONENT_REF, datum, component); - - if (datum == error_mark_node - || TREE_TYPE (datum) == error_mark_node) - return error_mark_node; - - /* BASETYPE holds the type of the class containing the COMPONENT. */ - basetype = TYPE_MAIN_VARIANT (TREE_TYPE (datum)); - - /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference - inside it. */ - switch (TREE_CODE (datum)) - { - case COMPOUND_EXPR: - { - tree value = build_component_ref (TREE_OPERAND (datum, 1), component, - basetype_path, protect); - return build (COMPOUND_EXPR, TREE_TYPE (value), - TREE_OPERAND (datum, 0), value); - } - case COND_EXPR: - return build_conditional_expr - (TREE_OPERAND (datum, 0), - build_component_ref (TREE_OPERAND (datum, 1), component, - basetype_path, protect), - build_component_ref (TREE_OPERAND (datum, 2), component, - basetype_path, protect)); - - case TEMPLATE_DECL: - cp_error ("invalid use of %D", datum); - datum = error_mark_node; - break; - - default: - break; - } - - code = TREE_CODE (basetype); - - if (code == REFERENCE_TYPE) - { - datum = convert_from_reference (datum); - basetype = TYPE_MAIN_VARIANT (TREE_TYPE (datum)); - code = TREE_CODE (basetype); - } - if (TREE_CODE (datum) == OFFSET_REF) - { - datum = resolve_offset_ref (datum); - basetype = TYPE_MAIN_VARIANT (TREE_TYPE (datum)); - code = TREE_CODE (basetype); - } - - /* First, see if there is a field or component with name COMPONENT. */ - if (TREE_CODE (component) == TREE_LIST) - { - /* I could not trigger this code. MvL */ - my_friendly_abort (980326); -#ifdef DEAD - my_friendly_assert (!(TREE_CHAIN (component) == NULL_TREE - && DECL_CHAIN (TREE_VALUE (component)) == NULL_TREE), 309); -#endif - return build (COMPONENT_REF, TREE_TYPE (component), datum, component); - } - - if (! IS_AGGR_TYPE_CODE (code)) - { - if (code != ERROR_MARK) - cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'", - component, datum, basetype); - return error_mark_node; - } - - if (!complete_type_or_else (basetype)) - return error_mark_node; - - if (TREE_CODE (component) == BIT_NOT_EXPR) - { - if (TYPE_IDENTIFIER (basetype) != TREE_OPERAND (component, 0)) - { - cp_error ("destructor specifier `%T::~%T' must have matching names", - basetype, TREE_OPERAND (component, 0)); - return error_mark_node; - } - if (! TYPE_HAS_DESTRUCTOR (basetype)) - { - cp_error ("type `%T' has no destructor", basetype); - return error_mark_node; - } - return TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 1); - } - - /* Look up component name in the structure type definition. */ - if (CLASSTYPE_VFIELD (basetype) - && DECL_NAME (CLASSTYPE_VFIELD (basetype)) == component) - /* Special-case this because if we use normal lookups in an ambiguous - hierarchy, the compiler will abort (because vptr lookups are - not supposed to be ambiguous. */ - field = CLASSTYPE_VFIELD (basetype); - else if (TREE_CODE (component) == FIELD_DECL) - field = component; - else if (TREE_CODE (component) == TYPE_DECL) - { - cp_error ("invalid use of type decl `%#D' as expression", component); - return error_mark_node; - } - else - { - tree name = component; - if (TREE_CODE (component) == VAR_DECL) - name = DECL_NAME (component); - if (basetype_path == NULL_TREE) - basetype_path = TYPE_BINFO (basetype); - field = lookup_field (basetype_path, name, - protect && !VFIELD_NAME_P (name), 0); - if (field == error_mark_node) - return error_mark_node; - - if (field == NULL_TREE) - { - /* Not found as a data field, look for it as a method. If found, - then if this is the only possible one, return it, else - report ambiguity error. */ - tree fndecls = lookup_fnfields (basetype_path, name, 1); - if (fndecls == error_mark_node) - return error_mark_node; - if (fndecls) - { - /* If the function is unique and static, we can resolve it - now. Otherwise, we have to wait and see what context it is - used in; a component_ref involving a non-static member - function can only be used in a call (expr.ref). */ - - if (TREE_CHAIN (fndecls) == NULL_TREE - && TREE_CODE (TREE_VALUE (fndecls)) == FUNCTION_DECL) - { - if (DECL_STATIC_FUNCTION_P (TREE_VALUE (fndecls))) - { - tree fndecl = TREE_VALUE (fndecls); - enforce_access (TREE_PURPOSE (fndecls), fndecl); - mark_used (fndecl); - return fndecl; - } - else - { - /* A unique non-static member function. Other parts - of the compiler expect something with - unknown_type_node to be really overloaded, so - let's oblige. */ - TREE_VALUE (fndecls) - = scratch_ovl_cons (TREE_VALUE (fndecls), NULL_TREE); - } - } - - ref = build (COMPONENT_REF, unknown_type_node, - datum, fndecls); - return ref; - } - - cp_error ("`%#T' has no member named `%D'", basetype, name); - return error_mark_node; - } - else if (TREE_TYPE (field) == error_mark_node) - return error_mark_node; - - if (TREE_CODE (field) != FIELD_DECL) - { - if (TREE_CODE (field) == TYPE_DECL) - cp_pedwarn ("invalid use of type decl `%#D' as expression", field); - else if (DECL_RTL (field) != 0) - mark_used (field); - else - TREE_USED (field) = 1; - return field; - } - } - - /* See if we have to do any conversions so that we pick up the field from the - right context. */ - if (DECL_FIELD_CONTEXT (field) != basetype) - { - tree context = DECL_FIELD_CONTEXT (field); - tree base = context; - while (!same_type_p (base, basetype) && TYPE_NAME (base) - && ANON_UNION_TYPE_P (base)) - { - base = TYPE_CONTEXT (base); - } - - /* Handle base classes here... */ - if (base != basetype && TYPE_USES_COMPLEX_INHERITANCE (basetype)) - { - tree addr = build_unary_op (ADDR_EXPR, datum, 0); - if (integer_zerop (addr)) - { - error ("invalid reference to NULL ptr, use ptr-to-member instead"); - return error_mark_node; - } - if (VBASE_NAME_P (DECL_NAME (field))) - { - /* It doesn't matter which vbase pointer we grab, just - find one of them. */ - tree binfo = get_binfo (base, - TREE_TYPE (TREE_TYPE (addr)), 0); - addr = convert_pointer_to_real (binfo, addr); - } - else - addr = convert_pointer_to (base, addr); - datum = build_indirect_ref (addr, NULL_PTR); - my_friendly_assert (datum != error_mark_node, 311); - } - basetype = base; - - /* Handle things from anon unions here... */ - if (TYPE_NAME (context) && ANON_UNION_TYPE_P (context)) - { - tree subfield = lookup_anon_field (basetype, context); - tree subdatum = build_component_ref (datum, subfield, - basetype_path, protect); - return build_component_ref (subdatum, field, basetype_path, protect); - } - } - - /* Compute the type of the field, as described in [expr.ref]. */ - type_quals = TYPE_UNQUALIFIED; - field_type = TREE_TYPE (field); - if (TREE_CODE (field_type) == REFERENCE_TYPE) - /* The standard says that the type of the result should be the - type referred to by the reference. But for now, at least, we - do the conversion from reference type later. */ - ; - else - { - type_quals = (CP_TYPE_QUALS (field_type) - | CP_TYPE_QUALS (TREE_TYPE (datum))); - - /* A field is const (volatile) if the enclosing object, or the - field itself, is const (volatile). But, a mutable field is - not const, even within a const object. */ - if (DECL_LANG_SPECIFIC (field) && DECL_MUTABLE_P (field)) - type_quals &= ~TYPE_QUAL_CONST; - if (!IS_SIGNATURE (field_type)) - field_type = cp_build_qualified_type (field_type, type_quals); - } - - ref = fold (build (COMPONENT_REF, field_type, - break_out_cleanups (datum), field)); - - /* Mark the expression const or volatile, as appropriate. Even - though we've dealt with the type above, we still have to mark the - expression itself. */ - if (type_quals & TYPE_QUAL_CONST) - TREE_READONLY (ref) = 1; - else if (type_quals & TYPE_QUAL_VOLATILE) - TREE_THIS_VOLATILE (ref) = 1; - - return ref; -} - -/* Variant of build_component_ref for use in expressions, which should - never have REFERENCE_TYPE. */ - -tree -build_x_component_ref (datum, component, basetype_path, protect) - tree datum, component, basetype_path; - int protect; -{ - tree t = build_component_ref (datum, component, basetype_path, protect); - - if (! processing_template_decl) - t = convert_from_reference (t); - - return t; -} - -/* Given an expression PTR for a pointer, return an expression - for the value pointed to. - ERRORSTRING is the name of the operator to appear in error messages. - - This function may need to overload OPERATOR_FNNAME. - Must also handle REFERENCE_TYPEs for C++. */ - -tree -build_x_indirect_ref (ptr, errorstring) - tree ptr; - char *errorstring; -{ - tree rval; - - if (processing_template_decl) - return build_min_nt (INDIRECT_REF, ptr); - - rval = build_opfncall (INDIRECT_REF, LOOKUP_NORMAL, ptr, NULL_TREE, - NULL_TREE); - if (rval) - return rval; - return build_indirect_ref (ptr, errorstring); -} - -tree -build_indirect_ref (ptr, errorstring) - tree ptr; - char *errorstring; -{ - register tree pointer, type; - - if (ptr == error_mark_node) - return error_mark_node; - - pointer = (TREE_CODE (TREE_TYPE (ptr)) == REFERENCE_TYPE - ? ptr : default_conversion (ptr)); - type = TREE_TYPE (pointer); - - if (ptr == current_class_ptr) - return current_class_ref; - - if (TYPE_PTR_P (type) || TREE_CODE (type) == REFERENCE_TYPE) - { - /* [expr.unary.op] - - If the type of the expression is "pointer to T," the type - of the result is "T." - - We must use the canonical variant because certain parts of - the back end, like fold, do pointer comparisons between - types. */ - tree t = canonical_type_variant (TREE_TYPE (type)); - - if (TREE_CODE (pointer) == ADDR_EXPR - && !flag_volatile - && same_type_p (t, TREE_TYPE (TREE_OPERAND (pointer, 0)))) - /* The POINTER was something like `&x'. We simplify `*&x' to - `x'. */ - return TREE_OPERAND (pointer, 0); - else - { - tree ref = build1 (INDIRECT_REF, t, pointer); - - /* We *must* set TREE_READONLY when dereferencing a pointer to const, - so that we get the proper error message if the result is used - to assign to. Also, &* is supposed to be a no-op. */ - TREE_READONLY (ref) = CP_TYPE_CONST_P (t); - TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t); - TREE_SIDE_EFFECTS (ref) - = (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (pointer) - || flag_volatile); - return ref; - } - } - /* `pointer' won't be an error_mark_node if we were given a - pointer to member, so it's cool to check for this here. */ - else if (TYPE_PTRMEM_P (type) || TYPE_PTRMEMFUNC_P (type)) - error ("invalid use of `%s' on pointer to member", errorstring); - else if (TREE_CODE (type) == RECORD_TYPE - && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type))) - error ("cannot dereference signature pointer/reference"); - else if (pointer != error_mark_node) - { - if (errorstring) - error ("invalid type argument of `%s'", errorstring); - else - error ("invalid type argument"); - } - return error_mark_node; -} - -/* This handles expressions of the form "a[i]", which denotes - an array reference. - - This is logically equivalent in C to *(a+i), but we may do it differently. - If A is a variable or a member, we generate a primitive ARRAY_REF. - This avoids forcing the array out of registers, and can work on - arrays that are not lvalues (for example, members of structures returned - by functions). - - If INDEX is of some user-defined type, it must be converted to - integer type. Otherwise, to make a compatible PLUS_EXPR, it - will inherit the type of the array, which will be some pointer type. */ - -tree -build_array_ref (array, idx) - tree array, idx; -{ - if (idx == 0) - { - error ("subscript missing in array reference"); - return error_mark_node; - } - - if (TREE_TYPE (array) == error_mark_node - || TREE_TYPE (idx) == error_mark_node) - return error_mark_node; - - if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE - && TREE_CODE (array) != INDIRECT_REF) - { - tree rval, type; - - /* Subscripting with type char is likely to lose - on a machine where chars are signed. - So warn on any machine, but optionally. - Don't warn for unsigned char since that type is safe. - Don't warn for signed char because anyone who uses that - must have done so deliberately. */ - if (warn_char_subscripts - && TYPE_MAIN_VARIANT (TREE_TYPE (idx)) == char_type_node) - warning ("array subscript has type `char'"); - - /* Apply default promotions *after* noticing character types. */ - idx = default_conversion (idx); - - if (TREE_CODE (TREE_TYPE (idx)) != INTEGER_TYPE) - { - error ("array subscript is not an integer"); - return error_mark_node; - } - - /* An array that is indexed by a non-constant - cannot be stored in a register; we must be able to do - address arithmetic on its address. - Likewise an array of elements of variable size. */ - if (TREE_CODE (idx) != INTEGER_CST - || (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))) != 0 - && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) - != INTEGER_CST))) - { - if (mark_addressable (array) == 0) - return error_mark_node; - } - /* An array that is indexed by a constant value which is not within - the array bounds cannot be stored in a register either; because we - would get a crash in store_bit_field/extract_bit_field when trying - to access a non-existent part of the register. */ - if (TREE_CODE (idx) == INTEGER_CST - && TYPE_VALUES (TREE_TYPE (array)) - && ! int_fits_type_p (idx, TYPE_VALUES (TREE_TYPE (array)))) - { - if (mark_addressable (array) == 0) - return error_mark_node; - } - - if (pedantic && !lvalue_p (array)) - pedwarn ("ANSI C++ forbids subscripting non-lvalue array"); - - /* Note in C++ it is valid to subscript a `register' array, since - it is valid to take the address of something with that - storage specification. */ - if (extra_warnings) - { - tree foo = array; - while (TREE_CODE (foo) == COMPONENT_REF) - foo = TREE_OPERAND (foo, 0); - if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo)) - warning ("subscripting array declared `register'"); - } - - type = TREE_TYPE (TREE_TYPE (array)); - rval = build (ARRAY_REF, type, array, idx); - /* Array ref is const/volatile if the array elements are - or if the array is.. */ - TREE_READONLY (rval) - |= (CP_TYPE_CONST_P (type) | TREE_READONLY (array)); - TREE_SIDE_EFFECTS (rval) - |= (CP_TYPE_VOLATILE_P (type) | TREE_SIDE_EFFECTS (array)); - TREE_THIS_VOLATILE (rval) - |= (CP_TYPE_VOLATILE_P (type) | TREE_THIS_VOLATILE (array)); - return require_complete_type (fold (rval)); - } - - { - tree ar = default_conversion (array); - tree ind = default_conversion (idx); - - /* Put the integer in IND to simplify error checking. */ - if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE) - { - tree temp = ar; - ar = ind; - ind = temp; - } - - if (ar == error_mark_node) - return ar; - - if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE) - { - error ("subscripted value is neither array nor pointer"); - return error_mark_node; - } - if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE) - { - error ("array subscript is not an integer"); - return error_mark_node; - } - - return build_indirect_ref (build_binary_op_nodefault (PLUS_EXPR, ar, - ind, PLUS_EXPR), - "array indexing"); - } -} - -/* Build a function call to function FUNCTION with parameters PARAMS. - PARAMS is a list--a chain of TREE_LIST nodes--in which the - TREE_VALUE of each node is a parameter-expression. The PARAMS do - not include any object pointer that may be required. FUNCTION's - data type may be a function type or a pointer-to-function. - - For C++: If FUNCTION's data type is a TREE_LIST, then the tree list - is the list of possible methods that FUNCTION could conceivably - be. If the list of methods comes from a class, then it will be - a list of lists (where each element is associated with the class - that produced it), otherwise it will be a simple list (for - functions overloaded in global scope). - - In the first case, TREE_VALUE (function) is the head of one of those - lists, and TREE_PURPOSE is the name of the function. - - In the second case, TREE_PURPOSE (function) is the function's - name directly. - - DECL is the class instance variable, usually CURRENT_CLASS_REF. - - When calling a TEMPLATE_DECL, we don't require a complete return - type. */ - -tree -build_x_function_call (function, params, decl) - tree function, params, decl; -{ - tree type; - tree template_id = NULL_TREE; - int is_method; - - if (function == error_mark_node) - return error_mark_node; - - if (processing_template_decl) - return build_min_nt (CALL_EXPR, function, params, NULL_TREE); - - /* Save explicit template arguments if found */ - if (TREE_CODE (function) == TEMPLATE_ID_EXPR) - { - template_id = function; - function = TREE_OPERAND (function, 0); - } - - type = TREE_TYPE (function); - - if (TREE_CODE (type) == OFFSET_TYPE - && TREE_TYPE (type) == unknown_type_node - && TREE_CODE (function) == TREE_LIST - && TREE_CHAIN (function) == NULL_TREE) - { - /* Undo (Foo:bar)()... */ - type = TYPE_OFFSET_BASETYPE (type); - function = TREE_VALUE (function); - my_friendly_assert (TREE_CODE (function) == TREE_LIST, 999); - my_friendly_assert (TREE_CHAIN (function) == NULL_TREE, 999); - function = TREE_VALUE (function); - if (TREE_CODE (function) == OVERLOAD) - function = OVL_FUNCTION (function); - my_friendly_assert (TREE_CODE (function) == FUNCTION_DECL, 999); - function = DECL_NAME (function); - return build_method_call (decl, function, params, - TYPE_BINFO (type), LOOKUP_NORMAL); - } - - is_method = ((TREE_CODE (function) == TREE_LIST - && current_class_type != NULL_TREE - && (IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (function)) - == function)) - || TREE_CODE (function) == IDENTIFIER_NODE - || TREE_CODE (type) == METHOD_TYPE - || TYPE_PTRMEMFUNC_P (type)); - - if ((TREE_CODE (function) == FUNCTION_DECL - && DECL_STATIC_FUNCTION_P (function)) - || (TREE_CODE (function) == TEMPLATE_DECL - && DECL_STATIC_FUNCTION_P (DECL_RESULT (function)))) - return build_member_call - (DECL_CONTEXT (function), DECL_NAME (function), params); - - /* A friend template. Make it look like a toplevel declaration. */ - if (! is_method && TREE_CODE (function) == TEMPLATE_DECL) - function = scratch_ovl_cons (function, NULL_TREE); - - /* Handle methods, friends, and overloaded functions, respectively. */ - if (is_method) - { - tree basetype = NULL_TREE; - - if (TREE_CODE (function) == FUNCTION_DECL - || DECL_FUNCTION_TEMPLATE_P (function)) - { - basetype = DECL_CLASS_CONTEXT (function); - - if (DECL_NAME (function)) - function = DECL_NAME (function); - else - function = TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function)); - } - else if (TREE_CODE (function) == TREE_LIST) - { - my_friendly_assert (TREE_CODE (TREE_VALUE (function)) - == FUNCTION_DECL, 312); - basetype = DECL_CLASS_CONTEXT (TREE_VALUE (function)); - function = TREE_PURPOSE (function); - } - else if (TREE_CODE (function) != IDENTIFIER_NODE) - { - if (TREE_CODE (function) == OFFSET_REF) - { - if (TREE_OPERAND (function, 0)) - decl = TREE_OPERAND (function, 0); - } - /* Call via a pointer to member function. */ - if (decl == NULL_TREE) - { - error ("pointer to member function called, but not in class scope"); - return error_mark_node; - } - /* What other type of POINTER_TYPE could this be? */ - if (TREE_CODE (TREE_TYPE (function)) != POINTER_TYPE - && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (function)) - && TREE_CODE (function) != OFFSET_REF) - function = build (OFFSET_REF, TREE_TYPE (type), NULL_TREE, - function); - goto do_x_function; - } - - /* this is an abbreviated method call. - must go through here in case it is a virtual function. - @@ Perhaps this could be optimized. */ - - if (basetype && (! current_class_type - || ! DERIVED_FROM_P (basetype, current_class_type))) - return build_member_call (basetype, function, params); - - if (decl == NULL_TREE) - { - if (current_class_type == NULL_TREE) - { - error ("object missing in call to method `%s'", - IDENTIFIER_POINTER (function)); - return error_mark_node; - } - /* Yow: call from a static member function. */ - decl = build_dummy_object (current_class_type); - } - - /* Put back explicit template arguments, if any. */ - if (template_id) - function = template_id; - return build_method_call (decl, function, params, - NULL_TREE, LOOKUP_NORMAL); - } - else if (TREE_CODE (function) == COMPONENT_REF - && type == unknown_type_node) - { - /* Undo what we did in build_component_ref. */ - decl = TREE_OPERAND (function, 0); - function = TREE_OPERAND (function, 1); - function = DECL_NAME (OVL_CURRENT (TREE_VALUE (function))); - return build_method_call (decl, function, params, - NULL_TREE, LOOKUP_NORMAL); - } - else if (really_overloaded_fn (function)) - { - if (OVL_FUNCTION (function) == NULL_TREE) - { - cp_error ("function `%D' declared overloaded, but no definitions appear with which to resolve it?!?", - TREE_PURPOSE (function)); - return error_mark_node; - } - else - { - /* Put back explicit template arguments, if any. */ - if (template_id) - function = template_id; - return build_new_function_call (function, params); - } - } - else - /* Remove a potential OVERLOAD around it */ - function = OVL_CURRENT (function); - - do_x_function: - if (TREE_CODE (function) == OFFSET_REF) - { - /* If the component is a data element (or a virtual function), we play - games here to make things work. */ - tree decl_addr; - - if (TREE_OPERAND (function, 0)) - decl = TREE_OPERAND (function, 0); - else - decl = current_class_ref; - - decl_addr = build_unary_op (ADDR_EXPR, decl, 0); - - /* Sigh. OFFSET_REFs are being used for too many things. - They're being used both for -> and ->*, and we want to resolve - the -> cases here, but leave the ->*. We could use - resolve_offset_ref for those, too, but it would call - get_member_function_from_ptrfunc and decl_addr wouldn't get - updated properly. Nasty. */ - if (TREE_CODE (TREE_OPERAND (function, 1)) == FIELD_DECL) - function = resolve_offset_ref (function); - else - function = TREE_OPERAND (function, 1); - - function = get_member_function_from_ptrfunc (&decl_addr, function); - params = expr_tree_cons (NULL_TREE, decl_addr, params); - return build_function_call (function, params); - } - - type = TREE_TYPE (function); - if (type != error_mark_node) - { - if (TREE_CODE (type) == REFERENCE_TYPE) - type = TREE_TYPE (type); - - if (IS_AGGR_TYPE (type)) - return build_opfncall (CALL_EXPR, LOOKUP_NORMAL, function, params, NULL_TREE); - } - - if (is_method) - { - tree fntype = TREE_TYPE (function); - tree ctypeptr = NULL_TREE; - - /* Explicitly named method? */ - if (TREE_CODE (function) == FUNCTION_DECL) - ctypeptr = build_pointer_type (DECL_CLASS_CONTEXT (function)); - /* Expression with ptr-to-method type? It could either be a plain - usage, or it might be a case where the ptr-to-method is being - passed in as an argument. */ - else if (TYPE_PTRMEMFUNC_P (fntype)) - { - tree rec = TYPE_METHOD_BASETYPE (TREE_TYPE - (TYPE_PTRMEMFUNC_FN_TYPE (fntype))); - ctypeptr = build_pointer_type (rec); - } - /* Unexpected node type? */ - else - my_friendly_abort (116); - if (decl == NULL_TREE) - { - if (current_function_decl - && DECL_STATIC_FUNCTION_P (current_function_decl)) - error ("invalid call to member function needing `this' in static member function scope"); - else - error ("pointer to member function called, but not in class scope"); - return error_mark_node; - } - if (TREE_CODE (TREE_TYPE (decl)) != POINTER_TYPE - && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (decl))) - { - decl = build_unary_op (ADDR_EXPR, decl, 0); - decl = convert_pointer_to (TREE_TYPE (ctypeptr), decl); - } - else - decl = build_c_cast (ctypeptr, decl); - params = expr_tree_cons (NULL_TREE, decl, params); - } - - return build_function_call (function, params); -} - -/* Resolve a pointer to member function. INSTANCE is the object - instance to use, if the member points to a virtual member. */ - -tree -get_member_function_from_ptrfunc (instance_ptrptr, function) - tree *instance_ptrptr; - tree function; -{ - if (TREE_CODE (function) == OFFSET_REF) - { - function = TREE_OPERAND (function, 1); - } - - if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function))) - { - tree fntype, idx, e1, delta, delta2, e2, e3, aref, vtbl; - tree instance, basetype; - - tree instance_ptr = *instance_ptrptr; - - if (TREE_SIDE_EFFECTS (instance_ptr)) - instance_ptr = save_expr (instance_ptr); - - if (TREE_SIDE_EFFECTS (function)) - function = save_expr (function); - - fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function)); - basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype)); - - delta = cp_convert (ptrdiff_type_node, - build_component_ref (function, delta_identifier, - NULL_TREE, 0)); - e3 = PFN_FROM_PTRMEMFUNC (function); - - if (TYPE_SIZE (basetype) != NULL_TREE - && ! TYPE_VIRTUAL_P (basetype)) - /* If basetype doesn't have virtual functions, don't emit code to - handle that case. */ - e1 = e3; - else - { - /* Promoting idx before saving it improves performance on RISC - targets. Without promoting, the first compare used - load-with-sign-extend, while the second used normal load then - shift to sign-extend. An optimizer flaw, perhaps, but it's - easier to make this change. */ - idx = save_expr (default_conversion - (build_component_ref (function, - index_identifier, - NULL_TREE, 0))); - e1 = build_binary_op (GT_EXPR, idx, integer_zero_node, 1); - - /* Convert down to the right base, before using the instance. */ - instance = convert_pointer_to_real (basetype, instance_ptr); - if (instance == error_mark_node && instance_ptr != error_mark_node) - return instance; - - vtbl = convert_pointer_to (ptr_type_node, instance); - delta2 = DELTA2_FROM_PTRMEMFUNC (function); - vtbl = build - (PLUS_EXPR, - build_pointer_type (build_pointer_type (vtable_entry_type)), - vtbl, cp_convert (ptrdiff_type_node, delta2)); - vtbl = build_indirect_ref (vtbl, NULL_PTR); - aref = build_array_ref (vtbl, build_binary_op (MINUS_EXPR, - idx, - integer_one_node, 1)); - if (! flag_vtable_thunks) - { - aref = save_expr (aref); - - delta = build_binary_op - (PLUS_EXPR, - build_conditional_expr (e1, - build_component_ref (aref, - delta_identifier, - NULL_TREE, 0), - integer_zero_node), - delta, 1); - } - - if (flag_vtable_thunks) - e2 = aref; - else - e2 = build_component_ref (aref, pfn_identifier, NULL_TREE, 0); - TREE_TYPE (e2) = TREE_TYPE (e3); - e1 = build_conditional_expr (e1, e2, e3); - - /* Make sure this doesn't get evaluated first inside one of the - branches of the COND_EXPR. */ - if (TREE_CODE (instance_ptr) == SAVE_EXPR) - e1 = build (COMPOUND_EXPR, TREE_TYPE (e1), - instance_ptr, e1); - } - - *instance_ptrptr = build (PLUS_EXPR, TREE_TYPE (instance_ptr), - instance_ptr, delta); - - if (instance_ptr == error_mark_node - && TREE_CODE (e1) != ADDR_EXPR - && TREE_CODE (TREE_OPERAND (e1, 0)) != FUNCTION_DECL) - cp_error ("object missing in `%E'", function); - - function = e1; - } - return function; -} - -tree -build_function_call_real (function, params, require_complete, flags) - tree function, params; - int require_complete, flags; -{ - register tree fntype, fndecl; - register tree value_type; - register tree coerced_params; - tree name = NULL_TREE, assembler_name = NULL_TREE; - int is_method; - - /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue. - Strip such NOP_EXPRs, since FUNCTION is used in non-lvalue context. */ - if (TREE_CODE (function) == NOP_EXPR - && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0))) - function = TREE_OPERAND (function, 0); - - if (TREE_CODE (function) == FUNCTION_DECL) - { - name = DECL_NAME (function); - assembler_name = DECL_ASSEMBLER_NAME (function); - - GNU_xref_call (current_function_decl, - IDENTIFIER_POINTER (name ? name - : TYPE_IDENTIFIER (DECL_CLASS_CONTEXT - (function)))); - mark_used (function); - fndecl = function; - - /* Convert anything with function type to a pointer-to-function. */ - if (pedantic && DECL_MAIN_P (function)) - pedwarn ("ANSI C++ forbids calling `main' from within program"); - - /* Differs from default_conversion by not setting TREE_ADDRESSABLE - (because calling an inline function does not mean the function - needs to be separately compiled). */ - - if (DECL_INLINE (function)) - function = inline_conversion (function); - else - function = build_addr_func (function); - } - else - { - fndecl = NULL_TREE; - - function = build_addr_func (function); - } - - if (function == error_mark_node) - return error_mark_node; - - fntype = TREE_TYPE (function); - - if (TYPE_PTRMEMFUNC_P (fntype)) - { - cp_error ("must use .* or ->* to call pointer-to-member function in `%E (...)'", - function); - return error_mark_node; - } - - is_method = (TREE_CODE (fntype) == POINTER_TYPE - && TREE_CODE (TREE_TYPE (fntype)) == METHOD_TYPE); - - if (!((TREE_CODE (fntype) == POINTER_TYPE - && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE) - || is_method - || TREE_CODE (function) == TEMPLATE_ID_EXPR)) - { - cp_error ("`%E' cannot be used as a function", function); - return error_mark_node; - } - - /* fntype now gets the type of function pointed to. */ - fntype = TREE_TYPE (fntype); - - /* Convert the parameters to the types declared in the - function prototype, or apply default promotions. */ - - if (flags & LOOKUP_COMPLAIN) - coerced_params = convert_arguments (TYPE_ARG_TYPES (fntype), - params, fndecl, LOOKUP_NORMAL); - else - coerced_params = convert_arguments (TYPE_ARG_TYPES (fntype), - params, fndecl, 0); - - if (coerced_params == error_mark_node) - { - if (flags & LOOKUP_SPECULATIVELY) - return NULL_TREE; - else - return error_mark_node; - } - - /* Check for errors in format strings. */ - - if (warn_format && (name || assembler_name)) - check_function_format (name, assembler_name, coerced_params); - - /* Recognize certain built-in functions so we can make tree-codes - other than CALL_EXPR. We do this when it enables fold-const.c - to do something useful. */ - - if (TREE_CODE (function) == ADDR_EXPR - && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL - && DECL_BUILT_IN (TREE_OPERAND (function, 0))) - switch (DECL_FUNCTION_CODE (TREE_OPERAND (function, 0))) - { - case BUILT_IN_ABS: - case BUILT_IN_LABS: - case BUILT_IN_FABS: - if (coerced_params == 0) - return integer_zero_node; - return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0); - - default: - break; - } - - /* C++ */ - value_type = TREE_TYPE (fntype) ? TREE_TYPE (fntype) : void_type_node; - { - register tree result - = build_call (function, value_type, coerced_params); - - if (require_complete) - { - if (value_type == void_type_node) - return result; - result = require_complete_type (result); - } - if (IS_AGGR_TYPE (value_type)) - result = build_cplus_new (value_type, result); - return convert_from_reference (result); - } -} - -tree -build_function_call (function, params) - tree function, params; -{ - return build_function_call_real (function, params, 1, LOOKUP_NORMAL); -} - -/* Convert the actual parameter expressions in the list VALUES - to the types in the list TYPELIST. - If parmdecls is exhausted, or when an element has NULL as its type, - perform the default conversions. - - NAME is an IDENTIFIER_NODE or 0. It is used only for error messages. - - This is also where warnings about wrong number of args are generated. - - Return a list of expressions for the parameters as converted. - - Both VALUES and the returned value are chains of TREE_LIST nodes - with the elements of the list in the TREE_VALUE slots of those nodes. - - In C++, unspecified trailing parameters can be filled in with their - default arguments, if such were specified. Do so here. */ - -tree -convert_arguments (typelist, values, fndecl, flags) - tree typelist, values, fndecl; - int flags; -{ - register tree typetail, valtail; - register tree result = NULL_TREE; - char *called_thing = 0; - int i = 0; - - /* Argument passing is always copy-initialization. */ - flags |= LOOKUP_ONLYCONVERTING; - - if (fndecl) - { - if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE) - { - if (DECL_NAME (fndecl) == NULL_TREE - || IDENTIFIER_HAS_TYPE_VALUE (DECL_NAME (fndecl))) - called_thing = "constructor"; - else - called_thing = "member function"; - } - else - called_thing = "function"; - } - - for (valtail = values, typetail = typelist; - valtail; - valtail = TREE_CHAIN (valtail), i++) - { - register tree type = typetail ? TREE_VALUE (typetail) : 0; - register tree val = TREE_VALUE (valtail); - - if (val == error_mark_node) - return error_mark_node; - - if (type == void_type_node) - { - if (fndecl) - { - cp_error_at ("too many arguments to %s `%+D'", called_thing, - fndecl); - error ("at this point in file"); - } - else - error ("too many arguments to function"); - /* In case anybody wants to know if this argument - list is valid. */ - if (result) - TREE_TYPE (tree_last (result)) = error_mark_node; - break; - } - - if (TREE_CODE (val) == OFFSET_REF) - val = resolve_offset_ref (val); - - /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue. - Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */ - if (TREE_CODE (val) == NOP_EXPR - && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)) - && (type == 0 || TREE_CODE (type) != REFERENCE_TYPE)) - val = TREE_OPERAND (val, 0); - - if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE) - { - if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE - || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE - || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE) - val = default_conversion (val); - - val = require_complete_type (val); - } - - if (val == error_mark_node) - return error_mark_node; - - if (type != 0) - { - /* Formal parm type is specified by a function prototype. */ - tree parmval; - - if (TYPE_SIZE (complete_type (type)) == 0) - { - error ("parameter type of called function is incomplete"); - parmval = val; - } - else - { - parmval = convert_for_initialization - (NULL_TREE, type, val, flags, - "argument passing", fndecl, i); -#ifdef PROMOTE_PROTOTYPES - if ((TREE_CODE (type) == INTEGER_TYPE - || TREE_CODE (type) == ENUMERAL_TYPE) - && (TYPE_PRECISION (type) - < TYPE_PRECISION (integer_type_node))) - parmval = default_conversion (parmval); -#endif - } - - if (parmval == error_mark_node) - return error_mark_node; - - result = expr_tree_cons (NULL_TREE, parmval, result); - } - else - { - if (TREE_CODE (TREE_TYPE (val)) == REFERENCE_TYPE) - val = convert_from_reference (val); - - result = expr_tree_cons (NULL_TREE, - convert_arg_to_ellipsis (val), - result); - } - - if (typetail) - typetail = TREE_CHAIN (typetail); - } - - if (typetail != 0 && typetail != void_list_node) - { - /* See if there are default arguments that can be used */ - if (TREE_PURPOSE (typetail)) - { - for (; typetail != void_list_node; ++i) - { - tree parmval - = convert_default_arg (TREE_VALUE (typetail), - TREE_PURPOSE (typetail), - fndecl); - - if (parmval == error_mark_node) - return error_mark_node; - - result = expr_tree_cons (0, parmval, result); - typetail = TREE_CHAIN (typetail); - /* ends with `...'. */ - if (typetail == NULL_TREE) - break; - } - } - else - { - if (fndecl) - { - char *buf = (char *)alloca (32 + strlen (called_thing)); - sprintf (buf, "too few arguments to %s `%%#D'", called_thing); - cp_error_at (buf, fndecl); - error ("at this point in file"); - } - else - error ("too few arguments to function"); - return error_mark_list; - } - } - - return nreverse (result); -} - -/* Build a binary-operation expression, after performing default - conversions on the operands. CODE is the kind of expression to build. */ - -tree -build_x_binary_op (code, arg1, arg2) - enum tree_code code; - tree arg1, arg2; -{ - if (processing_template_decl) - return build_min_nt (code, arg1, arg2); - - return build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE); -} - -tree -build_binary_op (code, arg1, arg2, convert_p) - enum tree_code code; - tree arg1, arg2; - int convert_p ATTRIBUTE_UNUSED; -{ - return build_binary_op_nodefault (code, arg1, arg2, code); -} - -/* Build a binary-operation expression without default conversions. - CODE is the kind of expression to build. - This function differs from `build' in several ways: - the data type of the result is computed and recorded in it, - warnings are generated if arg data types are invalid, - special handling for addition and subtraction of pointers is known, - and some optimization is done (operations on narrow ints - are done in the narrower type when that gives the same result). - Constant folding is also done before the result is returned. - - ERROR_CODE is the code that determines what to say in error messages. - It is usually, but not always, the same as CODE. - - Note that the operands will never have enumeral types - because either they have just had the default conversions performed - or they have both just been converted to some other type in which - the arithmetic is to be done. - - C++: must do special pointer arithmetic when implementing - multiple inheritance, and deal with pointer to member functions. */ - -tree -build_binary_op_nodefault (code, orig_op0, orig_op1, error_code) - enum tree_code code; - tree orig_op0, orig_op1; - enum tree_code error_code; -{ - tree op0, op1; - register enum tree_code code0, code1; - tree type0, type1; - - /* Expression code to give to the expression when it is built. - Normally this is CODE, which is what the caller asked for, - but in some special cases we change it. */ - register enum tree_code resultcode = code; - - /* Data type in which the computation is to be performed. - In the simplest cases this is the common type of the arguments. */ - register tree result_type = NULL; - - /* Nonzero means operands have already been type-converted - in whatever way is necessary. - Zero means they need to be converted to RESULT_TYPE. */ - int converted = 0; - - /* Nonzero means create the expression with this type, rather than - RESULT_TYPE. */ - tree build_type = 0; - - /* Nonzero means after finally constructing the expression - convert it to this type. */ - tree final_type = 0; - - /* Nonzero if this is an operation like MIN or MAX which can - safely be computed in short if both args are promoted shorts. - Also implies COMMON. - -1 indicates a bitwise operation; this makes a difference - in the exact conditions for when it is safe to do the operation - in a narrower mode. */ - int shorten = 0; - - /* Nonzero if this is a comparison operation; - if both args are promoted shorts, compare the original shorts. - Also implies COMMON. */ - int short_compare = 0; - - /* Nonzero if this is a right-shift operation, which can be computed on the - original short and then promoted if the operand is a promoted short. */ - int short_shift = 0; - - /* Nonzero means set RESULT_TYPE to the common type of the args. */ - int common = 0; - - /* Apply default conversions. */ - if (code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR - || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR - || code == TRUTH_XOR_EXPR) - { - op0 = decay_conversion (orig_op0); - op1 = decay_conversion (orig_op1); - } - else - { - op0 = default_conversion (orig_op0); - op1 = default_conversion (orig_op1); - } - - type0 = TREE_TYPE (op0); - type1 = TREE_TYPE (op1); - - /* The expression codes of the data types of the arguments tell us - whether the arguments are integers, floating, pointers, etc. */ - code0 = TREE_CODE (type0); - code1 = TREE_CODE (type1); - - /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */ - STRIP_TYPE_NOPS (op0); - STRIP_TYPE_NOPS (op1); - - /* If an error was already reported for one of the arguments, - avoid reporting another error. */ - - if (code0 == ERROR_MARK || code1 == ERROR_MARK) - return error_mark_node; - - switch (code) - { - case PLUS_EXPR: - /* Handle the pointer + int case. */ - if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) - return pointer_int_sum (PLUS_EXPR, op0, op1); - else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE) - return pointer_int_sum (PLUS_EXPR, op1, op0); - else - common = 1; - break; - - case MINUS_EXPR: - /* Subtraction of two similar pointers. - We must subtract them as integers, then divide by object size. */ - if (code0 == POINTER_TYPE && code1 == POINTER_TYPE - && comp_target_types (type0, type1, 1)) - return pointer_diff (op0, op1, common_type (type0, type1)); - /* Handle pointer minus int. Just like pointer plus int. */ - else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) - return pointer_int_sum (MINUS_EXPR, op0, op1); - else - common = 1; - break; - - case MULT_EXPR: - common = 1; - break; - - case TRUNC_DIV_EXPR: - case CEIL_DIV_EXPR: - case FLOOR_DIV_EXPR: - case ROUND_DIV_EXPR: - case EXACT_DIV_EXPR: - if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE - || code0 == COMPLEX_TYPE) - && (code1 == INTEGER_TYPE || code1 == REAL_TYPE - || code1 == COMPLEX_TYPE)) - { - if (TREE_CODE (op1) == INTEGER_CST && integer_zerop (op1)) - cp_warning ("division by zero in `%E / 0'", op0); - else if (TREE_CODE (op1) == REAL_CST && real_zerop (op1)) - cp_warning ("division by zero in `%E / 0.'", op0); - - if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)) - resultcode = RDIV_EXPR; - else - /* When dividing two signed integers, we have to promote to int. - unless we divide by a constant != -1. Note that default - conversion will have been performed on the operands at this - point, so we have to dig out the original type to find out if - it was unsigned. */ - shorten = ((TREE_CODE (op0) == NOP_EXPR - && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0)))) - || (TREE_CODE (op1) == INTEGER_CST - && (TREE_INT_CST_LOW (op1) != -1 - || TREE_INT_CST_HIGH (op1) != -1))); - common = 1; - } - break; - - case BIT_AND_EXPR: - case BIT_ANDTC_EXPR: - case BIT_IOR_EXPR: - case BIT_XOR_EXPR: - if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) - shorten = -1; - /* If one operand is a constant, and the other is a short type - that has been converted to an int, - really do the work in the short type and then convert the - result to int. If we are lucky, the constant will be 0 or 1 - in the short type, making the entire operation go away. */ - if (TREE_CODE (op0) == INTEGER_CST - && TREE_CODE (op1) == NOP_EXPR - && (TYPE_PRECISION (type1) - > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))) - && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1, 0)))) - { - final_type = result_type; - op1 = TREE_OPERAND (op1, 0); - result_type = TREE_TYPE (op1); - } - if (TREE_CODE (op1) == INTEGER_CST - && TREE_CODE (op0) == NOP_EXPR - && (TYPE_PRECISION (type0) - > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))) - && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0)))) - { - final_type = result_type; - op0 = TREE_OPERAND (op0, 0); - result_type = TREE_TYPE (op0); - } - break; - - case TRUNC_MOD_EXPR: - case FLOOR_MOD_EXPR: - if (code1 == INTEGER_TYPE && integer_zerop (op1)) - cp_warning ("division by zero in `%E %% 0'", op0); - else if (code1 == REAL_TYPE && real_zerop (op1)) - cp_warning ("division by zero in `%E %% 0.'", op0); - - if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) - { - /* Although it would be tempting to shorten always here, that loses - on some targets, since the modulo instruction is undefined if the - quotient can't be represented in the computation mode. We shorten - only if unsigned or if dividing by something we know != -1. */ - shorten = ((TREE_CODE (op0) == NOP_EXPR - && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0)))) - || (TREE_CODE (op1) == INTEGER_CST - && (TREE_INT_CST_LOW (op1) != -1 - || TREE_INT_CST_HIGH (op1) != -1))); - common = 1; - } - break; - - case TRUTH_ANDIF_EXPR: - case TRUTH_ORIF_EXPR: - case TRUTH_AND_EXPR: - case TRUTH_OR_EXPR: - result_type = boolean_type_node; - break; - - /* Shift operations: result has same type as first operand; - always convert second operand to int. - Also set SHORT_SHIFT if shifting rightward. */ - - case RSHIFT_EXPR: - if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) - { - result_type = type0; - if (TREE_CODE (op1) == INTEGER_CST) - { - if (tree_int_cst_lt (op1, integer_zero_node)) - warning ("right shift count is negative"); - else - { - if (TREE_INT_CST_LOW (op1) | TREE_INT_CST_HIGH (op1)) - short_shift = 1; - if (TREE_INT_CST_HIGH (op1) != 0 - || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1) - >= TYPE_PRECISION (type0))) - warning ("right shift count >= width of type"); - } - } - /* Convert the shift-count to an integer, regardless of - size of value being shifted. */ - if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) - op1 = cp_convert (integer_type_node, op1); - /* Avoid converting op1 to result_type later. */ - converted = 1; - } - break; - - case LSHIFT_EXPR: - if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) - { - result_type = type0; - if (TREE_CODE (op1) == INTEGER_CST) - { - if (tree_int_cst_lt (op1, integer_zero_node)) - warning ("left shift count is negative"); - else if (TREE_INT_CST_HIGH (op1) != 0 - || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1) - >= TYPE_PRECISION (type0))) - warning ("left shift count >= width of type"); - } - /* Convert the shift-count to an integer, regardless of - size of value being shifted. */ - if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) - op1 = cp_convert (integer_type_node, op1); - /* Avoid converting op1 to result_type later. */ - converted = 1; - } - break; - - case RROTATE_EXPR: - case LROTATE_EXPR: - if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) - { - result_type = type0; - if (TREE_CODE (op1) == INTEGER_CST) - { - if (tree_int_cst_lt (op1, integer_zero_node)) - warning ("%s rotate count is negative", - (code == LROTATE_EXPR) ? "left" : "right"); - else if (TREE_INT_CST_HIGH (op1) != 0 - || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1) - >= TYPE_PRECISION (type0))) - warning ("%s rotate count >= width of type", - (code == LROTATE_EXPR) ? "left" : "right"); - } - /* Convert the shift-count to an integer, regardless of - size of value being shifted. */ - if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) - op1 = cp_convert (integer_type_node, op1); - } - break; - - case EQ_EXPR: - case NE_EXPR: - build_type = boolean_type_node; - if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE - || code0 == COMPLEX_TYPE) - && (code1 == INTEGER_TYPE || code1 == REAL_TYPE - || code1 == COMPLEX_TYPE)) - short_compare = 1; - else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) - { - register tree tt0 = TYPE_MAIN_VARIANT (TREE_TYPE (type0)); - register tree tt1 = TYPE_MAIN_VARIANT (TREE_TYPE (type1)); - - if (comp_target_types (type0, type1, 1)) - result_type = common_type (type0, type1); - else if (tt0 == void_type_node) - { - if (pedantic && TREE_CODE (tt1) == FUNCTION_TYPE - && tree_int_cst_lt (TYPE_SIZE (type0), TYPE_SIZE (type1))) - pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer"); - else if (TREE_CODE (tt1) == OFFSET_TYPE) - pedwarn ("ANSI C++ forbids conversion of a pointer to member to `void *'"); - } - else if (tt1 == void_type_node) - { - if (pedantic && TREE_CODE (tt0) == FUNCTION_TYPE - && tree_int_cst_lt (TYPE_SIZE (type1), TYPE_SIZE (type0))) - pedwarn ("ANSI C++ forbids comparison of `void *' with function pointer"); - } - else - cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast", - type0, type1); - - if (result_type == NULL_TREE) - result_type = ptr_type_node; - } - else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST - && integer_zerop (op1)) - result_type = type0; - else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST - && integer_zerop (op0)) - result_type = type1; - else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) - { - result_type = type0; - error ("ANSI C++ forbids comparison between pointer and integer"); - } - else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) - { - result_type = type1; - error ("ANSI C++ forbids comparison between pointer and integer"); - } - else if (TYPE_PTRMEMFUNC_P (type0) && TREE_CODE (op1) == INTEGER_CST - && integer_zerop (op1)) - { - op0 = build_component_ref (op0, index_identifier, NULL_TREE, 0); - op1 = integer_zero_node; - result_type = TREE_TYPE (op0); - } - else if (TYPE_PTRMEMFUNC_P (type1) && TREE_CODE (op0) == INTEGER_CST - && integer_zerop (op0)) - { - op0 = build_component_ref (op1, index_identifier, NULL_TREE, 0); - op1 = integer_zero_node; - result_type = TREE_TYPE (op0); - } - else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1) - && (TYPE_PTRMEMFUNC_FN_TYPE (type0) - == TYPE_PTRMEMFUNC_FN_TYPE (type1))) - { - /* The code we generate for the test is: - - (op0.index == op1.index - && ((op1.index != -1 && op0.delta2 == op1.delta2) - || op0.pfn == op1.pfn)) */ - - tree index0 = build_component_ref (op0, index_identifier, - NULL_TREE, 0); - tree index1 = save_expr (build_component_ref (op1, index_identifier, - NULL_TREE, 0)); - tree pfn0 = PFN_FROM_PTRMEMFUNC (op0); - tree pfn1 = PFN_FROM_PTRMEMFUNC (op1); - tree delta20 = DELTA2_FROM_PTRMEMFUNC (op0); - tree delta21 = DELTA2_FROM_PTRMEMFUNC (op1); - tree e1, e2, e3; - tree integer_neg_one_node - = build_binary_op (MINUS_EXPR, integer_zero_node, - integer_one_node, 1); - e1 = build_binary_op (EQ_EXPR, index0, index1, 1); - e2 = build_binary_op (NE_EXPR, index1, integer_neg_one_node, 1); - e2 = build_binary_op (TRUTH_ANDIF_EXPR, e2, - build_binary_op (EQ_EXPR, delta20, delta21, 1), - 1); - e3 = build_binary_op (EQ_EXPR, pfn0, pfn1, 1); - e2 = build_binary_op (TRUTH_ORIF_EXPR, e2, e3, 1); - e2 = build_binary_op (TRUTH_ANDIF_EXPR, e1, e2, 1); - if (code == EQ_EXPR) - return e2; - return build_binary_op (EQ_EXPR, e2, integer_zero_node, 1); - } - else if (TYPE_PTRMEMFUNC_P (type0) - && TYPE_PTRMEMFUNC_FN_TYPE (type0) == type1) - { - tree index0 = build_component_ref (op0, index_identifier, - NULL_TREE, 0); - tree index1; - tree pfn0 = PFN_FROM_PTRMEMFUNC (op0); - tree delta20 = DELTA2_FROM_PTRMEMFUNC (op0); - tree delta21 = integer_zero_node; - tree e1, e2, e3; - tree integer_neg_one_node - = build_binary_op (MINUS_EXPR, integer_zero_node, integer_one_node, 1); - if (TREE_CODE (TREE_OPERAND (op1, 0)) == FUNCTION_DECL - && DECL_VINDEX (TREE_OPERAND (op1, 0))) - { - /* Map everything down one to make room for - the null pointer to member. */ - index1 = size_binop (PLUS_EXPR, - DECL_VINDEX (TREE_OPERAND (op1, 0)), - integer_one_node); - op1 = integer_zero_node; - delta21 = CLASSTYPE_VFIELD (TYPE_METHOD_BASETYPE - (TREE_TYPE (type1))); - delta21 = DECL_FIELD_BITPOS (delta21); - delta21 = size_binop (FLOOR_DIV_EXPR, delta21, - size_int (BITS_PER_UNIT)); - delta21 = convert (sizetype, delta21); - } - else - index1 = integer_neg_one_node; - { - tree nop1 = build1 (NOP_EXPR, TYPE_PTRMEMFUNC_FN_TYPE (type0), - op1); - TREE_CONSTANT (nop1) = TREE_CONSTANT (op1); - op1 = nop1; - } - e1 = build_binary_op (EQ_EXPR, index0, index1, 1); - e2 = build_binary_op (NE_EXPR, index1, integer_neg_one_node, 1); - e2 = build_binary_op (TRUTH_ANDIF_EXPR, e2, - build_binary_op (EQ_EXPR, delta20, delta21, 1), - 1); - e3 = build_binary_op (EQ_EXPR, pfn0, op1, 1); - e2 = build_binary_op (TRUTH_ORIF_EXPR, e2, e3, 1); - e2 = build_binary_op (TRUTH_ANDIF_EXPR, e1, e2, 1); - if (code == EQ_EXPR) - return e2; - return build_binary_op (EQ_EXPR, e2, integer_zero_node, 1); - } - else if (TYPE_PTRMEMFUNC_P (type1) - && TYPE_PTRMEMFUNC_FN_TYPE (type1) == type0) - { - return build_binary_op (code, op1, op0, 1); - } - break; - - case MAX_EXPR: - case MIN_EXPR: - if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE) - && (code1 == INTEGER_TYPE || code1 == REAL_TYPE)) - shorten = 1; - else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) - { - if (comp_target_types (type0, type1, 1)) - result_type = common_type (type0, type1); - else - { - cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast", - type0, type1); - result_type = ptr_type_node; - } - } - break; - - case LE_EXPR: - case GE_EXPR: - case LT_EXPR: - case GT_EXPR: - build_type = boolean_type_node; - if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE) - && (code1 == INTEGER_TYPE || code1 == REAL_TYPE)) - short_compare = 1; - else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) - { - if (comp_target_types (type0, type1, 1)) - result_type = common_type (type0, type1); - else - { - cp_pedwarn ("comparison of distinct pointer types `%T' and `%T' lacks a cast", - type0, type1); - result_type = ptr_type_node; - } - } - else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST - && integer_zerop (op1)) - result_type = type0; - else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST - && integer_zerop (op0)) - result_type = type1; - else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) - { - result_type = type0; - pedwarn ("ANSI C++ forbids comparison between pointer and integer"); - } - else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) - { - result_type = type1; - pedwarn ("ANSI C++ forbids comparison between pointer and integer"); - } - break; - - default: - break; - } - - if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE) - && - (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE)) - { - int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE); - - if (shorten || common || short_compare) - result_type = common_type (type0, type1); - - /* For certain operations (which identify themselves by shorten != 0) - if both args were extended from the same smaller type, - do the arithmetic in that type and then extend. - - shorten !=0 and !=1 indicates a bitwise operation. - For them, this optimization is safe only if - both args are zero-extended or both are sign-extended. - Otherwise, we might change the result. - Eg, (short)-1 | (unsigned short)-1 is (int)-1 - but calculated in (unsigned short) it would be (unsigned short)-1. */ - - if (shorten && none_complex) - { - int unsigned0, unsigned1; - tree arg0 = get_narrower (op0, &unsigned0); - tree arg1 = get_narrower (op1, &unsigned1); - /* UNS is 1 if the operation to be done is an unsigned one. */ - int uns = TREE_UNSIGNED (result_type); - tree type; - - final_type = result_type; - - /* Handle the case that OP0 does not *contain* a conversion - but it *requires* conversion to FINAL_TYPE. */ - - if (op0 == arg0 && TREE_TYPE (op0) != final_type) - unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0)); - if (op1 == arg1 && TREE_TYPE (op1) != final_type) - unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1)); - - /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */ - - /* For bitwise operations, signedness of nominal type - does not matter. Consider only how operands were extended. */ - if (shorten == -1) - uns = unsigned0; - - /* Note that in all three cases below we refrain from optimizing - an unsigned operation on sign-extended args. - That would not be valid. */ - - /* Both args variable: if both extended in same way - from same width, do it in that width. - Do it unsigned if args were zero-extended. */ - if ((TYPE_PRECISION (TREE_TYPE (arg0)) - < TYPE_PRECISION (result_type)) - && (TYPE_PRECISION (TREE_TYPE (arg1)) - == TYPE_PRECISION (TREE_TYPE (arg0))) - && unsigned0 == unsigned1 - && (unsigned0 || !uns)) - result_type - = signed_or_unsigned_type (unsigned0, - common_type (TREE_TYPE (arg0), - TREE_TYPE (arg1))); - else if (TREE_CODE (arg0) == INTEGER_CST - && (unsigned1 || !uns) - && (TYPE_PRECISION (TREE_TYPE (arg1)) - < TYPE_PRECISION (result_type)) - && (type = signed_or_unsigned_type (unsigned1, - TREE_TYPE (arg1)), - int_fits_type_p (arg0, type))) - result_type = type; - else if (TREE_CODE (arg1) == INTEGER_CST - && (unsigned0 || !uns) - && (TYPE_PRECISION (TREE_TYPE (arg0)) - < TYPE_PRECISION (result_type)) - && (type = signed_or_unsigned_type (unsigned0, - TREE_TYPE (arg0)), - int_fits_type_p (arg1, type))) - result_type = type; - } - - /* Shifts can be shortened if shifting right. */ - - if (short_shift) - { - int unsigned_arg; - tree arg0 = get_narrower (op0, &unsigned_arg); - - final_type = result_type; - - if (arg0 == op0 && final_type == TREE_TYPE (op0)) - unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0)); - - if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type) - /* We can shorten only if the shift count is less than the - number of bits in the smaller type size. */ - && TREE_INT_CST_HIGH (op1) == 0 - && TYPE_PRECISION (TREE_TYPE (arg0)) > TREE_INT_CST_LOW (op1) - /* If arg is sign-extended and then unsigned-shifted, - we can simulate this with a signed shift in arg's type - only if the extended result is at least twice as wide - as the arg. Otherwise, the shift could use up all the - ones made by sign-extension and bring in zeros. - We can't optimize that case at all, but in most machines - it never happens because available widths are 2**N. */ - && (!TREE_UNSIGNED (final_type) - || unsigned_arg - || (((unsigned) 2 * TYPE_PRECISION (TREE_TYPE (arg0))) - <= TYPE_PRECISION (result_type)))) - { - /* Do an unsigned shift if the operand was zero-extended. */ - result_type - = signed_or_unsigned_type (unsigned_arg, - TREE_TYPE (arg0)); - /* Convert value-to-be-shifted to that type. */ - if (TREE_TYPE (op0) != result_type) - op0 = cp_convert (result_type, op0); - converted = 1; - } - } - - /* Comparison operations are shortened too but differently. - They identify themselves by setting short_compare = 1. */ - - if (short_compare) - { - /* Don't write &op0, etc., because that would prevent op0 - from being kept in a register. - Instead, make copies of the our local variables and - pass the copies by reference, then copy them back afterward. */ - tree xop0 = op0, xop1 = op1, xresult_type = result_type; - enum tree_code xresultcode = resultcode; - tree val - = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode); - if (val != 0) - return cp_convert (boolean_type_node, val); - op0 = xop0, op1 = xop1; - converted = 1; - resultcode = xresultcode; - } - - if (short_compare && warn_sign_compare) - { - int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0)); - int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1)); - - int unsignedp0, unsignedp1; - tree primop0 = get_narrower (op0, &unsignedp0); - tree primop1 = get_narrower (op1, &unsignedp1); - - /* Check for comparison of different enum types. */ - if (TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE - && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE - && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0)) - != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1))) - { - cp_warning ("comparison between `%#T' and `%#T'", - TREE_TYPE (orig_op0), TREE_TYPE (orig_op1)); - } - - /* Give warnings for comparisons between signed and unsigned - quantities that may fail. */ - /* Do the checking based on the original operand trees, so that - casts will be considered, but default promotions won't be. */ - - /* Do not warn if the comparison is being done in a signed type, - since the signed type will only be chosen if it can represent - all the values of the unsigned type. */ - if (! TREE_UNSIGNED (result_type)) - /* OK */; - /* Do not warn if both operands are unsigned. */ - else if (op0_signed == op1_signed) - /* OK */; - /* Do not warn if the signed quantity is an unsuffixed - integer literal (or some static constant expression - involving such literals) and it is non-negative. */ - else if ((op0_signed && TREE_CODE (orig_op0) == INTEGER_CST - && tree_int_cst_sgn (orig_op0) >= 0) - || (op1_signed && TREE_CODE (orig_op1) == INTEGER_CST - && tree_int_cst_sgn (orig_op1) >= 0)) - /* OK */; - /* Do not warn if the comparison is an equality operation, - the unsigned quantity is an integral constant and it does - not use the most significant bit of result_type. */ - else if ((resultcode == EQ_EXPR || resultcode == NE_EXPR) - && ((op0_signed && TREE_CODE (orig_op1) == INTEGER_CST - && int_fits_type_p (orig_op1, - signed_type (result_type))) - || (op1_signed && TREE_CODE (orig_op0) == INTEGER_CST - && int_fits_type_p (orig_op0, - signed_type (result_type))))) - /* OK */; - else - warning ("comparison between signed and unsigned"); - - /* Warn if two unsigned values are being compared in a size - larger than their original size, and one (and only one) is the - result of a `~' operator. This comparison will always fail. - - Also warn if one operand is a constant, and the constant does not - have all bits set that are set in the ~ operand when it is - extended. */ - - if ((TREE_CODE (primop0) == BIT_NOT_EXPR) - ^ (TREE_CODE (primop1) == BIT_NOT_EXPR)) - { - if (TREE_CODE (primop0) == BIT_NOT_EXPR) - primop0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0); - if (TREE_CODE (primop1) == BIT_NOT_EXPR) - primop1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1); - - if (TREE_CODE (primop0) == INTEGER_CST - || TREE_CODE (primop1) == INTEGER_CST) - { - tree primop; - HOST_WIDE_INT constant, mask; - int unsignedp; - unsigned bits; - - if (TREE_CODE (primop0) == INTEGER_CST) - { - primop = primop1; - unsignedp = unsignedp1; - constant = TREE_INT_CST_LOW (primop0); - } - else - { - primop = primop0; - unsignedp = unsignedp0; - constant = TREE_INT_CST_LOW (primop1); - } - - bits = TYPE_PRECISION (TREE_TYPE (primop)); - if (bits < TYPE_PRECISION (result_type) - && bits < HOST_BITS_PER_LONG && unsignedp) - { - mask = (~ (HOST_WIDE_INT) 0) << bits; - if ((mask & constant) != mask) - warning ("comparison of promoted ~unsigned with constant"); - } - } - else if (unsignedp0 && unsignedp1 - && (TYPE_PRECISION (TREE_TYPE (primop0)) - < TYPE_PRECISION (result_type)) - && (TYPE_PRECISION (TREE_TYPE (primop1)) - < TYPE_PRECISION (result_type))) - warning ("comparison of promoted ~unsigned with unsigned"); - } - } - } - - /* At this point, RESULT_TYPE must be nonzero to avoid an error message. - If CONVERTED is zero, both args will be converted to type RESULT_TYPE. - Then the expression will be built. - It will be given type FINAL_TYPE if that is nonzero; - otherwise, it will be given type RESULT_TYPE. */ - - if (!result_type) - { - cp_error ("invalid operands `%T' and `%T' to binary `%O'", - TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), error_code); - return error_mark_node; - } - - /* Issue warnings about peculiar, but legal, uses of NULL. */ - if (/* It's reasonable to use pointer values as operands of && - and ||, so NULL is no exception. */ - !(code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR) - && (/* If OP0 is NULL and OP1 is not a pointer, or vice versa. */ - (orig_op0 == null_node - && TREE_CODE (TREE_TYPE (op1)) != POINTER_TYPE) - /* Or vice versa. */ - || (orig_op1 == null_node - && TREE_CODE (TREE_TYPE (op0)) != POINTER_TYPE) - /* Or, both are NULL and the operation was not a comparison. */ - || (orig_op0 == null_node && orig_op1 == null_node - && code != EQ_EXPR && code != NE_EXPR))) - /* Some sort of arithmetic operation involving NULL was - performed. Note that pointer-difference and pointer-addition - have already been handled above, and so we don't end up here in - that case. */ - cp_warning ("NULL used in arithmetic"); - - if (! converted) - { - if (TREE_TYPE (op0) != result_type) - op0 = cp_convert (result_type, op0); - if (TREE_TYPE (op1) != result_type) - op1 = cp_convert (result_type, op1); - - if (op0 == error_mark_node || op1 == error_mark_node) - return error_mark_node; - } - - if (build_type == NULL_TREE) - build_type = result_type; - - { - register tree result = build (resultcode, build_type, op0, op1); - register tree folded; - - folded = fold (result); - if (folded == result) - TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1); - if (final_type != 0) - return cp_convert (final_type, folded); - return folded; - } -} - -/* Return a tree for the sum or difference (RESULTCODE says which) - of pointer PTROP and integer INTOP. */ - -static tree -pointer_int_sum (resultcode, ptrop, intop) - enum tree_code resultcode; - register tree ptrop, intop; -{ - tree size_exp; - - register tree result; - register tree folded = fold (intop); - - /* The result is a pointer of the same type that is being added. */ - - register tree result_type = TREE_TYPE (ptrop); - - if (!complete_type_or_else (result_type)) - return error_mark_node; - - if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE) - { - if (pedantic || warn_pointer_arith) - pedwarn ("ANSI C++ forbids using pointer of type `void *' in arithmetic"); - size_exp = integer_one_node; - } - else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE) - { - if (pedantic || warn_pointer_arith) - pedwarn ("ANSI C++ forbids using pointer to a function in arithmetic"); - size_exp = integer_one_node; - } - else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE) - { - if (pedantic || warn_pointer_arith) - pedwarn ("ANSI C++ forbids using pointer to a method in arithmetic"); - size_exp = integer_one_node; - } - else if (TREE_CODE (TREE_TYPE (result_type)) == OFFSET_TYPE) - { - if (pedantic || warn_pointer_arith) - pedwarn ("ANSI C++ forbids using pointer to a member in arithmetic"); - size_exp = integer_one_node; - } - else - size_exp = size_in_bytes (complete_type (TREE_TYPE (result_type))); - - /* Needed to make OOPS V2R3 work. */ - intop = folded; - if (TREE_CODE (intop) == INTEGER_CST - && TREE_INT_CST_LOW (intop) == 0 - && TREE_INT_CST_HIGH (intop) == 0) - return ptrop; - - /* If what we are about to multiply by the size of the elements - contains a constant term, apply distributive law - and multiply that constant term separately. - This helps produce common subexpressions. */ - - if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR) - && ! TREE_CONSTANT (intop) - && TREE_CONSTANT (TREE_OPERAND (intop, 1)) - && TREE_CONSTANT (size_exp)) - { - enum tree_code subcode = resultcode; - if (TREE_CODE (intop) == MINUS_EXPR) - subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR); - ptrop = build_binary_op (subcode, ptrop, TREE_OPERAND (intop, 1), 1); - intop = TREE_OPERAND (intop, 0); - } - - /* Convert the integer argument to a type the same size as sizetype - so the multiply won't overflow spuriously. */ - - if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)) - intop = cp_convert (type_for_size (TYPE_PRECISION (sizetype), 0), intop); - - /* Replace the integer argument with a suitable product by the object size. - Do this multiplication as signed, then convert to the appropriate - pointer type (actually unsigned integral). */ - - intop = cp_convert (result_type, - build_binary_op (MULT_EXPR, intop, - cp_convert (TREE_TYPE (intop), - size_exp), - 1)); - - /* Create the sum or difference. */ - - result = build (resultcode, result_type, ptrop, intop); - - folded = fold (result); - if (folded == result) - TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop); - return folded; -} - -/* Return a tree for the difference of pointers OP0 and OP1. - The resulting tree has type int. */ - -static tree -pointer_diff (op0, op1, ptrtype) - register tree op0, op1; - register tree ptrtype; -{ - register tree result, folded; - tree restype = ptrdiff_type_node; - tree target_type = TREE_TYPE (ptrtype); - - if (!complete_type_or_else (target_type)) - return error_mark_node; - - if (pedantic || warn_pointer_arith) - { - if (TREE_CODE (target_type) == VOID_TYPE) - pedwarn ("ANSI C++ forbids using pointer of type `void *' in subtraction"); - if (TREE_CODE (target_type) == FUNCTION_TYPE) - pedwarn ("ANSI C++ forbids using pointer to a function in subtraction"); - if (TREE_CODE (target_type) == METHOD_TYPE) - pedwarn ("ANSI C++ forbids using pointer to a method in subtraction"); - if (TREE_CODE (target_type) == OFFSET_TYPE) - pedwarn ("ANSI C++ forbids using pointer to a member in subtraction"); - } - - /* First do the subtraction as integers; - then drop through to build the divide operator. */ - - op0 = build_binary_op (MINUS_EXPR, cp_convert (restype, op0), - cp_convert (restype, op1), 1); - - /* This generates an error if op1 is a pointer to an incomplete type. */ - if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1))) == 0) - error ("arithmetic on pointer to an incomplete type"); - - op1 = ((TREE_CODE (target_type) == VOID_TYPE - || TREE_CODE (target_type) == FUNCTION_TYPE - || TREE_CODE (target_type) == METHOD_TYPE - || TREE_CODE (target_type) == OFFSET_TYPE) - ? integer_one_node - : size_in_bytes (target_type)); - - /* Do the division. */ - - result = build (EXACT_DIV_EXPR, restype, op0, cp_convert (restype, op1)); - - folded = fold (result); - if (folded == result) - TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1); - return folded; -} - -/* Handle the case of taking the address of a COMPONENT_REF. - Called by `build_unary_op' and `build_up_reference'. - - ARG is the COMPONENT_REF whose address we want. - ARGTYPE is the pointer type that this address should have. - MSG is an error message to print if this COMPONENT_REF is not - addressable (such as a bitfield). */ - -tree -build_component_addr (arg, argtype, msg) - tree arg, argtype; - char *msg; -{ - tree field = TREE_OPERAND (arg, 1); - tree basetype = decl_type_context (field); - tree rval = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0); - - my_friendly_assert (TREE_CODE (field) == FIELD_DECL, 981018); - - if (DECL_C_BIT_FIELD (field)) - { - error (msg, IDENTIFIER_POINTER (DECL_NAME (field))); - return error_mark_node; - } - - if (TREE_CODE (field) == FIELD_DECL - && TYPE_USES_COMPLEX_INHERITANCE (basetype)) - { - /* Can't convert directly to ARGTYPE, since that - may have the same pointer type as one of our - baseclasses. */ - rval = build1 (NOP_EXPR, argtype, - convert_pointer_to (basetype, rval)); - TREE_CONSTANT (rval) = TREE_CONSTANT (TREE_OPERAND (rval, 0)); - } - else - /* This conversion is harmless. */ - rval = convert_force (argtype, rval, 0); - - if (! integer_zerop (DECL_FIELD_BITPOS (field))) - { - tree offset = size_binop (EASY_DIV_EXPR, DECL_FIELD_BITPOS (field), - size_int (BITS_PER_UNIT)); - int flag = TREE_CONSTANT (rval); - offset = convert (sizetype, offset); - rval = fold (build (PLUS_EXPR, argtype, - rval, cp_convert (argtype, offset))); - TREE_CONSTANT (rval) = flag; - } - return rval; -} - -/* Construct and perhaps optimize a tree representation - for a unary operation. CODE, a tree_code, specifies the operation - and XARG is the operand. */ - -tree -build_x_unary_op (code, xarg) - enum tree_code code; - tree xarg; -{ - if (processing_template_decl) - return build_min_nt (code, xarg, NULL_TREE); - - /* & rec, on incomplete RECORD_TYPEs is the simple opr &, not an - error message. */ - if (code == ADDR_EXPR - && TREE_CODE (xarg) != TEMPLATE_ID_EXPR - && ((IS_AGGR_TYPE_CODE (TREE_CODE (TREE_TYPE (xarg))) - && TYPE_SIZE (TREE_TYPE (xarg)) == NULL_TREE) - || (TREE_CODE (xarg) == OFFSET_REF))) - /* don't look for a function */; - else - { - tree rval; - - rval = build_new_op (code, LOOKUP_NORMAL, xarg, - NULL_TREE, NULL_TREE); - if (rval || code != ADDR_EXPR) - return rval; - } - - if (code == ADDR_EXPR) - { - if (TREE_CODE (xarg) == TARGET_EXPR) - warning ("taking address of temporary"); - } - - return build_unary_op (code, xarg, 0); -} - -/* Just like truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */ - -tree -condition_conversion (expr) - tree expr; -{ - tree t; - if (processing_template_decl) - return expr; - t = cp_convert (boolean_type_node, expr); - t = fold (build1 (CLEANUP_POINT_EXPR, boolean_type_node, t)); - return t; -} - -/* C++: Must handle pointers to members. - - Perhaps type instantiation should be extended to handle conversion - from aggregates to types we don't yet know we want? (Or are those - cases typically errors which should be reported?) - - NOCONVERT nonzero suppresses the default promotions - (such as from short to int). */ - -tree -build_unary_op (code, xarg, noconvert) - enum tree_code code; - tree xarg; - int noconvert; -{ - /* No default_conversion here. It causes trouble for ADDR_EXPR. */ - register tree arg = xarg; - register tree argtype = 0; - char *errstring = NULL; - tree val; - - if (arg == error_mark_node) - return error_mark_node; - - switch (code) - { - case CONVERT_EXPR: - /* This is used for unary plus, because a CONVERT_EXPR - is enough to prevent anybody from looking inside for - associativity, but won't generate any code. */ - if (!(arg = build_expr_type_conversion - (WANT_ARITH | WANT_ENUM | WANT_POINTER, arg, 1))) - errstring = "wrong type argument to unary plus"; - else - { - if (!noconvert) - arg = default_conversion (arg); - arg = build1 (NON_LVALUE_EXPR, TREE_TYPE (arg), arg); - TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0)); - } - break; - - case NEGATE_EXPR: - if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, 1))) - errstring = "wrong type argument to unary minus"; - else if (!noconvert) - arg = default_conversion (arg); - break; - - case BIT_NOT_EXPR: - if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) - { - code = CONJ_EXPR; - if (!noconvert) - arg = default_conversion (arg); - } - else if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM, - arg, 1))) - errstring = "wrong type argument to bit-complement"; - else if (!noconvert) - arg = default_conversion (arg); - break; - - case ABS_EXPR: - if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, 1))) - errstring = "wrong type argument to abs"; - else if (!noconvert) - arg = default_conversion (arg); - break; - - case CONJ_EXPR: - /* Conjugating a real value is a no-op, but allow it anyway. */ - if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, 1))) - errstring = "wrong type argument to conjugation"; - else if (!noconvert) - arg = default_conversion (arg); - break; - - case TRUTH_NOT_EXPR: - arg = cp_convert (boolean_type_node, arg); - val = invert_truthvalue (arg); - if (arg != error_mark_node) - return val; - errstring = "in argument to unary !"; - break; - - case NOP_EXPR: - break; - - case REALPART_EXPR: - if (TREE_CODE (arg) == COMPLEX_CST) - return TREE_REALPART (arg); - else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) - return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg)); - else - return arg; - - case IMAGPART_EXPR: - if (TREE_CODE (arg) == COMPLEX_CST) - return TREE_IMAGPART (arg); - else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) - return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg)); - else - return cp_convert (TREE_TYPE (arg), integer_zero_node); - - case PREINCREMENT_EXPR: - case POSTINCREMENT_EXPR: - case PREDECREMENT_EXPR: - case POSTDECREMENT_EXPR: - /* Handle complex lvalues (when permitted) - by reduction to simpler cases. */ - - val = unary_complex_lvalue (code, arg); - if (val != 0) - return val; - - /* Increment or decrement the real part of the value, - and don't change the imaginary part. */ - if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) - { - tree real, imag; - - arg = stabilize_reference (arg); - real = build_unary_op (REALPART_EXPR, arg, 1); - imag = build_unary_op (IMAGPART_EXPR, arg, 1); - return build (COMPLEX_EXPR, TREE_TYPE (arg), - build_unary_op (code, real, 1), imag); - } - - /* Report invalid types. */ - - if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_POINTER, - arg, 1))) - { - if (code == PREINCREMENT_EXPR) - errstring ="no pre-increment operator for type"; - else if (code == POSTINCREMENT_EXPR) - errstring ="no post-increment operator for type"; - else if (code == PREDECREMENT_EXPR) - errstring ="no pre-decrement operator for type"; - else - errstring ="no post-decrement operator for type"; - break; - } - - /* Report something read-only. */ - - if (CP_TYPE_CONST_P (TREE_TYPE (arg)) - || TREE_READONLY (arg)) - readonly_error (arg, ((code == PREINCREMENT_EXPR - || code == POSTINCREMENT_EXPR) - ? "increment" : "decrement"), - 0); - - { - register tree inc; - tree result_type = TREE_TYPE (arg); - - arg = get_unwidened (arg, 0); - argtype = TREE_TYPE (arg); - - /* ARM $5.2.5 last annotation says this should be forbidden. */ - if (TREE_CODE (argtype) == ENUMERAL_TYPE) - pedwarn ("ANSI C++ forbids %sing an enum", - (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) - ? "increment" : "decrement"); - - /* Compute the increment. */ - - if (TREE_CODE (argtype) == POINTER_TYPE) - { - enum tree_code tmp = TREE_CODE (TREE_TYPE (argtype)); - if (TYPE_SIZE (complete_type (TREE_TYPE (argtype))) == 0) - cp_error ("cannot %s a pointer to incomplete type `%T'", - ((code == PREINCREMENT_EXPR - || code == POSTINCREMENT_EXPR) - ? "increment" : "decrement"), TREE_TYPE (argtype)); - else if ((pedantic || warn_pointer_arith) - && (tmp == FUNCTION_TYPE || tmp == METHOD_TYPE - || tmp == VOID_TYPE || tmp == OFFSET_TYPE)) - cp_pedwarn ("ANSI C++ forbids %sing a pointer of type `%T'", - ((code == PREINCREMENT_EXPR - || code == POSTINCREMENT_EXPR) - ? "increment" : "decrement"), argtype); - inc = c_sizeof_nowarn (TREE_TYPE (argtype)); - } - else - inc = integer_one_node; - - inc = cp_convert (argtype, inc); - - /* Handle incrementing a cast-expression. */ - - switch (TREE_CODE (arg)) - { - case NOP_EXPR: - case CONVERT_EXPR: - case FLOAT_EXPR: - case FIX_TRUNC_EXPR: - case FIX_FLOOR_EXPR: - case FIX_ROUND_EXPR: - case FIX_CEIL_EXPR: - { - tree incremented, modify, value, compound; - if (! lvalue_p (arg) && pedantic) - pedwarn ("cast to non-reference type used as lvalue"); - arg = stabilize_reference (arg); - if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR) - value = arg; - else - value = save_expr (arg); - incremented = build (((code == PREINCREMENT_EXPR - || code == POSTINCREMENT_EXPR) - ? PLUS_EXPR : MINUS_EXPR), - argtype, value, inc); - TREE_SIDE_EFFECTS (incremented) = 1; - - modify = build_modify_expr (arg, NOP_EXPR, incremented); - compound = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value); - - /* Eliminate warning about unused result of + or -. */ - TREE_NO_UNUSED_WARNING (compound) = 1; - return compound; - } - - default: - break; - } - - /* Complain about anything else that is not a true lvalue. */ - if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR - || code == POSTINCREMENT_EXPR) - ? "increment" : "decrement"))) - return error_mark_node; - - /* Forbid using -- on `bool'. */ - if (TREE_TYPE (arg) == boolean_type_node) - { - if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR) - { - cp_error ("invalid use of `--' on bool variable `%D'", arg); - return error_mark_node; - } -#if 0 - /* This will only work if someone can convince Kenner to accept - my patch to expand_increment. (jason) */ - val = build (code, TREE_TYPE (arg), arg, inc); -#else - if (code == POSTINCREMENT_EXPR) - { - arg = stabilize_reference (arg); - val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, - boolean_true_node); - TREE_SIDE_EFFECTS (val) = 1; - arg = save_expr (arg); - val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg); - val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val); - } - else - val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, - boolean_true_node); -#endif - } - else - val = build (code, TREE_TYPE (arg), arg, inc); - - TREE_SIDE_EFFECTS (val) = 1; - return cp_convert (result_type, val); - } - - case ADDR_EXPR: - /* Note that this operation never does default_conversion - regardless of NOCONVERT. */ - - argtype = lvalue_type (arg); - if (TREE_CODE (argtype) == REFERENCE_TYPE) - { - arg = build1 - (CONVERT_EXPR, - build_pointer_type (TREE_TYPE (argtype)), arg); - TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0)); - return arg; - } - else if (pedantic && DECL_MAIN_P (arg)) - /* ARM $3.4 */ - pedwarn ("taking address of function `main'"); - - /* Let &* cancel out to simplify resulting code. */ - if (TREE_CODE (arg) == INDIRECT_REF) - { - /* We don't need to have `current_class_ptr' wrapped in a - NON_LVALUE_EXPR node. */ - if (arg == current_class_ref) - return current_class_ptr; - - arg = TREE_OPERAND (arg, 0); - if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE) - { - arg = build1 - (CONVERT_EXPR, - build_pointer_type (TREE_TYPE (TREE_TYPE (arg))), arg); - TREE_CONSTANT (arg) = TREE_CONSTANT (TREE_OPERAND (arg, 0)); - } - else if (lvalue_p (arg)) - /* Don't let this be an lvalue. */ - return non_lvalue (arg); - return arg; - } - - /* For &x[y], return x+y */ - if (TREE_CODE (arg) == ARRAY_REF) - { - if (mark_addressable (TREE_OPERAND (arg, 0)) == 0) - return error_mark_node; - return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0), - TREE_OPERAND (arg, 1), 1); - } - - /* Uninstantiated types are all functions. Taking the - address of a function is a no-op, so just return the - argument. */ - - if (TREE_CODE (arg) == IDENTIFIER_NODE - && IDENTIFIER_OPNAME_P (arg)) - { - my_friendly_abort (117); - /* We don't know the type yet, so just work around the problem. - We know that this will resolve to an lvalue. */ - return build1 (ADDR_EXPR, unknown_type_node, arg); - } - - if (TREE_CODE (arg) == TEMPLATE_ID_EXPR) - { - tree targs; - tree fn; - - /* We don't require a match here; it's possible that the - context (like a cast to a particular type) will resolve - the particular choice of template. */ - fn = determine_specialization (arg, - NULL_TREE, - &targs, - 0, - 0); - - if (fn) - { - fn = instantiate_template (fn, targs); - mark_addressable (fn); - return build_unary_op (ADDR_EXPR, fn, 0); - } - - return build1 (ADDR_EXPR, unknown_type_node, arg); - } - else if (type_unknown_p (arg)) - return build1 (ADDR_EXPR, unknown_type_node, arg); - - /* Handle complex lvalues (when permitted) - by reduction to simpler cases. */ - val = unary_complex_lvalue (code, arg); - if (val != 0) - return val; - - switch (TREE_CODE (arg)) - { - case NOP_EXPR: - case CONVERT_EXPR: - case FLOAT_EXPR: - case FIX_TRUNC_EXPR: - case FIX_FLOOR_EXPR: - case FIX_ROUND_EXPR: - case FIX_CEIL_EXPR: - if (! lvalue_p (arg) && pedantic) - pedwarn ("taking the address of a cast to non-reference type"); - break; - - default: - break; - } - - /* Allow the address of a constructor if all the elements - are constant. */ - if (TREE_CODE (arg) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (arg) - && TREE_CONSTANT (arg)) - ; - /* Anything not already handled and not a true memory reference - is an error. */ - else if (TREE_CODE (argtype) != FUNCTION_TYPE - && TREE_CODE (argtype) != METHOD_TYPE - && !lvalue_or_else (arg, "unary `&'")) - return error_mark_node; - - if (argtype != error_mark_node) - argtype = build_pointer_type (argtype); - - if (mark_addressable (arg) == 0) - return error_mark_node; - - { - tree addr; - - if (TREE_CODE (arg) == COMPONENT_REF) - addr = build_component_addr - (arg, argtype, - "attempt to take address of bit-field structure member `%s'"); - else - addr = build1 (code, argtype, arg); - - /* Address of a static or external variable or - function counts as a constant */ - if (staticp (arg)) - TREE_CONSTANT (addr) = 1; - - if (TREE_CODE (argtype) == POINTER_TYPE - && TREE_CODE (TREE_TYPE (argtype)) == METHOD_TYPE) - { - build_ptrmemfunc_type (argtype); - addr = build_ptrmemfunc (argtype, addr, 0); - } - - return addr; - } - - default: - break; - } - - if (!errstring) - { - if (argtype == 0) - argtype = TREE_TYPE (arg); - return fold (build1 (code, argtype, arg)); - } - - error (errstring); - return error_mark_node; -} - -#if 0 -/* If CONVERSIONS is a conversion expression or a nested sequence of such, - convert ARG with the same conversions in the same order - and return the result. */ - -static tree -convert_sequence (conversions, arg) - tree conversions; - tree arg; -{ - switch (TREE_CODE (conversions)) - { - case NOP_EXPR: - case CONVERT_EXPR: - case FLOAT_EXPR: - case FIX_TRUNC_EXPR: - case FIX_FLOOR_EXPR: - case FIX_ROUND_EXPR: - case FIX_CEIL_EXPR: - return cp_convert (TREE_TYPE (conversions), - convert_sequence (TREE_OPERAND (conversions, 0), - arg)); - - default: - return arg; - } -} -#endif - -/* Apply unary lvalue-demanding operator CODE to the expression ARG - for certain kinds of expressions which are not really lvalues - but which we can accept as lvalues. - - If ARG is not a kind of expression we can handle, return zero. */ - -tree -unary_complex_lvalue (code, arg) - enum tree_code code; - tree arg; -{ - /* Handle (a, b) used as an "lvalue". */ - if (TREE_CODE (arg) == COMPOUND_EXPR) - { - tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0); - return build (COMPOUND_EXPR, TREE_TYPE (real_result), - TREE_OPERAND (arg, 0), real_result); - } - - /* Handle (a ? b : c) used as an "lvalue". */ - if (TREE_CODE (arg) == COND_EXPR - || TREE_CODE (arg) == MIN_EXPR || TREE_CODE (arg) == MAX_EXPR) - return rationalize_conditional_expr (code, arg); - - if (TREE_CODE (arg) == MODIFY_EXPR - || TREE_CODE (arg) == PREINCREMENT_EXPR - || TREE_CODE (arg) == PREDECREMENT_EXPR) - return unary_complex_lvalue - (code, build (COMPOUND_EXPR, TREE_TYPE (TREE_OPERAND (arg, 0)), - arg, TREE_OPERAND (arg, 0))); - - if (code != ADDR_EXPR) - return 0; - - /* Handle (a = b) used as an "lvalue" for `&'. */ - if (TREE_CODE (arg) == MODIFY_EXPR - || TREE_CODE (arg) == INIT_EXPR) - { - tree real_result = build_unary_op (code, TREE_OPERAND (arg, 0), 0); - arg = build (COMPOUND_EXPR, TREE_TYPE (real_result), arg, real_result); - TREE_NO_UNUSED_WARNING (arg) = 1; - return arg; - } - - if (TREE_CODE (TREE_TYPE (arg)) == FUNCTION_TYPE - || TREE_CODE (TREE_TYPE (arg)) == METHOD_TYPE - || TREE_CODE (TREE_TYPE (arg)) == OFFSET_TYPE) - { - /* The representation of something of type OFFSET_TYPE - is really the representation of a pointer to it. - Here give the representation its true type. */ - tree t; - - my_friendly_assert (TREE_CODE (arg) != SCOPE_REF, 313); - - if (TREE_CODE (arg) != OFFSET_REF) - return 0; - - t = TREE_OPERAND (arg, 1); - - /* Check all this code for right semantics. */ - if (TREE_CODE (t) == FUNCTION_DECL) - { - if (DECL_DESTRUCTOR_P (t)) - cp_error ("taking address of destructor"); - return build_unary_op (ADDR_EXPR, t, 0); - } - if (TREE_CODE (t) == VAR_DECL) - return build_unary_op (ADDR_EXPR, t, 0); - else - { - tree type; - - if (TREE_OPERAND (arg, 0) - && ! is_dummy_object (TREE_OPERAND (arg, 0)) - && TREE_CODE (t) != FIELD_DECL) - { - cp_error ("taking address of bound pointer-to-member expression"); - return error_mark_node; - } - - type = build_offset_type (DECL_FIELD_CONTEXT (t), TREE_TYPE (t)); - type = build_pointer_type (type); - - t = make_node (PTRMEM_CST); - TREE_TYPE (t) = type; - PTRMEM_CST_MEMBER (t) = TREE_OPERAND (arg, 1); - return t; - } - } - - - /* We permit compiler to make function calls returning - objects of aggregate type look like lvalues. */ - { - tree targ = arg; - - if (TREE_CODE (targ) == SAVE_EXPR) - targ = TREE_OPERAND (targ, 0); - - if (TREE_CODE (targ) == CALL_EXPR && IS_AGGR_TYPE (TREE_TYPE (targ))) - { - if (TREE_CODE (arg) == SAVE_EXPR) - targ = arg; - else - targ = build_cplus_new (TREE_TYPE (arg), arg); - return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (arg)), targ); - } - - if (TREE_CODE (arg) == SAVE_EXPR && TREE_CODE (targ) == INDIRECT_REF) - return build (SAVE_EXPR, build_pointer_type (TREE_TYPE (arg)), - TREE_OPERAND (targ, 0), current_function_decl, NULL); - } - - /* Don't let anything else be handled specially. */ - return 0; -} - -/* Mark EXP saying that we need to be able to take the - address of it; it should not be allocated in a register. - Value is 1 if successful. - - C++: we do not allow `current_class_ptr' to be addressable. */ - -int -mark_addressable (exp) - tree exp; -{ - register tree x = exp; - - if (TREE_ADDRESSABLE (x) == 1) - return 1; - - while (1) - switch (TREE_CODE (x)) - { - case ADDR_EXPR: - case COMPONENT_REF: - case ARRAY_REF: - case REALPART_EXPR: - case IMAGPART_EXPR: - x = TREE_OPERAND (x, 0); - break; - - case PARM_DECL: - if (x == current_class_ptr) - { - if (! flag_this_is_variable) - error ("address of `this' not available"); - TREE_ADDRESSABLE (x) = 1; /* so compiler doesn't die later */ - put_var_into_stack (x); - return 1; - } - case VAR_DECL: - if (TREE_STATIC (x) && TREE_READONLY (x) - && DECL_RTL (x) != 0 - && ! DECL_IN_MEMORY_P (x)) - { - /* We thought this would make a good constant variable, - but we were wrong. */ - push_obstacks_nochange (); - end_temporary_allocation (); - - TREE_ASM_WRITTEN (x) = 0; - DECL_RTL (x) = 0; - rest_of_decl_compilation (x, 0, - !DECL_FUNCTION_SCOPE_P (x), - 0); - TREE_ADDRESSABLE (x) = 1; - - pop_obstacks (); - - return 1; - } - /* Caller should not be trying to mark initialized - constant fields addressable. */ - my_friendly_assert (DECL_LANG_SPECIFIC (x) == 0 - || DECL_IN_AGGR_P (x) == 0 - || TREE_STATIC (x) - || DECL_EXTERNAL (x), 314); - - case CONST_DECL: - case RESULT_DECL: - if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x) - && !DECL_ARTIFICIAL (x) && extra_warnings) - cp_warning ("address requested for `%D', which is declared `register'", - x); - put_var_into_stack (x); - TREE_ADDRESSABLE (x) = 1; - return 1; - - case FUNCTION_DECL: - if (DECL_LANG_SPECIFIC (x) != 0) - { - x = DECL_MAIN_VARIANT (x); - /* We have to test both conditions here. The first may be - non-zero in the case of processing a default function. The - second may be non-zero in the case of a template function. */ - if (DECL_TEMPLATE_INFO (x) && !DECL_TEMPLATE_SPECIALIZATION (x)) - mark_used (x); - } - TREE_ADDRESSABLE (x) = 1; - TREE_USED (x) = 1; - TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1; - return 1; - - case CONSTRUCTOR: - TREE_ADDRESSABLE (x) = 1; - return 1; - - case TARGET_EXPR: - TREE_ADDRESSABLE (x) = 1; - mark_addressable (TREE_OPERAND (x, 0)); - return 1; - - default: - return 1; - } -} - -/* Build and return a conditional expression IFEXP ? OP1 : OP2. */ - -tree -build_x_conditional_expr (ifexp, op1, op2) - tree ifexp, op1, op2; -{ - if (processing_template_decl) - return build_min_nt (COND_EXPR, ifexp, op1, op2); - - return build_new_op (COND_EXPR, LOOKUP_NORMAL, ifexp, op1, op2); -} - -tree -build_conditional_expr (ifexp, op1, op2) - tree ifexp, op1, op2; -{ - register tree type1; - register tree type2; - register enum tree_code code1; - register enum tree_code code2; - register tree result_type = NULL_TREE; - - /* If second operand is omitted, it is the same as the first one; - make sure it is calculated only once. */ - if (op1 == 0) - { - if (pedantic) - pedwarn ("ANSI C++ forbids omitting the middle term of a ?: expression"); - ifexp = op1 = save_expr (ifexp); - } - - ifexp = cp_convert (boolean_type_node, ifexp); - - if (TREE_CODE (ifexp) == ERROR_MARK) - return error_mark_node; - - /* C++: REFERENCE_TYPES must be dereferenced. */ - type1 = TREE_TYPE (op1); - code1 = TREE_CODE (type1); - type2 = TREE_TYPE (op2); - code2 = TREE_CODE (type2); - - if (code1 == REFERENCE_TYPE) - { - op1 = convert_from_reference (op1); - type1 = TREE_TYPE (op1); - code1 = TREE_CODE (type1); - } - if (code2 == REFERENCE_TYPE) - { - op2 = convert_from_reference (op2); - type2 = TREE_TYPE (op2); - code2 = TREE_CODE (type2); - } - - /* Don't promote the operands separately if they promote - the same way. Return the unpromoted type and let the combined - value get promoted if necessary. */ - - if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2) - && code2 != ARRAY_TYPE - && code2 != FUNCTION_TYPE - && code2 != METHOD_TYPE) - { - tree result; - - if (TREE_CONSTANT (ifexp) - && (TREE_CODE (ifexp) == INTEGER_CST - || TREE_CODE (ifexp) == ADDR_EXPR)) - return (integer_zerop (ifexp) ? op2 : op1); - - if (TREE_CODE (op1) == CONST_DECL) - op1 = DECL_INITIAL (op1); - else if (TREE_READONLY_DECL_P (op1)) - op1 = decl_constant_value (op1); - if (TREE_CODE (op2) == CONST_DECL) - op2 = DECL_INITIAL (op2); - else if (TREE_READONLY_DECL_P (op2)) - op2 = decl_constant_value (op2); - if (type1 != type2) - type1 = cp_build_qualified_type - (type1, (CP_TYPE_QUALS (TREE_TYPE (op1)) - | CP_TYPE_QUALS (TREE_TYPE (op2)))); - /* ??? This is a kludge to deal with the fact that - we don't sort out integers and enums properly, yet. */ - result = fold (build (COND_EXPR, type1, ifexp, op1, op2)); - if (TREE_TYPE (result) != type1) - result = build1 (NOP_EXPR, type1, result); - /* Expand both sides into the same slot, - hopefully the target of the ?: expression. */ - if (TREE_CODE (op1) == TARGET_EXPR && TREE_CODE (op2) == TARGET_EXPR) - { - tree slot = build (VAR_DECL, TREE_TYPE (result)); - layout_decl (slot, 0); - result = build (TARGET_EXPR, TREE_TYPE (result), - slot, result, NULL_TREE, NULL_TREE); - } - return result; - } - - /* They don't match; promote them both and then try to reconcile them. - But don't permit mismatching enum types. */ - if (code1 == ENUMERAL_TYPE) - { - if (code2 == ENUMERAL_TYPE) - { - cp_error ("enumeral mismatch in conditional expression: `%T' vs `%T'", - type1, type2); - return error_mark_node; - } - else if (extra_warnings && ! IS_AGGR_TYPE_CODE (code2) - && type2 != type_promotes_to (type1)) - warning ("enumeral and non-enumeral type in conditional expression"); - } - else if (extra_warnings - && code2 == ENUMERAL_TYPE && ! IS_AGGR_TYPE_CODE (code1) - && type1 != type_promotes_to (type2)) - warning ("enumeral and non-enumeral type in conditional expression"); - - if (code1 != VOID_TYPE) - { - op1 = default_conversion (op1); - type1 = TREE_TYPE (op1); - if (TYPE_PTRMEMFUNC_P (type1)) - type1 = TYPE_PTRMEMFUNC_FN_TYPE (type1); - code1 = TREE_CODE (type1); - } - if (code2 != VOID_TYPE) - { - op2 = default_conversion (op2); - type2 = TREE_TYPE (op2); - if (TYPE_PTRMEMFUNC_P (type2)) - type2 = TYPE_PTRMEMFUNC_FN_TYPE (type2); - code2 = TREE_CODE (type2); - } - - if (code1 == RECORD_TYPE && code2 == RECORD_TYPE - && real_lvalue_p (op1) && real_lvalue_p (op2) - && comptypes (type1, type2, COMPARE_BASE | COMPARE_RELAXED)) - { - type1 = build_reference_type (type1); - type2 = build_reference_type (type2); - result_type = common_type (type1, type2); - op1 = convert_to_reference (result_type, op1, CONV_IMPLICIT, - LOOKUP_NORMAL, NULL_TREE); - op2 = convert_to_reference (result_type, op2, CONV_IMPLICIT, - LOOKUP_NORMAL, NULL_TREE); - } - /* Quickly detect the usual case where op1 and op2 have the same type - after promotion. */ - else if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2)) - { - if (type1 == type2) - result_type = type1; - else - result_type = - cp_build_qualified_type (type1, - CP_TYPE_QUALS (TREE_TYPE (op1)) - | CP_TYPE_QUALS (TREE_TYPE (op2))); - } - else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE) - && (code2 == INTEGER_TYPE || code2 == REAL_TYPE)) - { - result_type = common_type (type1, type2); - } - else if (code1 == VOID_TYPE || code2 == VOID_TYPE) - { - if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE)) - pedwarn ("ANSI C++ forbids conditional expr with only one void side"); - result_type = void_type_node; - } - else if (code1 == POINTER_TYPE && null_ptr_cst_p (op2)) - result_type = qualify_type (type1, type2); - else if (code2 == POINTER_TYPE && null_ptr_cst_p (op1)) - result_type = qualify_type (type2, type1); - else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE) - { - if (comp_target_types (type1, type2, 1)) - result_type = common_type (type1, type2); - else if (TYPE_MAIN_VARIANT (TREE_TYPE (type1)) == void_type_node) - { - if (pedantic && TREE_CODE (type2) == FUNCTION_TYPE) - pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer"); - result_type = qualify_type (type1, type2); - } - else if (TYPE_MAIN_VARIANT (TREE_TYPE (type2)) == void_type_node) - { - if (pedantic && TREE_CODE (type1) == FUNCTION_TYPE) - pedwarn ("ANSI C++ forbids conditional expr between `void *' and function pointer"); - result_type = qualify_type (type2, type1); - } - /* C++ */ - else if (same_or_base_type_p (type2, type1)) - result_type = type2; - else if (IS_AGGR_TYPE (TREE_TYPE (type1)) - && IS_AGGR_TYPE (TREE_TYPE (type2)) - && (result_type = common_base_type (TREE_TYPE (type1), - TREE_TYPE (type2)))) - { - if (result_type == error_mark_node) - { - cp_error ("common base type of types `%T' and `%T' is ambiguous", - TREE_TYPE (type1), TREE_TYPE (type2)); - result_type = ptr_type_node; - } - else - { - if (pedantic - && result_type != TREE_TYPE (type1) - && result_type != TREE_TYPE (type2)) - cp_pedwarn ("`%T' and `%T' converted to `%T *' in conditional expression", - type1, type2, result_type); - - result_type = build_pointer_type (result_type); - } - } - else - { - pedwarn ("pointer type mismatch in conditional expression"); - result_type = ptr_type_node; - } - } - else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE) - { - pedwarn ("pointer/integer type mismatch in conditional expression"); - result_type = type1; - } - else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE) - { - pedwarn ("pointer/integer type mismatch in conditional expression"); - result_type = type2; - } - if (type2 == unknown_type_node) - result_type = type1; - else if (type1 == unknown_type_node) - result_type = type2; - - if (!result_type) - { - /* The match does not look good. If either is - an aggregate value, try converting to a scalar type. */ - if (code1 == RECORD_TYPE && code2 == RECORD_TYPE) - { - cp_error ("aggregate mismatch in conditional expression: `%T' vs `%T'", - type1, type2); - return error_mark_node; - } - /* Warning: this code assumes that conversion between cv-variants of - a type is done using NOP_EXPRs. */ - if (code1 == RECORD_TYPE && TYPE_HAS_CONVERSION (type1)) - { - /* There are other types besides pointers and records. */ - tree tmp; - if (code2 == POINTER_TYPE) - tmp = build_pointer_type - (cp_build_qualified_type (TREE_TYPE (type2), - TYPE_QUAL_CONST - | TYPE_QUAL_VOLATILE - | TYPE_QUAL_RESTRICT)); - else - tmp = type2; - tmp = build_type_conversion (CONVERT_EXPR, tmp, op1, 0); - if (tmp == NULL_TREE) - { - cp_error ("incompatible types `%T' and `%T' in `?:'", - type1, type2); - return error_mark_node; - } - if (tmp == error_mark_node) - error ("ambiguous pointer conversion"); - else - STRIP_NOPS (tmp); - result_type = common_type (type2, TREE_TYPE (tmp)); - op1 = tmp; - } - else if (code2 == RECORD_TYPE && TYPE_HAS_CONVERSION (type2)) - { - tree tmp; - if (code1 == POINTER_TYPE) - tmp = build_pointer_type - (cp_build_qualified_type (TREE_TYPE (type1), - TYPE_QUAL_CONST - | TYPE_QUAL_VOLATILE - | TYPE_QUAL_RESTRICT)); - else - tmp = type1; - - tmp = build_type_conversion (CONVERT_EXPR, tmp, op2, 0); - if (tmp == NULL_TREE) - { - cp_error ("incompatible types `%T' and `%T' in `?:'", - type1, type2); - return error_mark_node; - } - if (tmp == error_mark_node) - error ("ambiguous pointer conversion"); - else - STRIP_NOPS (tmp); - result_type = common_type (type1, TREE_TYPE (tmp)); - op2 = tmp; - } - else if (flag_cond_mismatch) - result_type = void_type_node; - else - { - error ("type mismatch in conditional expression"); - return error_mark_node; - } - } - - if (TREE_CODE (result_type) == POINTER_TYPE - && TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE) - result_type = build_ptrmemfunc_type (result_type); - - if (result_type != TREE_TYPE (op1)) - op1 = convert_for_initialization - (NULL_TREE, result_type, op1, LOOKUP_NORMAL, "converting", NULL_TREE, 0); - if (result_type != TREE_TYPE (op2)) - op2 = convert_for_initialization - (NULL_TREE, result_type, op2, LOOKUP_NORMAL, "converting", NULL_TREE, 0); - - if (TREE_CODE (ifexp) == INTEGER_CST) - return integer_zerop (ifexp) ? op2 : op1; - - return convert_from_reference - (fold (build (COND_EXPR, result_type, ifexp, op1, op2))); -} - -/* Handle overloading of the ',' operator when needed. Otherwise, - this function just builds an expression list. */ - -tree -build_x_compound_expr (list) - tree list; -{ - tree rest = TREE_CHAIN (list); - tree result; - - if (processing_template_decl) - return build_min_nt (COMPOUND_EXPR, list, NULL_TREE); - - if (rest == NULL_TREE) - return build_compound_expr (list); - - result = build_opfncall (COMPOUND_EXPR, LOOKUP_NORMAL, - TREE_VALUE (list), TREE_VALUE (rest), NULL_TREE); - if (result) - return build_x_compound_expr (expr_tree_cons (NULL_TREE, result, - TREE_CHAIN (rest))); - - if (! TREE_SIDE_EFFECTS (TREE_VALUE (list))) - { - /* the left-hand operand of a comma expression is like an expression - statement: we should warn if it doesn't have any side-effects, - unless it was explicitly cast to (void). */ - if ((extra_warnings || warn_unused) - && !(TREE_CODE (TREE_VALUE(list)) == CONVERT_EXPR - && TREE_TYPE (TREE_VALUE(list)) == void_type_node)) - warning("left-hand operand of comma expression has no effect"); - } -#if 0 /* this requires a gcc backend patch to export warn_if_unused_value */ - else if (warn_unused) - warn_if_unused_value (TREE_VALUE(list)); -#endif - - return build_compound_expr - (expr_tree_cons (NULL_TREE, TREE_VALUE (list), - build_expr_list (NULL_TREE, - build_x_compound_expr (rest)))); -} - -/* Given a list of expressions, return a compound expression - that performs them all and returns the value of the last of them. */ - -tree -build_compound_expr (list) - tree list; -{ - register tree rest; - - if (TREE_READONLY_DECL_P (TREE_VALUE (list))) - TREE_VALUE (list) = decl_constant_value (TREE_VALUE (list)); - - if (TREE_CHAIN (list) == 0) - { - /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue. - Strip such NOP_EXPRs, since LIST is used in non-lvalue context. */ - if (TREE_CODE (list) == NOP_EXPR - && TREE_TYPE (list) == TREE_TYPE (TREE_OPERAND (list, 0))) - list = TREE_OPERAND (list, 0); - - /* Convert arrays to pointers. */ - if (TREE_CODE (TREE_TYPE (TREE_VALUE (list))) == ARRAY_TYPE) - return default_conversion (TREE_VALUE (list)); - else - return TREE_VALUE (list); - } - - rest = build_compound_expr (TREE_CHAIN (list)); - - /* When pedantic, a compound expression cannot be a constant expression. */ - if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)) && ! pedantic) - return rest; - - return build (COMPOUND_EXPR, TREE_TYPE (rest), - break_out_cleanups (TREE_VALUE (list)), rest); -} - -tree -build_static_cast (type, expr) - tree type, expr; -{ - tree intype, binfo; - int ok; - - if (type == error_mark_node || expr == error_mark_node) - return error_mark_node; - - if (TREE_CODE (expr) == OFFSET_REF) - expr = resolve_offset_ref (expr); - - if (processing_template_decl) - { - tree t = build_min (STATIC_CAST_EXPR, copy_to_permanent (type), - expr); - return t; - } - - /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue. - Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */ - if (TREE_CODE (type) != REFERENCE_TYPE - && TREE_CODE (expr) == NOP_EXPR - && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0))) - expr = TREE_OPERAND (expr, 0); - - if (TREE_CODE (type) == VOID_TYPE) - return build1 (CONVERT_EXPR, type, expr); - - if (TREE_CODE (type) == REFERENCE_TYPE) - return (convert_from_reference - (convert_to_reference (type, expr, CONV_STATIC|CONV_IMPLICIT, - LOOKUP_COMPLAIN, NULL_TREE))); - - if (IS_AGGR_TYPE (type)) - return build_cplus_new - (type, (build_method_call - (NULL_TREE, ctor_identifier, build_expr_list (NULL_TREE, expr), - TYPE_BINFO (type), LOOKUP_NORMAL))); - - expr = decay_conversion (expr); - intype = TREE_TYPE (expr); - - /* FIXME handle casting to array type. */ - - ok = 0; - if (can_convert_arg (type, intype, expr)) - ok = 1; - else if (TYPE_PTROB_P (type) && TYPE_PTROB_P (intype)) - { - tree binfo; - if (IS_AGGR_TYPE (TREE_TYPE (type)) && IS_AGGR_TYPE (TREE_TYPE (intype)) - && at_least_as_qualified_p (TREE_TYPE (type), - TREE_TYPE (intype)) - && (binfo = get_binfo (TREE_TYPE (intype), TREE_TYPE (type), 0)) - && ! TREE_VIA_VIRTUAL (binfo)) - ok = 1; - } - else if (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype)) - { - if (same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type))), - TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (intype)))) - && at_least_as_qualified_p (TREE_TYPE (TREE_TYPE (type)), - TREE_TYPE (TREE_TYPE (intype))) - && (binfo = get_binfo (TYPE_OFFSET_BASETYPE (TREE_TYPE (type)), - TYPE_OFFSET_BASETYPE (TREE_TYPE (intype)), 0)) - && ! TREE_VIA_VIRTUAL (binfo)) - ok = 1; - } - else if (TREE_CODE (intype) != BOOLEAN_TYPE - && TREE_CODE (type) != ARRAY_TYPE - && TREE_CODE (type) != FUNCTION_TYPE - && can_convert (intype, type)) - ok = 1; - - if (ok) - return build_c_cast (type, expr); - - cp_error ("static_cast from `%T' to `%T'", intype, type); - return error_mark_node; -} - -tree -build_reinterpret_cast (type, expr) - tree type, expr; -{ - tree intype; - - if (type == error_mark_node || expr == error_mark_node) - return error_mark_node; - - if (TREE_CODE (expr) == OFFSET_REF) - expr = resolve_offset_ref (expr); - - if (processing_template_decl) - { - tree t = build_min (REINTERPRET_CAST_EXPR, - copy_to_permanent (type), expr); - return t; - } - - if (TREE_CODE (type) != REFERENCE_TYPE) - { - expr = decay_conversion (expr); - - /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue. - Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */ - if (TREE_CODE (expr) == NOP_EXPR - && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0))) - expr = TREE_OPERAND (expr, 0); - } - - intype = TREE_TYPE (expr); - - if (TREE_CODE (type) == REFERENCE_TYPE) - { - if (! real_lvalue_p (expr)) - { - cp_error ("reinterpret_cast from `%T' rvalue to `%T'", intype, type); - return error_mark_node; - } - expr = build_unary_op (ADDR_EXPR, expr, 0); - if (expr != error_mark_node) - expr = build_reinterpret_cast - (build_pointer_type (TREE_TYPE (type)), expr); - if (expr != error_mark_node) - expr = build_indirect_ref (expr, 0); - return expr; - } - else if (same_type_p (TYPE_MAIN_VARIANT (intype), - TYPE_MAIN_VARIANT (type))) - return build_static_cast (type, expr); - - if (TYPE_PTR_P (type) && (TREE_CODE (intype) == INTEGER_TYPE - || TREE_CODE (intype) == ENUMERAL_TYPE)) - /* OK */; - else if (TREE_CODE (type) == INTEGER_TYPE && TYPE_PTR_P (intype)) - { - if (TYPE_PRECISION (type) < TYPE_PRECISION (intype)) - cp_pedwarn ("reinterpret_cast from `%T' to `%T' loses precision", - intype, type); - } - else if ((TYPE_PTRFN_P (type) && TYPE_PTRFN_P (intype)) - || (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype))) - { - if (TREE_READONLY_DECL_P (expr)) - expr = decl_constant_value (expr); - return fold (build1 (NOP_EXPR, type, expr)); - } - else if ((TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (intype)) - || (TYPE_PTROBV_P (type) && TYPE_PTROBV_P (intype))) - { - if (! comp_ptr_ttypes_reinterpret (TREE_TYPE (type), TREE_TYPE (intype))) - cp_pedwarn ("reinterpret_cast from `%T' to `%T' casts away const (or volatile)", - intype, type); - - if (TREE_READONLY_DECL_P (expr)) - expr = decl_constant_value (expr); - return fold (build1 (NOP_EXPR, type, expr)); - } - else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype)) - || (TYPE_PTRFN_P (intype) && TYPE_PTROBV_P (type))) - { - pedwarn ("ANSI C++ forbids casting between pointers to functions and objects"); - if (TREE_READONLY_DECL_P (expr)) - expr = decl_constant_value (expr); - return fold (build1 (NOP_EXPR, type, expr)); - } - else - { - cp_error ("reinterpret_cast from `%T' to `%T'", intype, type); - return error_mark_node; - } - - return cp_convert (type, expr); -} - -tree -build_const_cast (type, expr) - tree type, expr; -{ - tree intype; - - if (type == error_mark_node || expr == error_mark_node) - return error_mark_node; - - if (TREE_CODE (expr) == OFFSET_REF) - expr = resolve_offset_ref (expr); - - if (processing_template_decl) - { - tree t = build_min (CONST_CAST_EXPR, copy_to_permanent (type), - expr); - return t; - } - - if (TREE_CODE (type) != REFERENCE_TYPE) - { - expr = decay_conversion (expr); - - /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue. - Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */ - if (TREE_CODE (expr) == NOP_EXPR - && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0))) - expr = TREE_OPERAND (expr, 0); - } - - intype = TREE_TYPE (expr); - - if (same_type_p (TYPE_MAIN_VARIANT (intype), TYPE_MAIN_VARIANT (type))) - return build_static_cast (type, expr); - else if (TREE_CODE (type) == REFERENCE_TYPE) - { - if (! real_lvalue_p (expr)) - { - cp_error ("const_cast from `%T' rvalue to `%T'", intype, type); - return error_mark_node; - } - - if (comp_ptr_ttypes_const (TREE_TYPE (type), intype)) - { - expr = build_unary_op (ADDR_EXPR, expr, 0); - expr = build1 (NOP_EXPR, type, expr); - return convert_from_reference (expr); - } - } - else if (TREE_CODE (type) == POINTER_TYPE - && TREE_CODE (intype) == POINTER_TYPE - && comp_ptr_ttypes_const (TREE_TYPE (type), TREE_TYPE (intype))) - return cp_convert (type, expr); - - cp_error ("const_cast from `%T' to `%T'", intype, type); - return error_mark_node; -} - -/* Build an expression representing a cast to type TYPE of expression EXPR. - - ALLOW_NONCONVERTING is true if we should allow non-converting constructors - when doing the cast. */ - -tree -build_c_cast (type, expr) - tree type, expr; -{ - register tree value = expr; - tree otype; - - if (type == error_mark_node || expr == error_mark_node) - return error_mark_node; - - /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue. - Strip such NOP_EXPRs if VALUE is being used in non-lvalue context. */ - if (TREE_CODE (type) != REFERENCE_TYPE - && TREE_CODE (value) == NOP_EXPR - && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0))) - value = TREE_OPERAND (value, 0); - - if (TREE_TYPE (expr) - && TREE_CODE (TREE_TYPE (expr)) == OFFSET_TYPE - && TREE_CODE (type) != OFFSET_TYPE) - value = resolve_offset_ref (value); - - if (TREE_CODE (type) == ARRAY_TYPE) - { - /* Allow casting from T1* to T2[] because Cfront allows it. - NIHCL uses it. It is not valid ANSI C however, and hence, not - valid ANSI C++. */ - if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE) - { - if (pedantic) - pedwarn ("ANSI C++ forbids casting to an array type"); - type = build_pointer_type (TREE_TYPE (type)); - } - else - { - error ("ANSI C++ forbids casting to an array type"); - return error_mark_node; - } - } - - if (TREE_CODE (type) == FUNCTION_TYPE - || TREE_CODE (type) == METHOD_TYPE) - { - cp_error ("casting to function type `%T'", type); - return error_mark_node; - } - - if (IS_SIGNATURE (type)) - { - error ("cast specifies signature type"); - return error_mark_node; - } - - if (processing_template_decl) - { - tree t = build_min (CAST_EXPR, type, - min_tree_cons (NULL_TREE, value, NULL_TREE)); - return t; - } - - /* Convert functions and arrays to pointers and - convert references to their expanded types, - but don't convert any other types. If, however, we are - casting to a class type, there's no reason to do this: the - cast will only succeed if there is a converting constructor, - and the default conversions will be done at that point. In - fact, doing the default conversion here is actually harmful - in cases like this: - - typedef int A[2]; - struct S { S(const A&); }; - - since we don't want the array-to-pointer conversion done. */ - if (!IS_AGGR_TYPE (type)) - { - if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE - || (TREE_CODE (TREE_TYPE (value)) == METHOD_TYPE - /* Don't do the default conversion on a ->* expression. */ - && ! (TREE_CODE (type) == POINTER_TYPE - && bound_pmf_p (value))) - || TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE - || TREE_CODE (TREE_TYPE (value)) == REFERENCE_TYPE) - value = default_conversion (value); - } - else if (TREE_CODE (TREE_TYPE (value)) == REFERENCE_TYPE) - /* However, even for class types, we still need to strip away - the reference type, since the call to convert_force below - does not expect the input expression to be of reference - type. */ - value = convert_from_reference (value); - - otype = TREE_TYPE (value); - - /* Optionally warn about potentially worrisome casts. */ - - if (warn_cast_qual - && TREE_CODE (type) == POINTER_TYPE - && TREE_CODE (otype) == POINTER_TYPE - && !at_least_as_qualified_p (TREE_TYPE (type), - TREE_TYPE (otype))) - cp_warning ("cast discards qualifiers from pointer target type"); - - /* Warn about possible alignment problems. */ - if (STRICT_ALIGNMENT && warn_cast_align - && TREE_CODE (type) == POINTER_TYPE - && TREE_CODE (otype) == POINTER_TYPE - && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE - && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE - && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype))) - warning ("cast increases required alignment of target type"); - -#if 0 - /* We should see about re-enabling these, they seem useful to - me. */ - if (TREE_CODE (type) == INTEGER_TYPE - && TREE_CODE (otype) == POINTER_TYPE - && TYPE_PRECISION (type) != TYPE_PRECISION (otype)) - warning ("cast from pointer to integer of different size"); - - if (TREE_CODE (type) == POINTER_TYPE - && TREE_CODE (otype) == INTEGER_TYPE - && TYPE_PRECISION (type) != TYPE_PRECISION (otype) - /* Don't warn about converting 0 to pointer, - provided the 0 was explicit--not cast or made by folding. */ - && !(TREE_CODE (value) == INTEGER_CST && integer_zerop (value))) - warning ("cast to pointer from integer of different size"); -#endif - - if (TREE_CODE (type) == REFERENCE_TYPE) - value = (convert_from_reference - (convert_to_reference (type, value, CONV_C_CAST, - LOOKUP_COMPLAIN, NULL_TREE))); - else - { - tree ovalue; - - if (TREE_READONLY_DECL_P (value)) - value = decl_constant_value (value); - - ovalue = value; - value = convert_force (type, value, CONV_C_CAST); - - /* Ignore any integer overflow caused by the cast. */ - if (TREE_CODE (value) == INTEGER_CST) - { - TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue); - TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue); - } - } - - /* Always produce some operator for an explicit cast, - so we can tell (for -pedantic) that the cast is no lvalue. */ - if (TREE_CODE (type) != REFERENCE_TYPE && value == expr - && real_lvalue_p (value)) - value = non_lvalue (value); - - return value; -} - -/* Build an assignment expression of lvalue LHS from value RHS. - MODIFYCODE is the code for a binary operator that we use - to combine the old value of LHS with RHS to get the new value. - Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. - - C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */ - -tree -build_modify_expr (lhs, modifycode, rhs) - tree lhs; - enum tree_code modifycode; - tree rhs; -{ - register tree result; - tree newrhs = rhs; - tree lhstype = TREE_TYPE (lhs); - tree olhstype = lhstype; - tree olhs = lhs; - - /* Avoid duplicate error messages from operands that had errors. */ - if (lhs == error_mark_node || rhs == error_mark_node) - return error_mark_node; - - /* Types that aren't fully specified cannot be used in assignments. */ - lhs = require_complete_type (lhs); - - newrhs = rhs; - - /* Handle assignment to signature pointers/refs. */ - - if (TYPE_LANG_SPECIFIC (lhstype) - && (IS_SIGNATURE_POINTER (lhstype) || IS_SIGNATURE_REFERENCE (lhstype))) - { - return build_signature_pointer_constructor (lhs, rhs); - } - - /* Handle control structure constructs used as "lvalues". */ - - switch (TREE_CODE (lhs)) - { - /* Handle --foo = 5; as these are valid constructs in C++ */ - case PREDECREMENT_EXPR: - case PREINCREMENT_EXPR: - if (TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0))) - lhs = build (TREE_CODE (lhs), TREE_TYPE (lhs), - stabilize_reference (TREE_OPERAND (lhs, 0)), - TREE_OPERAND (lhs, 1)); - return build (COMPOUND_EXPR, lhstype, - lhs, - build_modify_expr (TREE_OPERAND (lhs, 0), - modifycode, rhs)); - - /* Handle (a, b) used as an "lvalue". */ - case COMPOUND_EXPR: - newrhs = build_modify_expr (TREE_OPERAND (lhs, 1), - modifycode, rhs); - if (newrhs == error_mark_node) - return error_mark_node; - return build (COMPOUND_EXPR, lhstype, - TREE_OPERAND (lhs, 0), newrhs); - - case MODIFY_EXPR: - newrhs = build_modify_expr (TREE_OPERAND (lhs, 0), modifycode, rhs); - if (newrhs == error_mark_node) - return error_mark_node; - return build (COMPOUND_EXPR, lhstype, lhs, newrhs); - - /* Handle (a ? b : c) used as an "lvalue". */ - case COND_EXPR: - rhs = save_expr (rhs); - { - /* Produce (a ? (b = rhs) : (c = rhs)) - except that the RHS goes through a save-expr - so the code to compute it is only emitted once. */ - tree cond - = build_conditional_expr (TREE_OPERAND (lhs, 0), - build_modify_expr (cp_convert (TREE_TYPE (lhs), TREE_OPERAND (lhs, 1)), - modifycode, rhs), - build_modify_expr (cp_convert (TREE_TYPE (lhs), TREE_OPERAND (lhs, 2)), - modifycode, rhs)); - if (cond == error_mark_node) - return cond; - /* Make sure the code to compute the rhs comes out - before the split. */ - return build (COMPOUND_EXPR, TREE_TYPE (lhs), - /* Case to void to suppress warning - from warn_if_unused_value. */ - cp_convert (void_type_node, rhs), cond); - } - - default: - break; - } - - if (TREE_CODE (lhs) == OFFSET_REF) - { - if (TREE_OPERAND (lhs, 0) == NULL_TREE) - { - /* Static class member? */ - tree member = TREE_OPERAND (lhs, 1); - if (TREE_CODE (member) == VAR_DECL) - lhs = member; - else - { - compiler_error ("invalid static class member"); - return error_mark_node; - } - } - else - lhs = resolve_offset_ref (lhs); - - olhstype = lhstype = TREE_TYPE (lhs); - } - - if (TREE_CODE (lhstype) == REFERENCE_TYPE - && modifycode != INIT_EXPR) - { - lhs = convert_from_reference (lhs); - olhstype = lhstype = TREE_TYPE (lhs); - } - - /* If a binary op has been requested, combine the old LHS value with the RHS - producing the value we should actually store into the LHS. */ - - if (modifycode == INIT_EXPR) - { - if (! IS_AGGR_TYPE (lhstype)) - /* Do the default thing */; - else - { - result = build_method_call (lhs, ctor_identifier, - build_expr_list (NULL_TREE, rhs), - TYPE_BINFO (lhstype), LOOKUP_NORMAL); - if (result == NULL_TREE) - return error_mark_node; - return result; - } - } - else if (modifycode == NOP_EXPR) - { - /* `operator=' is not an inheritable operator. */ - if (! IS_AGGR_TYPE (lhstype)) - /* Do the default thing */; - else - { - result = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL, - lhs, rhs, make_node (NOP_EXPR)); - if (result == NULL_TREE) - return error_mark_node; - return result; - } - lhstype = olhstype; - } - else if (PROMOTES_TO_AGGR_TYPE (lhstype, REFERENCE_TYPE)) - { - my_friendly_abort (978652); - } - else - { - lhs = stabilize_reference (lhs); - newrhs = build_binary_op (modifycode, lhs, rhs, 1); - if (newrhs == error_mark_node) - { - cp_error (" in evaluation of `%Q(%#T, %#T)'", modifycode, - TREE_TYPE (lhs), TREE_TYPE (rhs)); - return error_mark_node; - } - } - - /* Handle a cast used as an "lvalue". - We have already performed any binary operator using the value as cast. - Now convert the result to the cast type of the lhs, - and then true type of the lhs and store it there; - then convert result back to the cast type to be the value - of the assignment. */ - - switch (TREE_CODE (lhs)) - { - case NOP_EXPR: - case CONVERT_EXPR: - case FLOAT_EXPR: - case FIX_TRUNC_EXPR: - case FIX_FLOOR_EXPR: - case FIX_ROUND_EXPR: - case FIX_CEIL_EXPR: - if (TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE - || TREE_CODE (TREE_TYPE (newrhs)) == FUNCTION_TYPE - || TREE_CODE (TREE_TYPE (newrhs)) == METHOD_TYPE - || TREE_CODE (TREE_TYPE (newrhs)) == OFFSET_TYPE) - newrhs = default_conversion (newrhs); - { - tree inner_lhs = TREE_OPERAND (lhs, 0); - tree result; - - /* WP 5.4.1: The result is an lvalue if T is a reference type, - otherwise the result is an rvalue. */ - if (! lvalue_p (lhs)) - pedwarn ("ANSI C++ forbids cast to non-reference type used as lvalue"); - - result = build_modify_expr (inner_lhs, NOP_EXPR, - cp_convert (TREE_TYPE (inner_lhs), - cp_convert (lhstype, newrhs))); - if (result == error_mark_node) - return result; - return cp_convert (TREE_TYPE (lhs), result); - } - - default: - break; - } - - /* Now we have handled acceptable kinds of LHS that are not truly lvalues. - Reject anything strange now. */ - - if (!lvalue_or_else (lhs, "assignment")) - return error_mark_node; - - GNU_xref_assign (lhs); - - /* Warn about storing in something that is `const'. */ - /* For C++, don't warn if this is initialization. */ - if (modifycode != INIT_EXPR - /* For assignment to `const' signature pointer/reference fields, - don't warn either, we already printed a better message before. */ - && ! (TREE_CODE (lhs) == COMPONENT_REF - && (IS_SIGNATURE_POINTER (TREE_TYPE (TREE_OPERAND (lhs, 0))) - || IS_SIGNATURE_REFERENCE (TREE_TYPE (TREE_OPERAND (lhs, 0))))) - && (TREE_READONLY (lhs) || CP_TYPE_CONST_P (lhstype) - /* Functions are not modifiable, even though they are - lvalues. */ - || TREE_CODE (TREE_TYPE (lhs)) == FUNCTION_TYPE - || ((TREE_CODE (lhstype) == RECORD_TYPE - || TREE_CODE (lhstype) == UNION_TYPE) - && C_TYPE_FIELDS_READONLY (lhstype)) - || (TREE_CODE (lhstype) == REFERENCE_TYPE - && CP_TYPE_CONST_P (TREE_TYPE (lhstype))))) - readonly_error (lhs, "assignment", 0); - - /* If storing into a structure or union member, - it has probably been given type `int'. - Compute the type that would go with - the actual amount of storage the member occupies. */ - - if (TREE_CODE (lhs) == COMPONENT_REF - && (TREE_CODE (lhstype) == INTEGER_TYPE - || TREE_CODE (lhstype) == REAL_TYPE - || TREE_CODE (lhstype) == ENUMERAL_TYPE)) - { - lhstype = TREE_TYPE (get_unwidened (lhs, 0)); - - /* If storing in a field that is in actuality a short or narrower - than one, we must store in the field in its actual type. */ - - if (lhstype != TREE_TYPE (lhs)) - { - lhs = copy_node (lhs); - TREE_TYPE (lhs) = lhstype; - } - } - - /* check to see if there is an assignment to `this' */ - if (lhs == current_class_ptr) - { - if (flag_this_is_variable > 0 - && DECL_NAME (current_function_decl) != NULL_TREE - && (DECL_NAME (current_function_decl) - != constructor_name (current_class_type))) - warning ("assignment to `this' not in constructor or destructor"); - current_function_just_assigned_this = 1; - } - - if (modifycode != INIT_EXPR) - { - /* Make modifycode now either a NOP_EXPR or an INIT_EXPR. */ - modifycode = NOP_EXPR; - /* Reference-bashing */ - if (TREE_CODE (lhstype) == REFERENCE_TYPE) - { - tree tmp = convert_from_reference (lhs); - lhstype = TREE_TYPE (tmp); - if (TYPE_SIZE (lhstype) == 0) - { - incomplete_type_error (lhs, lhstype); - return error_mark_node; - } - lhs = tmp; - olhstype = lhstype; - } - if (TREE_CODE (TREE_TYPE (newrhs)) == REFERENCE_TYPE) - { - tree tmp = convert_from_reference (newrhs); - if (TYPE_SIZE (TREE_TYPE (tmp)) == 0) - { - incomplete_type_error (newrhs, TREE_TYPE (tmp)); - return error_mark_node; - } - newrhs = tmp; - } - } - - if (TREE_SIDE_EFFECTS (lhs)) - lhs = stabilize_reference (lhs); - if (TREE_SIDE_EFFECTS (newrhs)) - newrhs = stabilize_reference (newrhs); - - /* Convert new value to destination type. */ - - if (TREE_CODE (lhstype) == ARRAY_TYPE) - { - int from_array; - - if (!same_or_base_type_p (lhstype, TREE_TYPE (rhs))) - { - cp_error ("incompatible types in assignment of `%T' to `%T'", - TREE_TYPE (rhs), lhstype); - return error_mark_node; - } - - /* Allow array assignment in compiler-generated code. */ - if (pedantic && ! DECL_ARTIFICIAL (current_function_decl)) - pedwarn ("ANSI C++ forbids assignment of arrays"); - - /* Have to wrap this in RTL_EXPR for two cases: - in base or member initialization and if we - are a branch of a ?: operator. Since we - can't easily know the latter, just do it always. */ - - result = make_node (RTL_EXPR); - - TREE_TYPE (result) = void_type_node; - do_pending_stack_adjust (); - start_sequence_for_rtl_expr (result); - - /* As a matter of principle, `start_sequence' should do this. */ - emit_note (0, -1); - - from_array = TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE - ? 1 + (modifycode != INIT_EXPR): 0; - expand_vec_init (lhs, lhs, array_type_nelts (lhstype), newrhs, - from_array); - - do_pending_stack_adjust (); - - TREE_SIDE_EFFECTS (result) = 1; - RTL_EXPR_SEQUENCE (result) = get_insns (); - RTL_EXPR_RTL (result) = const0_rtx; - end_sequence (); - return result; - } - - if (modifycode == INIT_EXPR) - { - newrhs = convert_for_initialization (lhs, lhstype, newrhs, LOOKUP_NORMAL, - "assignment", NULL_TREE, 0); - if (lhs == DECL_RESULT (current_function_decl)) - { - if (DECL_INITIAL (lhs)) - warning ("return value from function receives multiple initializations"); - DECL_INITIAL (lhs) = newrhs; - } - } - else - { - /* Avoid warnings on enum bit fields. */ - if (TREE_CODE (olhstype) == ENUMERAL_TYPE - && TREE_CODE (lhstype) == INTEGER_TYPE) - { - newrhs = convert_for_assignment (olhstype, newrhs, "assignment", - NULL_TREE, 0); - newrhs = convert_force (lhstype, newrhs, 0); - } - else - newrhs = convert_for_assignment (lhstype, newrhs, "assignment", - NULL_TREE, 0); - if (TREE_CODE (newrhs) == CALL_EXPR - && TYPE_NEEDS_CONSTRUCTING (lhstype)) - newrhs = build_cplus_new (lhstype, newrhs); - - /* Can't initialize directly from a TARGET_EXPR, since that would - cause the lhs to be constructed twice, and possibly result in - accidental self-initialization. So we force the TARGET_EXPR to be - expanded without a target. */ - if (TREE_CODE (newrhs) == TARGET_EXPR) - newrhs = build (COMPOUND_EXPR, TREE_TYPE (newrhs), newrhs, - TREE_OPERAND (newrhs, 0)); - } - - if (newrhs == error_mark_node) - return error_mark_node; - - if (TREE_CODE (newrhs) == COND_EXPR) - { - tree lhs1; - tree cond = TREE_OPERAND (newrhs, 0); - - if (TREE_SIDE_EFFECTS (lhs)) - cond = build_compound_expr (tree_cons - (NULL_TREE, lhs, - build_expr_list (NULL_TREE, cond))); - - /* Cannot have two identical lhs on this one tree (result) as preexpand - calls will rip them out and fill in RTL for them, but when the - rtl is generated, the calls will only be in the first side of the - condition, not on both, or before the conditional jump! (mrs) */ - lhs1 = break_out_calls (lhs); - - if (lhs == lhs1) - /* If there's no change, the COND_EXPR behaves like any other rhs. */ - result = build (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR, - lhstype, lhs, newrhs); - else - { - tree result_type = TREE_TYPE (newrhs); - /* We have to convert each arm to the proper type because the - types may have been munged by constant folding. */ - result - = build (COND_EXPR, result_type, cond, - build_modify_expr (lhs, modifycode, - cp_convert (result_type, - TREE_OPERAND (newrhs, 1))), - build_modify_expr (lhs1, modifycode, - cp_convert (result_type, - TREE_OPERAND (newrhs, 2)))); - } - } - else - result = build (modifycode == NOP_EXPR ? MODIFY_EXPR : INIT_EXPR, - lhstype, lhs, newrhs); - - TREE_SIDE_EFFECTS (result) = 1; - - /* If we got the LHS in a different type for storing in, - convert the result back to the nominal type of LHS - so that the value we return always has the same type - as the LHS argument. */ - - if (olhstype == TREE_TYPE (result)) - return result; - /* Avoid warnings converting integral types back into enums - for enum bit fields. */ - if (TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE - && TREE_CODE (olhstype) == ENUMERAL_TYPE) - { - result = build (COMPOUND_EXPR, olhstype, result, olhs); - TREE_NO_UNUSED_WARNING (result) = 1; - return result; - } - return convert_for_assignment (olhstype, result, "assignment", - NULL_TREE, 0); -} - -tree -build_x_modify_expr (lhs, modifycode, rhs) - tree lhs; - enum tree_code modifycode; - tree rhs; -{ - if (processing_template_decl) - return build_min_nt (MODOP_EXPR, lhs, - build_min_nt (modifycode, NULL_TREE, NULL_TREE), rhs); - - if (modifycode != NOP_EXPR) - { - tree rval = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs, - make_node (modifycode)); - if (rval) - return rval; - } - return build_modify_expr (lhs, modifycode, rhs); -} - - -/* Get difference in deltas for different pointer to member function - types. Return integer_zero_node, if FROM cannot be converted to a - TO type. If FORCE is true, then allow reverse conversions as well. */ - -static tree -get_delta_difference (from, to, force) - tree from, to; - int force; -{ - tree delta = integer_zero_node; - tree binfo; - - if (to == from) - return delta; - - /* Should get_base_distance here, so we can check if any thing along the - path is virtual, and we need to make sure we stay - inside the real binfos when going through virtual bases. - Maybe we should replace virtual bases with - binfo_member (...CLASSTYPE_VBASECLASSES...)... (mrs) */ - binfo = get_binfo (from, to, 1); - if (binfo == error_mark_node) - { - error (" in pointer to member function conversion"); - return delta; - } - if (binfo == 0) - { - if (!force) - { - error_not_base_type (from, to); - error (" in pointer to member conversion"); - return delta; - } - binfo = get_binfo (to, from, 1); - if (binfo == 0 || binfo == error_mark_node) - return delta; - if (TREE_VIA_VIRTUAL (binfo)) - { - binfo = binfo_member (BINFO_TYPE (binfo), - CLASSTYPE_VBASECLASSES (from)); - cp_warning ("pointer to member cast to virtual base `%T'", - BINFO_TYPE (binfo)); - warning (" will only work if you are very careful"); - } - delta = BINFO_OFFSET (binfo); - delta = cp_convert (ptrdiff_type_node, delta); - - return build_binary_op (MINUS_EXPR, - integer_zero_node, - delta, 1); - } - - if (TREE_VIA_VIRTUAL (binfo)) - { - if (force) - { - cp_warning ("pointer to member cast from virtual base `%T'", - BINFO_TYPE (binfo)); - warning (" will only work if you are very careful"); - } - else - cp_error ("pointer to member conversion from virtual base `%T'", - BINFO_TYPE (binfo)); - } - - return BINFO_OFFSET (binfo); -} - -static tree -build_ptrmemfunc1 (type, delta, idx, pfn, delta2) - tree type, delta, idx, pfn, delta2; -{ - tree u; - -#if 0 - /* This is the old way we did it. We want to avoid calling - digest_init, so that it can give an error if we use { } when - initializing a pointer to member function. */ - - if (pfn) - { - u = build_nt (CONSTRUCTOR, NULL_TREE, - expr_tree_cons (pfn_identifier, pfn, NULL_TREE)); - } - else - { - u = build_nt (CONSTRUCTOR, NULL_TREE, - expr_tree_cons (delta2_identifier, delta2, NULL_TREE)); - } - - u = build_nt (CONSTRUCTOR, NULL_TREE, - expr_tree_cons (NULL_TREE, delta, - expr_tree_cons (NULL_TREE, idx, - expr_tree_cons (NULL_TREE, u, NULL_TREE)))); - - return digest_init (type, u, (tree*)0); -#else - tree delta_field, idx_field, pfn_or_delta2_field, pfn_field, delta2_field; - tree subtype; - int allconstant, allsimple; - - delta_field = TYPE_FIELDS (type); - idx_field = TREE_CHAIN (delta_field); - pfn_or_delta2_field = TREE_CHAIN (idx_field); - subtype = TREE_TYPE (pfn_or_delta2_field); - pfn_field = TYPE_FIELDS (subtype); - delta2_field = TREE_CHAIN (pfn_field); - - if (pfn) - { - allconstant = TREE_CONSTANT (pfn); - allsimple = !! initializer_constant_valid_p (pfn, TREE_TYPE (pfn)); - u = expr_tree_cons (pfn_field, pfn, NULL_TREE); - } - else - { - delta2 = convert_and_check (delta_type_node, delta2); - allconstant = TREE_CONSTANT (delta2); - allsimple = !! initializer_constant_valid_p (delta2, TREE_TYPE (delta2)); - u = expr_tree_cons (delta2_field, delta2, NULL_TREE); - } - - delta = convert_and_check (delta_type_node, delta); - idx = convert_and_check (delta_type_node, idx); - - allconstant = allconstant && TREE_CONSTANT (delta) && TREE_CONSTANT (idx); - allsimple = allsimple - && initializer_constant_valid_p (delta, TREE_TYPE (delta)) - && initializer_constant_valid_p (idx, TREE_TYPE (idx)); - - u = build (CONSTRUCTOR, subtype, NULL_TREE, u); - u = expr_tree_cons (delta_field, delta, - expr_tree_cons (idx_field, idx, - expr_tree_cons (pfn_or_delta2_field, u, NULL_TREE))); - u = build (CONSTRUCTOR, type, NULL_TREE, u); - TREE_CONSTANT (u) = allconstant; - TREE_STATIC (u) = allconstant && allsimple; - return u; -#endif -} - -/* Build a constructor for a pointer to member function. It can be - used to initialize global variables, local variable, or used - as a value in expressions. TYPE is the POINTER to METHOD_TYPE we - want to be. - - If FORCE is non-zero, then force this conversion, even if - we would rather not do it. Usually set when using an explicit - cast. - - Return error_mark_node, if something goes wrong. */ - -tree -build_ptrmemfunc (type, pfn, force) - tree type, pfn; - int force; -{ - tree idx = integer_zero_node; - tree delta = integer_zero_node; - tree delta2 = integer_zero_node; - tree vfield_offset; - tree npfn = NULL_TREE; - - /* Handle multiple conversions of pointer to member functions. */ - if (TYPE_PTRMEMFUNC_P (TREE_TYPE (pfn))) - { - tree ndelta, ndelta2; - tree e1, e2, e3, n; - tree pfn_type; - - /* Is is already the right type? */ - if (type == TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn))) - return pfn; - - pfn_type = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (pfn)); - if (!force - && comp_target_types (type, pfn_type, 1) != 1) - cp_error ("conversion to `%T' from `%T'", type, pfn_type); - - ndelta = cp_convert (ptrdiff_type_node, build_component_ref (pfn, delta_identifier, NULL_TREE, 0)); - ndelta2 = cp_convert (ptrdiff_type_node, DELTA2_FROM_PTRMEMFUNC (pfn)); - idx = build_component_ref (pfn, index_identifier, NULL_TREE, 0); - - n = get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (pfn_type)), - TYPE_METHOD_BASETYPE (TREE_TYPE (type)), - force); - - delta = build_binary_op (PLUS_EXPR, ndelta, n, 1); - delta2 = build_binary_op (PLUS_EXPR, ndelta2, n, 1); - e1 = fold (build (GT_EXPR, boolean_type_node, idx, integer_zero_node)); - - e2 = build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type), delta, idx, - NULL_TREE, delta2); - - pfn = PFN_FROM_PTRMEMFUNC (pfn); - npfn = build1 (NOP_EXPR, type, pfn); - TREE_CONSTANT (npfn) = TREE_CONSTANT (pfn); - - e3 = build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type), delta, idx, npfn, - NULL_TREE); - return build_conditional_expr (e1, e2, e3); - } - - /* Handle null pointer to member function conversions. */ - if (integer_zerop (pfn)) - { - pfn = build_c_cast (type, integer_zero_node); - return build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type), - integer_zero_node, integer_zero_node, - pfn, NULL_TREE); - } - - if (type_unknown_p (pfn)) - return instantiate_type (type, pfn, 1); - - if (!force - && comp_target_types (type, TREE_TYPE (pfn), 0) != 1) - cp_error ("conversion to `%T' from `%T'", type, TREE_TYPE (pfn)); - - /* Allow pointer to member conversions here. */ - delta = get_delta_difference (TYPE_METHOD_BASETYPE (TREE_TYPE (TREE_TYPE (pfn))), - TYPE_METHOD_BASETYPE (TREE_TYPE (type)), - force); - delta2 = build_binary_op (PLUS_EXPR, delta2, delta, 1); - - if (TREE_CODE (TREE_OPERAND (pfn, 0)) != FUNCTION_DECL) - warning ("assuming pointer to member function is non-virtual"); - - if (TREE_CODE (TREE_OPERAND (pfn, 0)) == FUNCTION_DECL - && DECL_VINDEX (TREE_OPERAND (pfn, 0))) - { - /* Find the offset to the vfield pointer in the object. */ - vfield_offset = get_binfo (DECL_CONTEXT (TREE_OPERAND (pfn, 0)), - DECL_CLASS_CONTEXT (TREE_OPERAND (pfn, 0)), - 0); - vfield_offset = get_vfield_offset (vfield_offset); - delta2 = size_binop (PLUS_EXPR, vfield_offset, delta2); - - /* Map everything down one to make room for the null pointer to member. */ - idx = size_binop (PLUS_EXPR, - DECL_VINDEX (TREE_OPERAND (pfn, 0)), - integer_one_node); - } - else - { - idx = size_binop (MINUS_EXPR, integer_zero_node, integer_one_node); - - if (type == TREE_TYPE (pfn)) - { - npfn = pfn; - } - else - { - npfn = build1 (NOP_EXPR, type, pfn); - TREE_CONSTANT (npfn) = TREE_CONSTANT (pfn); - } - } - - return build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type), delta, idx, npfn, delta2); -} - -/* Convert value RHS to type TYPE as preparation for an assignment - to an lvalue of type TYPE. - The real work of conversion is done by `convert'. - The purpose of this function is to generate error messages - for assignments that are not allowed in C. - ERRTYPE is a string to use in error messages: - "assignment", "return", etc. - - C++: attempts to allow `convert' to find conversions involving - implicit type conversion between aggregate and scalar types - as per 8.5.6 of C++ manual. Does not randomly dereference - pointers to aggregates! */ - -static tree -convert_for_assignment (type, rhs, errtype, fndecl, parmnum) - tree type, rhs; - char *errtype; - tree fndecl; - int parmnum; -{ - register enum tree_code codel = TREE_CODE (type); - register tree rhstype; - register enum tree_code coder = TREE_CODE (TREE_TYPE (rhs)); - - /* Issue warnings about peculiar, but legal, uses of NULL. */ - if (ARITHMETIC_TYPE_P (type) && rhs == null_node) - cp_warning ("converting NULL to non-pointer type"); - - if (coder == ERROR_MARK) - return error_mark_node; - - if (codel == OFFSET_TYPE) - { - type = TREE_TYPE (type); - codel = TREE_CODE (type); - } - - /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ - if (TREE_CODE (rhs) == NON_LVALUE_EXPR) - rhs = TREE_OPERAND (rhs, 0); - - if (rhs == error_mark_node) - return error_mark_node; - - if (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node) - return error_mark_node; - - if (TREE_CODE (TREE_TYPE (rhs)) == OFFSET_TYPE) - { - rhs = resolve_offset_ref (rhs); - if (rhs == error_mark_node) - return error_mark_node; - rhstype = TREE_TYPE (rhs); - coder = TREE_CODE (rhstype); - } - - if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE - || is_overloaded_fn (rhs)) - rhs = default_conversion (rhs); - else if (TREE_CODE (TREE_TYPE (rhs)) == REFERENCE_TYPE) - rhs = convert_from_reference (rhs); - - /* If rhs is some sort of overloaded function, ocp_convert will either - do the right thing or complain; we don't need to check anything else. - So just hand off. */ - if (type_unknown_p (rhs)) - return ocp_convert (type, rhs, CONV_IMPLICIT, LOOKUP_NORMAL); - - rhstype = TREE_TYPE (rhs); - coder = TREE_CODE (rhstype); - - /* This should no longer change types on us. */ - if (TREE_CODE (rhs) == CONST_DECL) - rhs = DECL_INITIAL (rhs); - else if (TREE_READONLY_DECL_P (rhs)) - rhs = decl_constant_value (rhs); - - if (same_type_p (type, rhstype)) - { - overflow_warning (rhs); - return rhs; - } - - if (coder == VOID_TYPE) - { - error ("void value not ignored as it ought to be"); - return error_mark_node; - } - /* Arithmetic types all interconvert. */ - if ((codel == INTEGER_TYPE || codel == REAL_TYPE || codel == BOOLEAN_TYPE - || codel == COMPLEX_TYPE) - && (coder == INTEGER_TYPE || coder == REAL_TYPE || coder == BOOLEAN_TYPE - || coder == COMPLEX_TYPE)) - { - /* But we should warn if assigning REAL_TYPE to INTEGER_TYPE. */ - if (coder == REAL_TYPE && codel == INTEGER_TYPE) - { - if (fndecl) - cp_warning ("`%T' used for argument %P of `%D'", - rhstype, parmnum, fndecl); - else - cp_warning ("%s to `%T' from `%T'", errtype, type, rhstype); - } - /* And we should warn if assigning a negative value to - an unsigned variable. */ - else if (TREE_UNSIGNED (type) && codel != BOOLEAN_TYPE) - { - if (TREE_CODE (rhs) == INTEGER_CST - && TREE_NEGATED_INT (rhs)) - { - if (fndecl) - cp_warning ("negative value `%E' passed as argument %P of `%D'", - rhs, parmnum, fndecl); - else - cp_warning ("%s of negative value `%E' to `%T'", - errtype, rhs, type); - } - overflow_warning (rhs); - if (TREE_CONSTANT (rhs)) - rhs = fold (rhs); - } - - return convert_and_check (type, rhs); - } - /* Conversions involving enums. */ - else if ((codel == ENUMERAL_TYPE - && (INTEGRAL_CODE_P (coder) || coder == REAL_TYPE)) - || (coder == ENUMERAL_TYPE - && (INTEGRAL_CODE_P (codel) || codel == REAL_TYPE))) - { - return ocp_convert (type, rhs, CONV_IMPLICIT, LOOKUP_NORMAL); - } - /* Conversions among pointers */ - else if (codel == POINTER_TYPE - && (coder == POINTER_TYPE - || (coder == RECORD_TYPE - && (IS_SIGNATURE_POINTER (rhstype) - || IS_SIGNATURE_REFERENCE (rhstype))))) - { - register tree ttl = TREE_TYPE (type); - register tree ttr; - int ctt = 0; - - if (coder == RECORD_TYPE) - { - rhs = build_optr_ref (rhs); - rhstype = TREE_TYPE (rhs); - } - ttr = TREE_TYPE (rhstype); - - /* If both pointers are of aggregate type, then we - can give better error messages, and save some work - as well. */ - if (TREE_CODE (ttl) == RECORD_TYPE && TREE_CODE (ttr) == RECORD_TYPE) - { - tree binfo; - - if (TYPE_MAIN_VARIANT (ttl) == TYPE_MAIN_VARIANT (ttr) - || type == class_star_type_node - || rhstype == class_star_type_node) - binfo = TYPE_BINFO (ttl); - else - binfo = get_binfo (ttl, ttr, 1); - - if (binfo == error_mark_node) - return error_mark_node; - if (binfo == 0) - return error_not_base_type (ttl, ttr); - - if (!at_least_as_qualified_p (ttl, ttr)) - { - if (fndecl) - cp_pedwarn ("passing `%T' as argument %P of `%D' discards qualifiers", - rhstype, parmnum, fndecl); - else - cp_pedwarn ("%s to `%T' from `%T' discards qualifiers", - errtype, type, rhstype); - } - } - - /* Any non-function converts to a [const][volatile] void * - and vice versa; otherwise, targets must be the same. - Meanwhile, the lhs target must have all the qualifiers of the rhs. */ - else if (TYPE_MAIN_VARIANT (ttl) == void_type_node - || TYPE_MAIN_VARIANT (ttr) == void_type_node - || (ctt = comp_target_types (type, rhstype, 1)) - || (unsigned_type (TYPE_MAIN_VARIANT (ttl)) - == unsigned_type (TYPE_MAIN_VARIANT (ttr)))) - { - /* ARM $4.8, commentary on p39. */ - if (TYPE_MAIN_VARIANT (ttl) == void_type_node - && TREE_CODE (ttr) == OFFSET_TYPE) - { - cp_error ("no standard conversion from `%T' to `void *'", ttr); - return error_mark_node; - } - - if (ctt < 0 && TYPE_MAIN_VARIANT (ttl) != TYPE_MAIN_VARIANT (ttr)) - cp_pedwarn ("converting `%T' to `%T' is a contravariance violation", - rhstype, type); - - if (TYPE_MAIN_VARIANT (ttl) != void_type_node - && TYPE_MAIN_VARIANT (ttr) == void_type_node - && ! null_ptr_cst_p (rhs)) - { - if (coder == RECORD_TYPE) - cp_pedwarn ("implicit conversion of signature pointer to type `%T'", - type); - else - pedwarn ("ANSI C++ forbids implicit conversion from `void *' in %s", - errtype); - } - /* Const and volatile mean something different for function types, - so the usual warnings are not appropriate. */ - else if ((TREE_CODE (ttr) != FUNCTION_TYPE && TREE_CODE (ttr) != METHOD_TYPE) - || (TREE_CODE (ttl) != FUNCTION_TYPE && TREE_CODE (ttl) != METHOD_TYPE)) - { - if (TREE_CODE (ttl) == OFFSET_TYPE - && binfo_member (TYPE_OFFSET_BASETYPE (ttr), - CLASSTYPE_VBASECLASSES (TYPE_OFFSET_BASETYPE (ttl)))) - { - error ("%s between pointer to members converting across virtual baseclasses", errtype); - return error_mark_node; - } - else if (!at_least_as_qualified_p (ttl, ttr)) - { - if (string_conv_p (type, rhs, 1)) - /* converting from string constant to char *, OK. */; - else if (fndecl) - cp_pedwarn ("passing `%T' as argument %P of `%D' discards qualifiers", - rhstype, parmnum, fndecl); - else - cp_pedwarn ("%s to `%T' from `%T' discards qualifiers", - errtype, type, rhstype); - } - else if (TREE_CODE (ttl) == TREE_CODE (ttr) - && ! comp_target_types (type, rhstype, 1)) - { - if (fndecl) - cp_pedwarn ("passing `%T' as argument %P of `%D' changes signedness", - rhstype, parmnum, fndecl); - else - cp_pedwarn ("%s to `%T' from `%T' changes signedness", - errtype, type, rhstype); - } - } - } - else - { - int add_quals = 0; - int drops_quals = 0; - int left_const = 1; - int unsigned_parity; - int nptrs = 0; - - /* This code is basically a duplicate of comp_ptr_ttypes_real. */ - for (; ; ttl = TREE_TYPE (ttl), ttr = TREE_TYPE (ttr)) - { - nptrs -= 1; - drops_quals |= !at_least_as_qualified_p (ttl, ttr); - - if (! left_const - && !at_least_as_qualified_p (ttr, ttl)) - add_quals = 1; - left_const &= TYPE_READONLY (ttl); - - if (TREE_CODE (ttl) != POINTER_TYPE - || TREE_CODE (ttr) != POINTER_TYPE) - break; - } - unsigned_parity = TREE_UNSIGNED (ttl) - TREE_UNSIGNED (ttr); - if (unsigned_parity) - { - if (TREE_UNSIGNED (ttl)) - ttr = unsigned_type (ttr); - else - ttl = unsigned_type (ttl); - } - - if (comp_target_types (ttl, ttr, nptrs) > 0) - { - if (add_quals) - { - if (fndecl) - cp_pedwarn ("passing `%T' as argument %P of `%D' adds cv-quals without intervening `const'", - rhstype, parmnum, fndecl); - else - cp_pedwarn ("%s to `%T' from `%T' adds cv-quals without intervening `const'", - errtype, type, rhstype); - } - if (drops_quals) - { - if (fndecl) - cp_pedwarn ("passing `%T' as argument %P of `%D' discards qualifiers", - rhstype, parmnum, fndecl); - else - cp_pedwarn ("%s to `%T' from `%T' discards qualifiers", - errtype, type, rhstype); - } - if (unsigned_parity > 0) - { - if (fndecl) - cp_pedwarn ("passing `%T' as argument %P of `%D' changes signed to unsigned", - rhstype, parmnum, fndecl); - else - cp_pedwarn ("%s to `%T' from `%T' changes signed to unsigned", - errtype, type, rhstype); - } - else if (unsigned_parity < 0) - { - if (fndecl) - cp_pedwarn ("passing `%T' as argument %P of `%D' changes unsigned to signed", - rhstype, parmnum, fndecl); - else - cp_pedwarn ("%s to `%T' from `%T' changes unsigned to signed", - errtype, type, rhstype); - } - - /* C++ is not so friendly about converting function and - member function pointers as C. Emit warnings here. */ - if (TREE_CODE (ttl) == FUNCTION_TYPE - || TREE_CODE (ttl) == METHOD_TYPE) - if (!same_or_base_type_p (ttl, ttr)) - { - warning ("conflicting function types in %s:", errtype); - cp_warning ("\t`%T' != `%T'", type, rhstype); - } - } - else - { - if (fndecl) - cp_error ("passing `%T' as argument %P of `%D'", - rhstype, parmnum, fndecl); - else - cp_error ("%s to `%T' from `%T'", errtype, type, rhstype); - return error_mark_node; - } - } - return cp_convert (type, rhs); - } - else if (codel == POINTER_TYPE && coder == INTEGER_TYPE) - { - /* An explicit constant 0 can convert to a pointer, - but not a 0 that results from casting or folding. */ - if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))) - { - if (fndecl) - cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast", - rhstype, parmnum, fndecl); - else - cp_pedwarn ("%s to `%T' from `%T' lacks a cast", - errtype, type, rhstype); - } - return cp_convert (type, rhs); - } - else if (codel == INTEGER_TYPE - && (coder == POINTER_TYPE - || (coder == RECORD_TYPE - && (IS_SIGNATURE_POINTER (rhstype) - || TYPE_PTRMEMFUNC_FLAG (rhstype) - || IS_SIGNATURE_REFERENCE (rhstype))))) - { - if (fndecl) - cp_pedwarn ("passing `%T' to argument %P of `%D' lacks a cast", - rhstype, parmnum, fndecl); - else - cp_pedwarn ("%s to `%T' from `%T' lacks a cast", - errtype, type, rhstype); - return cp_convert (type, rhs); - } - else if (codel == BOOLEAN_TYPE - && (coder == POINTER_TYPE - || (coder == RECORD_TYPE - && (IS_SIGNATURE_POINTER (rhstype) - || TYPE_PTRMEMFUNC_FLAG (rhstype) - || IS_SIGNATURE_REFERENCE (rhstype))))) - return cp_convert (type, rhs); - - /* C++ */ - else if (((coder == POINTER_TYPE - && TREE_CODE (TREE_TYPE (rhstype)) == METHOD_TYPE) - || integer_zerop (rhs) - || TYPE_PTRMEMFUNC_P (rhstype)) - && TYPE_PTRMEMFUNC_P (type)) - { - tree ttl = TYPE_PTRMEMFUNC_FN_TYPE (type); - tree ttr = (TYPE_PTRMEMFUNC_P (rhstype) - ? TYPE_PTRMEMFUNC_FN_TYPE (rhstype) - : rhstype); - int ctt = (TREE_CODE (rhstype) == INTEGER_TYPE ? 1 - : comp_target_types (ttl, ttr, 1)); - - if (ctt < 0) - cp_pedwarn ("converting `%T' to `%T' is a contravariance violation", - ttr, ttl); - else if (ctt == 0) - cp_error ("%s to `%T' from `%T'", errtype, ttl, ttr); - - /* compatible pointer to member functions. */ - return build_ptrmemfunc (ttl, rhs, 0); - } - else if (codel == ERROR_MARK || coder == ERROR_MARK) - return error_mark_node; - - /* This should no longer happen. References are initialized via - `convert_for_initialization'. They should otherwise be - bashed before coming here. */ - else if (codel == REFERENCE_TYPE) - my_friendly_abort (317); - else if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (rhs))) - { - tree nrhs = build1 (NOP_EXPR, type, rhs); - TREE_CONSTANT (nrhs) = TREE_CONSTANT (rhs); - return nrhs; - } - else if (TYPE_HAS_CONSTRUCTOR (type) || IS_AGGR_TYPE (TREE_TYPE (rhs))) - return cp_convert (type, rhs); - /* Handle anachronistic conversions from (::*)() to cv void* or (*)(). */ - else if (TREE_CODE (type) == POINTER_TYPE - && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE - || TYPE_MAIN_VARIANT (TREE_TYPE (type)) == void_type_node) - && TREE_TYPE (rhs) - && TYPE_PTRMEMFUNC_P (TREE_TYPE (rhs))) - return cp_convert (type, rhs); - - cp_error ("%s to `%T' from `%T'", errtype, type, rhstype); - return error_mark_node; -} - -/* Convert RHS to be of type TYPE. - If EXP is non-zero, it is the target of the initialization. - ERRTYPE is a string to use in error messages. - - Two major differences between the behavior of - `convert_for_assignment' and `convert_for_initialization' - are that references are bashed in the former, while - copied in the latter, and aggregates are assigned in - the former (operator=) while initialized in the - latter (X(X&)). - - If using constructor make sure no conversion operator exists, if one does - exist, an ambiguity exists. - - If flags doesn't include LOOKUP_COMPLAIN, don't complain about anything. */ - -tree -convert_for_initialization (exp, type, rhs, flags, errtype, fndecl, parmnum) - tree exp, type, rhs; - int flags; - char *errtype; - tree fndecl; - int parmnum; -{ - register enum tree_code codel = TREE_CODE (type); - register tree rhstype; - register enum tree_code coder; - - /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue. - Strip such NOP_EXPRs, since RHS is used in non-lvalue context. */ - if (TREE_CODE (rhs) == NOP_EXPR - && TREE_TYPE (rhs) == TREE_TYPE (TREE_OPERAND (rhs, 0)) - && codel != REFERENCE_TYPE) - rhs = TREE_OPERAND (rhs, 0); - - if (rhs == error_mark_node - || (TREE_CODE (rhs) == TREE_LIST && TREE_VALUE (rhs) == error_mark_node)) - return error_mark_node; - - if (TREE_CODE (TREE_TYPE (rhs)) == OFFSET_TYPE) - { - rhs = resolve_offset_ref (rhs); - if (rhs == error_mark_node) - return error_mark_node; - } - - if (TREE_CODE (TREE_TYPE (rhs)) == REFERENCE_TYPE) - rhs = convert_from_reference (rhs); - - if ((TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE - && TREE_CODE (type) != ARRAY_TYPE - && (TREE_CODE (type) != REFERENCE_TYPE - || TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE)) - || (TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE - && (TREE_CODE (type) != REFERENCE_TYPE - || TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)) - || TREE_CODE (TREE_TYPE (rhs)) == METHOD_TYPE) - rhs = default_conversion (rhs); - - rhstype = TREE_TYPE (rhs); - coder = TREE_CODE (rhstype); - - if (coder == ERROR_MARK) - return error_mark_node; - - /* We accept references to incomplete types, so we can - return here before checking if RHS is of complete type. */ - - if (codel == REFERENCE_TYPE) - { - /* This should eventually happen in convert_arguments. */ - extern int warningcount, errorcount; - int savew = 0, savee = 0; - - if (fndecl) - savew = warningcount, savee = errorcount; - rhs = convert_to_reference (type, rhs, CONV_IMPLICIT, flags, - exp ? exp : error_mark_node); - if (fndecl) - { - if (warningcount > savew) - cp_warning_at ("in passing argument %P of `%+D'", parmnum, fndecl); - else if (errorcount > savee) - cp_error_at ("in passing argument %P of `%+D'", parmnum, fndecl); - } - return rhs; - } - - rhs = require_complete_type (rhs); - if (rhs == error_mark_node) - return error_mark_node; - - if (exp != 0) exp = require_complete_type (exp); - if (exp == error_mark_node) - return error_mark_node; - - if (TREE_CODE (rhstype) == REFERENCE_TYPE) - rhstype = TREE_TYPE (rhstype); - - type = complete_type (type); - - if (TYPE_LANG_SPECIFIC (type) - && (IS_SIGNATURE_POINTER (type) || IS_SIGNATURE_REFERENCE (type))) - return build_signature_pointer_constructor (type, rhs); - - if (IS_AGGR_TYPE (type)) - return ocp_convert (type, rhs, CONV_IMPLICIT|CONV_FORCE_TEMP, flags); - - if (type == TREE_TYPE (rhs)) - { - /* Issue warnings about peculiar, but legal, uses of NULL. We - do this *before* the call to decl_constant_value so as to - avoid duplicate warnings on code like `const int I = NULL; - f(I);'. */ - if (ARITHMETIC_TYPE_P (type) && rhs == null_node) - cp_warning ("converting NULL to non-pointer type"); - - if (TREE_READONLY_DECL_P (rhs)) - rhs = decl_constant_value (rhs); - - return rhs; - } - - return convert_for_assignment (type, rhs, errtype, fndecl, parmnum); -} - -/* Expand an ASM statement with operands, handling output operands - that are not variables or INDIRECT_REFS by transforming such - cases into cases that expand_asm_operands can handle. - - Arguments are same as for expand_asm_operands. - - We don't do default conversions on all inputs, because it can screw - up operands that are expected to be in memory. */ - -void -c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line) - tree string, outputs, inputs, clobbers; - int vol; - char *filename; - int line; -{ - int noutputs = list_length (outputs); - register int i; - /* o[I] is the place that output number I should be written. */ - register tree *o = (tree *) alloca (noutputs * sizeof (tree)); - register tree tail; - - /* Record the contents of OUTPUTS before it is modified. */ - for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++) - o[i] = TREE_VALUE (tail); - - /* Generate the ASM_OPERANDS insn; - store into the TREE_VALUEs of OUTPUTS some trees for - where the values were actually stored. */ - expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line); - - /* Copy all the intermediate outputs into the specified outputs. */ - for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++) - { - if (o[i] != TREE_VALUE (tail)) - { - expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)), - const0_rtx, VOIDmode, EXPAND_NORMAL); - free_temp_slots (); - } - /* Detect modification of read-only values. - (Otherwise done by build_modify_expr.) */ - else - { - tree type = TREE_TYPE (o[i]); - if (CP_TYPE_CONST_P (type) - || ((TREE_CODE (type) == RECORD_TYPE - || TREE_CODE (type) == UNION_TYPE) - && C_TYPE_FIELDS_READONLY (type))) - readonly_error (o[i], "modification by `asm'", 1); - } - } - - /* Those MODIFY_EXPRs could do autoincrements. */ - emit_queue (); -} - -/* Expand a C `return' statement. - RETVAL is the expression for what to return, - or a null pointer for `return;' with no value. - - C++: upon seeing a `return', we must call destructors on all - variables in scope which had constructors called on them. - This means that if in a destructor, the base class destructors - must be called before returning. - - The RETURN statement in C++ has initialization semantics. */ - -void -c_expand_return (retval) - tree retval; -{ - extern struct nesting *cond_stack, *loop_stack, *case_stack; - extern tree dtor_label, ctor_label; - tree result = DECL_RESULT (current_function_decl); - tree valtype = TREE_TYPE (result); - - if (TREE_THIS_VOLATILE (current_function_decl)) - warning ("function declared `noreturn' has a `return' statement"); - - if (retval == error_mark_node) - { - current_function_returns_null = 1; - return; - } - - if (processing_template_decl) - { - add_tree (build_min_nt (RETURN_STMT, retval)); - return; - } - - if (dtor_label) - { - if (retval) - error ("returning a value from a destructor"); - - /* Can't just return from a destructor. */ - expand_goto (dtor_label); - return; - } - - if (retval == NULL_TREE) - { - /* A non-named return value does not count. */ - - if (DECL_CONSTRUCTOR_P (current_function_decl)) - retval = current_class_ptr; - else if (DECL_NAME (result) != NULL_TREE - && TREE_CODE (valtype) != VOID_TYPE) - retval = result; - else - { - current_function_returns_null = 1; - - if (valtype != NULL_TREE && TREE_CODE (valtype) != VOID_TYPE) - { - if (DECL_NAME (DECL_RESULT (current_function_decl)) == NULL_TREE) - { - pedwarn ("`return' with no value, in function returning non-void"); - /* Clear this, so finish_function won't say that we - reach the end of a non-void function (which we don't, - we gave a return!). */ - current_function_returns_null = 0; - } - } - - expand_null_return (); - return; - } - } - else if (DECL_CONSTRUCTOR_P (current_function_decl)) - { - if (flag_this_is_variable) - error ("return from a constructor: use `this = ...' instead"); - else - error ("returning a value from a constructor"); - retval = current_class_ptr; - } - - /* Effective C++ rule 15. See also start_function. */ - if (warn_ecpp - && DECL_NAME (current_function_decl) == ansi_opname[(int) MODIFY_EXPR] - && retval != current_class_ref) - cp_warning ("`operator=' should return a reference to `*this'"); - - if (valtype == NULL_TREE || TREE_CODE (valtype) == VOID_TYPE) - { - current_function_returns_null = 1; - if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE) - pedwarn ("`return' with a value, in function returning void"); - expand_return (retval); - return; - } - - /* Now deal with possible C++ hair: - (1) Compute the return value. - (2) If there are aggregate values with destructors which - must be cleaned up, clean them (taking care - not to clobber the return value). - (3) If an X(X&) constructor is defined, the return - value must be returned via that. */ - - if (retval == result - || DECL_CONSTRUCTOR_P (current_function_decl)) - /* It's already done for us. */; - else if (TREE_TYPE (retval) == void_type_node) - { - pedwarn ("return of void value in function returning non-void"); - expand_expr_stmt (retval); - retval = 0; - } - else - { - tree functype = TREE_TYPE (TREE_TYPE (current_function_decl)); - - /* First convert the value to the function's return type, then - to the type of return value's location to handle the - case that functype is thiner than the valtype. */ - - retval = convert_for_initialization - (NULL_TREE, functype, retval, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING, - "return", NULL_TREE, 0); - - retval = convert (valtype, retval); - - if (retval == error_mark_node) - { - /* Avoid warning about control reaching end of function. */ - expand_null_return (); - return; - } - - /* We can't initialize a register from a AGGR_INIT_EXPR. */ - else if (! current_function_returns_struct - && TREE_CODE (retval) == TARGET_EXPR - && TREE_CODE (TREE_OPERAND (retval, 1)) == AGGR_INIT_EXPR) - retval = build (COMPOUND_EXPR, TREE_TYPE (retval), retval, - TREE_OPERAND (retval, 0)); - - /* Add some useful error checking for C++. */ - else if (TREE_CODE (valtype) == REFERENCE_TYPE) - { - tree whats_returned; - - /* Sort through common things to see what it is - we are returning. */ - whats_returned = retval; - if (TREE_CODE (whats_returned) == COMPOUND_EXPR) - { - whats_returned = TREE_OPERAND (whats_returned, 1); - if (TREE_CODE (whats_returned) == ADDR_EXPR) - whats_returned = TREE_OPERAND (whats_returned, 0); - } - while (TREE_CODE (whats_returned) == CONVERT_EXPR - || TREE_CODE (whats_returned) == NOP_EXPR) - whats_returned = TREE_OPERAND (whats_returned, 0); - if (TREE_CODE (whats_returned) == ADDR_EXPR) - { - whats_returned = TREE_OPERAND (whats_returned, 0); - while (TREE_CODE (whats_returned) == AGGR_INIT_EXPR - || TREE_CODE (whats_returned) == TARGET_EXPR) - { - /* Get the target. */ - whats_returned = TREE_OPERAND (whats_returned, 0); - warning ("returning reference to temporary"); - } - } - - if (TREE_CODE (whats_returned) == VAR_DECL && DECL_NAME (whats_returned)) - { - if (TEMP_NAME_P (DECL_NAME (whats_returned))) - warning ("reference to non-lvalue returned"); - else if (TREE_CODE (TREE_TYPE (whats_returned)) != REFERENCE_TYPE - && DECL_FUNCTION_SCOPE_P (whats_returned) - && !(TREE_STATIC (whats_returned) - || TREE_PUBLIC (whats_returned))) - cp_warning_at ("reference to local variable `%D' returned", whats_returned); - } - } - else if (TREE_CODE (retval) == ADDR_EXPR) - { - tree whats_returned = TREE_OPERAND (retval, 0); - - if (TREE_CODE (whats_returned) == VAR_DECL - && DECL_NAME (whats_returned) - && DECL_FUNCTION_SCOPE_P (whats_returned) - && !(TREE_STATIC (whats_returned) - || TREE_PUBLIC (whats_returned))) - cp_warning_at ("address of local variable `%D' returned", whats_returned); - } - } - - if (retval != NULL_TREE - && TREE_CODE_CLASS (TREE_CODE (retval)) == 'd' - && cond_stack == 0 && loop_stack == 0 && case_stack == 0) - current_function_return_value = retval; - - if (ctor_label && TREE_CODE (ctor_label) != ERROR_MARK) - { - /* Here RETVAL is CURRENT_CLASS_PTR, so there's nothing to do. */ - expand_goto (ctor_label); - } - - if (retval && retval != result) - { - result = build (INIT_EXPR, TREE_TYPE (result), result, retval); - TREE_SIDE_EFFECTS (result) = 1; - } - - expand_start_target_temps (); - - expand_return (result); - - expand_end_target_temps (); - - current_function_returns_value = 1; -} - -/* Start a C switch statement, testing expression EXP. - Return EXP if it is valid, an error node otherwise. */ - -tree -c_expand_start_case (exp) - tree exp; -{ - tree type, idx; - - exp = build_expr_type_conversion (WANT_INT | WANT_ENUM, exp, 1); - if (exp == NULL_TREE) - { - error ("switch quantity not an integer"); - exp = error_mark_node; - } - if (exp == error_mark_node) - return error_mark_node; - - exp = default_conversion (exp); - type = TREE_TYPE (exp); - idx = get_unwidened (exp, 0); - /* We can't strip a conversion from a signed type to an unsigned, - because if we did, int_fits_type_p would do the wrong thing - when checking case values for being in range, - and it's too hard to do the right thing. */ - if (TREE_UNSIGNED (TREE_TYPE (exp)) == TREE_UNSIGNED (TREE_TYPE (idx))) - exp = idx; - - expand_start_case - (1, fold (build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp)), - type, "switch statement"); - - return exp; -} - -/* Returns non-zero if the pointer-type FROM can be converted to the - pointer-type TO via a qualification conversion. If CONSTP is -1, - then we return non-zero if the pointers are similar, and the - cv-qualification signature of FROM is a proper subset of that of TO. - - If CONSTP is positive, then all outer pointers have been - const-qualified. */ - -static int -comp_ptr_ttypes_real (to, from, constp) - tree to, from; - int constp; -{ - int to_more_cv_qualified = 0; - - for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from)) - { - if (TREE_CODE (to) != TREE_CODE (from)) - return 0; - - if (TREE_CODE (from) == OFFSET_TYPE - && same_type_p (TYPE_OFFSET_BASETYPE (from), - TYPE_OFFSET_BASETYPE (to))) - continue; - - /* Const and volatile mean something different for function types, - so the usual checks are not appropriate. */ - if (TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE) - { - if (!at_least_as_qualified_p (to, from)) - return 0; - - if (!at_least_as_qualified_p (from, to)) - { - if (constp == 0) - return 0; - else - ++to_more_cv_qualified; - } - - if (constp > 0) - constp &= TYPE_READONLY (to); - } - - if (TREE_CODE (to) != POINTER_TYPE) - return - same_type_p (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from)) - && (constp >= 0 || to_more_cv_qualified); - } -} - -/* When comparing, say, char ** to char const **, this function takes the - 'char *' and 'char const *'. Do not pass non-pointer types to this - function. */ - -int -comp_ptr_ttypes (to, from) - tree to, from; -{ - return comp_ptr_ttypes_real (to, from, 1); -} - -/* Returns 1 if to and from are (possibly multi-level) pointers to the same - type or inheritance-related types, regardless of cv-quals. */ - -int -ptr_reasonably_similar (to, from) - tree to, from; -{ - for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from)) - { - if (TREE_CODE (to) != TREE_CODE (from)) - return 0; - - if (TREE_CODE (from) == OFFSET_TYPE - && comptypes (TYPE_OFFSET_BASETYPE (to), - TYPE_OFFSET_BASETYPE (from), - COMPARE_BASE | COMPARE_RELAXED)) - continue; - - if (TREE_CODE (to) != POINTER_TYPE) - return comptypes - (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from), - COMPARE_BASE | COMPARE_RELAXED); - } -} - -/* Like comp_ptr_ttypes, for const_cast. */ - -static int -comp_ptr_ttypes_const (to, from) - tree to, from; -{ - for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from)) - { - if (TREE_CODE (to) != TREE_CODE (from)) - return 0; - - if (TREE_CODE (from) == OFFSET_TYPE - && same_type_p (TYPE_OFFSET_BASETYPE (from), - TYPE_OFFSET_BASETYPE (to))) - continue; - - if (TREE_CODE (to) != POINTER_TYPE) - return same_type_p (TYPE_MAIN_VARIANT (to), - TYPE_MAIN_VARIANT (from)); - } -} - -/* Like comp_ptr_ttypes, for reinterpret_cast. */ - -static int -comp_ptr_ttypes_reinterpret (to, from) - tree to, from; -{ - int constp = 1; - - for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from)) - { - if (TREE_CODE (from) == OFFSET_TYPE) - from = TREE_TYPE (from); - if (TREE_CODE (to) == OFFSET_TYPE) - to = TREE_TYPE (to); - - /* Const and volatile mean something different for function types, - so the usual checks are not appropriate. */ - if (TREE_CODE (from) != FUNCTION_TYPE && TREE_CODE (from) != METHOD_TYPE - && TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE) - { - if (!at_least_as_qualified_p (to, from)) - return 0; - - if (! constp - && !at_least_as_qualified_p (from, to)) - return 0; - constp &= TYPE_READONLY (to); - } - - if (TREE_CODE (from) != POINTER_TYPE - || TREE_CODE (to) != POINTER_TYPE) - return 1; - } -} - -/* Returns the type-qualifier set corresponding to TYPE. */ - -int -cp_type_quals (type) - tree type; -{ - while (TREE_CODE (type) == ARRAY_TYPE) - type = TREE_TYPE (type); - - return TYPE_QUALS (type); -} - -/* Returns non-zero if the TYPE contains a mutable member */ - -int -cp_has_mutable_p (type) - tree type; -{ - while (TREE_CODE (type) == ARRAY_TYPE) - type = TREE_TYPE (type); - - return CLASS_TYPE_P (type) && CLASSTYPE_HAS_MUTABLE (type); -} |