libcxxrt

git clone https://git.neptards.moe/neptards/libcxxrt.git
Log | Files | Refs | README | LICENSE

typeinfo.cc (3835B)

      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 == NULL)
     90 		{
     91 			if (n)
     92 			{
     93 				*n = len;
     94 			}
     95 			return demangled;
     96 		}
     97 		if (*n < len+1)
     98 		{
     99 			buf = static_cast<char*>(realloc(buf, len+1));
    100 		}
    101 		if (0 != buf)
    102 		{
    103 			memcpy(buf, demangled, len);
    104 			buf[len] = 0;
    105 			if (n)
    106 			{
    107 				*n = len;
    108 			}
    109 			if (status)
    110 			{
    111 				*status = 0;
    112 			}
    113 		}
    114 		else
    115 		{
    116 			if (status)
    117 			{
    118 				*status = -1;
    119 			}
    120 		}
    121 		free(demangled);
    122 	}
    123 	else
    124 	{
    125 		if (status)
    126 		{
    127 			*status = -2;
    128 		}
    129 		return NULL;
    130 	}
    131 	return buf;
    132 }