Merge pull request #188 from shinh/remove-configure
[platform/upstream/glog.git] / 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 #ifdef __ppc64__
264 // Symbolize stack consumption should be within 4kB.
265 const int kStackConsumptionUpperLimit = 4096;
266 #else
267 // Symbolize stack consumption should be within 2kB.
268 const int kStackConsumptionUpperLimit = 2048;
269 #endif
270
271 TEST(Symbolize, SymbolizeStackConsumption) {
272   int stack_consumed;
273   const char* symbol;
274
275   symbol = SymbolizeStackConsumption((void *)(&nonstatic_func),
276                                      &stack_consumed);
277   EXPECT_STREQ("nonstatic_func", symbol);
278   EXPECT_GT(stack_consumed, 0);
279   EXPECT_LT(stack_consumed, kStackConsumptionUpperLimit);
280
281   // The name of an internal linkage symbol is not specified; allow either a
282   // mangled or an unmangled name here.
283   symbol = SymbolizeStackConsumption((void *)(&static_func),
284                                      &stack_consumed);
285   CHECK(NULL != symbol);
286   EXPECT_TRUE(strcmp("static_func", symbol) == 0 ||
287               strcmp("static_func()", symbol) == 0);
288   EXPECT_GT(stack_consumed, 0);
289   EXPECT_LT(stack_consumed, kStackConsumptionUpperLimit);
290 }
291
292 #ifdef TEST_WITH_MODERN_GCC
293 TEST(Symbolize, SymbolizeWithDemanglingStackConsumption) {
294   Foo::func(100);
295   int stack_consumed;
296   const char* symbol;
297
298   symbol = SymbolizeStackConsumption((void *)(&Foo::func), &stack_consumed);
299
300   EXPECT_STREQ("Foo::func()", symbol);
301   EXPECT_GT(stack_consumed, 0);
302   EXPECT_LT(stack_consumed, kStackConsumptionUpperLimit);
303 }
304 #endif
305
306 #endif  // HAVE_SIGALTSTACK
307
308 // x86 specific tests.  Uses some inline assembler.
309 extern "C" {
310 inline void* always_inline inline_func() {
311   register void *pc = NULL;
312 #ifdef TEST_X86_32_AND_64
313   __asm__ __volatile__("call 1f; 1: pop %0" : "=r"(pc));
314 #endif
315   return pc;
316 }
317
318 void* ATTRIBUTE_NOINLINE non_inline_func() {
319   register void *pc = NULL;
320 #ifdef TEST_X86_32_AND_64
321   __asm__ __volatile__("call 1f; 1: pop %0" : "=r"(pc));
322 #endif
323   return pc;
324 }
325
326 void ATTRIBUTE_NOINLINE TestWithPCInsideNonInlineFunction() {
327 #if defined(TEST_X86_32_AND_64) && defined(HAVE_ATTRIBUTE_NOINLINE)
328   void *pc = non_inline_func();
329   const char *symbol = TrySymbolize(pc);
330   CHECK(symbol != NULL);
331   CHECK_STREQ(symbol, "non_inline_func");
332   cout << "Test case TestWithPCInsideNonInlineFunction passed." << endl;
333 #endif
334 }
335
336 void ATTRIBUTE_NOINLINE TestWithPCInsideInlineFunction() {
337 #if defined(TEST_X86_32_AND_64) && defined(HAVE_ALWAYS_INLINE)
338   void *pc = inline_func();  // Must be inlined.
339   const char *symbol = TrySymbolize(pc);
340   CHECK(symbol != NULL);
341   CHECK_STREQ(symbol, __FUNCTION__);
342   cout << "Test case TestWithPCInsideInlineFunction passed." << endl;
343 #endif
344 }
345 }
346
347 // Test with a return address.
348 void ATTRIBUTE_NOINLINE TestWithReturnAddress() {
349 #if defined(HAVE_ATTRIBUTE_NOINLINE)
350   void *return_address = __builtin_return_address(0);
351   const char *symbol = TrySymbolize(return_address);
352   CHECK(symbol != NULL);
353   CHECK_STREQ(symbol, "main");
354   cout << "Test case TestWithReturnAddress passed." << endl;
355 #endif
356 }
357
358 int main(int argc, char **argv) {
359   FLAGS_logtostderr = true;
360   InitGoogleLogging(argv[0]);
361   InitGoogleTest(&argc, argv);
362 #ifdef HAVE_SYMBOLIZE
363   // We don't want to get affected by the callback interface, that may be
364   // used to install some callback function at InitGoogle() time.
365   InstallSymbolizeCallback(NULL);
366
367   TestWithPCInsideInlineFunction();
368   TestWithPCInsideNonInlineFunction();
369   TestWithReturnAddress();
370   return RUN_ALL_TESTS();
371 #else
372   return 0;
373 #endif
374 }
375
376 #else
377 int main() {
378 #ifdef HAVE_SYMBOLIZE
379   printf("PASS (no symbolize_unittest support)\n");
380 #else
381   printf("PASS (no symbolize support)\n");
382 #endif
383   return 0;
384 }
385 #endif  // HAVE_STACKTRACE