This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
C++ PATCH: Remove old ABI bits in libsupc++
- To: gcc-patches at gcc dot gnu dot org
- Subject: C++ PATCH: Remove old ABI bits in libsupc++
- From: Mark Mitchell <mark at codesourcery dot com>
- Date: Thu, 15 Feb 2001 17:33:59 -0800
- Organization: CodeSourcery, LLC
The libsupc++ library still contained support bits for the old ABI.
To make reading the code easier, I've applied this patch on the
mainline. I will also apply it on the branch in order to avoid user
confusion, and so that it is as easy as possible to apply any future
fixes in both places.
Tested on i686-pc-linux-gnu.
--
Mark Mitchell mark@codesourcery.com
CodeSourcery, LLC http://www.codesourcery.com
2001-02-15 Mark Mitchell <mark@codesourcery.com>
Remove old ABI support from libsupc++.
* libsupc++/cxxabi.h: Remove conditionally compiled code.
* libsupc++/exception_support.cc: Likewise.
* libsupc++/pure.cc: Likewise.
* libsupc++/tinfo.cc: Likewise.
* libsupc++/tinfo.h: Likewise.
* libsupc++/tinfo2.cc: Likewise.
* libsupc++/typeinfo: Likewise.
* libsupc++/vec.cc: Likewise.
Index: libsupc++/cxxabi.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/libsupc++/cxxabi.h,v
retrieving revision 1.2
diff -c -p -r1.2 cxxabi.h
*** cxxabi.h 2001/02/16 00:43:41 1.2
--- cxxabi.h 2001/02/16 01:22:19
***************
*** 42,53 ****
#ifndef __CXXABI_H
#define __CXXABI_H 1
- #if defined(__cplusplus) && (!defined(__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100)
- /* These structures only make sense when targeting the new abi, catch a
- bonehead error early rather than let the user get very confused. */
- #error "Not targetting the new abi, supply -fnew-abi"
- #endif
-
#ifdef __cplusplus
// We use the compiler builtins __SIZE_TYPE__ and __PTRDIFF_TYPE__ instead of
--- 42,47 ----
Index: libsupc++/exception_support.cc
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/libsupc++/exception_support.cc,v
retrieving revision 1.9
diff -c -p -r1.9 exception_support.cc
*** exception_support.cc 2001/02/16 00:43:41 1.9
--- exception_support.cc 2001/02/16 01:22:19
*************** __cplus_type_matcher (__eh_info *info_,
*** 151,160 ****
void *match_type = match_info;
- #if !defined (__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100
- match_type = ((void *(*)())match_type) ();
- #endif
-
if (__throw_type_match_rtti_2 (match_type, info->type,
info->original_value, &info->value))
// Arbitrary non-null pointer.
--- 151,156 ----
*************** __check_null_eh_spec (void)
*** 352,358 ****
// Helpers for rtti. Although these don't return, we give them return types so
// that the type system is not broken.
extern "C" void *
! __cxa_bad_cast()
{
#ifdef __EXCEPTIONS
throw std::bad_cast();
--- 348,354 ----
// Helpers for rtti. Although these don't return, we give them return types so
// that the type system is not broken.
extern "C" void *
! __cxa_bad_cast ()
{
#ifdef __EXCEPTIONS
throw std::bad_cast();
*************** __cxa_bad_cast()
*** 363,369 ****
}
extern "C" std::type_info const &
! __cxa_bad_typeid()
{
#ifdef __EXCEPTIONS
throw std::bad_typeid();
--- 359,365 ----
}
extern "C" std::type_info const &
! __cxa_bad_typeid ()
{
#ifdef __EXCEPTIONS
throw std::bad_typeid();
Index: libsupc++/pure.cc
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/libsupc++/pure.cc,v
retrieving revision 1.6
diff -c -p -r1.6 pure.cc
*** pure.cc 2001/02/16 00:43:41 1.6
--- pure.cc 2001/02/16 01:22:19
***************
*** 1,6 ****
// -*- C++ -*-
!
! // Copyright (C) 2000 Free Software Foundation
//
// This file is part of GNU CC.
//
--- 1,5 ----
// -*- C++ -*-
! // Copyright (C) 2000, 2001 Free Software Foundation
//
// This file is part of GNU CC.
//
*************** extern "C" {
*** 47,62 ****
extern void __terminate(void) __attribute__ ((__noreturn__));
- // The name of the function to be placed in vtables in place of a pure
- // virtual function is different in the two ABIs.
- #if !defined(__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100
- #define PURE_VIRTUAL_NAME __pure_virtual
- #else
- #define PURE_VIRTUAL_NAME __cxa_pure_virtual
- #endif
-
void
! PURE_VIRTUAL_NAME (void)
{
writestr ("pure virtual method called\n");
__terminate ();
--- 46,53 ----
extern void __terminate(void) __attribute__ ((__noreturn__));
void
! __cxa_pure_virtual (void)
{
writestr ("pure virtual method called\n");
__terminate ();
Index: libsupc++/tinfo.cc
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/libsupc++/tinfo.cc,v
retrieving revision 1.4
diff -c -p -r1.4 tinfo.cc
*** tinfo.cc 2001/02/16 00:43:41 1.4
--- tinfo.cc 2001/02/16 01:22:19
***************
*** 1,6 ****
// Methods for type_info for -*- C++ -*- Run Time Type Identification.
!
! // Copyright (C) 1994, 1996, 1998, 1999, 2000 Free Software Foundation
//
// This file is part of GNU CC.
//
--- 1,5 ----
// Methods for type_info for -*- C++ -*- Run Time Type Identification.
! // Copyright (C) 1994, 1996, 1998, 1999, 2000, 2001 Free Software Foundation
//
// This file is part of GNU CC.
//
*************** operator== (const std::type_info& arg) c
*** 53,552 ****
#endif
- #if !defined(__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100
- // original (old) abi
-
- namespace
- {
- // ADDR is a pointer to an object. Convert it to a pointer to a base,
- // using OFFSET.
- inline void*
- convert_to_base (void *addr, bool is_virtual, myint32 offset)
- {
- if (!addr)
- return NULL;
-
- if (!is_virtual)
- return (char *) addr + offset;
-
- // Under the old ABI, the offset gives us the address of a pointer
- // to the virtual base.
- return *((void **) ((char *) addr + offset));
- }
-
- }
-
- extern "C" void
- __rtti_class (void *addr, const char *name,
- const __class_type_info::base_info *bl, std::size_t bn)
- { new (addr) __class_type_info (name, bl, bn); }
-
- extern "C" void
- __rtti_si (void *addr, const char *n, const std::type_info *ti)
- {
- new (addr) __si_type_info
- (n, static_cast <const __user_type_info &> (*ti));
- }
-
- extern "C" void
- __rtti_user (void *addr, const char *name)
- { new (addr) __user_type_info (name); }
-
- // Upcast for catch checking. OBJPTR points to the thrown object and might be
- // NULL. Return 0 on failure, non-zero on success. Set *ADJPTR to adjusted
- // object pointer.
- int __user_type_info::
- upcast (const type_info &target, void *objptr,
- void **adjptr) const
- {
- upcast_result result;
-
- if (do_upcast (contained_public, target, objptr, result))
- return 0;
- *adjptr = result.target_obj;
- return contained_public_p (result.whole2target);
- }
-
- // Down or cross cast for dynamic_cast. OBJPTR points to the most derrived
- // object, SUBPTR points to the static base object. Both must not be NULL.
- // TARGET specifies the desired target type, SUBTYPE specifies the static
- // type. Both must be defined. Returns adjusted object pointer on success,
- // NULL on failure. [expr.dynamic.cast]/8 says 'unambiguous public base'. This
- // itself is an ambiguous statement. We choose it to mean the base must be
- // separately unambiguous and public, rather than unambiguous considering only
- // public bases.
- void *__user_type_info::
- dyncast (int boff,
- const type_info &target, void *objptr,
- const type_info &subtype, void *subptr) const
- {
- dyncast_result result;
-
- do_dyncast (boff, contained_public,
- target, objptr, subtype, subptr, result);
- if (!result.target_obj)
- return NULL;
- if (contained_public_p (result.target2sub))
- return result.target_obj;
- if (contained_public_p (sub_kind (result.whole2sub & result.whole2target)))
- // Found a valid cross cast
- return result.target_obj;
- if (contained_nonvirtual_p (result.whole2sub))
- // Found an invalid cross cast, which cannot also be a down cast
- return NULL;
- if (result.target2sub == unknown)
- result.target2sub = static_cast <const __user_type_info &> (target)
- .find_public_subobj (boff, subtype,
- result.target_obj, subptr);
- if (contained_public_p (result.target2sub))
- // Found a valid down cast
- return result.target_obj;
- // Must be an invalid down cast, or the cross cast wasn't bettered
- return NULL;
- }
-
- // Catch cast helper. ACCESS_PATH is the access from the complete thrown
- // object to this base. TARGET is the desired type we want to catch. OBJPTR
- // points to this base within the throw object, it might be NULL. Fill in
- // RESULT with what we find. Return true, should we determine catch must fail.
- bool __user_type_info::
- do_upcast (sub_kind access_path,
- const type_info &target, void *objptr,
- upcast_result &__restrict result) const
- {
- if (*this == target)
- {
- result.target_obj = objptr;
- result.base_type = nonvirtual_base_type;
- result.whole2target = access_path;
- return contained_nonpublic_p (access_path);
- }
- return false;
- }
-
- // dynamic cast helper. ACCESS_PATH gives the access from the most derived
- // object to this base. TARGET indicates the desired type we want. OBJPTR
- // points to this base within the object. SUBTYPE indicates the static type
- // started from and SUBPTR points to that base within the most derived object.
- // Fill in RESULT with what we find. Return true if we have located an
- // ambiguous match.
- bool __user_type_info::
- do_dyncast (int, sub_kind access_path,
- const type_info &target, void *objptr,
- const type_info &subtype, void *subptr,
- dyncast_result &__restrict result) const
- {
- if (objptr == subptr && *this == subtype)
- {
- // The subobject we started from. Indicate how we are accessible from
- // the most derived object.
- result.whole2sub = access_path;
- return false;
- }
- if (*this == target)
- {
- result.target_obj = objptr;
- result.whole2target = access_path;
- result.target2sub = not_contained;
- return false;
- }
- return false;
- }
-
- // find_public_subobj helper. Return contained_public if we are the desired
- // subtype. OBJPTR points to this base type, SUBPTR points to the desired base
- // object.
- __user_type_info::sub_kind __user_type_info::
- do_find_public_subobj (int, const type_info &, void *objptr, void *subptr) const
- {
- if (subptr == objptr)
- // Must be our type, as the pointers match.
- return contained_public;
- return not_contained;
- }
-
- // catch helper for single public inheritance types. See
- // __user_type_info::do_upcast for semantics.
- bool __si_type_info::
- do_upcast (sub_kind access_path,
- const type_info &target, void *objptr,
- upcast_result &__restrict result) const
- {
- if (*this == target)
- {
- result.target_obj = objptr;
- result.base_type = nonvirtual_base_type;
- result.whole2target = access_path;
- return contained_nonpublic_p (access_path);
- }
- return base.do_upcast (access_path, target, objptr, result);
- }
-
- // dynamic cast helper for single public inheritance types. See
- // __user_type_info::do_dyncast for semantics. BOFF indicates how SUBTYPE
- // types are inherited by TARGET types.
- bool __si_type_info::
- do_dyncast (int boff, sub_kind access_path,
- const type_info &target, void *objptr,
- const type_info &subtype, void *subptr,
- dyncast_result &__restrict result) const
- {
- if (objptr == subptr && *this == subtype)
- {
- // The subobject we started from. Indicate how we are accessible from
- // the most derived object.
- result.whole2sub = access_path;
- return false;
- }
- if (*this == target)
- {
- result.target_obj = objptr;
- result.whole2target = access_path;
- if (boff >= 0)
- result.target2sub = ((char *)subptr - (char *)objptr) == boff
- ? contained_public : not_contained;
- else if (boff == -2)
- result.target2sub = not_contained;
- return false;
- }
- return base.do_dyncast (boff, access_path,
- target, objptr, subtype, subptr, result);
- }
-
- // find_public_subobj helper. See __user_type_info::do_find_public_subobj or
- // semantics. BOFF indicates how SUBTYPE types are inherited by the original
- // target object.
- __user_type_info::sub_kind __si_type_info::
- do_find_public_subobj (int boff, const type_info &subtype, void *objptr, void *subptr) const
- {
- if (subptr == objptr && subtype == *this)
- return contained_public;
- return base.do_find_public_subobj (boff, subtype, objptr, subptr);
- }
-
- // catch helper for multiple or non-public inheritance types. See
- // __user_type_info::do_upcast for semantics.
- bool __class_type_info::
- do_upcast (sub_kind access_path,
- const type_info &target, void *objptr,
- upcast_result &__restrict result) const
- {
- if (*this == target)
- {
- result.target_obj = objptr;
- result.base_type = nonvirtual_base_type;
- result.whole2target = access_path;
- return contained_nonpublic_p (access_path);
- }
-
- for (std::size_t i = n_bases; i--;)
- {
- upcast_result result2;
- void *p = objptr;
- sub_kind sub_access = access_path;
- p = convert_to_base (p,
- base_list[i].is_virtual,
- base_list[i].offset);
- if (base_list[i].is_virtual)
- sub_access = sub_kind (sub_access | contained_virtual_mask);
- if (base_list[i].access != PUBLIC)
- sub_access = sub_kind (sub_access & ~contained_public_mask);
- if (base_list[i].base->do_upcast (sub_access, target, p, result2)
- && !contained_virtual_p (result2.whole2target))
- return true; // must fail
- if (result2.base_type)
- {
- if (result2.base_type == nonvirtual_base_type
- && base_list[i].is_virtual)
- result2.base_type = base_list[i].base;
- if (!result.base_type)
- result = result2;
- else if (result.target_obj != result2.target_obj)
- {
- // Found an ambiguity.
- result.target_obj = NULL;
- result.whole2target = contained_ambig;
- return true;
- }
- else if (result.target_obj)
- {
- // Ok, found real object via a virtual path.
- result.whole2target
- = sub_kind (result.whole2target | result2.whole2target);
- }
- else
- {
- // Dealing with a null pointer, need to check vbase
- // containing each of the two choices.
- if (result2.base_type == nonvirtual_base_type
- || result.base_type == nonvirtual_base_type
- || !(*result2.base_type == *result.base_type))
- {
- // Already ambiguous, not virtual or via different virtuals.
- // Cannot match.
- result.whole2target = contained_ambig;
- return true;
- }
- result.whole2target
- = sub_kind (result.whole2target | result2.whole2target);
- }
- }
- }
- return false;
- }
-
- // dynamic cast helper for non-public or multiple inheritance types. See
- // __user_type_info::do_dyncast for overall semantics.
- // This is a big hairy function. Although the run-time behaviour of
- // dynamic_cast is simple to describe, it gives rise to some non-obvious
- // behaviour. We also desire to determine as early as possible any definite
- // answer we can get. Because it is unknown what the run-time ratio of
- // succeeding to failing dynamic casts is, we do not know in which direction
- // to bias any optimizations. To that end we make no particular effort towards
- // early fail answers or early success answers. Instead we try to minimize
- // work by filling in things lazily (when we know we need the information),
- // and opportunisticly take early success or failure results.
- bool __class_type_info::
- do_dyncast (int boff, sub_kind access_path,
- const type_info &target, void *objptr,
- const type_info &subtype, void *subptr,
- dyncast_result &__restrict result) const
- {
- if (objptr == subptr && *this == subtype)
- {
- // The subobject we started from. Indicate how we are accessible from
- // the most derived object.
- result.whole2sub = access_path;
- return false;
- }
- if (*this == target)
- {
- result.target_obj = objptr;
- result.whole2target = access_path;
- if (boff >= 0)
- result.target2sub = ((char *)subptr - (char *)objptr) == boff
- ? contained_public : not_contained;
- else if (boff == -2)
- result.target2sub = not_contained;
- return false;
- }
- bool result_ambig = false;
- for (std::size_t i = n_bases; i--;)
- {
- dyncast_result result2;
- void *p;
- sub_kind sub_access = access_path;
- p = convert_to_base (objptr,
- base_list[i].is_virtual,
- base_list[i].offset);
- if (base_list[i].is_virtual)
- sub_access = sub_kind (sub_access | contained_virtual_mask);
- if (base_list[i].access != PUBLIC)
- sub_access = sub_kind (sub_access & ~contained_public_mask);
-
- bool result2_ambig
- = base_list[i].base->do_dyncast (boff, sub_access,
- target, p, subtype, subptr, result2);
- result.whole2sub = sub_kind (result.whole2sub | result2.whole2sub);
- if (result2.target2sub == contained_public
- || result2.target2sub == contained_ambig)
- {
- result.target_obj = result2.target_obj;
- result.whole2target = result2.whole2target;
- result.target2sub = result2.target2sub;
- // Found a downcast which can't be bettered or an ambiguous downcast
- // which can't be disambiguated
- return result2_ambig;
- }
-
- if (!result_ambig && !result.target_obj)
- {
- // Not found anything yet.
- result.target_obj = result2.target_obj;
- result.whole2target = result2.whole2target;
- result_ambig = result2_ambig;
- }
- else if (result.target_obj && result.target_obj == result2.target_obj)
- {
- // Found at same address, must be via virtual. Pick the most
- // accessible path.
- result.whole2target =
- sub_kind (result.whole2target | result2.whole2target);
- }
- else if ((result.target_obj && result2.target_obj)
- || (result_ambig && result2.target_obj)
- || (result2_ambig && result.target_obj))
- {
- // Found two different TARGET bases, or a valid one and a set of
- // ambiguous ones, must disambiguate. See whether SUBOBJ is
- // contained publicly within one of the non-ambiguous choices.
- // If it is in only one, then that's the choice. If it is in
- // both, then we're ambiguous and fail. If it is in neither,
- // we're ambiguous, but don't yet fail as we might later find a
- // third base which does contain SUBPTR.
-
- sub_kind new_sub_kind = result2.target2sub;
- sub_kind old_sub_kind = result.target2sub;
-
- if (contained_nonvirtual_p (result.whole2sub))
- {
- // We already found SUBOBJ as a non-virtual base of most
- // derived. Therefore if it is in either choice, it can only be
- // in one of them, and we will already know.
- if (old_sub_kind == unknown)
- old_sub_kind = not_contained;
- if (new_sub_kind == unknown)
- new_sub_kind = not_contained;
- }
- else
- {
- const __user_type_info &t =
- static_cast <const __user_type_info &> (target);
-
- if (old_sub_kind >= not_contained)
- ;// already calculated
- else if (contained_nonvirtual_p (new_sub_kind))
- // Already found non-virtually inside the other choice,
- // cannot be in this.
- old_sub_kind = not_contained;
- else
- old_sub_kind = t.find_public_subobj (boff, subtype,
- result.target_obj, subptr);
-
- if (new_sub_kind >= not_contained)
- ;// already calculated
- else if (contained_nonvirtual_p (old_sub_kind))
- // Already found non-virtually inside the other choice,
- // cannot be in this.
- new_sub_kind = not_contained;
- else
- new_sub_kind = t.find_public_subobj (boff, subtype,
- result2.target_obj, subptr);
- }
-
- // Neither sub_kind can be contained_ambig -- we bail out early
- // when we find those.
- if (contained_p (sub_kind (new_sub_kind ^ old_sub_kind)))
- {
- // Only on one choice, not ambiguous.
- if (contained_p (new_sub_kind))
- {
- // Only in new.
- result.target_obj = result2.target_obj;
- result.whole2target = result2.whole2target;
- result_ambig = false;
- old_sub_kind = new_sub_kind;
- }
- result.target2sub = old_sub_kind;
- if (result.target2sub == contained_public)
- return false; // Can't be an ambiguating downcast for later discovery.
- }
- else if (contained_p (sub_kind (new_sub_kind & old_sub_kind)))
- {
- // In both.
- result.target_obj = NULL;
- result.target2sub = contained_ambig;
- return true; // Fail.
- }
- else
- {
- // In neither publicly, ambiguous for the moment, but keep
- // looking. It is possible that it was private in one or
- // both and therefore we should fail, but that's just tough.
- result.target_obj = NULL;
- result.target2sub = not_contained;
- result_ambig = true;
- }
- }
-
- if (result.whole2sub == contained_private)
- // We found SUBOBJ as a private non-virtual base, therefore all
- // cross casts will fail. We have already found a down cast, if
- // there is one.
- return result_ambig;
- }
-
- return result_ambig;
- }
-
- // find_public_subobj helper for non-public or multiple inheritance types. See
- // __user_type_info::do_find_public_subobj for semantics. We make use of BOFF
- // to prune the base class walk.
- __user_type_info::sub_kind __class_type_info::
- do_find_public_subobj (int boff, const type_info &subtype, void *objptr, void *subptr) const
- {
- if (objptr == subptr && subtype == *this)
- return contained_public;
-
- for (std::size_t i = n_bases; i--;)
- {
- if (base_list[i].access != PUBLIC)
- continue; // Not public, can't be here.
- void *p;
-
- if (base_list[i].is_virtual && boff == -3)
- // Not a virtual base, so can't be here.
- continue;
-
- p = convert_to_base (objptr,
- base_list[i].is_virtual,
- base_list[i].offset);
-
- sub_kind base_kind = base_list[i].base->do_find_public_subobj
- (boff, subtype, p, subptr);
- if (contained_p (base_kind))
- {
- if (base_list[i].is_virtual)
- base_kind = sub_kind (base_kind | contained_virtual_mask);
- return base_kind;
- }
- }
-
- return not_contained;
- }
- #else
- // new abi
-
namespace std {
// return true if this is a type_info for a pointer type
--- 52,57 ----
*************** __dynamic_cast (const void *src_ptr,
*** 1212,1215 ****
}
}; // namespace __cxxabiv1
- #endif
--- 717,719 ----
Index: libsupc++/tinfo.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/libsupc++/tinfo.h,v
retrieving revision 1.4
diff -c -p -r1.4 tinfo.h
*** tinfo.h 2001/02/16 00:43:41 1.4
--- tinfo.h 2001/02/16 01:22:19
***************
*** 1,225 ****
// RTTI support internals for -*- C++ -*-
!
! // Copyright (C) 1994, 1995, 1996, 1998, 1999, 2000 Free Software Foundation
!
#include "typeinfo"
#include <cstddef>
// Class declarations shared between the typeinfo implementation files.
- #if !defined(__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100
- // original (old) abi
-
- // type_info for a class with no base classes (or an enum).
-
- struct __user_type_info : public std::type_info {
- __user_type_info (const char *n) : type_info (n) {}
-
- // If our type can be upcast to a public and unambiguous base, then return
- // non-zero and set RES to point to the base object. OBJ points to the throw
- // object and can be NULL, if there is no object to adjust.
- int upcast (const type_info &target, void *obj, void **res) const;
-
- // If our type can be dynamicly cast to the target type, then return
- // pointer to the target object. OBJ is the pointer to the most derived
- // type and cannot be NULL. SUBTYPE and SUBOBJ indicate the static type
- // base object from whence we came, it cannot be NULL. SUBTYPE cannot be
- // the same as TARGET. TARGET cannot be a base of SUBTYPE.
- // BOFF indicates how SUBTYPE is related to TARGET.
- // BOFF >= 0, there is only one public non-virtual SUBTYPE base at offset
- // BOFF, and there are no public virtual SUBTYPE bases.
- // Therefore check if SUBOBJ is at offset BOFF when we find a target
- // BOFF == -1, SUBTYPE occurs as multiple public virtual or non-virtual bases.
- // Lazily search all the bases of TARGET.
- // BOFF == -2, SUBTYPE is not a public base.
- // BOFF == -3, SUBTYPE occurs as multiple public non-virtual bases.
- // Lazily search the non-virtual bases of TARGET.
- // For backwards compatibility set BOFF to -1, that is the safe "unknown"
- // value. We do not care about SUBTYPES as private bases of TARGET, as they
- // can never succeed as downcasts, only as crosscasts -- and then only if
- // they are virtual. This is more complicated that it might seem.
- void *dyncast (int boff,
- const type_info &target, void *obj,
- const type_info &subtype, void *subobj) const;
-
- // non_virtual_base_type is used to indicate that a base class is via a
- // non-virtual access path.
- static const type_info *const nonvirtual_base_type
- = static_cast <const type_info *> (0) + 1;
-
- // sub_kind tells us about how a base object is contained within a derived
- // object. We often do this lazily, hence the UNKNOWN value. At other times
- // we may use NOT_CONTAINED to mean not publicly contained.
- enum sub_kind
- {
- unknown = 0, // we have no idea
- not_contained, // not contained within us (in some
- // circumstances this might mean not contained
- // publicly)
- contained_ambig, // contained ambiguously
- contained_mask = 4, // contained within us
- contained_virtual_mask = 1, // via a virtual path
- contained_public_mask = 2, // via a public path
- contained_private = contained_mask,
- contained_public = contained_mask | contained_public_mask
- };
- // some predicate functions for sub_kind
- static inline bool contained_p (sub_kind access_path)
- {
- return access_path >= contained_mask;
- }
- static inline bool contained_public_p (sub_kind access_path)
- {
- return access_path >= contained_public;
- }
- static inline bool contained_nonpublic_p (sub_kind access_path)
- {
- return (access_path & contained_public) == contained_mask;
- }
- static inline bool contained_nonvirtual_p (sub_kind access_path)
- {
- return (access_path & (contained_mask | contained_virtual_mask))
- == contained_mask;
- }
- static inline bool contained_virtual_p (sub_kind access_path)
- {
- return (access_path & (contained_mask | contained_virtual_mask))
- == (contained_mask | contained_virtual_mask);
- }
-
- struct upcast_result
- {
- void *target_obj; // pointer to target object or NULL (init NULL)
- sub_kind whole2target; // path from most derived object to target
- const type_info *base_type; // where we found the target, (init NULL)
- // if in vbase the __user_type_info of vbase)
- // if a non-virtual base then 1
- // else NULL
- public:
- upcast_result ()
- :target_obj (NULL), whole2target (unknown), base_type (NULL)
- {}
- };
- struct dyncast_result
- {
- void *target_obj; // pointer to target object or NULL (init NULL)
- sub_kind whole2target; // path from most derived object to target
- sub_kind whole2sub; // path from most derived object to sub object
- sub_kind target2sub; // path from target to sub object
-
- public:
- dyncast_result ()
- :target_obj (NULL), whole2target (unknown),
- whole2sub (unknown), target2sub (unknown)
- {}
- };
-
- public:
- // Helper for upcast. See if TARGET is us, or one of our bases. ACCESS_PATH
- // gives the access from the start object. Return TRUE if we know the catch
- // fails.
- virtual bool do_upcast (sub_kind access_path,
- const type_info &target, void *obj,
- upcast_result &__restrict result) const;
- // Helper for dyncast. BOFF indicates how the SUBTYPE is related to TARGET.
- // ACCESS_PATH indicates the access from the most derived object. It is
- // used to prune the DAG walk. All information about what we find is put
- // into RESULT. Return true, if the match we have found is ambiguous.
- virtual bool do_dyncast (int boff, sub_kind access_path,
- const type_info &target, void *obj,
- const type_info &subtype, void *subptr,
- dyncast_result &__restrict result) const;
- public:
- // Indicate whether SUBPTR of type SUBTYPE is contained publicly within
- // OBJPTR. OBJPTR points to this base object. BOFF indicates how SUBTYPE
- // objects might be contained within this type. If SUBPTR is one of our
- // SUBTYPE bases, indicate virtuality. Returns not_contained for non
- // containment or private containment.
- sub_kind find_public_subobj (int boff, const type_info &subtype,
- void *objptr, void *subptr) const
- {
- if (boff >= 0)
- return ((char *)subptr - (char *)objptr) == boff
- ? contained_public : not_contained;
- if (boff == -2)
- return not_contained;
- return do_find_public_subobj (boff, subtype, objptr, subptr);
- }
-
- public:
- // Helper for find_subobj. BOFF indicates how SUBTYPE bases are inherited by
- // the type started from -- which is not necessarily the current type.
- // OBJPTR points to the current base.
- virtual sub_kind do_find_public_subobj (int boff, const type_info &subtype,
- void *objptr, void *subptr) const;
- };
-
- // type_info for a class with one public, nonvirtual base class.
-
- class __si_type_info : public __user_type_info {
- const __user_type_info &base;
-
- public:
- __si_type_info (const char *n, const __user_type_info &b)
- : __user_type_info (n), base (b) { }
-
- private:
- virtual bool do_upcast (sub_kind access_path,
- const type_info &target, void *obj,
- upcast_result &__restrict result) const;
- virtual bool do_dyncast (int boff, sub_kind access_path,
- const type_info &target, void *obj,
- const type_info &subtype, void *subptr,
- dyncast_result &__restrict result) const;
- virtual sub_kind do_find_public_subobj (int boff, const type_info &subtype,
- void *objptr, void *subptr) const;
- };
-
- // type_info for a general class.
-
- #include <climits>
-
- #if INT_MAX == 2147483647
- typedef int myint32;
- #elif SHRT_MAX == 2147483647
- typedef short myint32;
- #elif SCHAR_MAX == 2147483647
- typedef signed char myint32;
- #elif LONG_MAX == 2147483647
- typedef long myint32;
- #else
- # error "No 32-bit data type?"
- #endif
-
- struct __class_type_info : public __user_type_info {
- enum access { PUBLIC = 1, PROTECTED = 2, PRIVATE = 3 };
-
- struct base_info {
- const __user_type_info *base;
- myint32 offset: 29;
- bool is_virtual: 1;
- enum access access: 2;
- };
-
- const base_info *base_list;
- std::size_t n_bases;
-
- __class_type_info (const char *name, const base_info *bl, std::size_t bn)
- : __user_type_info (name), base_list (bl), n_bases (bn) {}
-
- public:
- virtual bool do_upcast (sub_kind access_path,
- const type_info &target, void *obj,
- upcast_result &__restrict result) const;
- virtual bool do_dyncast (int boff, sub_kind access_path,
- const type_info &target, void *obj,
- const type_info &subtype, void *subptr,
- dyncast_result &__restrict result) const;
- virtual sub_kind do_find_public_subobj (int boff, const type_info &subtype,
- void *objptr, void *subptr) const;
- };
- #else
- // new abi
#include <cxxabi.h>
- #endif
--- 1,9 ----
// RTTI support internals for -*- C++ -*-
! // Copyright (C) 1994, 1995, 1996, 1998, 1999, 2000, 2001 Free Software Foundation
#include "typeinfo"
#include <cstddef>
// Class declarations shared between the typeinfo implementation files.
#include <cxxabi.h>
Index: libsupc++/tinfo2.cc
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/libsupc++/tinfo2.cc,v
retrieving revision 1.4
diff -c -p -r1.4 tinfo2.cc
*** tinfo2.cc 2001/02/16 00:43:41 1.4
--- tinfo2.cc 2001/02/16 01:22:19
*************** type_info::before (const type_info &arg)
*** 48,112 ****
#endif
- #if !defined(__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100
-
- // type info for pointer type.
-
- struct __pointer_type_info : public type_info {
- const type_info& type;
-
- __pointer_type_info (const char *n, const type_info& ti)
- : type_info (n), type (ti) {}
- };
-
- // type info for attributes
-
- struct __attr_type_info : public type_info {
- enum cv { NONE = 0, CONST = 1, VOLATILE = 2, CONSTVOL = 1 | 2 };
-
- const type_info& type;
- cv attr;
-
- __attr_type_info (const char *n, cv a, const type_info& t)
- : type_info (n), type (t), attr (a) {}
- };
-
- // type_info for builtin type
-
- struct __builtin_type_info : public type_info {
- __builtin_type_info (const char *n): type_info (n) {}
- };
-
- // type info for function.
-
- struct __func_type_info : public type_info {
- __func_type_info (const char *n) : type_info (n) {}
- };
-
- // type info for pointer to member function.
-
- struct __ptmf_type_info : public type_info {
- __ptmf_type_info (const char *n) : type_info (n) {}
- };
-
- // type info for pointer to data member.
-
- struct __ptmd_type_info : public type_info {
- __ptmd_type_info (const char *n): type_info (n) {}
- };
-
- // type info for array.
-
- struct __array_type_info : public type_info {
- __array_type_info (const char *n): type_info (n) {}
- };
-
- #else
-
#include <cxxabi.h>
- #endif
- #if defined(__GXX_ABI_VERSION) && __GXX_ABI_VERSION >= 100
namespace __cxxabiv1 {
using namespace std;
--- 48,55 ----
*************** __pointer_catch (const __pbase_type_info
*** 222,228 ****
}
} // namespace std
- #endif
// Entry points for the compiler.
--- 165,170 ----
*************** __throw_type_match_rtti_2 (const void *c
*** 238,377 ****
*valp = objptr;
- #if !defined(__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100
- // old abi
- if (catch_type == throw_type)
- return 1;
-
- if (const __user_type_info *p
- = dynamic_cast <const __user_type_info *> (&throw_type))
- {
- return p->upcast (catch_type, objptr, valp);
- }
- else if (const __pointer_type_info *fr =
- dynamic_cast <const __pointer_type_info *> (&throw_type))
- {
- const __pointer_type_info *to =
- dynamic_cast <const __pointer_type_info *> (&catch_type);
-
- if (! to)
- return 0;
-
- const type_info *subfr = &fr->type, *subto = &to->type;
- __attr_type_info::cv cvfrom, cvto;
-
- if (const __attr_type_info *at
- = dynamic_cast <const __attr_type_info *> (subfr))
- {
- cvfrom = at->attr;
- subfr = &at->type;
- }
- else
- cvfrom = __attr_type_info::NONE;
-
- if (const __attr_type_info *at
- = dynamic_cast <const __attr_type_info *> (subto))
- {
- cvto = at->attr;
- subto = &at->type;
- }
- else
- cvto = __attr_type_info::NONE;
-
- if (((cvfrom & __attr_type_info::CONST)
- > (cvto & __attr_type_info::CONST))
- || ((cvfrom & __attr_type_info::VOLATILE)
- > (cvto & __attr_type_info::VOLATILE)))
- return 0;
-
- if (*subto == *subfr)
- return 1;
- else if (*subto == typeid (void)
- && dynamic_cast <const __func_type_info *> (subfr) == 0)
- return 1;
- else if (const __user_type_info *p
- = dynamic_cast <const __user_type_info *> (subfr))
- return p->upcast (*subto, objptr, valp);
- else if (const __pointer_type_info *pfr
- = dynamic_cast <const __pointer_type_info *> (subfr))
- {
- // Multi-level pointer conversion.
-
- const __pointer_type_info *pto
- = dynamic_cast <const __pointer_type_info *> (subto);
-
- if (! pto)
- return 0;
-
- bool constp = (cvto & __attr_type_info::CONST);
- for (subto = &pto->type, subfr = &pfr->type; ;
- subto = &pto->type, subfr = &pfr->type)
- {
- if (const __attr_type_info *at
- = dynamic_cast <const __attr_type_info *> (subfr))
- {
- cvfrom = at->attr;
- subfr = &at->type;
- }
- else
- cvfrom = __attr_type_info::NONE;
-
- if (const __attr_type_info *at
- = dynamic_cast <const __attr_type_info *> (subto))
- {
- cvto = at->attr;
- subto = &at->type;
- }
- else
- cvto = __attr_type_info::NONE;
-
- if (((cvfrom & __attr_type_info::CONST)
- > (cvto & __attr_type_info::CONST))
- || ((cvfrom & __attr_type_info::VOLATILE)
- > (cvto & __attr_type_info::VOLATILE)))
- return 0;
-
- if (! constp
- && (((cvfrom & __attr_type_info::CONST)
- < (cvto & __attr_type_info::CONST))
- || ((cvfrom & __attr_type_info::VOLATILE)
- < (cvto & __attr_type_info::VOLATILE))))
- return 0;
-
- if (*subto == *subfr)
- return 1;
-
- pto = dynamic_cast <const __pointer_type_info *> (subto);
- pfr = dynamic_cast <const __pointer_type_info *> (subfr);
- if (! pto || ! pfr)
- return 0;
-
- if (! (cvto & __attr_type_info::CONST))
- constp = false;
- }
- }
- }
- #else
- // new abi
-
return catch_type.__do_catch (&throw_type, valp, 1);
- #endif
- return 0;
- }
-
- #if !defined(__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100
- /* Backward compatibility wrapper. */
-
- extern "C" void*
- __throw_type_match_rtti (const void *catch_type_r, const void *throw_type_r,
- void *objptr)
- {
- void *ret;
- if (__throw_type_match_rtti_2 (catch_type_r, throw_type_r, objptr, &ret))
- return ret;
- return NULL;
}
- #endif
/* Called from __cp_pop_exception. Is P the type_info node for a pointer
of some kind? */
--- 180,187 ----
*************** bool
*** 380,459 ****
__is_pointer (void *p)
{
const type_info *t = reinterpret_cast <const type_info *>(p);
- #if !defined(__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100
- // old abi
- const __pointer_type_info *pt =
- dynamic_cast <const __pointer_type_info *> (t);
- return pt != 0;
- #else
- // new abi
return t->__is_pointer_p ();
- #endif
}
- #if !defined(__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100
- // old abi
-
- extern "C" void
- __rtti_ptr (void *addr, const char *n, const type_info *ti)
- { new (addr) __pointer_type_info (n, *ti); }
-
- extern "C" void
- __rtti_attr (void *addr, const char *n, int attrval, const type_info *ti)
- {
- new (addr) __attr_type_info
- (n, static_cast <__attr_type_info::cv> (attrval), *ti);
- }
-
- extern "C" void
- __rtti_func (void *addr, const char *name)
- { new (addr) __func_type_info (name); }
-
- extern "C" void
- __rtti_ptmf (void *addr, const char *name)
- { new (addr) __ptmf_type_info (name); }
-
- extern "C" void
- __rtti_ptmd (void *addr, const char *name)
- { new (addr) __ptmd_type_info (name); }
-
- extern "C" void
- __rtti_array (void *addr, const char *name)
- { new (addr) __array_type_info (name); }
-
- extern "C" void *
- __dynamic_cast (const type_info& (*from)(void), const type_info& (*to)(void),
- int require_public, void *address, const type_info & (*sub)(void), void *subptr)
- {
- if (!require_public) abort();
- return static_cast <__user_type_info const &> (from ()).dyncast
- (/*boff=*/-1, to (), address, sub (), subptr);
- }
-
- extern "C" void *
- __dynamic_cast_2 (const type_info& (*from)(void), const type_info& (*to)(void),
- int boff,
- void *address, const type_info & (*sub)(void), void *subptr)
- {
- return static_cast <__user_type_info const &> (from ()).dyncast
- (boff, to (), address, sub (), subptr);
- }
-
- // type_info nodes and functions for the builtin types. The mangling here
- // must match the mangling in gcc/cp/rtti.c.
-
- #define BUILTIN(mangled) \
- unsigned char __ti##mangled [sizeof (__builtin_type_info)] \
- __attribute__ ((aligned (__alignof__ (void *)))); \
- extern "C" const type_info &__tf##mangled (void) { \
- if ((*(void **) __ti##mangled) == 0) \
- new (__ti##mangled) __builtin_type_info (#mangled); \
- return *(type_info *)__ti##mangled; \
- }
-
- BUILTIN (v); BUILTIN (x); BUILTIN (l); BUILTIN (i); BUILTIN (s); BUILTIN (b);
- BUILTIN (c); BUILTIN (w); BUILTIN (r); BUILTIN (d); BUILTIN (f);
- BUILTIN (Ui); BUILTIN (Ul); BUILTIN (Ux); BUILTIN (Us); BUILTIN (Uc);
- BUILTIN (Sc);
-
- #endif
--- 190,195 ----
Index: libsupc++/typeinfo
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/libsupc++/typeinfo,v
retrieving revision 1.4
diff -c -p -r1.4 typeinfo
*** typeinfo 2001/02/16 00:43:41 1.4
--- typeinfo 2001/02/16 01:22:19
***************
*** 1,6 ****
// RTTI support for -*- C++ -*-
!
! // Copyright (C) 1994, 1995, 1996, 1997, 1998, 2000 Free Software Foundation
//
// This file is part of GNU CC.
//
--- 1,5 ----
// RTTI support for -*- C++ -*-
! // Copyright (C) 1994, 1995, 1996, 1997, 1998, 2000, 2001 Free Software Foundation
//
// This file is part of GNU CC.
//
***************
*** 28,38 ****
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
- // __GXX_ABI_VERSION distinguishes the ABI that is being used. Values <100
- // indicate the `old' abi, which grew as C++ was defined. Values >=100
- // indicate the `new' abi, which is a cross vendor C++ abi, documented at
- // `http://reality.sgi.com/dehnert_engr/cxx/'.
-
#ifndef __TYPEINFO__
#define __TYPEINFO__
--- 27,32 ----
***************
*** 42,64 ****
extern "C++" {
- #if defined(__GXX_ABI_VERSION) && __GXX_ABI_VERSION >= 100
namespace __cxxabiv1
{
class __class_type_info;
} // namespace __cxxabiv1
- #endif
!
! #if !defined(__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100
! // In the old ABI, typeinfo name strings were not merged.
! #define __GXX_MERGED_TYPEINFO_NAMES 0
! #elif !__GXX_WEAK__
! // If weak symbols are not supported, they are still not merged.
#define __GXX_MERGED_TYPEINFO_NAMES 0
#else
! // In the new ABI, on platforms that support weak symbols, they are
! // merged.
#define __GXX_MERGED_TYPEINFO_NAMES 1
#endif
--- 36,51 ----
extern "C++" {
namespace __cxxabiv1
{
class __class_type_info;
} // namespace __cxxabiv1
! #if !__GXX_WEAK__
! // If weak symbols are not supported, typeinfo names are not merged.
#define __GXX_MERGED_TYPEINFO_NAMES 0
#else
! // On platforms that support weak symbols, typeinfo names are merged.
#define __GXX_MERGED_TYPEINFO_NAMES 1
#endif
*************** namespace std
*** 86,98 ****
public:
// the public interface
- #if !defined(__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100
const char* name() const
{ return __name; }
- #else
- const char* name() const
- { return __name; }
- #endif
#if !__GXX_MERGED_TYPEINFO_NAMES
bool before(const type_info& arg) const;
--- 73,80 ----
*************** namespace std
*** 112,118 ****
{ return !operator==(__arg); }
// the internal interface
- #if defined(__GXX_ABI_VERSION) && __GXX_ABI_VERSION >= 100
public:
// return true if this is a pointer type of some kind
virtual bool __is_pointer_p() const;
--- 94,99 ----
*************** namespace std
*** 131,137 ****
// internally used during catch matching
virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
void **__obj_ptr) const;
- #endif
};
class bad_cast : public exception
--- 112,117 ----
Index: libsupc++/vec.cc
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/libsupc++/vec.cc,v
retrieving revision 1.4
diff -c -p -r1.4 vec.cc
*** vec.cc 2001/02/16 00:43:41 1.4
--- vec.cc 2001/02/16 01:22:19
*************** namespace __cxxabiv1
*** 298,300 ****
--- 298,301 ----
dealloc(base, size);
}
} // namespace __cxxabiv1
+