diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index b5dc083fdfb..d15bc1acf0e 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,18 @@ +Fri Apr 17 14:30:45 1998 Jason Merrill + + * decl2.c (lang_decode_option): -fnew-abi implies -fvtable-thunks. + + * typeck.c (comp_target_types): Tweak pedantic case. + (comp_target_parms): Tweak pedantic case. Clean up somewhat. + Return -1 or 1 instead of 1 or 2. + (compparms): Remove STRICT handling. + +Fri Apr 17 14:04:16 1998 Mark Mitchell + + * typeck.c (comp_target_types): Handle references like pointers. + (comp_target_parms): Note that return code from comp_target_types + can be negative to indicate failure. + Fri Apr 17 09:10:52 1998 Andreas Schwab * Make-lang.in (c++.all.build): Don't depend on $(DEMANGLER_PROG), @@ -51,6 +66,8 @@ Fri Apr 17 00:45:12 1998 Mark Mitchell * typeck2.c (process_init_constructor): Don't strip cv-qualifiers when doing initializations. + * pt.c (unify): Use comptypes to compare type args. + Fri Apr 17 00:24:22 1998 Jason Merrill * decl.c (duplicate_decls): Fix check for when it's safe to free @@ -58,8 +75,6 @@ Fri Apr 17 00:24:22 1998 Jason Merrill * pt.c (mangle_class_name_for_template): Don't pass a typedef type to type_as_string. - From Mark Mitchell: - (unify): Use comptypes to compare type args. Thu Apr 16 17:47:30 1998 Jeffrey A Law (law@cygnus.com) diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c index 42e0e21eace..8f0c95499f2 100644 --- a/gcc/cp/decl2.c +++ b/gcc/cp/decl2.c @@ -571,6 +571,7 @@ lang_decode_option (p) { flag_new_abi = 1; flag_do_squangling = 1; + flag_vtable_thunks = 1; } else if (!strcmp (p, "no-new-abi")) { diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c index e13a312f020..de021ea6c2a 100644 --- a/gcc/cp/typeck.c +++ b/gcc/cp/typeck.c @@ -877,7 +877,10 @@ comptypes (type1, type2, strict) 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**. */ + 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) @@ -892,12 +895,13 @@ comp_target_types (ttl, ttr, nptrs) if (TREE_CODE (ttr) != TREE_CODE (ttl)) return 0; - if (TREE_CODE (ttr) == POINTER_TYPE) + if (TREE_CODE (ttr) == POINTER_TYPE + || (TREE_CODE (ttr) == REFERENCE_TYPE)) { ttl = TREE_TYPE (ttl); ttr = TREE_TYPE (ttr); - if (nptrs > 0) + if (nptrs > 0 && TREE_CODE (ttr) == POINTER_TYPE) { if (TREE_CODE (ttl) == UNKNOWN_TYPE || TREE_CODE (ttr) == UNKNOWN_TYPE) @@ -949,27 +953,23 @@ comp_target_types (ttl, ttr, nptrs) } } - if (TREE_CODE (ttr) == REFERENCE_TYPE) - return comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), nptrs); if (TREE_CODE (ttr) == ARRAY_TYPE) return comp_array_types (comp_target_types, ttl, ttr, 0); else if (TREE_CODE (ttr) == FUNCTION_TYPE || TREE_CODE (ttr) == METHOD_TYPE) { - if (comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), -1)) - switch (comp_target_parms (TYPE_ARG_TYPES (ttl), - TYPE_ARG_TYPES (ttr), 1)) - { - case 0: + if (pedantic) + { + if (comptypes (TREE_TYPE (ttl), TREE_TYPE (ttr), 1) == 0) return 0; - case 1: - return 1; - case 2: - return -1; - default: - my_friendly_abort (112); - } + } else - return 0; + { + if (comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), -1) == 0) + return 0; + } + + return comp_target_parms (TYPE_ARG_TYPES (ttl), + TYPE_ARG_TYPES (ttr), 1); } /* for C++ */ else if (TREE_CODE (ttr) == OFFSET_TYPE) @@ -1059,9 +1059,9 @@ common_base_type (tt1, tt2) 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. - If STRICT == 3, it means checking is strict, but do not compare - default parameter values. */ + C++: See comment above about TYPE1, TYPE2. + + STRICT is no longer used. */ int compparms (parms1, parms2, strict) @@ -1073,34 +1073,16 @@ compparms (parms1, parms2, strict) /* An unspecified parmlist matches any specified parmlist whose argument types don't need default promotions. */ - if (strict <= 0 && t1 == 0) - return self_promoting_args_p (t2); - if (strict < 0 && t2 == 0) - return self_promoting_args_p (t1); - while (1) { if (t1 == 0 && t2 == 0) return 1; /* If one parmlist is shorter than the other, - they fail to match, unless STRICT is <= 0. */ + they fail to match. */ if (t1 == 0 || t2 == 0) - { - if (strict > 0) - return 0; - if (strict < 0) - return 1; - if (strict == 0) - return t1 && TREE_PURPOSE (t1); - } - if (! comptypes (TREE_VALUE (t2), TREE_VALUE (t1), strict)) - { - if (strict > 0) - return 0; - if (strict == 0) - return t2 == void_list_node && TREE_PURPOSE (t1); - return TREE_PURPOSE (t1) || TREE_PURPOSE (t2); - } + return 0; + if (! comptypes (TREE_VALUE (t2), TREE_VALUE (t1), 1)) + return 0; t1 = TREE_CHAIN (t1); t2 = TREE_CHAIN (t2); @@ -1108,7 +1090,13 @@ compparms (parms1, parms2, strict) } /* This really wants return whether or not parameter type lists - would make their owning functions assignment compatible or not. */ + 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) @@ -1118,9 +1106,9 @@ comp_target_parms (parms1, parms2, strict) register tree t1 = parms1, t2 = parms2; int warn_contravariance = 0; - /* An unspecified parmlist matches any specified parmlist - whose argument types don't need default promotions. - @@@ see 13.3.3 for a counterexample... */ + /* 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) { @@ -1147,9 +1135,12 @@ comp_target_parms (parms1, parms2, strict) } p1 = TREE_VALUE (t1); p2 = TREE_VALUE (t2); - if (p1 == p2) + if (comptypes (p1, p2, 1)) 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)) @@ -1170,20 +1161,15 @@ comp_target_parms (parms1, parms2, strict) } if (IS_AGGR_TYPE (TREE_TYPE (p1))) { - if (comptypes (p2, p1, 0) == 0) - { - if (comptypes (p1, p2, 0) != 0) - warn_contravariance = 1; - else - return 0; - } - continue; + if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (p1)), + TYPE_MAIN_VARIANT (TREE_TYPE (p2)), 1) == 0) + return 0; } } /* Note backwards order due to contravariance. */ - if (comp_target_types (p2, p1, 1) == 0) + if (comp_target_types (p2, p1, 1) <= 0) { - if (comp_target_types (p1, p2, 1)) + if (comp_target_types (p1, p2, 1) > 0) { warn_contravariance = 1; continue; @@ -1191,31 +1177,8 @@ comp_target_parms (parms1, parms2, strict) if (strict != 0) return 0; } - /* Target types are compatible--just make sure that if - we use parameter lists, that they are ok as well. */ - if (TREE_CODE (p1) == FUNCTION_TYPE || TREE_CODE (p1) == METHOD_TYPE) - switch (comp_target_parms (TYPE_ARG_TYPES (p1), - TYPE_ARG_TYPES (p2), - strict)) - { - case 0: - return 0; - case 1: - break; - case 2: - warn_contravariance = 1; - } - - if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2)) - { - int cmp = simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)); - if (cmp < 0) - my_friendly_abort (114); - if (cmp == 0) - return 0; - } } - return 1 + warn_contravariance; + return warn_contravariance ? -1 : 1; } /* Return 1 if PARMS specifies a fixed number of parameters @@ -6876,7 +6839,7 @@ convert_for_assignment (type, rhs, errtype, fndecl, parmnum) { tree ttl = TYPE_PTRMEMFUNC_FN_TYPE (type); tree ttr = (TREE_CODE (rhstype) == POINTER_TYPE ? rhstype - : TYPE_PTRMEMFUNC_FN_TYPE (type)); + : TYPE_PTRMEMFUNC_FN_TYPE (rhstype)); int ctt = comp_target_types (ttl, ttr, 1); if (ctt < 0)