1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // Slightly adapted for inclusion in V8.
6 // Copyright 2016 the V8 project authors. All rights reserved.
7
8 #include "src/base/debug/stack_trace.h"
9
10 #include <windows.h>
11 #include <dbghelp.h>
12 #include <Shlwapi.h>
13 #include <stddef.h>
14
15 #include <iostream>
16 #include <memory>
17
18 #include "src/base/logging.h"
19 #include "src/base/macros.h"
20
21 namespace v8 {
22 namespace base {
23 namespace debug {
24
25 namespace {
26
27 // Previous unhandled filter. Will be called if not NULL when we intercept an
28 // exception. Only used in unit tests.
29 LPTOP_LEVEL_EXCEPTION_FILTER g_previous_filter = NULL;
30
31 bool g_dump_stack_in_signal_handler = true;
32 bool g_initialized_symbols = false;
33 DWORD g_init_error = ERROR_SUCCESS;
34
35 // Prints the exception call stack.
36 // This is the unit tests exception filter.
StackDumpExceptionFilter(EXCEPTION_POINTERS * info)37 long WINAPI StackDumpExceptionFilter(EXCEPTION_POINTERS* info) { // NOLINT
38 if (g_dump_stack_in_signal_handler) {
39 debug::StackTrace(info).Print();
40 }
41 if (g_previous_filter) return g_previous_filter(info);
42 return EXCEPTION_CONTINUE_SEARCH;
43 }
44
GetExePath(wchar_t * path_out)45 void GetExePath(wchar_t* path_out) {
46 GetModuleFileName(NULL, path_out, MAX_PATH);
47 path_out[MAX_PATH - 1] = L'\0';
48 PathRemoveFileSpec(path_out);
49 }
50
InitializeSymbols()51 bool InitializeSymbols() {
52 if (g_initialized_symbols) return g_init_error == ERROR_SUCCESS;
53 g_initialized_symbols = true;
54 // Defer symbol load until they're needed, use undecorated names, and get line
55 // numbers.
56 SymSetOptions(SYMOPT_DEFERRED_LOADS | SYMOPT_UNDNAME | SYMOPT_LOAD_LINES);
57 if (!SymInitialize(GetCurrentProcess(), NULL, TRUE)) {
58 g_init_error = GetLastError();
59 // TODO(awong): Handle error: SymInitialize can fail with
60 // ERROR_INVALID_PARAMETER.
61 // When it fails, we should not call debugbreak since it kills the current
62 // process (prevents future tests from running or kills the browser
63 // process).
64 return false;
65 }
66
67 // When transferring the binaries e.g. between bots, path put
68 // into the executable will get off. To still retrieve symbols correctly,
69 // add the directory of the executable to symbol search path.
70 // All following errors are non-fatal.
71 const size_t kSymbolsArraySize = 1024;
72 std::unique_ptr<wchar_t[]> symbols_path(new wchar_t[kSymbolsArraySize]);
73
74 // Note: The below function takes buffer size as number of characters,
75 // not number of bytes!
76 if (!SymGetSearchPathW(GetCurrentProcess(), symbols_path.get(),
77 kSymbolsArraySize)) {
78 g_init_error = GetLastError();
79 return false;
80 }
81
82 wchar_t exe_path[MAX_PATH];
83 GetExePath(exe_path);
84 std::wstring new_path(std::wstring(symbols_path.get()) + L";" +
85 std::wstring(exe_path));
86 if (!SymSetSearchPathW(GetCurrentProcess(), new_path.c_str())) {
87 g_init_error = GetLastError();
88 return false;
89 }
90
91 g_init_error = ERROR_SUCCESS;
92 return true;
93 }
94
95 // For the given trace, attempts to resolve the symbols, and output a trace
96 // to the ostream os. The format for each line of the backtrace is:
97 //
98 // <tab>SymbolName[0xAddress+Offset] (FileName:LineNo)
99 //
100 // This function should only be called if Init() has been called. We do not
101 // LOG(FATAL) here because this code is called might be triggered by a
102 // LOG(FATAL) itself. Also, it should not be calling complex code that is
103 // extensible like PathService since that can in turn fire CHECKs.
OutputTraceToStream(const void * const * trace,size_t count,std::ostream * os)104 void OutputTraceToStream(const void* const* trace, size_t count,
105 std::ostream* os) {
106 for (size_t i = 0; (i < count) && os->good(); ++i) {
107 const int kMaxNameLength = 256;
108 DWORD_PTR frame = reinterpret_cast<DWORD_PTR>(trace[i]);
109
110 // Code adapted from MSDN example:
111 // http://msdn.microsoft.com/en-us/library/ms680578(VS.85).aspx
112 ULONG64 buffer[(sizeof(SYMBOL_INFO) + kMaxNameLength * sizeof(wchar_t) +
113 sizeof(ULONG64) - 1) /
114 sizeof(ULONG64)];
115 memset(buffer, 0, sizeof(buffer));
116
117 // Initialize symbol information retrieval structures.
118 DWORD64 sym_displacement = 0;
119 PSYMBOL_INFO symbol = reinterpret_cast<PSYMBOL_INFO>(&buffer[0]);
120 symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
121 symbol->MaxNameLen = kMaxNameLength - 1;
122 BOOL has_symbol =
123 SymFromAddr(GetCurrentProcess(), frame, &sym_displacement, symbol);
124
125 // Attempt to retrieve line number information.
126 DWORD line_displacement = 0;
127 IMAGEHLP_LINE64 line = {};
128 line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
129 BOOL has_line = SymGetLineFromAddr64(GetCurrentProcess(), frame,
130 &line_displacement, &line);
131
132 // Output the backtrace line.
133 (*os) << "\t";
134 if (has_symbol) {
135 (*os) << symbol->Name << " [0x" << trace[i] << "+" << sym_displacement
136 << "]";
137 } else {
138 // If there is no symbol information, add a spacer.
139 (*os) << "(No symbol) [0x" << trace[i] << "]";
140 }
141 if (has_line) {
142 (*os) << " (" << line.FileName << ":" << line.LineNumber << ")";
143 }
144 (*os) << "\n";
145 }
146 }
147
148 } // namespace
149
EnableInProcessStackDumping()150 bool EnableInProcessStackDumping() {
151 // Add stack dumping support on exception on windows. Similar to OS_POSIX
152 // signal() handling in process_util_posix.cc.
153 g_previous_filter = SetUnhandledExceptionFilter(&StackDumpExceptionFilter);
154 g_dump_stack_in_signal_handler = true;
155
156 // Need to initialize symbols early in the process or else this fails on
157 // swarming (since symbols are in different directory than in the exes) and
158 // also release x64.
159 return InitializeSymbols();
160 }
161
DisableSignalStackDump()162 void DisableSignalStackDump() {
163 g_dump_stack_in_signal_handler = false;
164 }
165
166 // Disable optimizations for the StackTrace::StackTrace function. It is
167 // important to disable at least frame pointer optimization ("y"), since
168 // that breaks CaptureStackBackTrace() and prevents StackTrace from working
169 // in Release builds (it may still be janky if other frames are using FPO,
170 // but at least it will make it further).
171 #if defined(COMPILER_MSVC)
172 #pragma optimize("", off)
173 #endif
174
StackTrace()175 StackTrace::StackTrace() {
176 // When walking our own stack, use CaptureStackBackTrace().
177 count_ = CaptureStackBackTrace(0, arraysize(trace_), trace_, NULL);
178 }
179
180 #if defined(COMPILER_MSVC)
181 #pragma optimize("", on)
182 #endif
183
StackTrace(EXCEPTION_POINTERS * exception_pointers)184 StackTrace::StackTrace(EXCEPTION_POINTERS* exception_pointers) {
185 InitTrace(exception_pointers->ContextRecord);
186 }
187
StackTrace(const CONTEXT * context)188 StackTrace::StackTrace(const CONTEXT* context) { InitTrace(context); }
189
InitTrace(const CONTEXT * context_record)190 void StackTrace::InitTrace(const CONTEXT* context_record) {
191 // StackWalk64 modifies the register context in place, so we have to copy it
192 // so that downstream exception handlers get the right context. The incoming
193 // context may have had more register state (YMM, etc) than we need to unwind
194 // the stack. Typically StackWalk64 only needs integer and control registers.
195 CONTEXT context_copy;
196 memcpy(&context_copy, context_record, sizeof(context_copy));
197 context_copy.ContextFlags = CONTEXT_INTEGER | CONTEXT_CONTROL;
198
199 // When walking an exception stack, we need to use StackWalk64().
200 count_ = 0;
201 // Initialize stack walking.
202 STACKFRAME64 stack_frame;
203 memset(&stack_frame, 0, sizeof(stack_frame));
204 #if defined(_WIN64)
205 int machine_type = IMAGE_FILE_MACHINE_AMD64;
206 stack_frame.AddrPC.Offset = context_record->Rip;
207 stack_frame.AddrFrame.Offset = context_record->Rbp;
208 stack_frame.AddrStack.Offset = context_record->Rsp;
209 #else
210 int machine_type = IMAGE_FILE_MACHINE_I386;
211 stack_frame.AddrPC.Offset = context_record->Eip;
212 stack_frame.AddrFrame.Offset = context_record->Ebp;
213 stack_frame.AddrStack.Offset = context_record->Esp;
214 #endif
215 stack_frame.AddrPC.Mode = AddrModeFlat;
216 stack_frame.AddrFrame.Mode = AddrModeFlat;
217 stack_frame.AddrStack.Mode = AddrModeFlat;
218 while (StackWalk64(machine_type, GetCurrentProcess(), GetCurrentThread(),
219 &stack_frame, &context_copy, NULL,
220 &SymFunctionTableAccess64, &SymGetModuleBase64, NULL) &&
221 count_ < arraysize(trace_)) {
222 trace_[count_++] = reinterpret_cast<void*>(stack_frame.AddrPC.Offset);
223 }
224
225 for (size_t i = count_; i < arraysize(trace_); ++i) trace_[i] = NULL;
226 }
227
Print() const228 void StackTrace::Print() const { OutputToStream(&std::cerr); }
229
OutputToStream(std::ostream * os) const230 void StackTrace::OutputToStream(std::ostream* os) const {
231 InitializeSymbols();
232 if (g_init_error != ERROR_SUCCESS) {
233 (*os) << "Error initializing symbols (" << g_init_error
234 << "). Dumping unresolved backtrace:\n";
235 for (size_t i = 0; (i < count_) && os->good(); ++i) {
236 (*os) << "\t" << trace_[i] << "\n";
237 }
238 } else {
239 (*os) << "\n";
240 (*os) << "==== C stack trace ===============================\n";
241 (*os) << "\n";
242 OutputTraceToStream(trace_, count_, os);
243 }
244 }
245
246 } // namespace debug
247 } // namespace base
248 } // namespace v8
249