2 * Copyright 2012 Facebook, Inc.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 #include "folly/experimental/exception_tracer/ExceptionTracer.h"
22 #include <glog/logging.h>
24 #include "folly/experimental/exception_tracer/ExceptionAbi.h"
25 #include "folly/experimental/exception_tracer/StackTrace.h"
26 #include "folly/experimental/symbolizer/Symbolizer.h"
27 #include "folly/String.h"
32 const StackTraceStack* getExceptionStackTraceStack(void) __attribute__((weak));
33 typedef const StackTraceStack* (*GetExceptionStackTraceStackType)(void);
34 GetExceptionStackTraceStackType getExceptionStackTraceStackFn;
39 using namespace ::facebook::symbolizer;
40 using namespace __cxxabiv1;
42 namespace exception_tracer {
44 std::ostream& operator<<(std::ostream& out, const ExceptionInfo& info) {
45 out << "Exception type: ";
47 out << folly::demangle(*info.type) << "\n";
49 out << "(unknown type)\n";
51 Symbolizer symbolizer;
52 folly::StringPiece symbolName;
53 Dwarf::LocationInfo location;
54 for (auto ip : info.frames) {
55 // Symbolize the previous address because the IP might be in the
56 // next function, per glog/src/signalhandler.cc
57 symbolizer.symbolize(ip-1, symbolName, location);
58 Symbolizer::write(out, ip, symbolName, location);
66 * Is this a standard C++ ABI exception?
68 * Dependent exceptions (thrown via std::rethrow_exception) aren't --
69 * exc doesn't actually point to a __cxa_exception structure, but
70 * the offset of unwindHeader is correct, so exc->unwindHeader actually
71 * returns a _Unwind_Exception object. Yeah, it's ugly like that.
73 bool isAbiCppException(const __cxa_exception* exc) {
74 // The least significant four bytes must be "C++\0"
75 static const uint64_t cppClass =
76 ((uint64_t)'C' << 24) |
77 ((uint64_t)'+' << 16) |
79 return (exc->unwindHeader.exception_class & 0xffffffff) == cppClass;
84 std::vector<ExceptionInfo> getCurrentExceptions() {
87 // See if linked in with us (getExceptionStackTraceStack is weak)
88 getExceptionStackTraceStackFn = getExceptionStackTraceStack;
90 if (!getExceptionStackTraceStackFn) {
91 // Nope, see if it's in a shared library
92 getExceptionStackTraceStackFn =
93 (GetExceptionStackTraceStackType)dlsym(
94 RTLD_NEXT, "getExceptionStackTraceStack");
100 std::vector<ExceptionInfo> exceptions;
101 auto currentException = __cxa_get_globals()->caughtExceptions;
102 if (!currentException) {
106 bool hasTraceStack = false;
107 const StackTraceStack* traceStack = nullptr;
108 if (!getExceptionStackTraceStackFn) {
109 static bool logged = false;
112 << "Exception tracer library not linked, stack traces not available";
115 } else if ((traceStack = getExceptionStackTraceStackFn()) == nullptr) {
116 static bool logged = false;
119 << "Exception stack trace invalid, stack traces not available";
123 hasTraceStack = true;
126 while (currentException) {
128 // Dependent exceptions (thrown via std::rethrow_exception) aren't
129 // standard ABI __cxa_exception objects, and are correctly labeled as
130 // such in the exception_class field. We could try to extract the
131 // primary exception type in horribly hacky ways, but, for now, NULL.
133 isAbiCppException(currentException) ?
134 currentException->exceptionType :
137 CHECK(traceStack) << "Invalid trace stack!";
139 traceStack->trace.frameIPs,
140 traceStack->trace.frameIPs + traceStack->trace.frameCount);
141 traceStack = traceStack->next;
143 currentException = currentException->nextException;
144 exceptions.push_back(std::move(info));
147 CHECK(!traceStack) << "Invalid trace stack!";
154 std::terminate_handler origTerminate = abort;
155 std::unexpected_handler origUnexpected = abort;
157 void dumpExceptionStack(const char* prefix) {
158 auto exceptions = getCurrentExceptions();
159 if (exceptions.empty()) {
162 LOG(ERROR) << prefix << ", exception stack follows\n";
163 for (auto& exc : exceptions) {
164 LOG(ERROR) << exc << "\n";
168 void terminateHandler() {
169 dumpExceptionStack("terminate() called");
173 void unexpectedHandler() {
174 dumpExceptionStack("Unexpected exception");
180 void installHandlers() {
183 origTerminate = std::set_terminate(terminateHandler);
184 origUnexpected = std::set_unexpected(unexpectedHandler);
190 } // namespace exception_tracer