Imported Upstream version 6.10.0.49

Former-commit-id: 1d6753294b2993e1fbf92de9366bb9544db4189b

external/llvm-project/lldb/source/Plugins/Language/Java/CMakeLists.txt

@@ -0,0 +1,12 @@
+add_lldb_library(lldbPluginJavaLanguage PLUGIN
+  JavaFormatterFunctions.cpp
+  JavaLanguage.cpp
+
+  LINK_LIBS
+    lldbCore
+    lldbDataFormatters
+    lldbSymbol
+    lldbTarget
+  LINK_COMPONENTS
+    Support
+)

external/llvm-project/lldb/source/Plugins/Language/Java/JavaFormatterFunctions.cpp

@@ -0,0 +1,167 @@
+//===-- JavaFormatterFunctions.cpp-------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "JavaFormatterFunctions.h"
+#include "lldb/DataFormatters/FormattersHelpers.h"
+#include "lldb/DataFormatters/StringPrinter.h"
+#include "lldb/Symbol/JavaASTContext.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::formatters;
+
+namespace {
+
+class JavaArraySyntheticFrontEnd : public SyntheticChildrenFrontEnd {
+public:
+  JavaArraySyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
+      : SyntheticChildrenFrontEnd(*valobj_sp) {
+    if (valobj_sp)
+      Update();
+  }
+
+  size_t CalculateNumChildren() override {
+    ValueObjectSP valobj = GetDereferencedValueObject();
+    if (!valobj)
+      return 0;
+
+    CompilerType type = valobj->GetCompilerType();
+    uint32_t size = JavaASTContext::CalculateArraySize(type, *valobj);
+    if (size == UINT32_MAX)
+      return 0;
+    return size;
+  }
+
+  lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
+    ValueObjectSP valobj = GetDereferencedValueObject();
+    if (!valobj)
+      return nullptr;
+
+    ProcessSP process_sp = valobj->GetProcessSP();
+    if (!process_sp)
+      return nullptr;
+
+    CompilerType type = valobj->GetCompilerType();
+    CompilerType element_type = type.GetArrayElementType();
+    lldb::addr_t address =
+        valobj->GetAddressOf() +
+        JavaASTContext::CalculateArrayElementOffset(type, idx);
+
+    Status error;
+    size_t byte_size = element_type.GetByteSize(nullptr);
+    DataBufferSP buffer_sp(new DataBufferHeap(byte_size, 0));
+    size_t bytes_read = process_sp->ReadMemory(address, buffer_sp->GetBytes(),
+                                               byte_size, error);
+    if (error.Fail() || byte_size != bytes_read)
+      return nullptr;
+
+    StreamString name;
+    name.Printf("[%" PRIu64 "]", (uint64_t)idx);
+    DataExtractor data(buffer_sp, process_sp->GetByteOrder(),
+                       process_sp->GetAddressByteSize());
+    return CreateValueObjectFromData(
+        name.GetString(), data, valobj->GetExecutionContextRef(), element_type);
+  }
+
+  bool Update() override { return false; }
+
+  bool MightHaveChildren() override { return true; }
+
+  size_t GetIndexOfChildWithName(const ConstString &name) override {
+    return ExtractIndexFromString(name.GetCString());
+  }
+
+private:
+  ValueObjectSP GetDereferencedValueObject() {
+    if (!m_backend.IsPointerOrReferenceType())
+      return m_backend.GetSP();
+
+    Status error;
+    return m_backend.Dereference(error);
+  }
+};
+
+} // end of anonymous namespace
+
+bool lldb_private::formatters::JavaStringSummaryProvider(
+    ValueObject &valobj, Stream &stream, const TypeSummaryOptions &opts) {
+  if (valobj.IsPointerOrReferenceType()) {
+    Status error;
+    ValueObjectSP deref = valobj.Dereference(error);
+    if (error.Fail())
+      return false;
+    return JavaStringSummaryProvider(*deref, stream, opts);
+  }
+
+  ProcessSP process_sp = valobj.GetProcessSP();
+  if (!process_sp)
+    return false;
+
+  ConstString data_name("value");
+  ConstString length_name("count");
+
+  ValueObjectSP length_sp = valobj.GetChildMemberWithName(length_name, true);
+  ValueObjectSP data_sp = valobj.GetChildMemberWithName(data_name, true);
+  if (!data_sp || !length_sp)
+    return false;
+
+  bool success = false;
+  uint64_t length = length_sp->GetValueAsUnsigned(0, &success);
+  if (!success)
+    return false;
+
+  if (length == 0) {
+    stream.Printf("\"\"");
+    return true;
+  }
+  lldb::addr_t valobj_addr = data_sp->GetAddressOf();
+
+  StringPrinter::ReadStringAndDumpToStreamOptions options(valobj);
+  options.SetLocation(valobj_addr);
+  options.SetProcessSP(process_sp);
+  options.SetStream(&stream);
+  options.SetSourceSize(length);
+  options.SetNeedsZeroTermination(false);
+  options.SetLanguage(eLanguageTypeJava);
+
+  if (StringPrinter::ReadStringAndDumpToStream<
+          StringPrinter::StringElementType::UTF16>(options))
+    return true;
+
+  stream.Printf("Summary Unavailable");
+  return true;
+}
+
+bool lldb_private::formatters::JavaArraySummaryProvider(
+    ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
+  if (valobj.IsPointerOrReferenceType()) {
+    Status error;
+    ValueObjectSP deref = valobj.Dereference(error);
+    if (error.Fail())
+      return false;
+    return JavaArraySummaryProvider(*deref, stream, options);
+  }
+
+  CompilerType type = valobj.GetCompilerType();
+  uint32_t size = JavaASTContext::CalculateArraySize(type, valobj);
+  if (size == UINT32_MAX)
+    return false;
+  stream.Printf("[%u]{...}", size);
+  return true;
+}
+
+SyntheticChildrenFrontEnd *
+lldb_private::formatters::JavaArraySyntheticFrontEndCreator(
+    CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
+  return valobj_sp ? new JavaArraySyntheticFrontEnd(valobj_sp) : nullptr;
+}

external/llvm-project/lldb/source/Plugins/Language/Java/JavaFormatterFunctions.h

@@ -0,0 +1,35 @@
+//===-- JavaFormatterFunctions.h---------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_JavaFormatterFunctions_h_
+#define liblldb_JavaFormatterFunctions_h_
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/lldb-forward.h"
+
+namespace lldb_private {
+namespace formatters {
+
+bool JavaStringSummaryProvider(ValueObject &valobj, Stream &stream,
+                               const TypeSummaryOptions &options);
+
+bool JavaArraySummaryProvider(ValueObject &valobj, Stream &stream,
+                              const TypeSummaryOptions &options);
+
+SyntheticChildrenFrontEnd *
+JavaArraySyntheticFrontEndCreator(CXXSyntheticChildren *,
+                                  lldb::ValueObjectSP valobj_sp);
+
+} // namespace formatters
+} // namespace lldb_private
+
+#endif // liblldb_JavaFormatterFunctions_h_

external/llvm-project/lldb/source/Plugins/Language/Java/JavaLanguage.cpp

@@ -0,0 +1,101 @@
+//===-- JavaLanguage.cpp ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// C Includes
+#include <string.h>
+// C++ Includes
+#include <functional>
+#include <mutex>
+
+// Other libraries and framework includes
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Threading.h"
+
+// Project includes
+#include "JavaFormatterFunctions.h"
+#include "JavaLanguage.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/DataFormatters/DataVisualization.h"
+#include "lldb/DataFormatters/FormattersHelpers.h"
+#include "lldb/Symbol/JavaASTContext.h"
+#include "lldb/Utility/ConstString.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::formatters;
+
+void JavaLanguage::Initialize() {
+  PluginManager::RegisterPlugin(GetPluginNameStatic(), "Java Language",
+                                CreateInstance);
+}
+
+void JavaLanguage::Terminate() {
+  PluginManager::UnregisterPlugin(CreateInstance);
+}
+
+lldb_private::ConstString JavaLanguage::GetPluginNameStatic() {
+  static ConstString g_name("Java");
+  return g_name;
+}
+
+lldb_private::ConstString JavaLanguage::GetPluginName() {
+  return GetPluginNameStatic();
+}
+
+uint32_t JavaLanguage::GetPluginVersion() { return 1; }
+
+Language *JavaLanguage::CreateInstance(lldb::LanguageType language) {
+  if (language == eLanguageTypeJava)
+    return new JavaLanguage();
+  return nullptr;
+}
+
+bool JavaLanguage::IsNilReference(ValueObject &valobj) {
+  if (!valobj.GetCompilerType().IsReferenceType())
+    return false;
+
+  // If we failed to read the value then it is not a nil reference.
+  return valobj.GetValueAsUnsigned(UINT64_MAX) == 0;
+}
+
+lldb::TypeCategoryImplSP JavaLanguage::GetFormatters() {
+  static llvm::once_flag g_initialize;
+  static TypeCategoryImplSP g_category;
+
+  llvm::call_once(g_initialize, [this]() -> void {
+    DataVisualization::Categories::GetCategory(GetPluginName(), g_category);
+    if (g_category) {
+      llvm::StringRef array_regexp("^.*\\[\\]&?$");
+
+      lldb::TypeSummaryImplSP string_summary_sp(new CXXFunctionSummaryFormat(
+          TypeSummaryImpl::Flags().SetDontShowChildren(true),
+          lldb_private::formatters::JavaStringSummaryProvider,
+          "java.lang.String summary provider"));
+      g_category->GetTypeSummariesContainer()->Add(
+          ConstString("java::lang::String"), string_summary_sp);
+
+      lldb::TypeSummaryImplSP array_summary_sp(new CXXFunctionSummaryFormat(
+          TypeSummaryImpl::Flags().SetDontShowChildren(true),
+          lldb_private::formatters::JavaArraySummaryProvider,
+          "Java array summary provider"));
+      g_category->GetRegexTypeSummariesContainer()->Add(
+          RegularExpressionSP(new RegularExpression(array_regexp)),
+          array_summary_sp);
+
+#ifndef LLDB_DISABLE_PYTHON
+      AddCXXSynthetic(
+          g_category,
+          lldb_private::formatters::JavaArraySyntheticFrontEndCreator,
+          "Java array synthetic children", ConstString(array_regexp),
+          SyntheticChildren::Flags().SetCascades(true), true);
+#endif
+    }
+  });
+  return g_category;
+}

external/llvm-project/lldb/source/Plugins/Language/Java/JavaLanguage.h

@@ -0,0 +1,52 @@
+//===-- JavaLanguage.h ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_JavaLanguage_h_
+#define liblldb_JavaLanguage_h_
+
+// C Includes
+// C++ Includes
+#include <vector>
+
+// Other libraries and framework includes
+#include "llvm/ADT/StringRef.h"
+
+// Project includes
+#include "lldb/Target/Language.h"
+#include "lldb/Utility/ConstString.h"
+#include "lldb/lldb-private.h"
+
+namespace lldb_private {
+
+class JavaLanguage : public Language {
+public:
+  lldb::LanguageType GetLanguageType() const override {
+    return lldb::eLanguageTypeJava;
+  }
+
+  static void Initialize();
+
+  static void Terminate();
+
+  static lldb_private::Language *CreateInstance(lldb::LanguageType language);
+
+  static lldb_private::ConstString GetPluginNameStatic();
+
+  ConstString GetPluginName() override;
+
+  uint32_t GetPluginVersion() override;
+
+  bool IsNilReference(ValueObject &valobj) override;
+
+  lldb::TypeCategoryImplSP GetFormatters() override;
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_JavaLanguage_h_