rtti_dump.h

Go to the documentation of this file.

/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
// This file is a standalone one-header-file library using only C++03.
//
// It assumes that the program is compiled for the "Itanium" C++ ABI
// (http://itanium-cxx-abi.github.io/cxx-abi/), a common C++ ABI used on many
// CPU architectures and operating systems.
//
 
#ifndef RTTI_DUMP
#define RTTI_DUMP
 
#include <assert.h>
#include <dlfcn.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include <set>
#include <string>
#include <typeinfo>
 
#if defined( __ANDROID__ ) && !defined( RTTI_DUMP_USE_PRINTF )
#include <android/log.h>
#define RTTI_DUMP_LOG( fmt, ... )                                                                  \
    __android_log_print( ANDROID_LOG_INFO, "rtti_dump", fmt, ##__VA_ARGS__ )
#else
#define RTTI_DUMP_LOG( fmt, ... ) printf( fmt "\n", ##__VA_ARGS__ )
#endif
 
// Avoid compiler warnings.
#define RTTI_DUMP_UNUSED __attribute__( ( unused ) )
 
// Use an anonymous namespace so this header file can be included at the top of
// multiple C++ source files without breaking the One Definition Rule.
namespace rtti_dump
{
namespace
{
 
    // Returns the type of the current exception object or NULL if the thread is
    // not currently in a catch block.
    extern "C" const std::type_info* __cxa_current_exception_type();
 
    // Using run-time type information, returns an std::type_info* corresponding to
    // the most-derived class of a pointer to an object. The pointed-to type must
    // be a polymorphic class. (i.e. The class must have a virtual function or a
    // base class with a virtual function.)
    //
    // The function can return NULL if the object's vtable comes from an object
    // file compiled without -frtti.
    template <typename T>
    RTTI_DUMP_UNUSED const std::type_info* runtime_typeid( const volatile T* dynptr )
    {
        T* dynptr_unqual = const_cast<T*>( dynptr );
 
        // Use dynamic_cast<void*> to ensure that T is polymorphic. The result is
        // discarded just in case the most-derived object vtable and the subobject
        // vtable point to different typeinfo objects. (XXX: I *think* that's
        // impossible, though.)
        (void) sizeof( dynamic_cast<void*>( dynptr_unqual ) );
 
        void* vptr = *reinterpret_cast<void**>( dynptr_unqual );
        void* typeid_void = reinterpret_cast<void**>( vptr )[-1];
        return reinterpret_cast<const std::type_info*>( typeid_void );
    }
 
    // Returns the name of the DSO or binary containing the given address.
    RTTI_DUMP_UNUSED std::string dladdr_fname( const void* ptr )
    {
        Dl_info info = { 0 };
 
        if( !dladdr( const_cast<void*>( ptr ), &info ) )
        {
            char buf[64];
            snprintf( buf, sizeof( buf ), "[error: dladdr failed - %d]", errno );
            return buf;
        }
        else
        {
            return std::string( info.dli_fname );
        }
    }
 
    // Dump the address of the std::type_info object, its name, and the shared
    // object where the type_info object is defined.
    RTTI_DUMP_UNUSED
    void dump_type( const std::type_info* type, const char* label = "dump_type", int indent = 0 )
    {
        const std::string prefix = label + std::string( ": " ) + std::string( indent, ' ' );
 
        if( type == NULL )
        {
            RTTI_DUMP_LOG( "%sERROR: dump_type called with type==NULL!", prefix.c_str() );
        }
        else
        {
            struct type_info
            {
                virtual ~type_info() {}
                const char* type_name;
            };
 
            assert( sizeof( type_info ) == sizeof( std::type_info ) );
            const char* const name = type->name();
            const char* const raw_name = reinterpret_cast<const type_info*>( type )->type_name;
 
            if( name == raw_name )
            {
                RTTI_DUMP_LOG( "%stype %s:", prefix.c_str(), name );
            }
            else if( raw_name + 1 == name )
            {
                RTTI_DUMP_LOG( "%stype %s (raw name == '%s' @ %p):", prefix.c_str(), name, raw_name,
                               raw_name );
            }
            else
            {
                RTTI_DUMP_LOG( "%stype %s (raw name == %p):", prefix.c_str(), name, raw_name );
            }
 
            RTTI_DUMP_LOG( "%s    type_info obj:  %p (in %s)", prefix.c_str(), type,
                           dladdr_fname( type ).c_str() );
            RTTI_DUMP_LOG( "%s    type_info name: %p (in %s)", prefix.c_str(), name,
                           dladdr_fname( name ).c_str() );
        }
    }
 
    // Call from a catch block to dump the type of the current exception.
    RTTI_DUMP_UNUSED
    void dump_current_exception( const char* label = "dump_current_exception" )
    {
        const std::type_info* type = __cxa_current_exception_type();
 
        if( type != NULL )
        {
            dump_type( type, label );
        }
        else
        {
            RTTI_DUMP_LOG( "%s: ERROR: dump_current_exception called outside a catch block!",
                           label );
        }
    }
 
    namespace hierarchy_dumper_internals
    {
 
        // std::type_info has virtual member functions, so the most-derived type of
        // a pointer to a std::type_info object can be determined at run-time by
        // looking for the std::type_info's own std::type_info. We rely upon this
        // property to walk a class's RTTI graph at run-time.
 
        struct __class_type_info : std::type_info
        {
        };
 
        struct __si_class_type_info : __class_type_info
        {
            const __class_type_info* __base_type;
        };
 
        struct __base_class_type_info
        {
            const __class_type_info* __base_type;
            long                     __offset_flags;
        };
 
        struct __vmi_class_type_info : __class_type_info
        {
            unsigned int           __flags;
            unsigned int           __base_count;
            __base_class_type_info __base_info[1];
        };
 
        class Dumper
        {
            const char*                     label_;
            std::set<const std::type_info*> seen_;
 
        public:
            Dumper( const char* label ) : label_( label ) {}
            void dump_type( const std::type_info* info, int indent );
        };
 
        const int kIndent = 4;
 
        void Dumper::dump_type( const std::type_info* info, int indent )
        {
            ::rtti_dump::dump_type( info, label_, indent * kIndent );
 
            if( info == NULL )
            {
                return;
            }
 
            const std::type_info*         info_type = runtime_typeid( info );
            __base_class_type_info        lone_base = { 0 };
            const __base_class_type_info* base_table = NULL;
            unsigned int                  base_count = 0;
 
            // Determine type equality using a string comparison, because this dumping
            // system doesn't trust std::type_info::operator== to work with multiple
            // shared objects.
 
            const int sub_indent_sp = ( indent + 1 ) * kIndent;
 
            if( info_type == NULL )
            {
                // I don't think info_type can ever be NULL here.
                RTTI_DUMP_LOG( "%s: %*sERROR: runtime_typeid(info) was NULL!", label_,
                               sub_indent_sp, "" );
            }
            else if( !strcmp( info_type->name(), "N10__cxxabiv120__si_class_type_infoE" ) )
            {
                const __si_class_type_info& infox =
                        *reinterpret_cast<const __si_class_type_info*>( info );
                lone_base.__base_type = infox.__base_type;
                base_count = 1;
                base_table = &lone_base;
            }
            else if( !strcmp( info_type->name(), "N10__cxxabiv121__vmi_class_type_infoE" ) )
            {
                const __vmi_class_type_info& infox =
                        *reinterpret_cast<const __vmi_class_type_info*>( info );
                base_count = infox.__base_count;
                base_table = infox.__base_info;
            }
 
            if( base_count > 0 )
            {
                if( seen_.find( info ) != seen_.end() )
                {
                    RTTI_DUMP_LOG( "%s: %*sbase classes: ...elided...", label_, sub_indent_sp, "" );
                }
                else
                {
                    RTTI_DUMP_LOG( "%s: %*sbase classes:", label_, sub_indent_sp, "" );
                    seen_.insert( info );
 
                    for( unsigned int i = 0; i < base_count; ++i )
                    {
                        dump_type( base_table[i].__base_type, indent + 2 );
                    }
                }
            }
        }
    } // namespace hierarchy_dumper_internals
 
    // Dump the std::type_info object, and if it represents a class with base
    // classes, then dumps the class hierarchy.
    RTTI_DUMP_UNUSED
    void dump_class_hierarchy( const std::type_info* info,
                               const char*           label = "dump_class_hierarchy" )
    {
        hierarchy_dumper_internals::Dumper dumper( label );
        dumper.dump_type( info, 0 );
    }
 
} // anonymous namespace
} // namespace rtti_dump
 
#endif // RTTI_DUMP