src/symbolize_unittest.cc

   1 // Copyright (c) 2006, Google Inc.
   2 // All rights reserved.
   3 //
   4 // Redistribution and use in source and binary forms, with or without
   5 // modification, are permitted provided that the following conditions are
   6 // met:
   7 //
   8 //     * Redistributions of source code must retain the above copyright
   9 // notice, this list of conditions and the following disclaimer.
  10 //     * Redistributions in binary form must reproduce the above
  11 // copyright notice, this list of conditions and the following disclaimer
  12 // in the documentation and/or other materials provided with the
  13 // distribution.
  14 //     * Neither the name of Google Inc. nor the names of its
  15 // contributors may be used to endorse or promote products derived from
  16 // this software without specific prior written permission.
  17 //
  18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 //
  30 // Author: Satoru Takabayashi
  31 //
  32 // Unit tests for functions in symbolize.cc.
  33
  34 #include "utilities.h"
  35
  36 #include <signal.h>
  37 #include <iostream>
  38
  39 #include "glog/logging.h"
  40 #include "symbolize.h"
  41 #include "googletest.h"
  42 #include "config.h"
  43
  44 #ifdef HAVE_LIB_GFLAGS
  45 #include <gflags/gflags.h>
  46 using namespace GFLAGS_NAMESPACE;
  47 #endif
  48
  49 using namespace std;
  50 using namespace GOOGLE_NAMESPACE;
  51
  52 #if defined(HAVE_STACKTRACE) && defined(__ELF__)
  53
  54 #define always_inline
  55
  56 // This unit tests make sense only with GCC.
  57 // Uses lots of GCC specific features.
  58 #if defined(__GNUC__) && !defined(__OPENCC__)
  59 #  if __GNUC__ >= 4
  60 #    define TEST_WITH_MODERN_GCC
  61 #    if __i386__  // always_inline isn't supported for x86_64 with GCC 4.1.0.
  62 #      undef always_inline
  63 #      define always_inline __attribute__((always_inline))
  64 #      define HAVE_ALWAYS_INLINE
  65 #    endif  // __i386__
  66 #  else
  67 #  endif  // __GNUC__ >= 4
  68 #  if defined(__i386__) || defined(__x86_64__)
  69 #    define TEST_X86_32_AND_64 1
  70 #  endif  // defined(__i386__) || defined(__x86_64__)
  71 #endif
  72
  73 // A wrapper function for Symbolize() to make the unit test simple.
  74 static const char *TrySymbolize(void *pc) {
  75   static char symbol[4096];
  76   if (Symbolize(pc, symbol, sizeof(symbol))) {
  77     return symbol;
  78   } else {
  79     return NULL;
  80   }
  81 }
  82
  83 // Make them C linkage to avoid mangled names.
  84 extern "C" {
  85 void nonstatic_func() {
  86   volatile int a = 0;
  87   ++a;
  88 }
  89
  90 static void static_func() {
  91   volatile int a = 0;
  92   ++a;
  93 }
  94 }
  95
  96 TEST(Symbolize, Symbolize) {
  97   // We do C-style cast since GCC 2.95.3 doesn't allow
  98   // reinterpret_cast<void *>(&func).
  99
 100   // Compilers should give us pointers to them.
 101   EXPECT_STREQ("nonstatic_func", TrySymbolize((void *)(&nonstatic_func)));
 102
 103   // The name of an internal linkage symbol is not specified; allow either a
 104   // mangled or an unmangled name here.
 105   const char *static_func_symbol = TrySymbolize((void *)(&static_func));
 106   CHECK(NULL != static_func_symbol);
 107   EXPECT_TRUE(strcmp("static_func", static_func_symbol) == 0 ||
 108               strcmp("static_func()", static_func_symbol) == 0);
 109
 110   EXPECT_TRUE(NULL == TrySymbolize(NULL));
 111 }
 112
 113 struct Foo {
 114   static void func(int x);
 115 };
 116
 117 void ATTRIBUTE_NOINLINE Foo::func(int x) {
 118   volatile int a = x;
 119   ++a;
 120 }
 121
 122 // With a modern GCC, Symbolize() should return demangled symbol
 123 // names.  Function parameters should be omitted.
 124 #ifdef TEST_WITH_MODERN_GCC
 125 TEST(Symbolize, SymbolizeWithDemangling) {
 126   Foo::func(100);
 127   EXPECT_STREQ("Foo::func()", TrySymbolize((void *)(&Foo::func)));
 128 }
 129 #endif
 130
 131 // Tests that verify that Symbolize footprint is within some limit.
 132
 133 // To measure the stack footprint of the Symbolize function, we create
 134 // a signal handler (for SIGUSR1 say) that calls the Symbolize function
 135 // on an alternate stack. This alternate stack is initialized to some
 136 // known pattern (0x55, 0x55, 0x55, ...). We then self-send this signal,
 137 // and after the signal handler returns, look at the alternate stack
 138 // buffer to see what portion has been touched.
 139 //
 140 // This trick gives us the the stack footprint of the signal handler.
 141 // But the signal handler, even before the call to Symbolize, consumes
 142 // some stack already. We however only want the stack usage of the
 143 // Symbolize function. To measure this accurately, we install two signal
 144 // handlers: one that does nothing and just returns, and another that
 145 // calls Symbolize. The difference between the stack consumption of these
 146 // two signals handlers should give us the Symbolize stack foorprint.
 147
 148 static void *g_pc_to_symbolize;
 149 static char g_symbolize_buffer[4096];
 150 static char *g_symbolize_result;
 151
 152 static void EmptySignalHandler(int signo) {}
 153
 154 static void SymbolizeSignalHandler(int signo) {
 155   if (Symbolize(g_pc_to_symbolize, g_symbolize_buffer,
 156                 sizeof(g_symbolize_buffer))) {
 157     g_symbolize_result = g_symbolize_buffer;
 158   } else {
 159     g_symbolize_result = NULL;
 160   }
 161 }
 162
 163 const int kAlternateStackSize = 8096;
 164 const char kAlternateStackFillValue = 0x55;
 165
 166 // These helper functions look at the alternate stack buffer, and figure
 167 // out what portion of this buffer has been touched - this is the stack
 168 // consumption of the signal handler running on this alternate stack.
 169 static ATTRIBUTE_NOINLINE bool StackGrowsDown(int *x) {
 170   int y;
 171   return &y < x;
 172 }
 173 static int GetStackConsumption(const char* alt_stack) {
 174   int x;
 175   if (StackGrowsDown(&x)) {
 176     for (int i = 0; i < kAlternateStackSize; i++) {
 177       if (alt_stack[i] != kAlternateStackFillValue) {
 178         return (kAlternateStackSize - i);
 179       }
 180     }
 181   } else {
 182     for (int i = (kAlternateStackSize - 1); i >= 0; i--) {
 183       if (alt_stack[i] != kAlternateStackFillValue) {
 184         return i;
 185       }
 186     }
 187   }
 188   return -1;
 189 }
 190
 191 #ifdef HAVE_SIGALTSTACK
 192
 193 // Call Symbolize and figure out the stack footprint of this call.
 194 static const char *SymbolizeStackConsumption(void *pc, int *stack_consumed) {
 195
 196   g_pc_to_symbolize = pc;
 197
 198   // The alt-signal-stack cannot be heap allocated because there is a
 199   // bug in glibc-2.2 where some signal handler setup code looks at the
 200   // current stack pointer to figure out what thread is currently running.
 201   // Therefore, the alternate stack must be allocated from the main stack
 202   // itself.
 203   char altstack[kAlternateStackSize];
 204   memset(altstack, kAlternateStackFillValue, kAlternateStackSize);
 205
 206   // Set up the alt-signal-stack (and save the older one).
 207   stack_t sigstk;
 208   memset(&sigstk, 0, sizeof(stack_t));
 209   stack_t old_sigstk;
 210   sigstk.ss_sp = altstack;
 211   sigstk.ss_size = kAlternateStackSize;
 212   sigstk.ss_flags = 0;
 213   CHECK_ERR(sigaltstack(&sigstk, &old_sigstk));
 214
 215   // Set up SIGUSR1 and SIGUSR2 signal handlers (and save the older ones).
 216   struct sigaction sa;
 217   memset(&sa, 0, sizeof(struct sigaction));
 218   struct sigaction old_sa1, old_sa2;
 219   sigemptyset(&sa.sa_mask);
 220   sa.sa_flags = SA_ONSTACK;
 221
 222   // SIGUSR1 maps to EmptySignalHandler.
 223   sa.sa_handler = EmptySignalHandler;
 224   CHECK_ERR(sigaction(SIGUSR1, &sa, &old_sa1));
 225
 226   // SIGUSR2 maps to SymbolizeSignalHanlder.
 227   sa.sa_handler = SymbolizeSignalHandler;
 228   CHECK_ERR(sigaction(SIGUSR2, &sa, &old_sa2));
 229
 230   // Send SIGUSR1 signal and measure the stack consumption of the empty
 231   // signal handler.
 232   CHECK_ERR(kill(getpid(), SIGUSR1));
 233   int stack_consumption1 = GetStackConsumption(altstack);
 234
 235   // Send SIGUSR2 signal and measure the stack consumption of the symbolize
 236   // signal handler.
 237   CHECK_ERR(kill(getpid(), SIGUSR2));
 238   int stack_consumption2 = GetStackConsumption(altstack);
 239
 240   // The difference between the two stack consumption values is the
 241   // stack footprint of the Symbolize function.
 242   if (stack_consumption1 != -1 && stack_consumption2 != -1) {
 243     *stack_consumed = stack_consumption2 - stack_consumption1;
 244   } else {
 245     *stack_consumed = -1;
 246   }
 247
 248   // Log the stack consumption values.
 249   LOG(INFO) << "Stack consumption of empty signal handler: "
 250             << stack_consumption1;
 251   LOG(INFO) << "Stack consumption of symbolize signal handler: "
 252             << stack_consumption2;
 253   LOG(INFO) << "Stack consumption of Symbolize: " << *stack_consumed;
 254
 255   // Now restore the old alt-signal-stack and signal handlers.
 256   CHECK_ERR(sigaltstack(&old_sigstk, NULL));
 257   CHECK_ERR(sigaction(SIGUSR1, &old_sa1, NULL));
 258   CHECK_ERR(sigaction(SIGUSR2, &old_sa2, NULL));
 259
 260   return g_symbolize_result;
 261 }
 262
 263 // Symbolize stack consumption should be within 2kB.
 264 const int kStackConsumptionUpperLimit = 2048;
 265
 266 TEST(Symbolize, SymbolizeStackConsumption) {
 267   int stack_consumed;
 268   const char* symbol;
 269
 270   symbol = SymbolizeStackConsumption((void *)(&nonstatic_func),
 271                                      &stack_consumed);
 272   EXPECT_STREQ("nonstatic_func", symbol);
 273   EXPECT_GT(stack_consumed, 0);
 274   EXPECT_LT(stack_consumed, kStackConsumptionUpperLimit);
 275
 276   // The name of an internal linkage symbol is not specified; allow either a
 277   // mangled or an unmangled name here.
 278   symbol = SymbolizeStackConsumption((void *)(&static_func),
 279                                      &stack_consumed);
 280   CHECK(NULL != symbol);
 281   EXPECT_TRUE(strcmp("static_func", symbol) == 0 ||
 282               strcmp("static_func()", symbol) == 0);
 283   EXPECT_GT(stack_consumed, 0);
 284   EXPECT_LT(stack_consumed, kStackConsumptionUpperLimit);
 285 }
 286
 287 #ifdef TEST_WITH_MODERN_GCC
 288 TEST(Symbolize, SymbolizeWithDemanglingStackConsumption) {
 289   Foo::func(100);
 290   int stack_consumed;
 291   const char* symbol;
 292
 293   symbol = SymbolizeStackConsumption((void *)(&Foo::func), &stack_consumed);
 294
 295   EXPECT_STREQ("Foo::func()", symbol);
 296   EXPECT_GT(stack_consumed, 0);
 297   EXPECT_LT(stack_consumed, kStackConsumptionUpperLimit);
 298 }
 299 #endif
 300
 301 #endif  // HAVE_SIGALTSTACK
 302
 303 // x86 specific tests.  Uses some inline assembler.
 304 extern "C" {
 305 inline void* always_inline inline_func() {
 306   register void *pc = NULL;
 307 #ifdef TEST_X86_32_AND_64
 308   __asm__ __volatile__("call 1f; 1: pop %0" : "=r"(pc));
 309 #endif
 310   return pc;
 311 }
 312
 313 void* ATTRIBUTE_NOINLINE non_inline_func() {
 314   register void *pc = NULL;
 315 #ifdef TEST_X86_32_AND_64
 316   __asm__ __volatile__("call 1f; 1: pop %0" : "=r"(pc));
 317 #endif
 318   return pc;
 319 }
 320
 321 void ATTRIBUTE_NOINLINE TestWithPCInsideNonInlineFunction() {
 322 #if defined(TEST_X86_32_AND_64) && defined(HAVE_ATTRIBUTE_NOINLINE)
 323   void *pc = non_inline_func();
 324   const char *symbol = TrySymbolize(pc);
 325   CHECK(symbol != NULL);
 326   CHECK_STREQ(symbol, "non_inline_func");
 327   cout << "Test case TestWithPCInsideNonInlineFunction passed." << endl;
 328 #endif
 329 }
 330
 331 void ATTRIBUTE_NOINLINE TestWithPCInsideInlineFunction() {
 332 #if defined(TEST_X86_32_AND_64) && defined(HAVE_ALWAYS_INLINE)
 333   void *pc = inline_func();  // Must be inlined.
 334   const char *symbol = TrySymbolize(pc);
 335   CHECK(symbol != NULL);
 336   CHECK_STREQ(symbol, __FUNCTION__);
 337   cout << "Test case TestWithPCInsideInlineFunction passed." << endl;
 338 #endif
 339 }
 340 }
 341
 342 // Test with a return address.
 343 void ATTRIBUTE_NOINLINE TestWithReturnAddress() {
 344 #if defined(HAVE_ATTRIBUTE_NOINLINE)
 345   void *return_address = __builtin_return_address(0);
 346   const char *symbol = TrySymbolize(return_address);
 347   CHECK(symbol != NULL);
 348   CHECK_STREQ(symbol, "main");
 349   cout << "Test case TestWithReturnAddress passed." << endl;
 350 #endif
 351 }
 352
 353 int main(int argc, char **argv) {
 354   FLAGS_logtostderr = true;
 355   InitGoogleLogging(argv[0]);
 356   InitGoogleTest(&argc, argv);
 357 #ifdef HAVE_SYMBOLIZE
 358   // We don't want to get affected by the callback interface, that may be
 359   // used to install some callback function at InitGoogle() time.
 360   InstallSymbolizeCallback(NULL);
 361
 362   TestWithPCInsideInlineFunction();
 363   TestWithPCInsideNonInlineFunction();
 364   TestWithReturnAddress();
 365   return RUN_ALL_TESTS();
 366 #else
 367   return 0;
 368 #endif
 369 }
 370
 371 #else
 372 int main() {
 373 #ifdef HAVE_SYMBOLIZE
 374   printf("PASS (no symbolize_unittest support)\n");
 375 #else
 376   printf("PASS (no symbolize support)\n");
 377 #endif
 378   return 0;
 379 }
 380 #endif  // HAVE_STACKTRACE