1 //===- Signals.cpp - Signal Handling support --------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file defines some helpful functions for dealing with the possibility of 10 // Unix signals occurring while your program is running. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/Support/Signals.h" 15 #include "llvm/ADT/STLExtras.h" 16 #include "llvm/ADT/StringRef.h" 17 #include "llvm/Config/llvm-config.h" 18 #include "llvm/Support/CommandLine.h" 19 #include "llvm/Support/ErrorOr.h" 20 #include "llvm/Support/FileSystem.h" 21 #include "llvm/Support/FileUtilities.h" 22 #include "llvm/Support/Format.h" 23 #include "llvm/Support/FormatAdapters.h" 24 #include "llvm/Support/FormatVariadic.h" 25 #include "llvm/Support/ManagedStatic.h" 26 #include "llvm/Support/MemoryBuffer.h" 27 #include "llvm/Support/Mutex.h" 28 #include "llvm/Support/Program.h" 29 #include "llvm/Support/StringSaver.h" 30 #include "llvm/Support/raw_ostream.h" 31 #include <vector> 32 33 //===----------------------------------------------------------------------===// 34 //=== WARNING: Implementation here must contain only TRULY operating system 35 //=== independent code. 36 //===----------------------------------------------------------------------===// 37 38 using namespace llvm; 39 40 // Use explicit storage to avoid accessing cl::opt in a signal handler. 41 static bool DisableSymbolicationFlag = false; 42 static cl::opt<bool, true> 43 DisableSymbolication("disable-symbolication", 44 cl::desc("Disable symbolizing crash backtraces."), 45 cl::location(DisableSymbolicationFlag), cl::Hidden); 46 47 // Callbacks to run in signal handler must be lock-free because a signal handler 48 // could be running as we add new callbacks. We don't add unbounded numbers of 49 // callbacks, an array is therefore sufficient. 50 struct CallbackAndCookie { 51 sys::SignalHandlerCallback Callback; 52 void *Cookie; 53 enum class Status { Empty, Initializing, Initialized, Executing }; 54 std::atomic<Status> Flag; 55 }; 56 static constexpr size_t MaxSignalHandlerCallbacks = 8; 57 static CallbackAndCookie CallBacksToRun[MaxSignalHandlerCallbacks]; 58 59 // Signal-safe. 60 void sys::RunSignalHandlers() { 61 for (size_t I = 0; I < MaxSignalHandlerCallbacks; ++I) { 62 auto &RunMe = CallBacksToRun[I]; 63 auto Expected = CallbackAndCookie::Status::Initialized; 64 auto Desired = CallbackAndCookie::Status::Executing; 65 if (!RunMe.Flag.compare_exchange_strong(Expected, Desired)) 66 continue; 67 (*RunMe.Callback)(RunMe.Cookie); 68 RunMe.Callback = nullptr; 69 RunMe.Cookie = nullptr; 70 RunMe.Flag.store(CallbackAndCookie::Status::Empty); 71 } 72 } 73 74 // Signal-safe. 75 static void insertSignalHandler(sys::SignalHandlerCallback FnPtr, 76 void *Cookie) { 77 for (size_t I = 0; I < MaxSignalHandlerCallbacks; ++I) { 78 auto &SetMe = CallBacksToRun[I]; 79 auto Expected = CallbackAndCookie::Status::Empty; 80 auto Desired = CallbackAndCookie::Status::Initializing; 81 if (!SetMe.Flag.compare_exchange_strong(Expected, Desired)) 82 continue; 83 SetMe.Callback = FnPtr; 84 SetMe.Cookie = Cookie; 85 SetMe.Flag.store(CallbackAndCookie::Status::Initialized); 86 return; 87 } 88 report_fatal_error("too many signal callbacks already registered"); 89 } 90 91 static bool findModulesAndOffsets(void **StackTrace, int Depth, 92 const char **Modules, intptr_t *Offsets, 93 const char *MainExecutableName, 94 StringSaver &StrPool); 95 96 /// Format a pointer value as hexadecimal. Zero pad it out so its always the 97 /// same width. 98 static FormattedNumber format_ptr(void *PC) { 99 // Each byte is two hex digits plus 2 for the 0x prefix. 100 unsigned PtrWidth = 2 + 2 * sizeof(void *); 101 return format_hex((uint64_t)PC, PtrWidth); 102 } 103 104 /// Helper that launches llvm-symbolizer and symbolizes a backtrace. 105 LLVM_ATTRIBUTE_USED 106 static bool printSymbolizedStackTrace(StringRef Argv0, void **StackTrace, 107 int Depth, llvm::raw_ostream &OS) { 108 if (DisableSymbolicationFlag) 109 return false; 110 111 // Don't recursively invoke the llvm-symbolizer binary. 112 if (Argv0.find("llvm-symbolizer") != std::string::npos) 113 return false; 114 115 // FIXME: Subtract necessary number from StackTrace entries to turn return addresses 116 // into actual instruction addresses. 117 // Use llvm-symbolizer tool to symbolize the stack traces. First look for it 118 // alongside our binary, then in $PATH. 119 ErrorOr<std::string> LLVMSymbolizerPathOrErr = std::error_code(); 120 if (!Argv0.empty()) { 121 StringRef Parent = llvm::sys::path::parent_path(Argv0); 122 if (!Parent.empty()) 123 LLVMSymbolizerPathOrErr = sys::findProgramByName("llvm-symbolizer", Parent); 124 } 125 if (!LLVMSymbolizerPathOrErr) 126 LLVMSymbolizerPathOrErr = sys::findProgramByName("llvm-symbolizer"); 127 if (!LLVMSymbolizerPathOrErr) 128 return false; 129 const std::string &LLVMSymbolizerPath = *LLVMSymbolizerPathOrErr; 130 131 // If we don't know argv0 or the address of main() at this point, try 132 // to guess it anyway (it's possible on some platforms). 133 std::string MainExecutableName = 134 sys::fs::exists(Argv0) ? (std::string)std::string(Argv0) 135 : sys::fs::getMainExecutable(nullptr, nullptr); 136 BumpPtrAllocator Allocator; 137 StringSaver StrPool(Allocator); 138 std::vector<const char *> Modules(Depth, nullptr); 139 std::vector<intptr_t> Offsets(Depth, 0); 140 if (!findModulesAndOffsets(StackTrace, Depth, Modules.data(), Offsets.data(), 141 MainExecutableName.c_str(), StrPool)) 142 return false; 143 int InputFD; 144 SmallString<32> InputFile, OutputFile; 145 sys::fs::createTemporaryFile("symbolizer-input", "", InputFD, InputFile); 146 sys::fs::createTemporaryFile("symbolizer-output", "", OutputFile); 147 FileRemover InputRemover(InputFile.c_str()); 148 FileRemover OutputRemover(OutputFile.c_str()); 149 150 { 151 raw_fd_ostream Input(InputFD, true); 152 for (int i = 0; i < Depth; i++) { 153 if (Modules[i]) 154 Input << Modules[i] << " " << (void*)Offsets[i] << "\n"; 155 } 156 } 157 158 Optional<StringRef> Redirects[] = {StringRef(InputFile), 159 StringRef(OutputFile), StringRef("")}; 160 StringRef Args[] = {"llvm-symbolizer", "--functions=linkage", "--inlining", 161 #ifdef _WIN32 162 // Pass --relative-address on Windows so that we don't 163 // have to add ImageBase from PE file. 164 // FIXME: Make this the default for llvm-symbolizer. 165 "--relative-address", 166 #endif 167 "--demangle"}; 168 int RunResult = 169 sys::ExecuteAndWait(LLVMSymbolizerPath, Args, None, Redirects); 170 if (RunResult != 0) 171 return false; 172 173 // This report format is based on the sanitizer stack trace printer. See 174 // sanitizer_stacktrace_printer.cc in compiler-rt. 175 auto OutputBuf = MemoryBuffer::getFile(OutputFile.c_str()); 176 if (!OutputBuf) 177 return false; 178 StringRef Output = OutputBuf.get()->getBuffer(); 179 SmallVector<StringRef, 32> Lines; 180 Output.split(Lines, "\n"); 181 auto CurLine = Lines.begin(); 182 int frame_no = 0; 183 for (int i = 0; i < Depth; i++) { 184 auto PrintLineHeader = [&]() { 185 OS << right_justify(formatv("#{0}", frame_no++).str(), 186 std::log10(Depth) + 2) 187 << ' ' << format_ptr(StackTrace[i]) << ' '; 188 }; 189 if (!Modules[i]) { 190 PrintLineHeader(); 191 OS << '\n'; 192 continue; 193 } 194 // Read pairs of lines (function name and file/line info) until we 195 // encounter empty line. 196 for (;;) { 197 if (CurLine == Lines.end()) 198 return false; 199 StringRef FunctionName = *CurLine++; 200 if (FunctionName.empty()) 201 break; 202 PrintLineHeader(); 203 if (!FunctionName.startswith("??")) 204 OS << FunctionName << ' '; 205 if (CurLine == Lines.end()) 206 return false; 207 StringRef FileLineInfo = *CurLine++; 208 if (!FileLineInfo.startswith("??")) 209 OS << FileLineInfo; 210 else 211 OS << "(" << Modules[i] << '+' << format_hex(Offsets[i], 0) << ")"; 212 OS << "\n"; 213 } 214 } 215 return true; 216 } 217 218 // Include the platform-specific parts of this class. 219 #ifdef LLVM_ON_UNIX 220 #include "Unix/Signals.inc" 221 #endif 222 #ifdef _WIN32 223 #include "Windows/Signals.inc" 224 #endif 225