libstdc++-v3/libsupc++/tinfo2.cc

   1 // Methods for type_info for -*- C++ -*- Run Time Type Identification.
   2
   3 // Copyright (C) 1994, 1996, 1997, 1998, 1999, 2000, 2001, 2002
   4 // Free Software Foundation
   5 //
   6 // This file is part of GCC.
   7 //
   8 // GCC is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 2, or (at your option)
  11 // any later version.
  12
  13 // GCC is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17
  18 // You should have received a copy of the GNU General Public License
  19 // along with GCC; see the file COPYING.  If not, write to
  20 // the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  21 // Boston, MA 02110-1301, USA.
  22
  23 // As a special exception, you may use this file as part of a free software
  24 // library without restriction.  Specifically, if other files instantiate
  25 // templates or use macros or inline functions from this file, or you compile
  26 // this file and link it with other files to produce an executable, this
  27 // file does not by itself cause the resulting executable to be covered by
  28 // the GNU General Public License.  This exception does not however
  29 // invalidate any other reasons why the executable file might be covered by
  30 // the GNU General Public License.
  31
  32 #include <cstddef>
  33 #include "tinfo.h"
  34 #include "new"                  // for placement new
  35
  36 // We can't rely on having stdlib.h if we're freestanding.
  37 extern "C" void abort ();
  38
  39 using std::type_info;
  40
  41 #if !__GXX_TYPEINFO_EQUALITY_INLINE
  42
  43 bool
  44 type_info::before (const type_info &arg) const
  45 {
  46 #if __GXX_MERGED_TYPEINFO_NAMES
  47   return name () < arg.name ();
  48 #else
  49   return __builtin_strcmp (name (), arg.name ()) < 0;
  50 #endif
  51 }
  52
  53 #endif
  54
  55 #include <cxxabi.h>
  56
  57 namespace __cxxabiv1 {
  58
  59 using namespace std;
  60
  61 // This has special meaning to the compiler, and will cause it
  62 // to emit the type_info structures for the fundamental types which are
  63 // mandated to exist in the runtime.
  64 __fundamental_type_info::
  65 ~__fundamental_type_info ()
  66 {}
  67
  68 __array_type_info::
  69 ~__array_type_info ()
  70 {}
  71
  72 __function_type_info::
  73 ~__function_type_info ()
  74 {}
  75
  76 __enum_type_info::
  77 ~__enum_type_info ()
  78 {}
  79
  80 __pbase_type_info::
  81 ~__pbase_type_info ()
  82 {}
  83
  84 __pointer_type_info::
  85 ~__pointer_type_info ()
  86 {}
  87
  88 __pointer_to_member_type_info::
  89 ~__pointer_to_member_type_info ()
  90 {}
  91
  92 bool __pointer_type_info::
  93 __is_pointer_p () const
  94 {
  95   return true;
  96 }
  97
  98 bool __function_type_info::
  99 __is_function_p () const
 100 {
 101   return true;
 102 }
 103
 104 bool __pbase_type_info::
 105 __do_catch (const type_info *thr_type,
 106             void **thr_obj,
 107             unsigned outer) const
 108 {
 109   if (*this == *thr_type)
 110     return true;      // same type
 111   if (typeid (*this) != typeid (*thr_type))
 112     return false;     // not both same kind of pointers
 113
 114   if (!(outer & 1))
 115     // We're not the same and our outer pointers are not all const qualified
 116     // Therefore there must at least be a qualification conversion involved
 117     // But for that to be valid, our outer pointers must be const qualified.
 118     return false;
 119
 120   const __pbase_type_info *thrown_type =
 121     static_cast <const __pbase_type_info *> (thr_type);
 122
 123   if (thrown_type->__flags & ~__flags)
 124     // We're less qualified.
 125     return false;
 126
 127   if (!(__flags & __const_mask))
 128     outer &= ~1;
 129
 130   return __pointer_catch (thrown_type, thr_obj, outer);
 131 }
 132
 133 inline bool __pbase_type_info::
 134 __pointer_catch (const __pbase_type_info *thrown_type,
 135                  void **thr_obj,
 136                  unsigned outer) const
 137 {
 138   return __pointee->__do_catch (thrown_type->__pointee, thr_obj, outer + 2);
 139 }
 140
 141 bool __pointer_type_info::
 142 __pointer_catch (const __pbase_type_info *thrown_type,
 143                  void **thr_obj,
 144                  unsigned outer) const
 145 {
 146   if (outer < 2 && *__pointee == typeid (void))
 147     {
 148       // conversion to void
 149       return !thrown_type->__pointee->__is_function_p ();
 150     }
 151
 152   return __pbase_type_info::__pointer_catch (thrown_type, thr_obj, outer);
 153 }
 154
 155 bool __pointer_to_member_type_info::
 156 __pointer_catch (const __pbase_type_info *thr_type,
 157                  void **thr_obj,
 158                  unsigned outer) const
 159 {
 160   // This static cast is always valid, as our caller will have determined that
 161   // thr_type is really a __pointer_to_member_type_info.
 162   const __pointer_to_member_type_info *thrown_type =
 163     static_cast <const __pointer_to_member_type_info *> (thr_type);
 164
 165   if (*__context != *thrown_type->__context)
 166     return false;     // not pointers to member of same class
 167
 168   return __pbase_type_info::__pointer_catch (thrown_type, thr_obj, outer);
 169 }
 170
 171 } // namespace std