typeinfo.cc

   1 /*
   2  * Copyright 2010-2012 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 "typeinfo.h"
  28 #include <string.h>
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31
  32 using std::type_info;
  33
  34 type_info::~type_info() {}
  35
  36 bool type_info::operator==(const type_info &other) const
  37 {
  38         return __type_name == other.__type_name;
  39 }
  40 bool type_info::operator!=(const type_info &other) const
  41 {
  42         return __type_name != other.__type_name;
  43 }
  44 bool type_info::before(const type_info &other) const
  45 {
  46         return __type_name < other.__type_name;
  47 }
  48 const char* type_info::name() const
  49 {
  50         return __type_name;
  51 }
  52 type_info::type_info (const type_info& rhs)
  53 {
  54         __type_name = rhs.__type_name;
  55 }
  56 type_info& type_info::operator= (const type_info& rhs)
  57 {
  58         return *new type_info(rhs);
  59 }
  60
  61 ABI_NAMESPACE::__fundamental_type_info::~__fundamental_type_info() {}
  62 ABI_NAMESPACE::__array_type_info::~__array_type_info() {}
  63 ABI_NAMESPACE::__function_type_info::~__function_type_info() {}
  64 ABI_NAMESPACE::__enum_type_info::~__enum_type_info() {}
  65 ABI_NAMESPACE::__class_type_info::~__class_type_info() {}
  66 ABI_NAMESPACE::__si_class_type_info::~__si_class_type_info() {}
  67 ABI_NAMESPACE::__vmi_class_type_info::~__vmi_class_type_info() {}
  68 ABI_NAMESPACE::__pbase_type_info::~__pbase_type_info() {}
  69 ABI_NAMESPACE::__pointer_type_info::~__pointer_type_info() {}
  70 ABI_NAMESPACE::__pointer_to_member_type_info::~__pointer_to_member_type_info() {}
  71
  72 // From libelftc
  73 extern "C" char    *__cxa_demangle_gnu3(const char *);
  74
  75 extern "C" char* __cxa_demangle(const char* mangled_name,
  76                                 char* buf,
  77                                 size_t* n,
  78                                 int* status)
  79 {
  80         // TODO: We should probably just be linking against libelf-tc, rather than
  81         // copying their code.  This requires them to do an actual release,
  82         // however, and for our changes to be pushed upstream.  We also need to
  83         // call a different demangling function here depending on the ABI (e.g.
  84         // ARM).
  85         char *demangled = __cxa_demangle_gnu3(mangled_name);
  86         if (NULL != demangled)
  87         {
  88                 size_t len = strlen(demangled);
  89                 if (!buf || (*n < len+1))
  90                 {
  91                         buf = static_cast<char*>(realloc(buf, len+1));
  92                 }
  93                 if (0 != buf)
  94                 {
  95                         memcpy(buf, demangled, len);
  96                         buf[len] = 0;
  97                         if (n)
  98                         {
  99                                 *n = len;
 100                         }
 101                         if (status)
 102                         {
 103                                 *status = 0;
 104                         }
 105                 }
 106                 else
 107                 {
 108                         if (status)
 109                         {
 110                                 *status = -1;
 111                         }
 112                 }
 113                 free(demangled);
 114         }
 115         else
 116         {
 117                 if (status)
 118                 {
 119                         *status = -2;
 120                 }
 121                 return NULL;
 122         }
 123         return buf;
 124 }