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

   1 // Copyright (C) 1994-2022 Free Software Foundation, Inc.
   2 //
   3 // This file is part of GCC.
   4 //
   5 // GCC is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 3, or (at your option)
   8 // any later version.
   9
  10 // GCC is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // Under Section 7 of GPL version 3, you are granted additional
  16 // permissions described in the GCC Runtime Library Exception, version
  17 // 3.1, as published by the Free Software Foundation.
  18
  19 // You should have received a copy of the GNU General Public License and
  20 // a copy of the GCC Runtime Library Exception along with this program;
  21 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  22 // <http://www.gnu.org/licenses/>.
  23
  24 #include "tinfo.h"
  25
  26 namespace __cxxabiv1 {
  27
  28 __pbase_type_info::
  29 ~__pbase_type_info ()
  30 {}
  31
  32 bool __pbase_type_info::
  33 __do_catch (const type_info *thr_type,
  34             void **thr_obj,
  35             unsigned outer) const
  36 {
  37   if (*this == *thr_type)
  38     return true;      // same type
  39
  40 #if __cpp_rtti
  41   if (*thr_type == typeid (nullptr))
  42     {
  43       // A catch handler for any pointer type matches nullptr_t.
  44       if (typeid (*this) == typeid(__pointer_type_info))
  45         {
  46           *thr_obj = nullptr;
  47           return true;
  48         }
  49       else if (typeid (*this) == typeid(__pointer_to_member_type_info))
  50         {
  51           if (__pointee->__is_function_p ())
  52             {
  53               using pmf_type = void (__pbase_type_info::*)();
  54               static const pmf_type pmf = nullptr;
  55               *thr_obj = const_cast<pmf_type*>(&pmf);
  56               return true;
  57             }
  58           else
  59             {
  60               using pm_type = int __pbase_type_info::*;
  61               static const pm_type pm = nullptr;
  62               *thr_obj = const_cast<pm_type*>(&pm);
  63               return true;
  64             }
  65         }
  66     }
  67
  68   if (typeid (*this) != typeid (*thr_type))
  69     return false;     // not both same kind of pointers
  70 #endif
  71
  72   if (!(outer & 1))
  73     // We're not the same and our outer pointers are not all const qualified
  74     // Therefore there must at least be a qualification conversion involved
  75     // But for that to be valid, our outer pointers must be const qualified.
  76     return false;
  77
  78 #if !__cpp_rtti
  79   if (!thr_type->__is_pointer_p ())
  80     return false;
  81 #endif
  82
  83   const __pbase_type_info *thrown_type =
  84     static_cast <const __pbase_type_info *> (thr_type);
  85
  86   unsigned tflags = thrown_type->__flags;
  87
  88   const unsigned fqual_mask = __transaction_safe_mask|__noexcept_mask;
  89   unsigned throw_fqual = (tflags & fqual_mask);
  90   unsigned catch_fqual = (__flags & fqual_mask);
  91   if (throw_fqual & ~catch_fqual)
  92     /* Catch can perform a function pointer conversion.  */
  93     tflags &= catch_fqual;
  94   if (catch_fqual & ~throw_fqual)
  95     /* But not the reverse.  */
  96     return false;
  97
  98   if (tflags & ~__flags)
  99     // We're less qualified.
 100     return false;
 101
 102   if (!(__flags & __const_mask))
 103     outer &= ~1;
 104
 105   return __pointer_catch (thrown_type, thr_obj, outer);
 106 }
 107
 108 }