Import LLVM 10.0.0 release including clang, lld and lldb.

ok hackroom
tested by plenty

1 files changed, 192 insertions, 0 deletions

diff --git a/gnu/llvm/lldb/source/Target/StackFrameRecognizer.cpp b/gnu/llvm/lldb/source/Target/StackFrameRecognizer.cpp
new file mode 100644
index 00000000000..75a6cd21512
--- /dev/null
+++ b/gnu/llvm/lldb/source/Target/StackFrameRecognizer.cpp
@@ -0,0 +1,192 @@
+//===-- StackFrameRecognizer.cpp --------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <vector>
+#include "lldb/Core/Module.h"
+#include "lldb/Interpreter/ScriptInterpreter.h"
+#include "lldb/Symbol/Symbol.h"
+#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/StackFrameRecognizer.h"
+#include "lldb/Utility/RegularExpression.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+class ScriptedRecognizedStackFrame : public RecognizedStackFrame {
+public:
+  ScriptedRecognizedStackFrame(ValueObjectListSP args) {
+    m_arguments = args;
+  }
+};
+
+ScriptedStackFrameRecognizer::ScriptedStackFrameRecognizer(
+    ScriptInterpreter *interpreter, const char *pclass)
+    : m_interpreter(interpreter), m_python_class(pclass) {
+  m_python_object_sp =
+      m_interpreter->CreateFrameRecognizer(m_python_class.c_str());
+}
+
+RecognizedStackFrameSP
+ScriptedStackFrameRecognizer::RecognizeFrame(lldb::StackFrameSP frame) {
+  if (!m_python_object_sp || !m_interpreter)
+    return RecognizedStackFrameSP();
+
+  ValueObjectListSP args =
+      m_interpreter->GetRecognizedArguments(m_python_object_sp, frame);
+  auto args_synthesized = ValueObjectListSP(new ValueObjectList());
+  for (const auto &o : args->GetObjects()) {
+    args_synthesized->Append(ValueObjectRecognizerSynthesizedValue::Create(
+        *o, eValueTypeVariableArgument));
+  }
+
+  return RecognizedStackFrameSP(
+      new ScriptedRecognizedStackFrame(args_synthesized));
+}
+
+class StackFrameRecognizerManagerImpl {
+public:
+  void AddRecognizer(StackFrameRecognizerSP recognizer,
+                     ConstString module, ConstString symbol,
+                     bool first_instruction_only) {
+    m_recognizers.push_front({(uint32_t)m_recognizers.size(), false, recognizer, false, module, RegularExpressionSP(),
+                              symbol, RegularExpressionSP(),
+                              first_instruction_only});
+  }
+
+  void AddRecognizer(StackFrameRecognizerSP recognizer,
+                     RegularExpressionSP module, RegularExpressionSP symbol,
+                     bool first_instruction_only) {
+    m_recognizers.push_front({(uint32_t)m_recognizers.size(), false, recognizer, true, ConstString(), module,
+                              ConstString(), symbol, first_instruction_only});
+  }
+
+  void ForEach(
+      std::function<void(uint32_t recognized_id, std::string recognizer_name, std::string module,
+                         std::string symbol, bool regexp)> const &callback) {
+    for (auto entry : m_recognizers) {
+      if (entry.is_regexp) {
+        callback(entry.recognizer_id, entry.recognizer->GetName(), entry.module_regexp->GetText(),
+                 entry.symbol_regexp->GetText(), true);
+      } else {
+        callback(entry.recognizer_id, entry.recognizer->GetName(), entry.module.GetCString(),
+                 entry.symbol.GetCString(), false);
+      }
+    }
+  }
+
+  bool RemoveRecognizerWithID(uint32_t recognizer_id) {
+    if (recognizer_id >= m_recognizers.size()) return false;
+    if (m_recognizers[recognizer_id].deleted) return false;
+    m_recognizers[recognizer_id].deleted = true;
+    return true;
+  }
+
+  void RemoveAllRecognizers() {
+    m_recognizers.clear();
+  }
+
+  StackFrameRecognizerSP GetRecognizerForFrame(StackFrameSP frame) {
+    const SymbolContext &symctx =
+        frame->GetSymbolContext(eSymbolContextModule | eSymbolContextFunction);
+    ConstString function_name = symctx.GetFunctionName();
+    ModuleSP module_sp = symctx.module_sp;
+    if (!module_sp) return StackFrameRecognizerSP();
+    ConstString module_name = module_sp->GetFileSpec().GetFilename();
+    Symbol *symbol = symctx.symbol;
+    if (!symbol) return StackFrameRecognizerSP();
+    Address start_addr = symbol->GetAddress();
+    Address current_addr = frame->GetFrameCodeAddress();
+
+    for (auto entry : m_recognizers) {
+      if (entry.deleted) continue;
+      if (entry.module)
+        if (entry.module != module_name) continue;
+
+      if (entry.module_regexp)
+        if (!entry.module_regexp->Execute(module_name.GetStringRef())) continue;
+
+      if (entry.symbol)
+        if (entry.symbol != function_name) continue;
+
+      if (entry.symbol_regexp)
+        if (!entry.symbol_regexp->Execute(function_name.GetStringRef()))
+          continue;
+
+      if (entry.first_instruction_only)
+        if (start_addr != current_addr) continue;
+
+      return entry.recognizer;
+    }
+    return StackFrameRecognizerSP();
+  }
+
+  RecognizedStackFrameSP RecognizeFrame(StackFrameSP frame) {
+    auto recognizer = GetRecognizerForFrame(frame);
+    if (!recognizer) return RecognizedStackFrameSP();
+    return recognizer->RecognizeFrame(frame);
+  }
+
+ private:
+  struct RegisteredEntry {
+    uint32_t recognizer_id;
+    bool deleted;
+    StackFrameRecognizerSP recognizer;
+    bool is_regexp;
+    ConstString module;
+    RegularExpressionSP module_regexp;
+    ConstString symbol;
+    RegularExpressionSP symbol_regexp;
+    bool first_instruction_only;
+  };
+
+  std::deque<RegisteredEntry> m_recognizers;
+};
+
+StackFrameRecognizerManagerImpl &GetStackFrameRecognizerManagerImpl() {
+  static StackFrameRecognizerManagerImpl instance =
+      StackFrameRecognizerManagerImpl();
+  return instance;
+}
+
+void StackFrameRecognizerManager::AddRecognizer(
+    StackFrameRecognizerSP recognizer, ConstString module,
+    ConstString symbol, bool first_instruction_only) {
+  GetStackFrameRecognizerManagerImpl().AddRecognizer(recognizer, module, symbol,
+                                                     first_instruction_only);
+}
+
+void StackFrameRecognizerManager::AddRecognizer(
+    StackFrameRecognizerSP recognizer, RegularExpressionSP module,
+    RegularExpressionSP symbol, bool first_instruction_only) {
+  GetStackFrameRecognizerManagerImpl().AddRecognizer(recognizer, module, symbol,
+                                                     first_instruction_only);
+}
+
+void StackFrameRecognizerManager::ForEach(
+    std::function<void(uint32_t recognized_id, std::string recognizer_name, std::string module,
+                       std::string symbol, bool regexp)> const &callback) {
+  GetStackFrameRecognizerManagerImpl().ForEach(callback);
+}
+
+void StackFrameRecognizerManager::RemoveAllRecognizers() {
+  GetStackFrameRecognizerManagerImpl().RemoveAllRecognizers();
+}
+
+bool StackFrameRecognizerManager::RemoveRecognizerWithID(uint32_t recognizer_id) {
+  return GetStackFrameRecognizerManagerImpl().RemoveRecognizerWithID(recognizer_id);
+}
+
+RecognizedStackFrameSP StackFrameRecognizerManager::RecognizeFrame(
+    StackFrameSP frame) {
+  return GetStackFrameRecognizerManagerImpl().RecognizeFrame(frame);
+}
+
+StackFrameRecognizerSP StackFrameRecognizerManager::GetRecognizerForFrame(
+    lldb::StackFrameSP frame) {
+  return GetStackFrameRecognizerManagerImpl().GetRecognizerForFrame(frame);
+}