lldb/source/Target/AssertFrameRecognizer.cpp

   1 #include "lldb/Target/AssertFrameRecognizer.h"
   2 #include "lldb/Core/Module.h"
   3 #include "lldb/Symbol/Function.h"
   4 #include "lldb/Symbol/SymbolContext.h"
   5 #include "lldb/Symbol/SymbolLocation.h"
   6 #include "lldb/Target/Process.h"
   7 #include "lldb/Target/StackFrameList.h"
   8 #include "lldb/Target/Target.h"
   9 #include "lldb/Target/Thread.h"
  10 #include "lldb/Utility/LLDBLog.h"
  11
  12 using namespace llvm;
  13 using namespace lldb;
  14 using namespace lldb_private;
  15
  16 namespace lldb_private {
  17 /// Fetches the abort frame location depending on the current platform.
  18 ///
  19 /// \param[in] os
  20 ///    The target's os type.
  21 /// \param[in,out] location
  22 ///    The struct that will contain the abort module spec and symbol names.
  23 /// \return
  24 ///    \b true, if the platform is supported
  25 ///    \b false, otherwise.
  26 bool GetAbortLocation(llvm::Triple::OSType os, SymbolLocation &location) {
  27   switch (os) {
  28   case llvm::Triple::Darwin:
  29   case llvm::Triple::MacOSX:
  30     location.module_spec = FileSpec("libsystem_kernel.dylib");
  31     location.symbols.push_back(ConstString("__pthread_kill"));
  32     break;
  33   case llvm::Triple::Linux:
  34     location.module_spec = FileSpec("libc.so.6");
  35     location.symbols.push_back(ConstString("raise"));
  36     location.symbols.push_back(ConstString("__GI_raise"));
  37     location.symbols.push_back(ConstString("gsignal"));
  38     location.symbols.push_back(ConstString("pthread_kill"));
  39     location.symbols_are_regex = true;
  40     break;
  41   default:
  42     Log *log = GetLog(LLDBLog::Unwind);
  43     LLDB_LOG(log, "AssertFrameRecognizer::GetAbortLocation Unsupported OS");
  44     return false;
  45   }
  46
  47   return true;
  48 }
  49
  50 /// Fetches the assert frame location depending on the current platform.
  51 ///
  52 /// \param[in] os
  53 ///    The target's os type.
  54 /// \param[in,out] location
  55 ///    The struct that will contain the assert module spec and symbol names.
  56 /// \return
  57 ///    \b true, if the platform is supported
  58 ///    \b false, otherwise.
  59 bool GetAssertLocation(llvm::Triple::OSType os, SymbolLocation &location) {
  60   switch (os) {
  61   case llvm::Triple::Darwin:
  62   case llvm::Triple::MacOSX:
  63     location.module_spec = FileSpec("libsystem_c.dylib");
  64     location.symbols.push_back(ConstString("__assert_rtn"));
  65     break;
  66   case llvm::Triple::Linux:
  67     location.module_spec = FileSpec("libc.so.6");
  68     location.symbols.push_back(ConstString("__assert_fail"));
  69     location.symbols.push_back(ConstString("__GI___assert_fail"));
  70     break;
  71   default:
  72     Log *log = GetLog(LLDBLog::Unwind);
  73     LLDB_LOG(log, "AssertFrameRecognizer::GetAssertLocation Unsupported OS");
  74     return false;
  75   }
  76
  77   return true;
  78 }
  79
  80 void RegisterAssertFrameRecognizer(Process *process) {
  81   Target &target = process->GetTarget();
  82   llvm::Triple::OSType os = target.GetArchitecture().GetTriple().getOS();
  83   SymbolLocation location;
  84
  85   if (!GetAbortLocation(os, location))
  86     return;
  87
  88   if (!location.symbols_are_regex) {
  89     target.GetFrameRecognizerManager().AddRecognizer(
  90         std::make_shared<AssertFrameRecognizer>(),
  91         location.module_spec.GetFilename(), location.symbols,
  92         Mangled::ePreferDemangled,
  93         /*first_instruction_only*/ false);
  94     return;
  95   }
  96   std::string module_re = "^";
  97   for (char c : location.module_spec.GetFilename().GetStringRef()) {
  98     if (c == '.')
  99       module_re += '\\';
 100     module_re += c;
 101   }
 102   module_re += '$';
 103   std::string symbol_re = "^(";
 104   for (auto it = location.symbols.cbegin(); it != location.symbols.cend();
 105        ++it) {
 106     if (it != location.symbols.cbegin())
 107       symbol_re += '|';
 108     symbol_re += it->GetStringRef();
 109   }
 110   // Strip the trailing @VER symbol version.
 111   symbol_re += ")(@.*)?$";
 112   target.GetFrameRecognizerManager().AddRecognizer(
 113       std::make_shared<AssertFrameRecognizer>(),
 114       std::make_shared<RegularExpression>(std::move(module_re)),
 115       std::make_shared<RegularExpression>(std::move(symbol_re)),
 116       Mangled::ePreferDemangled,
 117       /*first_instruction_only*/ false);
 118 }
 119
 120 } // namespace lldb_private
 121
 122 lldb::RecognizedStackFrameSP
 123 AssertFrameRecognizer::RecognizeFrame(lldb::StackFrameSP frame_sp) {
 124   ThreadSP thread_sp = frame_sp->GetThread();
 125   ProcessSP process_sp = thread_sp->GetProcess();
 126   Target &target = process_sp->GetTarget();
 127   llvm::Triple::OSType os = target.GetArchitecture().GetTriple().getOS();
 128   SymbolLocation location;
 129
 130   if (!GetAssertLocation(os, location))
 131     return RecognizedStackFrameSP();
 132
 133   const uint32_t frames_to_fetch = 6;
 134   const uint32_t last_frame_index = frames_to_fetch - 1;
 135   StackFrameSP prev_frame_sp = nullptr;
 136
 137   // Fetch most relevant frame
 138   for (uint32_t frame_index = 0; frame_index < frames_to_fetch; frame_index++) {
 139     prev_frame_sp = thread_sp->GetStackFrameAtIndex(frame_index);
 140
 141     if (!prev_frame_sp) {
 142       Log *log = GetLog(LLDBLog::Unwind);
 143       LLDB_LOG(log, "Abort Recognizer: Hit unwinding bound ({1} frames)!",
 144                frames_to_fetch);
 145       break;
 146     }
 147
 148     SymbolContext sym_ctx =
 149         prev_frame_sp->GetSymbolContext(eSymbolContextEverything);
 150
 151     if (!sym_ctx.module_sp ||
 152         !sym_ctx.module_sp->GetFileSpec().FileEquals(location.module_spec))
 153       continue;
 154
 155     ConstString func_name = sym_ctx.GetFunctionName();
 156
 157     if (llvm::is_contained(location.symbols, func_name)) {
 158       // We go a frame beyond the assert location because the most relevant
 159       // frame for the user is the one in which the assert function was called.
 160       // If the assert location is the last frame fetched, then it is set as
 161       // the most relevant frame.
 162
 163       StackFrameSP most_relevant_frame_sp = thread_sp->GetStackFrameAtIndex(
 164           std::min(frame_index + 1, last_frame_index));
 165
 166       // Pass assert location to AbortRecognizedStackFrame to set as most
 167       // relevant frame.
 168       return lldb::RecognizedStackFrameSP(
 169           new AssertRecognizedStackFrame(most_relevant_frame_sp));
 170     }
 171   }
 172
 173   return RecognizedStackFrameSP();
 174 }
 175
 176 AssertRecognizedStackFrame::AssertRecognizedStackFrame(
 177     StackFrameSP most_relevant_frame_sp)
 178     : m_most_relevant_frame(most_relevant_frame_sp) {
 179   m_stop_desc = "hit program assert";
 180 }
 181
 182 lldb::StackFrameSP AssertRecognizedStackFrame::GetMostRelevantFrame() {
 183   return m_most_relevant_frame;
 184 }