blob: 303e9b104289064d8ed30ffe9cc01786e5995cf0 [file] [log] [blame]
// Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef BASE_TYPE_ID_H_
#define BASE_TYPE_ID_H_
#include <stdint.h>
#include <string>
#include "base/base_export.h"
#include "base/compiler_specific.h"
#include "base/logging.h"
#include "base/strings/string_piece.h"
#include "build/build_config.h"
#if defined(COMPILER_MSVC)
#include <typeindex>
#include <typeinfo>
namespace base {
namespace internal {
// The __attribute__((visibility("default"))) trick does not work for shared
// libraries in MSVC. MSVC does support a reduced functionality typeid operator
// with -fno-rtti, just enough for our needs.
// Biggest drawback is that using typeid prevents us from having constexpr
// methods (as the typeid operator is not constexpr)
#if defined(COMPILER_MSVC)
using TypeUniqueId = std::type_index;
template <typename Type>
inline TypeUniqueId UniqueIdFromType() {
return std::type_index(typeid(Type));
#elif defined(COMPONENT_BUILD)
// A substitute for RTTI that uses the hash of the PRETTY_FUNCTION and
// __BASE_FILE__ to identify the type. Hash collisions can occur so don't use
// this in production code. The reason we use this at all is the dynamic linker
// can end up reserving two symbols for |dummy_var| below when the .SO is loaded
// first. This only seems to affect templates with non-builtin types, e.g.
// std::unique_ptr<int> is fine but |dummy_var| gets duplicated for
// std::unique_ptr<MyType>.
using TypeUniqueId = uint64_t;
// TODO(alexclarke): Replace these when StringPiece gets more constexpr support.
static constexpr bool string_starts_with(char const* s, char const* prefix) {
while (*prefix) {
if (*s++ != *prefix++)
return false;
return true;
static constexpr bool string_contains(char const* str, char const* fragment) {
while (*str) {
if (string_starts_with(str++, fragment))
return true;
return false;
template <typename Type>
constexpr inline TypeUniqueId UniqueIdFromType() {
// This is an SDBM hash of PRETTY_FUNCTION, SMBD hash seems to be better than
// djb2 or other simple hashes, and should be good enough for our purposes.
// Source:
constexpr const char* function_name = PRETTY_FUNCTION;
uint64_t hash = 0;
for (uint64_t i = 0; function_name[i]; ++i) {
hash = function_name[i] + (hash << 6) + (hash << 16) - hash;
// There doesn't seem to be an official way of figuring out if a type is from
// an anonymous namespace so we fall back to inspecting the decorated function
// name.
constexpr const char* compiler_specific_anonymous_namespace_fragment =
#if defined(__clang__)
"base::internal::UniqueIdFromType() [Type = (anonymous namespace)::";
#elif defined(__clang__)
"base::internal::UniqueIdFromType() [with T = {anonymous}::";
#elif defined(COMPILER_MSVC)
"base::internal::UniqueIdFromType<`anonymous namespace'::";
#error Compiler unsupported
// To disambiguate types in anonymous namespaces add __BASE_FILE_ to the hash.
if (string_contains(function_name,
compiler_specific_anonymous_namespace_fragment)) {
constexpr auto* base_file = __BASE_FILE__;
for (uint64_t i = 0; base_file[i]; ++i) {
hash = base_file[i] + (hash << 6) + (hash << 16) - hash;
return hash;
// A substitute for RTTI that uses the linker to uniquely reserve an address in
// the binary for each type.
// We need to make sure dummy_var has default visibility since we need to make
// sure that there is only one definition across all libraries (shared or
// static).
template <typename Type>
struct __attribute__((visibility("default"))) TypeTag {
static constexpr char dummy_var = 0;
// static
template <typename Type>
constexpr char TypeTag<Type>::dummy_var;
using TypeUniqueId = const void*;
template <typename Type>
constexpr inline TypeUniqueId UniqueIdFromType() {
return &TypeTag<Type>::dummy_var;
struct NoType {};
} // namespace internal
class BASE_EXPORT TypeId {
template <typename T>
static TypeId From() {
return TypeId(
TypeId(const TypeId& other) = default;
TypeId& operator=(const TypeId& other) = default;
bool operator==(TypeId other) const {
return unique_type_id_ == other.unique_type_id_;
bool operator!=(TypeId other) const { return !(*this == other); }
std::string ToString() const;
const char* function_name,
internal::TypeUniqueId unique_type_id);
const char* function_name_;
internal::TypeUniqueId unique_type_id_;
BASE_EXPORT std::ostream& operator<<(std::ostream& out, const TypeId& type_id);
} // namespace base
#endif // BASE_TYPE_ID_H_