LLVM  13.0.0git
Signals.cpp
Go to the documentation of this file.
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 
16 #include "DebugOptions.h"
17 
18 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/Config/llvm-config.h"
22 #include "llvm/Support/ErrorOr.h"
25 #include "llvm/Support/Format.h"
30 #include "llvm/Support/Mutex.h"
31 #include "llvm/Support/Program.h"
34 #include <vector>
35 
36 //===----------------------------------------------------------------------===//
37 //=== WARNING: Implementation here must contain only TRULY operating system
38 //=== independent code.
39 //===----------------------------------------------------------------------===//
40 
41 using namespace llvm;
42 
43 // Use explicit storage to avoid accessing cl::opt in a signal handler.
44 static bool DisableSymbolicationFlag = false;
46 namespace {
47 struct CreateDisableSymbolication {
48  static void *call() {
49  return new cl::opt<bool, true>(
50  "disable-symbolication",
51  cl::desc("Disable symbolizing crash backtraces."),
53  }
54 };
55 struct CreateCrashDiagnosticsDir {
56  static void *call() {
57  return new cl::opt<std::string, true>(
58  "crash-diagnostics-dir", cl::value_desc("directory"),
59  cl::desc("Directory for crash diagnostic files."),
61  }
62 };
63 } // namespace
65  static ManagedStatic<cl::opt<bool, true>, CreateDisableSymbolication>
66  DisableSymbolication;
67  static ManagedStatic<cl::opt<std::string, true>, CreateCrashDiagnosticsDir>
68  CrashDiagnosticsDir;
69  *DisableSymbolication;
70  *CrashDiagnosticsDir;
71 }
72 
73 constexpr char DisableSymbolizationEnv[] = "LLVM_DISABLE_SYMBOLIZATION";
74 constexpr char LLVMSymbolizerPathEnv[] = "LLVM_SYMBOLIZER_PATH";
75 
76 // Callbacks to run in signal handler must be lock-free because a signal handler
77 // could be running as we add new callbacks. We don't add unbounded numbers of
78 // callbacks, an array is therefore sufficient.
81  void *Cookie;
82  enum class Status { Empty, Initializing, Initialized, Executing };
83  std::atomic<Status> Flag;
84 };
85 static constexpr size_t MaxSignalHandlerCallbacks = 8;
87 
88 // Signal-safe.
90  for (size_t I = 0; I < MaxSignalHandlerCallbacks; ++I) {
91  auto &RunMe = CallBacksToRun[I];
94  if (!RunMe.Flag.compare_exchange_strong(Expected, Desired))
95  continue;
96  (*RunMe.Callback)(RunMe.Cookie);
97  RunMe.Callback = nullptr;
98  RunMe.Cookie = nullptr;
99  RunMe.Flag.store(CallbackAndCookie::Status::Empty);
100  }
101 }
102 
103 // Signal-safe.
105  void *Cookie) {
106  for (size_t I = 0; I < MaxSignalHandlerCallbacks; ++I) {
107  auto &SetMe = CallBacksToRun[I];
110  if (!SetMe.Flag.compare_exchange_strong(Expected, Desired))
111  continue;
112  SetMe.Callback = FnPtr;
113  SetMe.Cookie = Cookie;
114  SetMe.Flag.store(CallbackAndCookie::Status::Initialized);
115  return;
116  }
117  report_fatal_error("too many signal callbacks already registered");
118 }
119 
120 static bool findModulesAndOffsets(void **StackTrace, int Depth,
121  const char **Modules, intptr_t *Offsets,
122  const char *MainExecutableName,
123  StringSaver &StrPool);
124 
125 /// Format a pointer value as hexadecimal. Zero pad it out so its always the
126 /// same width.
127 static FormattedNumber format_ptr(void *PC) {
128  // Each byte is two hex digits plus 2 for the 0x prefix.
129  unsigned PtrWidth = 2 + 2 * sizeof(void *);
130  return format_hex((uint64_t)PC, PtrWidth);
131 }
132 
133 /// Helper that launches llvm-symbolizer and symbolizes a backtrace.
135 static bool printSymbolizedStackTrace(StringRef Argv0, void **StackTrace,
136  int Depth, llvm::raw_ostream &OS) {
138  return false;
139 
140  // Don't recursively invoke the llvm-symbolizer binary.
141  if (Argv0.find("llvm-symbolizer") != std::string::npos)
142  return false;
143 
144  // FIXME: Subtract necessary number from StackTrace entries to turn return addresses
145  // into actual instruction addresses.
146  // Use llvm-symbolizer tool to symbolize the stack traces. First look for it
147  // alongside our binary, then in $PATH.
148  ErrorOr<std::string> LLVMSymbolizerPathOrErr = std::error_code();
149  if (const char *Path = getenv(LLVMSymbolizerPathEnv)) {
150  LLVMSymbolizerPathOrErr = sys::findProgramByName(Path);
151  } else if (!Argv0.empty()) {
152  StringRef Parent = llvm::sys::path::parent_path(Argv0);
153  if (!Parent.empty())
154  LLVMSymbolizerPathOrErr = sys::findProgramByName("llvm-symbolizer", Parent);
155  }
156  if (!LLVMSymbolizerPathOrErr)
157  LLVMSymbolizerPathOrErr = sys::findProgramByName("llvm-symbolizer");
158  if (!LLVMSymbolizerPathOrErr)
159  return false;
160  const std::string &LLVMSymbolizerPath = *LLVMSymbolizerPathOrErr;
161 
162  // If we don't know argv0 or the address of main() at this point, try
163  // to guess it anyway (it's possible on some platforms).
164  std::string MainExecutableName =
165  sys::fs::exists(Argv0) ? (std::string)std::string(Argv0)
166  : sys::fs::getMainExecutable(nullptr, nullptr);
168  StringSaver StrPool(Allocator);
169  std::vector<const char *> Modules(Depth, nullptr);
170  std::vector<intptr_t> Offsets(Depth, 0);
171  if (!findModulesAndOffsets(StackTrace, Depth, Modules.data(), Offsets.data(),
172  MainExecutableName.c_str(), StrPool))
173  return false;
174  int InputFD;
175  SmallString<32> InputFile, OutputFile;
176  sys::fs::createTemporaryFile("symbolizer-input", "", InputFD, InputFile);
177  sys::fs::createTemporaryFile("symbolizer-output", "", OutputFile);
178  FileRemover InputRemover(InputFile.c_str());
179  FileRemover OutputRemover(OutputFile.c_str());
180 
181  {
182  raw_fd_ostream Input(InputFD, true);
183  for (int i = 0; i < Depth; i++) {
184  if (Modules[i])
185  Input << Modules[i] << " " << (void*)Offsets[i] << "\n";
186  }
187  }
188 
189  Optional<StringRef> Redirects[] = {InputFile.str(), OutputFile.str(),
190  StringRef("")};
191  StringRef Args[] = {"llvm-symbolizer", "--functions=linkage", "--inlining",
192 #ifdef _WIN32
193  // Pass --relative-address on Windows so that we don't
194  // have to add ImageBase from PE file.
195  // FIXME: Make this the default for llvm-symbolizer.
196  "--relative-address",
197 #endif
198  "--demangle"};
199  int RunResult =
200  sys::ExecuteAndWait(LLVMSymbolizerPath, Args, None, Redirects);
201  if (RunResult != 0)
202  return false;
203 
204  // This report format is based on the sanitizer stack trace printer. See
205  // sanitizer_stacktrace_printer.cc in compiler-rt.
206  auto OutputBuf = MemoryBuffer::getFile(OutputFile.c_str());
207  if (!OutputBuf)
208  return false;
209  StringRef Output = OutputBuf.get()->getBuffer();
211  Output.split(Lines, "\n");
212  auto CurLine = Lines.begin();
213  int frame_no = 0;
214  for (int i = 0; i < Depth; i++) {
215  auto PrintLineHeader = [&]() {
216  OS << right_justify(formatv("#{0}", frame_no++).str(),
217  std::log10(Depth) + 2)
218  << ' ' << format_ptr(StackTrace[i]) << ' ';
219  };
220  if (!Modules[i]) {
221  PrintLineHeader();
222  OS << '\n';
223  continue;
224  }
225  // Read pairs of lines (function name and file/line info) until we
226  // encounter empty line.
227  for (;;) {
228  if (CurLine == Lines.end())
229  return false;
230  StringRef FunctionName = *CurLine++;
231  if (FunctionName.empty())
232  break;
233  PrintLineHeader();
234  if (!FunctionName.startswith("??"))
235  OS << FunctionName << ' ';
236  if (CurLine == Lines.end())
237  return false;
238  StringRef FileLineInfo = *CurLine++;
239  if (!FileLineInfo.startswith("??"))
240  OS << FileLineInfo;
241  else
242  OS << "(" << Modules[i] << '+' << format_hex(Offsets[i], 0) << ")";
243  OS << "\n";
244  }
245  }
246  return true;
247 }
248 
249 // Include the platform-specific parts of this class.
250 #ifdef LLVM_ON_UNIX
251 #include "Unix/Signals.inc"
252 #endif
253 #ifdef _WIN32
254 #include "Windows/Signals.inc"
255 #endif
i
i
Definition: README.txt:29
llvm::sys::findProgramByName
ErrorOr< std::string > findProgramByName(StringRef Name, ArrayRef< StringRef > Paths={})
Find the first executable file Name in Paths.
MemoryBuffer.h
LLVM_ATTRIBUTE_USED
#define LLVM_ATTRIBUTE_USED
Definition: Compiler.h:144
llvm::StringRef::startswith
LLVM_NODISCARD bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:286
Signals.h
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::StringRef::empty
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
FileSystem.h
intptr_t
llvm::cl::location
LocationClass< Ty > location(Ty &L)
Definition: CommandLine.h:459
llvm::FileRemover
FileRemover - This class is a simple object meant to be stack allocated.
Definition: FileUtilities.h:42
StringRef.h
CallBacksToRun
static CallbackAndCookie CallBacksToRun[MaxSignalHandlerCallbacks]
Definition: Signals.cpp:86
llvm::StringRef::find
LLVM_NODISCARD size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:315
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
llvm::FormattedNumber
This is a helper class used for format_hex() and format_decimal().
Definition: Format.h:164
ManagedStatic.h
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:143
llvm::Depth
@ Depth
Definition: SIMachineScheduler.h:34
llvm::sys::RunSignalHandlers
void RunSignalHandlers()
Definition: Signals.cpp:89
DebugOptions.h
format_ptr
static FormattedNumber format_ptr(void *PC)
Format a pointer value as hexadecimal.
Definition: Signals.cpp:127
llvm::Optional
Definition: APInt.h:33
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
STLExtras.h
Format.h
LLVMSymbolizerPathEnv
constexpr char LLVMSymbolizerPathEnv[]
Definition: Signals.cpp:74
CallbackAndCookie::Status::Initialized
@ Initialized
llvm::sys::SignalHandlerCallback
void(*)(void *) SignalHandlerCallback
Definition: Signals.h:60
CommandLine.h
llvm::formatv
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
Definition: FormatVariadic.h:250
llvm::initSignalsOptions
void initSignalsOptions()
Definition: Signals.cpp:64
llvm::MemoryBuffer::getFile
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, bool IsVolatile=false)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...
Definition: MemoryBuffer.cpp:246
CrashDiagnosticsDirectory
static ManagedStatic< std::string > CrashDiagnosticsDirectory
Definition: Signals.cpp:45
llvm::StringRef::split
LLVM_NODISCARD std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Definition: StringRef.h:749
CallbackAndCookie
Definition: Signals.cpp:79
llvm::ManagedStatic
ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on...
Definition: ManagedStatic.h:83
CallbackAndCookie::Flag
std::atomic< Status > Flag
Definition: Signals.cpp:83
insertSignalHandler
static void insertSignalHandler(sys::SignalHandlerCallback FnPtr, void *Cookie)
Definition: Signals.cpp:104
llvm::report_fatal_error
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:140
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
CallbackAndCookie::Callback
sys::SignalHandlerCallback Callback
Definition: Signals.cpp:80
FormatVariadic.h
llvm::None
const NoneType None
Definition: None.h:23
llvm::SmallString< 32 >
StringSaver.h
llvm::cl::opt
Definition: CommandLine.h:1422
llvm::SmallString::c_str
const char * c_str()
Definition: SmallString.h:262
printSymbolizedStackTrace
static LLVM_ATTRIBUTE_USED bool printSymbolizedStackTrace(StringRef Argv0, void **StackTrace, int Depth, llvm::raw_ostream &OS)
Helper that launches llvm-symbolizer and symbolizes a backtrace.
Definition: Signals.cpp:135
llvm::sys::fs::exists
bool exists(const basic_file_status &status)
Does file exist?
Definition: Path.cpp:1073
llvm::BumpPtrAllocatorImpl
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:67
ErrorOr.h
I
#define I(x, y, z)
Definition: MD5.cpp:59
call
S is passed via registers r2 But gcc stores them to the and then reload them to and r3 before issuing the call(r0 contains the address of the format string)
Definition: README.txt:190
DisableSymbolicationFlag
static bool DisableSymbolicationFlag
Definition: Signals.cpp:44
llvm::sys::path::parent_path
StringRef parent_path(StringRef path, Style style=Style::native)
Get parent path.
Definition: Path.cpp:465
Status
Definition: SIModeRegister.cpp:28
llvm::StringSaver
Saves strings in the provided stable storage and returns a StringRef with a stable character pointer.
Definition: StringSaver.h:21
llvm::sys::fs::createTemporaryFile
std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix, int &ResultFD, SmallVectorImpl< char > &ResultPath, OpenFlags Flags=OF_None)
Create a file in the system temporary directory.
Definition: Path.cpp:858
FileUtilities.h
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
Mutex.h
llvm::raw_fd_ostream
A raw_ostream that writes to a file descriptor.
Definition: raw_ostream.h:441
CallbackAndCookie::Status::Empty
@ Empty
llvm::right_justify
FormattedString right_justify(StringRef Str, unsigned Width)
right_justify - add spaces before string so total output is Width characters.
Definition: Format.h:152
Signals.inc
llvm::sys::fs::getMainExecutable
std::string getMainExecutable(const char *argv0, void *MainExecAddr)
Return the path to the main executable, given the value of argv[0] from program startup and the addre...
llvm::cl::value_desc
Definition: CommandLine.h:424
llvm::SmallString::str
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:259
Signals.inc
FormatAdapters.h
DisableSymbolizationEnv
constexpr char DisableSymbolizationEnv[]
Definition: Signals.cpp:73
CallbackAndCookie::Status::Executing
@ Executing
CallbackAndCookie::Status::Initializing
@ Initializing
Allocator
Basic Register Allocator
Definition: RegAllocBasic.cpp:146
Program.h
llvm::sys::ExecuteAndWait
int ExecuteAndWait(StringRef Program, ArrayRef< StringRef > Args, Optional< ArrayRef< StringRef >> Env=None, ArrayRef< Optional< StringRef >> Redirects={}, unsigned SecondsToWait=0, unsigned MemoryLimit=0, std::string *ErrMsg=nullptr, bool *ExecutionFailed=nullptr, Optional< ProcessStatistics > *ProcStat=nullptr, BitVector *AffinityMask=nullptr)
This function executes the program using the arguments provided.
Definition: Program.cpp:32
llvm::ErrorOr
Represents either an error or a value T.
Definition: ErrorOr.h:56
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:389
llvm::cl::desc
Definition: CommandLine.h:414
findModulesAndOffsets
static bool findModulesAndOffsets(void **StackTrace, int Depth, const char **Modules, intptr_t *Offsets, const char *MainExecutableName, StringSaver &StrPool)
CallbackAndCookie::Cookie
void * Cookie
Definition: Signals.cpp:81
MaxSignalHandlerCallbacks
static constexpr size_t MaxSignalHandlerCallbacks
Definition: Signals.cpp:85
raw_ostream.h
llvm::SI::KernelInputOffsets::Offsets
Offsets
Offsets in bytes from the start of the input buffer.
Definition: SIInstrInfo.h:1247
llvm::format_hex
FormattedNumber format_hex(uint64_t N, unsigned Width, bool Upper=false)
format_hex - Output N as a fixed width hexadecimal.
Definition: Format.h:186