Skip to content

A
abseil-cpp
Commit 08a7e7bf by Abseil Team Committed by Andy Getz
Options

Export of internal Abseil changes 

--
1bc4d36e13fb9175ea8cdaa00213aa9d4417c669 by Andy Getzendanner <durandal@google.com>:

Fix pointer format specifier in documentation

Import of https://github.com/abseil/abseil-cpp/pull/614

PiperOrigin-RevId: 293227540

--
c7b43b30493c4fb5f2ec3264672b08bfe1ea3709 by Abseil Team <absl-team@google.com>:

Internal change.

PiperOrigin-RevId: 293160245

--
64439365e2b4a0b5e51ae0a7dafdb15912402dfd by Shahriar Rouf <nafi@google.com>:

Add benchmarks for string_view: BM_CompareFirstOneLess and BM_CompareSecondOneLess.

PiperOrigin-RevId: 293031676

--
b273b420cab24a6e3f487430987e09f4eb1caec4 by Greg Falcon <gfalcon@google.com>:

Remove an unreachable line from charconv.cc.

Fixes github issue #613.

PiperOrigin-RevId: 292980167

--
70babb5f7a3d9fdd00a2b3085c3c2b9fe0265c79 by Gennadiy Rozental <rogeeff@google.com>:

Move GetFlag implementation into FlagImpl.

This change will allow us to hide details of GetFlag overloads inside implementation detais. Eventually we'll migrate to a different implementation. No semantic changes in this CL.

PiperOrigin-RevId: 292930847

--
94bee7b7cc31e0167ee4b953281c1e78c96a574a by Abseil Team <absl-team@google.com>:

Clarification in absl::Exponential documentation.

PiperOrigin-RevId: 292912672

--
d6916d30c5c1d3ee9ae46d69ec0a166a760c99c7 by Derek Mauro <dmauro@google.com>:

Make AtomicHook constant-initializable on Clang for Windows.

Only mark AtomicHook as constant-initializable on platforms where it
is actually constant-initializable.

PiperOrigin-RevId: 292655939
GitOrigin-RevId: 1bc4d36e13fb9175ea8cdaa00213aa9d4417c669
Change-Id: I090b231a0ca0d92868e494ab5b3fa86c902889d5
parent 36bcd959
Showing with 128 additions and 67 deletions
absl/base/BUILD.bazel
...@@ -34,7 +34,10 @@ cc_library( ...@@ -34,7 +34,10 @@ cc_library(
visibility = [ visibility = [
"//absl:__subpackages__", "//absl:__subpackages__",
], ],
deps = [":config"], deps = [
":config",
":core_headers",
],
) )
cc_library( cc_library(
......
absl/base/CMakeLists.txt
...@@ -23,6 +23,7 @@ absl_cc_library( ...@@ -23,6 +23,7 @@ absl_cc_library(
"internal/atomic_hook.h" "internal/atomic_hook.h"
DEPS DEPS
absl::config absl::config
absl::core_headers
COPTS COPTS
${ABSL_DEFAULT_COPTS} ${ABSL_DEFAULT_COPTS}
) )
......
absl/base/internal/atomic_hook.h
...@@ -20,16 +20,21 @@ ...@@ -20,16 +20,21 @@
#include <cstdint> #include <cstdint>
#include <utility> #include <utility>
#include "absl/base/attributes.h"
#include "absl/base/config.h" #include "absl/base/config.h"
#ifdef _MSC_FULL_VER #if defined(_MSC_VER) && !defined(__clang__)
#define ABSL_HAVE_WORKING_ATOMIC_POINTER 0
#define ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT 0 #define ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT 0
#else #else
#define ABSL_HAVE_WORKING_ATOMIC_POINTER 1
#define ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT 1 #define ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT 1
#endif #endif
#if defined(_MSC_VER)
#define ABSL_HAVE_WORKING_ATOMIC_POINTER 0
#else
#define ABSL_HAVE_WORKING_ATOMIC_POINTER 1
#endif
namespace absl { namespace absl {
ABSL_NAMESPACE_BEGIN ABSL_NAMESPACE_BEGIN
namespace base_internal { namespace base_internal {
...@@ -37,6 +42,15 @@ namespace base_internal { ...@@ -37,6 +42,15 @@ namespace base_internal {
template <typename T> template <typename T>
class AtomicHook; class AtomicHook;
// To workaround AtomicHook not being constant-initializable on some platforms,
// prefer to annotate instances with `ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES`
// instead of `ABSL_CONST_INIT`.
#if ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
#define ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES ABSL_CONST_INIT
#else
#define ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
#endif
// `AtomicHook` is a helper class, templatized on a raw function pointer type, // `AtomicHook` is a helper class, templatized on a raw function pointer type,
// for implementing Abseil customization hooks. It is a callable object that // for implementing Abseil customization hooks. It is a callable object that
// dispatches to the registered hook. Objects of type `AtomicHook` must have // dispatches to the registered hook. Objects of type `AtomicHook` must have
...@@ -45,8 +59,11 @@ class AtomicHook; ...@@ -45,8 +59,11 @@ class AtomicHook;
// A default constructed object performs a no-op (and returns a default // A default constructed object performs a no-op (and returns a default
// constructed object) if no hook has been registered. // constructed object) if no hook has been registered.
// //
// Hooks can be pre-registered via constant initialization, for example, // Hooks can be pre-registered via constant initialization, for example:
// `ABSL_CONST_INIT static AtomicHook<void(*)()> my_hook(DefaultAction);` //
// ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static AtomicHook<void(*)()>
// my_hook(DefaultAction);
//
// and then changed at runtime via a call to `Store()`. // and then changed at runtime via a call to `Store()`.
// //
// Reads and writes guarantee memory_order_acquire/memory_order_release // Reads and writes guarantee memory_order_acquire/memory_order_release
...@@ -65,11 +82,15 @@ class AtomicHook<ReturnType (*)(Args...)> { ...@@ -65,11 +82,15 @@ class AtomicHook<ReturnType (*)(Args...)> {
#if ABSL_HAVE_WORKING_ATOMIC_POINTER && ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT #if ABSL_HAVE_WORKING_ATOMIC_POINTER && ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
explicit constexpr AtomicHook(FnPtr default_fn) explicit constexpr AtomicHook(FnPtr default_fn)
: hook_(default_fn), default_fn_(default_fn) {} : hook_(default_fn), default_fn_(default_fn) {}
#elif ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
explicit constexpr AtomicHook(FnPtr default_fn)
: hook_(kUninitialized), default_fn_(default_fn) {}
#else #else
// On MSVC, this function sometimes executes after dynamic initialization =(. // As of January 2020, on all known versions of MSVC this constructor runs in
// If a non-zero `hook_` has been installed by a dynamic initializer, we want // the global constructor sequence. If `Store()` is called by a dynamic
// to preserve it. If not, `hook_` will be zero initialized and we have no // initializer, we want to preserve the value, even if this constructor runs
// need to set it to `kUninitialized`. // after the call to `Store()`. If not, `hook_` will be
// zero-initialized by the linker and we have no need to set it.
// https://developercommunity.visualstudio.com/content/problem/336946/class-with-constexpr-constructor-not-using-static.html // https://developercommunity.visualstudio.com/content/problem/336946/class-with-constexpr-constructor-not-using-static.html
explicit constexpr AtomicHook(FnPtr default_fn) explicit constexpr AtomicHook(FnPtr default_fn)
: /* hook_(deliberately omitted), */ default_fn_(default_fn) { : /* hook_(deliberately omitted), */ default_fn_(default_fn) {
......
absl/base/internal/atomic_hook_test.cc
...@@ -27,7 +27,9 @@ int value = 0; ...@@ -27,7 +27,9 @@ int value = 0;
void TestHook(int x) { value = x; } void TestHook(int x) { value = x; }
TEST(AtomicHookTest, NoDefaultFunction) { TEST(AtomicHookTest, NoDefaultFunction) {
ABSL_CONST_INIT static absl::base_internal::AtomicHook<void(*)(int)> hook; ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static absl::base_internal::AtomicHook<
void (*)(int)>
hook;
value = 0; value = 0;
// Test the default DummyFunction. // Test the default DummyFunction.
...@@ -53,8 +55,9 @@ TEST(AtomicHookTest, NoDefaultFunction) { ...@@ -53,8 +55,9 @@ TEST(AtomicHookTest, NoDefaultFunction) {
TEST(AtomicHookTest, WithDefaultFunction) { TEST(AtomicHookTest, WithDefaultFunction) {
// Set the default value to TestHook at compile-time. // Set the default value to TestHook at compile-time.
ABSL_CONST_INIT static absl::base_internal::AtomicHook<void (*)(int)> hook( ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static absl::base_internal::AtomicHook<
TestHook); void (*)(int)>
hook(TestHook);
value = 0; value = 0;
// Test the default value is TestHook. // Test the default value is TestHook.
......
absl/base/internal/atomic_hook_test_helper.cc
...@@ -21,7 +21,8 @@ namespace absl { ...@@ -21,7 +21,8 @@ namespace absl {
ABSL_NAMESPACE_BEGIN ABSL_NAMESPACE_BEGIN
namespace atomic_hook_internal { namespace atomic_hook_internal {
ABSL_CONST_INIT absl::base_internal::AtomicHook<VoidF> func(DefaultFunc); ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES absl::base_internal::AtomicHook<VoidF>
func(DefaultFunc);
ABSL_CONST_INIT int default_func_calls = 0; ABSL_CONST_INIT int default_func_calls = 0;
void DefaultFunc() { default_func_calls++; } void DefaultFunc() { default_func_calls++; }
void RegisterFunc(VoidF f) { func.Store(f); } void RegisterFunc(VoidF f) { func.Store(f); }
......
absl/base/internal/raw_logging.cc
...@@ -71,10 +71,12 @@ ...@@ -71,10 +71,12 @@
// Explicitly #error out when not ABSL_LOW_LEVEL_WRITE_SUPPORTED, except for a // Explicitly #error out when not ABSL_LOW_LEVEL_WRITE_SUPPORTED, except for a
// whitelisted set of platforms for which we expect not to be able to raw log. // whitelisted set of platforms for which we expect not to be able to raw log.
ABSL_CONST_INIT static absl::base_internal::AtomicHook< ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static absl::base_internal::AtomicHook<
absl::raw_logging_internal::LogPrefixHook> log_prefix_hook; absl::raw_logging_internal::LogPrefixHook>
ABSL_CONST_INIT static absl::base_internal::AtomicHook< log_prefix_hook;
absl::raw_logging_internal::AbortHook> abort_hook; ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static absl::base_internal::AtomicHook<
absl::raw_logging_internal::AbortHook>
abort_hook;
#ifdef ABSL_LOW_LEVEL_WRITE_SUPPORTED #ifdef ABSL_LOW_LEVEL_WRITE_SUPPORTED
static const char kTruncated[] = " ... (message truncated)\n"; static const char kTruncated[] = " ... (message truncated)\n";
...@@ -225,7 +227,7 @@ bool RawLoggingFullySupported() { ...@@ -225,7 +227,7 @@ bool RawLoggingFullySupported() {
#endif // !ABSL_LOW_LEVEL_WRITE_SUPPORTED #endif // !ABSL_LOW_LEVEL_WRITE_SUPPORTED
} }
ABSL_CONST_INIT ABSL_DLL ABSL_DLL ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
absl::base_internal::AtomicHook<InternalLogFunction> absl::base_internal::AtomicHook<InternalLogFunction>
internal_log_function(DefaultInternalLog); internal_log_function(DefaultInternalLog);
......
absl/base/internal/raw_logging.h
...@@ -170,7 +170,8 @@ using InternalLogFunction = void (*)(absl::LogSeverity severity, ...@@ -170,7 +170,8 @@ using InternalLogFunction = void (*)(absl::LogSeverity severity,
const char* file, int line, const char* file, int line,
const std::string& message); const std::string& message);
ABSL_DLL extern base_internal::AtomicHook<InternalLogFunction> ABSL_DLL ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES extern base_internal::AtomicHook<
InternalLogFunction>
internal_log_function; internal_log_function;
void RegisterInternalLogFunction(InternalLogFunction func); void RegisterInternalLogFunction(InternalLogFunction func);
......
absl/base/internal/spinlock.cc
...@@ -57,8 +57,8 @@ namespace absl { ...@@ -57,8 +57,8 @@ namespace absl {
ABSL_NAMESPACE_BEGIN ABSL_NAMESPACE_BEGIN
namespace base_internal { namespace base_internal {
ABSL_CONST_INIT static base_internal::AtomicHook<void (*)(const void *lock, ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static base_internal::AtomicHook<void (*)(
int64_t wait_cycles)> const void *lock, int64_t wait_cycles)>
submit_profile_data; submit_profile_data;
void RegisterSpinLockProfiler(void (*fn)(const void *contendedlock, void RegisterSpinLockProfiler(void (*fn)(const void *contendedlock,
......
absl/flags/flag.h
...@@ -186,15 +186,17 @@ class Flag { ...@@ -186,15 +186,17 @@ class Flag {
// //
// // FLAGS_firstname is a Flag of type `std::string` // // FLAGS_firstname is a Flag of type `std::string`
// std::string first_name = absl::GetFlag(FLAGS_firstname); // std::string first_name = absl::GetFlag(FLAGS_firstname);
template <typename T>
ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
return flag.Get();
}
#ifndef NDEBUG #ifndef NDEBUG
// We want to validate the type mismatch between type definition and // We want to validate the type mismatch between type definition and
// declaration. The lock-free implementation does not allow us to do it, // declaration. The lock-free implementation does not allow us to do it,
// so in debug builds we always use the slower implementation, which always // so in debug builds we always use the slower implementation, which always
// validates the type. // validates the type.
template <typename T>
ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
return flag.Get();
}
// We currently need an external linkage for built-in types because shared // We currently need an external linkage for built-in types because shared
// libraries have different addresses of flags_internal::FlagOps<T> which // libraries have different addresses of flags_internal::FlagOps<T> which
// might cause log spam when checking the same flag type. // might cause log spam when checking the same flag type.
...@@ -202,29 +204,6 @@ ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) { ...@@ -202,29 +204,6 @@ ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag); ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag);
ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(ABSL_FLAGS_INTERNAL_BUILT_IN_EXPORT) ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(ABSL_FLAGS_INTERNAL_BUILT_IN_EXPORT)
#undef ABSL_FLAGS_INTERNAL_BUILT_IN_EXPORT #undef ABSL_FLAGS_INTERNAL_BUILT_IN_EXPORT
#else
template <typename T,
typename std::enable_if<
!flags_internal::IsAtomicFlagTypeTrait<T>::value, int>::type = 0>
ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
return flag.Get();
}
// Overload for `GetFlag()` for types that support lock-free reads.
template <typename T,
typename std::enable_if<
flags_internal::IsAtomicFlagTypeTrait<T>::value, int>::type = 0>
ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
// T might not be default constructible.
union U {
T value;
U() {}
};
U result;
if (flag.AtomicGet(&result.value)) {
return result.value;
}
return flag.Get();
}
#endif #endif
// SetFlag() // SetFlag()
......
absl/flags/internal/flag.h
...@@ -244,16 +244,32 @@ class FlagImpl { ...@@ -244,16 +244,32 @@ class FlagImpl {
bool TryParse(void** dst, absl::string_view value, std::string* err) const bool TryParse(void** dst, absl::string_view value, std::string* err) const
ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard()); ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
#ifndef NDEBUG
template <typename T> template <typename T>
bool AtomicGet(T* v) const { void Get(T* dst) const {
Read(dst, &flags_internal::FlagOps<T>);
}
#else
template <typename T, typename std::enable_if<
!flags_internal::IsAtomicFlagTypeTrait<T>::value,
int>::type = 0>
void Get(T* dst) const {
Read(dst, &flags_internal::FlagOps<T>);
}
// Overload for `GetFlag()` for types that support lock-free reads.
template <typename T,
typename std::enable_if<
flags_internal::IsAtomicFlagTypeTrait<T>::value, int>::type = 0>
void Get(T* dst) const {
using U = flags_internal::BestAtomicType<T>; using U = flags_internal::BestAtomicType<T>;
const typename U::type r = atomics_.template load<T>(); const typename U::type r = atomics_.template load<T>();
if (r != U::AtomicInit()) { if (r != U::AtomicInit()) {
std::memcpy(static_cast<void*>(v), &r, sizeof(T)); std::memcpy(static_cast<void*>(dst), &r, sizeof(T));
return true; } else {
Read(dst, &flags_internal::FlagOps<T>);
} }
return false;
} }
#endif
// Mutating access methods // Mutating access methods
void Write(const void* src, const flags_internal::FlagOpFn src_op) void Write(const void* src, const flags_internal::FlagOpFn src_op)
...@@ -397,12 +413,10 @@ class Flag final : public flags_internal::CommandLineFlag { ...@@ -397,12 +413,10 @@ class Flag final : public flags_internal::CommandLineFlag {
}; };
U u; U u;
impl_.Read(&u.value, &flags_internal::FlagOps<T>); impl_.Get(&u.value);
return std::move(u.value); return std::move(u.value);
} }
bool AtomicGet(T* v) const { return impl_.AtomicGet(v); }
void Set(const T& v) { impl_.Write(&v, &flags_internal::FlagOps<T>); } void Set(const T& v) { impl_.Write(&v, &flags_internal::FlagOps<T>); }
void SetCallback(const flags_internal::FlagCallback mutation_callback) { void SetCallback(const flags_internal::FlagCallback mutation_callback) {
......
absl/random/distributions.h
...@@ -291,10 +291,10 @@ RealType Beta(URBG&& urbg, // NOLINT(runtime/references) ...@@ -291,10 +291,10 @@ RealType Beta(URBG&& urbg, // NOLINT(runtime/references)
// absl::Exponential<T>(bitgen, lambda = 1) // absl::Exponential<T>(bitgen, lambda = 1)
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// //
// `absl::Exponential` produces a floating point number for discrete // `absl::Exponential` produces a floating point number representing the
// distributions of events occurring continuously and independently at a // distance (time) between two consecutive events in a point process of events
// constant average rate. `T` must be a floating point type, but may be inferred // occurring continuously and independently at a constant average rate. `T` must
// from the type of `lambda`. // be a floating point type, but may be inferred from the type of `lambda`.
// //
// See https://en.wikipedia.org/wiki/Exponential_distribution. // See https://en.wikipedia.org/wiki/Exponential_distribution.
// //
......
absl/strings/charconv.cc
...@@ -673,7 +673,6 @@ from_chars_result FromCharsImpl(const char* first, const char* last, ...@@ -673,7 +673,6 @@ from_chars_result FromCharsImpl(const char* first, const char* last,
EncodeResult(calculated, negative, &result, &value); EncodeResult(calculated, negative, &result, &value);
return result; return result;
} }
return result;
} }
} // namespace } // namespace
......
absl/strings/string_view_benchmark.cc
...@@ -160,11 +160,45 @@ void BM_CompareSame(benchmark::State& state) { ...@@ -160,11 +160,45 @@ void BM_CompareSame(benchmark::State& state) {
absl::string_view b = y; absl::string_view b = y;
for (auto _ : state) { for (auto _ : state) {
benchmark::DoNotOptimize(a);
benchmark::DoNotOptimize(b);
benchmark::DoNotOptimize(a.compare(b)); benchmark::DoNotOptimize(a.compare(b));
} }
} }
BENCHMARK(BM_CompareSame)->DenseRange(0, 3)->Range(4, 1 << 10); BENCHMARK(BM_CompareSame)->DenseRange(0, 3)->Range(4, 1 << 10);
void BM_CompareFirstOneLess(benchmark::State& state) {
const int len = state.range(0);
std::string x(len, 'a');
std::string y = x;
y.back() = 'b';
absl::string_view a = x;
absl::string_view b = y;
for (auto _ : state) {
benchmark::DoNotOptimize(a);
benchmark::DoNotOptimize(b);
benchmark::DoNotOptimize(a.compare(b));
}
}
BENCHMARK(BM_CompareFirstOneLess)->DenseRange(1, 3)->Range(4, 1 << 10);
void BM_CompareSecondOneLess(benchmark::State& state) {
const int len = state.range(0);
std::string x(len, 'a');
std::string y = x;
x.back() = 'b';
absl::string_view a = x;
absl::string_view b = y;
for (auto _ : state) {
benchmark::DoNotOptimize(a);
benchmark::DoNotOptimize(b);
benchmark::DoNotOptimize(a.compare(b));
}
}
BENCHMARK(BM_CompareSecondOneLess)->DenseRange(1, 3)->Range(4, 1 << 10);
void BM_find_string_view_len_one(benchmark::State& state) { void BM_find_string_view_len_one(benchmark::State& state) {
std::string haystack(state.range(0), '0'); std::string haystack(state.range(0), '0');
absl::string_view s(haystack); absl::string_view s(haystack);
......
absl/synchronization/mutex.cc
...@@ -107,13 +107,16 @@ static_assert( ...@@ -107,13 +107,16 @@ static_assert(
sizeof(MutexGlobals) == ABSL_CACHELINE_SIZE, sizeof(MutexGlobals) == ABSL_CACHELINE_SIZE,
"MutexGlobals must occupy an entire cacheline to prevent false sharing"); "MutexGlobals must occupy an entire cacheline to prevent false sharing");
ABSL_CONST_INIT absl::base_internal::AtomicHook<void (*)(int64_t wait_cycles)> ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
absl::base_internal::AtomicHook<void (*)(int64_t wait_cycles)>
submit_profile_data; submit_profile_data;
ABSL_CONST_INIT absl::base_internal::AtomicHook< ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES absl::base_internal::AtomicHook<void (*)(
void (*)(const char *msg, const void *obj, int64_t wait_cycles)> mutex_tracer; const char *msg, const void *obj, int64_t wait_cycles)>
ABSL_CONST_INIT absl::base_internal::AtomicHook< mutex_tracer;
void (*)(const char *msg, const void *cv)> cond_var_tracer; ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
ABSL_CONST_INIT absl::base_internal::AtomicHook< absl::base_internal::AtomicHook<void (*)(const char *msg, const void *cv)>
cond_var_tracer;
ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES absl::base_internal::AtomicHook<
bool (*)(const void *pc, char *out, int out_size)> bool (*)(const void *pc, char *out, int out_size)>
symbolizer(absl::Symbolize); symbolizer(absl::Symbolize);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment