contrib/libcxxrt/typeinfo.h

   1 /*
   2  * Copyright 2010-2011 PathScale, Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are met:
   6  *
   7  * 1. Redistributions of source code must retain the above copyright notice,
   8  *    this list of conditions and the following disclaimer.
   9  *
  10  * 2. Redistributions in binary form must reproduce the above copyright notice,
  11  *    this list of conditions and the following disclaimer in the documentation
  12  *    and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
  15  * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  16  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
  18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  21  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  22  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  23  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  24  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include <stddef.h>
  28 #include "abi_namespace.h"
  29
  30 namespace ABI_NAMESPACE
  31 {
  32         struct __class_type_info;
  33 }
  34 namespace std
  35 {
  36         /**
  37           * Standard type info class.  The layout of this class is specified by the
  38           * ABI.  The layout of the vtable is not, but is intended to be
  39           * compatible with the GNU ABI.
  40           *
  41           * Unlike the GNU version, the vtable layout is considered semi-private.
  42           */
  43         class type_info
  44         {
  45                 public:
  46                 /**
  47                  * Virtual destructor.  This class must have one virtual function to
  48                  * ensure that it has a vtable.
  49                  */
  50                 virtual ~type_info();
  51                 bool operator==(const type_info &) const;
  52                 bool operator!=(const type_info &) const;
  53                 bool before(const type_info &) const;
  54                 const char* name() const;
  55                 type_info();
  56                 private:
  57                 type_info(const type_info& rhs);
  58                 type_info& operator= (const type_info& rhs);
  59                 const char *__type_name;
  60                 /*
  61                  * The following functions are in this order to match the
  62                  * vtable layout of libsupc++.  This allows libcxxrt to be used
  63                  * with libraries that depend on this.
  64                  *
  65                  * These functions are in the public headers for libstdc++, so
  66                  * we have to assume that someone will probably call them and
  67                  * expect them to work.  Their names must also match the names used in
  68                  * libsupc++, so that code linking against this library can subclass
  69                  * type_info and correctly fill in the values in the vtables.
  70                  */
  71                 public:
  72                 /**
  73                  * Returns true if this is some pointer type, false otherwise.
  74                  */
  75                 virtual bool __is_pointer_p() const { return false; }
  76                 /**
  77                  * Returns true if this is some function type, false otherwise.
  78                  */
  79                 virtual bool __is_function_p() const { return false; }
  80                 /**
  81                  * Catch function.  Allows external libraries to implement
  82                  * their own basic types.  This is used, for example, in the
  83                  * GNUstep Objective-C runtime to allow Objective-C types to be
  84                  * caught in G++ catch blocks.
  85                  *
  86                  * The outer parameter indicates the number of outer pointers
  87                  * in the high bits.  The low bit indicates whether the
  88                  * pointers are const qualified.
  89                  */
  90                 virtual bool __do_catch(const type_info *thrown_type,
  91                                         void **thrown_object,
  92                                         unsigned outer) const;
  93                 /**
  94                  * Performs an upcast.  This is used in exception handling to
  95                  * cast from subclasses to superclasses.  If the upcast is
  96                  * possible, it returns true and adjusts the pointer.  If the
  97                  * upcast is not possible, it returns false and does not adjust
  98                  * the pointer.
  99                  */
 100                 virtual bool __do_upcast(
 101                                 const ABI_NAMESPACE::__class_type_info *target,
 102                                 void **thrown_object) const
 103                 {
 104                         return false;
 105                 }
 106         };
 107 }
 108
 109
 110 namespace ABI_NAMESPACE
 111 {
 112         /**
 113          * Primitive type info, for intrinsic types.
 114          */
 115         struct __fundamental_type_info : public std::type_info
 116         {
 117                 virtual ~__fundamental_type_info();
 118         };
 119         /**
 120          * Type info for arrays.
 121          */
 122         struct __array_type_info : public std::type_info
 123         {
 124                 virtual ~__array_type_info();
 125         };
 126         /**
 127          * Type info for functions.
 128          */
 129         struct __function_type_info : public std::type_info
 130         {
 131                 virtual ~__function_type_info();
 132                 virtual bool __is_function_p() const { return true; }
 133         };
 134         /**
 135          * Type info for enums.
 136          */
 137         struct __enum_type_info : public std::type_info
 138         {
 139                 virtual ~__enum_type_info();
 140         };
 141
 142         /**
 143          * Base class for class type info.  Used only for tentative definitions.
 144          */
 145         struct __class_type_info : public std::type_info
 146         {
 147                 virtual ~__class_type_info();
 148                 /**
 149                  * Function implementing dynamic casts.
 150                  */
 151                 virtual void *cast_to(void *obj, const struct __class_type_info *other) const;
 152                 virtual bool __do_upcast(const __class_type_info *target,
 153                                        void **thrown_object) const
 154                 {
 155                         return this == target;
 156                 }
 157         };
 158
 159         /**
 160          * Single-inheritance class type info.  This is used for classes containing
 161          * a single non-virtual base class at offset 0.
 162          */
 163         struct __si_class_type_info : public __class_type_info
 164         {
 165                 virtual ~__si_class_type_info();
 166                 const __class_type_info *__base_type;
 167                 virtual bool __do_upcast(
 168                                 const ABI_NAMESPACE::__class_type_info *target,
 169                                 void **thrown_object) const;
 170                 virtual void *cast_to(void *obj, const struct __class_type_info *other) const;
 171         };
 172
 173         /**
 174          * Type info for base classes.  Classes with multiple bases store an array
 175          * of these, one for each superclass.
 176          */
 177         struct __base_class_type_info
 178         {
 179                 const __class_type_info *__base_type;
 180                 private:
 181                         /**
 182                          * The high __offset_shift bits of this store the (signed) offset
 183                          * of the base class.  The low bits store flags from
 184                          * __offset_flags_masks.
 185                          */
 186                         long __offset_flags;
 187                         /**
 188                          * Flags used in the low bits of __offset_flags.
 189                          */
 190                         enum __offset_flags_masks
 191                         {
 192                                 /** This base class is virtual. */
 193                                 __virtual_mask = 0x1,
 194                                 /** This base class is public. */
 195                                 __public_mask = 0x2,
 196                                 /** The number of bits reserved for flags. */
 197                                 __offset_shift = 8
 198                         };
 199                 public:
 200                         /**
 201                          * Returns the offset of the base class.
 202                          */
 203                         long offset() const
 204                         {
 205                                 return __offset_flags >> __offset_shift;
 206                         }
 207                         /**
 208                          * Returns the flags.
 209                          */
 210                         long flags() const
 211                         {
 212                                 return __offset_flags & ((1 << __offset_shift) - 1);
 213                         }
 214                         /**
 215                          * Returns whether this is a public base class.
 216                          */
 217                         bool isPublic() const { return flags() & __public_mask; }
 218                         /**
 219                          * Returns whether this is a virtual base class.
 220                          */
 221                         bool isVirtual() const { return flags() & __virtual_mask; }
 222         };
 223
 224         /**
 225          * Type info for classes with virtual bases or multiple superclasses.
 226          */
 227         struct __vmi_class_type_info : public __class_type_info
 228         {
 229                 virtual ~__vmi_class_type_info();
 230                 /** Flags describing this class.  Contains values from __flags_masks. */
 231                 unsigned int __flags;
 232                 /** The number of base classes. */
 233                 unsigned int __base_count;
 234                 /**
 235                  * Array of base classes - this actually has __base_count elements, not
 236                  * 1.
 237                  */
 238                 __base_class_type_info __base_info[1];
 239
 240                 /**
 241                  * Flags used in the __flags field.
 242                  */
 243                 enum __flags_masks
 244                 {
 245                         /** The class has non-diamond repeated inheritance. */
 246                         __non_diamond_repeat_mask = 0x1,
 247                         /** The class is diamond shaped. */
 248                         __diamond_shaped_mask = 0x2
 249                 };
 250                 virtual bool __do_upcast(
 251                                 const ABI_NAMESPACE::__class_type_info *target,
 252                                 void **thrown_object) const;
 253                 virtual void *cast_to(void *obj, const struct __class_type_info *other) const;
 254         };
 255
 256         /**
 257          * Base class used for both pointer and pointer-to-member type info.
 258          */
 259         struct __pbase_type_info : public std::type_info
 260         {
 261                 virtual ~__pbase_type_info();
 262                 /**
 263                  * Flags.  Values from __masks.
 264                  */
 265                 unsigned int __flags;
 266                 /**
 267                  * The type info for the pointee.
 268                  */
 269                 const std::type_info *__pointee;
 270
 271                 /**
 272                  * Masks used for qualifiers on the pointer.
 273                  */
 274                 enum __masks
 275                 {
 276                         /** Pointer has const qualifier. */
 277                         __const_mask = 0x1,
 278                         /** Pointer has volatile qualifier. */
 279                         __volatile_mask = 0x2,
 280                         /** Pointer has restrict qualifier. */
 281                         __restrict_mask = 0x4,
 282                         /** Pointer points to an incomplete type. */
 283                         __incomplete_mask = 0x8,
 284                         /** Pointer is a pointer to a member of an incomplete class. */
 285                         __incomplete_class_mask = 0x10
 286                 };
 287                 virtual bool __do_catch(const type_info *thrown_type,
 288                                         void **thrown_object,
 289                                         unsigned outer) const;
 290         };
 291
 292         /**
 293          * Pointer type info.
 294          */
 295         struct __pointer_type_info : public __pbase_type_info
 296         {
 297                 virtual ~__pointer_type_info();
 298                 virtual bool __is_pointer_p() const { return true; }
 299         };
 300
 301         /**
 302          * Pointer to member type info.
 303          */
 304         struct __pointer_to_member_type_info : public __pbase_type_info
 305         {
 306                 virtual ~__pointer_to_member_type_info();
 307                 /**
 308                  * Pointer to the class containing this member.
 309                  */
 310                 const __class_type_info *__context;
 311         };
 312
 313 }