// 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 #include #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))); } // Test the GNU abi_tag extension. TEST(Demangle, AbiTags) { char tmp[80]; // Mangled name generated via: // struct [[gnu::abi_tag("abc")]] A{}; // A a; EXPECT_TRUE(Demangle("_Z1aB3abc", tmp, sizeof(tmp))); EXPECT_STREQ("a[abi:abc]", tmp); // Mangled name generated via: // struct B { // B [[gnu::abi_tag("xyz")]] (){}; // }; // B b; EXPECT_TRUE(Demangle("_ZN1BC2B3xyzEv", tmp, sizeof(tmp))); EXPECT_STREQ("B::B[abi:xyz]()", tmp); // Mangled name generated via: // [[gnu::abi_tag("foo", "bar")]] void C() {} EXPECT_TRUE(Demangle("_Z1CB3barB3foov", tmp, sizeof(tmp))); EXPECT_STREQ("C[abi:bar][abi:foo]()", 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(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