220 lines
8.4 KiB
C++
220 lines
8.4 KiB
C++
// Copyright 2018 The Abseil Authors.
|
|
//
|
|
// 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
|
|
//
|
|
// https://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.
|
|
|
|
#include "absl/debugging/internal/demangle.h"
|
|
|
|
#include <cstdlib>
|
|
#include <string>
|
|
|
|
#include "gtest/gtest.h"
|
|
#include "absl/base/config.h"
|
|
#include "absl/base/internal/raw_logging.h"
|
|
#include "absl/debugging/internal/stack_consumption.h"
|
|
#include "absl/memory/memory.h"
|
|
|
|
namespace absl {
|
|
ABSL_NAMESPACE_BEGIN
|
|
namespace debugging_internal {
|
|
namespace {
|
|
|
|
// A wrapper function for Demangle() to make the unit test simple.
|
|
static const char *DemangleIt(const char * const mangled) {
|
|
static char demangled[4096];
|
|
if (Demangle(mangled, demangled, sizeof(demangled))) {
|
|
return demangled;
|
|
} else {
|
|
return mangled;
|
|
}
|
|
}
|
|
|
|
// Test corner cases of bounary conditions.
|
|
TEST(Demangle, CornerCases) {
|
|
char tmp[10];
|
|
EXPECT_TRUE(Demangle("_Z6foobarv", tmp, sizeof(tmp)));
|
|
// sizeof("foobar()") == 9
|
|
EXPECT_STREQ("foobar()", tmp);
|
|
EXPECT_TRUE(Demangle("_Z6foobarv", tmp, 9));
|
|
EXPECT_STREQ("foobar()", tmp);
|
|
EXPECT_FALSE(Demangle("_Z6foobarv", tmp, 8)); // Not enough.
|
|
EXPECT_FALSE(Demangle("_Z6foobarv", tmp, 1));
|
|
EXPECT_FALSE(Demangle("_Z6foobarv", tmp, 0));
|
|
EXPECT_FALSE(Demangle("_Z6foobarv", nullptr, 0)); // Should not cause SEGV.
|
|
EXPECT_FALSE(Demangle("_Z1000000", tmp, 9));
|
|
}
|
|
|
|
// Test handling of functions suffixed with .clone.N, which is used
|
|
// by GCC 4.5.x (and our locally-modified version of GCC 4.4.x), and
|
|
// .constprop.N and .isra.N, which are used by GCC 4.6.x. These
|
|
// suffixes are used to indicate functions which have been cloned
|
|
// during optimization. We ignore these suffixes.
|
|
TEST(Demangle, Clones) {
|
|
char tmp[20];
|
|
EXPECT_TRUE(Demangle("_ZL3Foov", tmp, sizeof(tmp)));
|
|
EXPECT_STREQ("Foo()", tmp);
|
|
EXPECT_TRUE(Demangle("_ZL3Foov.clone.3", tmp, sizeof(tmp)));
|
|
EXPECT_STREQ("Foo()", tmp);
|
|
EXPECT_TRUE(Demangle("_ZL3Foov.constprop.80", tmp, sizeof(tmp)));
|
|
EXPECT_STREQ("Foo()", tmp);
|
|
EXPECT_TRUE(Demangle("_ZL3Foov.isra.18", tmp, sizeof(tmp)));
|
|
EXPECT_STREQ("Foo()", tmp);
|
|
EXPECT_TRUE(Demangle("_ZL3Foov.isra.2.constprop.18", tmp, sizeof(tmp)));
|
|
EXPECT_STREQ("Foo()", tmp);
|
|
// Demangle suffixes produced by -funique-internal-linkage-names.
|
|
EXPECT_TRUE(Demangle("_ZL3Foov.__uniq.12345", tmp, sizeof(tmp)));
|
|
EXPECT_STREQ("Foo()", tmp);
|
|
EXPECT_TRUE(Demangle("_ZL3Foov.__uniq.12345.isra.2.constprop.18", tmp,
|
|
sizeof(tmp)));
|
|
EXPECT_STREQ("Foo()", tmp);
|
|
// Suffixes without the number should also demangle.
|
|
EXPECT_TRUE(Demangle("_ZL3Foov.clo", tmp, sizeof(tmp)));
|
|
EXPECT_STREQ("Foo()", tmp);
|
|
// Suffixes with just the number should also demangle.
|
|
EXPECT_TRUE(Demangle("_ZL3Foov.123", tmp, sizeof(tmp)));
|
|
EXPECT_STREQ("Foo()", tmp);
|
|
// (.clone. followed by non-number), should also demangle.
|
|
EXPECT_TRUE(Demangle("_ZL3Foov.clone.foo", tmp, sizeof(tmp)));
|
|
EXPECT_STREQ("Foo()", tmp);
|
|
// (.clone. followed by multiple numbers), should also demangle.
|
|
EXPECT_TRUE(Demangle("_ZL3Foov.clone.123.456", tmp, sizeof(tmp)));
|
|
EXPECT_STREQ("Foo()", tmp);
|
|
// (a long valid suffix), should demangle.
|
|
EXPECT_TRUE(Demangle("_ZL3Foov.part.9.165493.constprop.775.31805", tmp,
|
|
sizeof(tmp)));
|
|
EXPECT_STREQ("Foo()", tmp);
|
|
// Invalid (. without anything else), should not demangle.
|
|
EXPECT_FALSE(Demangle("_ZL3Foov.", tmp, sizeof(tmp)));
|
|
// Invalid (. with mix of alpha and digits), should not demangle.
|
|
EXPECT_FALSE(Demangle("_ZL3Foov.abc123", tmp, sizeof(tmp)));
|
|
// Invalid (.clone. not followed by number), should not demangle.
|
|
EXPECT_FALSE(Demangle("_ZL3Foov.clone.", tmp, sizeof(tmp)));
|
|
// Invalid (.constprop. not followed by number), should not demangle.
|
|
EXPECT_FALSE(Demangle("_ZL3Foov.isra.2.constprop.", tmp, sizeof(tmp)));
|
|
}
|
|
|
|
// Tests that verify that Demangle footprint is within some limit.
|
|
// They are not to be run under sanitizers as the sanitizers increase
|
|
// stack consumption by about 4x.
|
|
#if defined(ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION) && \
|
|
!defined(ABSL_HAVE_ADDRESS_SANITIZER) && \
|
|
!defined(ABSL_HAVE_MEMORY_SANITIZER) && \
|
|
!defined(ABSL_HAVE_THREAD_SANITIZER)
|
|
|
|
static const char *g_mangled;
|
|
static char g_demangle_buffer[4096];
|
|
static char *g_demangle_result;
|
|
|
|
static void DemangleSignalHandler(int signo) {
|
|
if (Demangle(g_mangled, g_demangle_buffer, sizeof(g_demangle_buffer))) {
|
|
g_demangle_result = g_demangle_buffer;
|
|
} else {
|
|
g_demangle_result = nullptr;
|
|
}
|
|
}
|
|
|
|
// Call Demangle and figure out the stack footprint of this call.
|
|
static const char *DemangleStackConsumption(const char *mangled,
|
|
int *stack_consumed) {
|
|
g_mangled = mangled;
|
|
*stack_consumed = GetSignalHandlerStackConsumption(DemangleSignalHandler);
|
|
ABSL_RAW_LOG(INFO, "Stack consumption of Demangle: %d", *stack_consumed);
|
|
return g_demangle_result;
|
|
}
|
|
|
|
// Demangle stack consumption should be within 8kB for simple mangled names
|
|
// with some level of nesting. With alternate signal stack we have 64K,
|
|
// but some signal handlers run on thread stack, and could have arbitrarily
|
|
// little space left (so we don't want to make this number too large).
|
|
const int kStackConsumptionUpperLimit = 8192;
|
|
|
|
// Returns a mangled name nested to the given depth.
|
|
static std::string NestedMangledName(int depth) {
|
|
std::string mangled_name = "_Z1a";
|
|
if (depth > 0) {
|
|
mangled_name += "IXL";
|
|
mangled_name += NestedMangledName(depth - 1);
|
|
mangled_name += "EEE";
|
|
}
|
|
return mangled_name;
|
|
}
|
|
|
|
TEST(Demangle, DemangleStackConsumption) {
|
|
// Measure stack consumption of Demangle for nested mangled names of varying
|
|
// depth. Since Demangle is implemented as a recursive descent parser,
|
|
// stack consumption will grow as the nesting depth increases. By measuring
|
|
// the stack consumption for increasing depths, we can see the growing
|
|
// impact of any stack-saving changes made to the code for Demangle.
|
|
int stack_consumed = 0;
|
|
|
|
const char *demangled =
|
|
DemangleStackConsumption("_Z6foobarv", &stack_consumed);
|
|
EXPECT_STREQ("foobar()", demangled);
|
|
EXPECT_GT(stack_consumed, 0);
|
|
EXPECT_LT(stack_consumed, kStackConsumptionUpperLimit);
|
|
|
|
const std::string nested_mangled_name0 = NestedMangledName(0);
|
|
demangled = DemangleStackConsumption(nested_mangled_name0.c_str(),
|
|
&stack_consumed);
|
|
EXPECT_STREQ("a", demangled);
|
|
EXPECT_GT(stack_consumed, 0);
|
|
EXPECT_LT(stack_consumed, kStackConsumptionUpperLimit);
|
|
|
|
const std::string nested_mangled_name1 = NestedMangledName(1);
|
|
demangled = DemangleStackConsumption(nested_mangled_name1.c_str(),
|
|
&stack_consumed);
|
|
EXPECT_STREQ("a<>", demangled);
|
|
EXPECT_GT(stack_consumed, 0);
|
|
EXPECT_LT(stack_consumed, kStackConsumptionUpperLimit);
|
|
|
|
const std::string nested_mangled_name2 = NestedMangledName(2);
|
|
demangled = DemangleStackConsumption(nested_mangled_name2.c_str(),
|
|
&stack_consumed);
|
|
EXPECT_STREQ("a<>", demangled);
|
|
EXPECT_GT(stack_consumed, 0);
|
|
EXPECT_LT(stack_consumed, kStackConsumptionUpperLimit);
|
|
|
|
const std::string nested_mangled_name3 = NestedMangledName(3);
|
|
demangled = DemangleStackConsumption(nested_mangled_name3.c_str(),
|
|
&stack_consumed);
|
|
EXPECT_STREQ("a<>", demangled);
|
|
EXPECT_GT(stack_consumed, 0);
|
|
EXPECT_LT(stack_consumed, kStackConsumptionUpperLimit);
|
|
}
|
|
|
|
#endif // Stack consumption tests
|
|
|
|
static void TestOnInput(const char* input) {
|
|
static const int kOutSize = 1048576;
|
|
auto out = absl::make_unique<char[]>(kOutSize);
|
|
Demangle(input, out.get(), kOutSize);
|
|
}
|
|
|
|
TEST(DemangleRegression, NegativeLength) {
|
|
TestOnInput("_ZZn4");
|
|
}
|
|
|
|
TEST(DemangleRegression, DeeplyNestedArrayType) {
|
|
const int depth = 100000;
|
|
std::string data = "_ZStI";
|
|
data.reserve(data.size() + 3 * depth + 1);
|
|
for (int i = 0; i < depth; i++) {
|
|
data += "A1_";
|
|
}
|
|
TestOnInput(data.c_str());
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace debugging_internal
|
|
ABSL_NAMESPACE_END
|
|
} // namespace absl
|