Merge pull request #9655 from adrian-prantl/cherry-pick-next

Cherry pick next

Author: adrian-prantl

lldb/include/lldb/API/SBFrame.h

@@ -93,10 +93,9 @@ class LLDB_API SBFrame {
   // guess the language type from the mangled name.
   lldb::LanguageType GuessLanguage() const;
 
+  LLDB_DEPRECATED("Use SBFrame::IsHidden() instead.")
   bool IsSwiftThunk() const;
 
-  lldb::SBStructuredData GetLanguageSpecificData() const;
-
   /// Return true if this frame represents an inlined function.
   ///
   /// See also GetFunctionName().
@@ -126,6 +125,11 @@ class LLDB_API SBFrame {
   lldb::SBValue EvaluateExpression(const char *expr,
                                    const SBExpressionOptions &options);
 
+  /// Language plugins can use this API to report language-specific
+  /// runtime information about this compile unit, such as additional
+  /// language version details or feature flags.
+  SBStructuredData GetLanguageSpecificData() const;
+
   /// Gets the lexical block that defines the stack frame. Another way to think
   /// of this is it will return the block that contains all of the variables
   /// for a stack frame. Inlined functions are represented as SBBlock objects

lldb/include/lldb/Target/LanguageRuntime.h

@@ -230,22 +230,6 @@ class LanguageRuntime : public Runtime, public PluginInterface {
   virtual bool isA(const void *ClassID) const { return ClassID == &ID; }
   static char ID;
 
-  /// Query the runtime for language specific metadata about the given frame.
-  ///
-  /// Properties that are common to all languages are exposed as dedicated APIs
-  /// of \c Frame and \c Function. This function complements those APIs by
-  /// producing a \c StructuredData instance that encapsulates non-common
-  /// properties about the frame and function.
-  ///
-  /// \param[in] frame
-  ///     The frame to compute metadata for.
-  ///
-  /// \return
-  ///     Returns a StructuredData containing the metadata.
-  virtual StructuredDataImpl *GetLanguageSpecificData(StackFrame &frame) {
-    return nullptr;
-  }
-
   virtual void FindFunctionPointersInCall(StackFrame &frame,
                                           std::vector<Address> &addresses,
                                           bool debug_only = true,
@@ -285,6 +269,11 @@ class LanguageRuntime : public Runtime, public PluginInterface {
                        lldb_private::RegisterContext *regctx,
                        bool &behaves_like_zeroth_frame);
 
+  /// Language runtime plugins can use this API to report
+  /// language-specific runtime information about this compile unit,
+  /// such as additional language version details or feature flags.
+  virtual StructuredData::ObjectSP GetLanguageSpecificData(SymbolContext sc);
+
 protected:
   // The static GetRuntimeUnwindPlan method above is only implemented in the
   // base class; subclasses may override this protected member if they can

lldb/include/lldb/Target/StackFrame.h

@@ -22,6 +22,7 @@
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
+#include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/UserID.h"
 #include "lldb/ValueObject/ValueObjectList.h"
 
@@ -408,6 +409,15 @@ class StackFrame : public ExecutionContextScope,
   /// system implementation details this way.
   bool IsHidden();
 
+  /// Query whether this frame is a Swift Thunk.
+  LLDB_DEPRECATED("Use IsHidden() instead.")
+  bool IsSwiftThunk();
+
+  /// Language plugins can use this API to report language-specific
+  /// runtime information about this compile unit, such as additional
+  /// language version details or feature flags.
+  StructuredData::ObjectSP GetLanguageSpecificData();
+
   /// Get the frame's demangled name.
   ///
   ///  /// \return

lldb/source/API/SBFrame.cpp

@@ -1163,6 +1163,21 @@ lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
   return expr_result;
 }
 
+SBStructuredData SBFrame::GetLanguageSpecificData() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  SBStructuredData sb_data;
+  std::unique_lock<std::recursive_mutex> lock;
+  ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+  StackFrame *frame = exe_ctx.GetFramePtr();
+  if (!frame)
+    return sb_data;
+
+  StructuredData::ObjectSP data(frame->GetLanguageSpecificData());
+  sb_data.m_impl_up->SetObjectSP(data);
+  return sb_data;
+}
+
 bool SBFrame::IsInlined() {
   LLDB_INSTRUMENT_VA(this);
 
@@ -1246,20 +1261,6 @@ lldb::LanguageType SBFrame::GuessLanguage() const {
   return eLanguageTypeUnknown;
 }
 
-lldb::SBStructuredData SBFrame::GetLanguageSpecificData() const {
-  std::unique_lock<std::recursive_mutex> lock;
-  ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
-  auto *process = exe_ctx.GetProcessPtr();
-  auto *frame = exe_ctx.GetFramePtr();
-  if (process && frame)
-    if (auto *runtime = process->GetLanguageRuntime(
-            frame->GuessLanguage().AsLanguageType()))
-      if (auto *data = runtime->GetLanguageSpecificData(*frame))
-        return SBStructuredData(*data);
-
-  return {};
-}
-
 // BEGIN SWIFT
 bool SBFrame::IsSwiftThunk() const {
   std::unique_lock<std::recursive_mutex> lock;

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

@@ -3411,6 +3411,14 @@ std::optional<uint64_t> AppleObjCRuntimeV2::GetSharedCacheImageHeaderVersion() {
   return std::nullopt;
 }
 
+StructuredData::ObjectSP
+AppleObjCRuntimeV2::GetLanguageSpecificData(SymbolContext sc) {
+  auto dict_up = std::make_unique<StructuredData::Dictionary>();
+  dict_up->AddItem("Objective-C runtime version",
+                   std::make_unique<StructuredData::UnsignedInteger>(2));
+  return dict_up;
+}
+
 #pragma mark Frame recognizers
 
 class ObjCExceptionRecognizedStackFrame : public RecognizedStackFrame {

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h

@@ -106,6 +106,8 @@ class AppleObjCRuntimeV2 : public AppleObjCRuntime {
 
   std::optional<uint64_t> GetSharedCacheImageHeaderVersion();
 
+  StructuredData::ObjectSP GetLanguageSpecificData(SymbolContext sc) override;
+
 protected:
   lldb::BreakpointResolverSP
   CreateExceptionResolver(const lldb::BreakpointSP &bkpt, bool catch_bp,

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.cpp

@@ -1179,20 +1179,32 @@ SwiftLanguageRuntimeImpl::GetObjectDescription(Stream &str,
   return RunObjectDescriptionExpr(object, expr_string, str);
 }
 
-StructuredDataImpl *
-SwiftLanguageRuntime::GetLanguageSpecificData(StackFrame &frame) {
-  auto sc = frame.GetSymbolContext(eSymbolContextFunction);
+StructuredData::ObjectSP
+SwiftLanguageRuntime::GetLanguageSpecificData(SymbolContext sc) {
   if (!sc.function)
-    return nullptr;
+    return {};
 
   auto dict_sp = std::make_shared<StructuredData::Dictionary>();
   auto symbol = sc.function->GetMangled().GetMangledName().GetStringRef();
   auto is_async = SwiftLanguageRuntime::IsAnySwiftAsyncFunctionSymbol(symbol);
   dict_sp->AddBooleanItem("IsSwiftAsyncFunction", is_async);
 
-  auto *data = new StructuredDataImpl;
-  data->SetObjectSP(dict_sp);
-  return data;
+  if (!m_process)
+    return dict_sp;
+
+  auto type_system_or_err =
+      m_process->GetTarget().GetScratchTypeSystemForLanguage(
+          eLanguageTypeSwift);
+  if (!type_system_or_err)
+    return dict_sp;
+
+  if (auto *ts = llvm::dyn_cast_or_null<TypeSystemSwiftTypeRef>(
+          type_system_or_err->get()))
+    if (auto *swift_ast_ctx = ts->GetSwiftASTContextOrNull(sc))
+      dict_sp->AddBooleanItem("SwiftExplicitModules",
+                              swift_ast_ctx->HasExplicitModules());
+
+  return dict_sp;
 }
 
 void SwiftLanguageRuntime::FindFunctionPointersInCall(

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.h

@@ -431,7 +431,7 @@ class SwiftLanguageRuntime : public LanguageRuntime {
   lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
                                                   bool stop_others) override;
 
-  StructuredDataImpl *GetLanguageSpecificData(StackFrame &frame) override;
+  StructuredData::ObjectSP GetLanguageSpecificData(SymbolContext sc) override;
 
   /// If you are at the initial instruction of the frame passed in,
   /// then this will examine the call arguments, and if any of them is

lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.cpp

@@ -15,6 +15,7 @@
 #include "Plugins/TypeSystem/Swift/StoringDiagnosticConsumer.h"
 #include "Plugins/ExpressionParser/Swift/SwiftPersistentExpressionState.h"
 
+#include "SwiftASTContext.h"
 #include "TypeSystemSwift.h"
 #include "TypeSystemSwiftTypeRef.h"
 #include "lldb/Utility/Log.h"
@@ -1799,11 +1800,18 @@ void SwiftASTContext::AddExtraClangArgs(
     const std::vector<std::string> &module_search_paths,
     const std::vector<std::pair<std::string, bool>> framework_search_paths,
     StringRef overrideOpts) {
+  swift::ClangImporterOptions &importer_options = GetClangImporterOptions();
+  auto defer = llvm::make_scope_exit([&]() {
+    // Detect explicitly-built modules.
+    m_has_explicit_modules =
+        llvm::any_of(importer_options.ExtraArgs, [](const std::string &arg) {
+          return StringRef(arg).starts_with("-fmodule-file=");
+        });
+  });
+
   if (ExtraArgs.empty())
     return;
 
-  swift::ClangImporterOptions &importer_options = GetClangImporterOptions();
-
   // Detect cc1 flags.  When DirectClangCC1ModuleBuild is on then the
   // clang arguments in the serialized invocation are clang cc1 flags,
   // which are very specific to one compiler version and cannot
@@ -1834,12 +1842,6 @@ void SwiftASTContext::AddExtraClangArgs(
   applyOverrideOptions(importer_options.ExtraArgs, overrideOpts);
   if (HasNonexistentExplicitModule(importer_options.ExtraArgs))
     RemoveExplicitModules(importer_options.ExtraArgs);
-
-  // Detect explicitly-built modules.
-  m_has_explicit_modules =
-      llvm::any_of(importer_options.ExtraArgs, [](const std::string &arg) {
-        return StringRef(arg).starts_with("-fmodule-file=");
-      });
 }
 
 void SwiftASTContext::AddExtraClangCC1Args(
@@ -5484,6 +5486,9 @@ void SwiftASTContext::LogConfiguration(bool is_repl) {
   if (!clang_importer_options.BridgingHeader.empty())
     HEALTH_LOG_PRINTF("  Bridging Header               : %s",
                       clang_importer_options.BridgingHeader.c_str());
+  if (auto *expr_ctx = llvm::dyn_cast<SwiftASTContextForExpressions>(this))
+    HEALTH_LOG_PRINTF("  Explicit modules              : %s",
+                      expr_ctx->HasExplicitModules() ? "true" : "false");
 
   HEALTH_LOG_PRINTF(
       "  Extra clang arguments            : (%llu items)",

lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.h

@@ -535,6 +535,7 @@ class SwiftASTContext : public TypeSystemSwift {
   void ClearModuleDependentCaches() override;
   void LogConfiguration(bool is_repl = false);
   bool HasTarget();
+  bool HasExplicitModules() const { return m_has_explicit_modules; }
   bool CheckProcessChanged();
 
   // FIXME: this should be removed once we figure out who should really own the

lldb/source/Target/LanguageRuntime.cpp

@@ -277,6 +277,11 @@ LanguageRuntime::GetRuntimeUnwindPlan(Thread &thread, RegisterContext *regctx,
   return UnwindPlanSP();
 }
 
+StructuredData::ObjectSP
+LanguageRuntime::GetLanguageSpecificData(SymbolContext sc) {
+  return {};
+}
+
 void LanguageRuntime::InitializeCommands(CommandObject *parent) {
   if (!parent)
     return;

lldb/source/Target/StackFrame.cpp

@@ -22,6 +22,7 @@
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrameRecognizer.h"
@@ -1237,6 +1238,35 @@ bool StackFrame::IsHidden() {
   return false;
 }
 
+bool StackFrame::IsSwiftThunk() {
+  ThreadSP thread_sp = GetThread();
+  if (!thread_sp)
+    return false;
+  ProcessSP process_sp = thread_sp->GetProcess();
+  if (!process_sp)
+    return false;
+
+  SymbolContext sc = GetSymbolContext(eSymbolContextSymbol);
+  if (!sc.symbol)
+    return false;
+  auto *runtime = process_sp->GetLanguageRuntime(eLanguageTypeSwift);
+  if (!runtime)
+    return false;
+  return runtime->IsSymbolARuntimeThunk(*sc.symbol);
+}
+
+StructuredData::ObjectSP StackFrame::GetLanguageSpecificData() {
+  auto process_sp = CalculateProcess();
+  SourceLanguage language = GetLanguage();
+  if (!language)
+    return {};
+  if (auto runtime_sp =
+          process_sp->GetLanguageRuntime(language.AsLanguageType()))
+    return runtime_sp->GetLanguageSpecificData(
+        GetSymbolContext(eSymbolContextFunction));
+  return {};
+}
+
 const char *StackFrame::GetFunctionName() {
   const char *name = nullptr;
   SymbolContext sc = GetSymbolContext(

lldb/test/API/lang/objc/languageinfo/Makefile

@@ -0,0 +1,4 @@
+OBJC_SOURCES := main.m
+LD_EXTRAS := -lobjc
+
+include Makefile.rules

lldb/test/API/lang/objc/languageinfo/TestObjCLanguageSpecificData.py

@@ -0,0 +1,16 @@
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class ObjCiVarIMPTestCase(TestBase):
+    @skipUnlessDarwin
+    @no_debug_info_test
+    def test_imp_ivar_type(self):
+        self.build()
+        target, process, thread, bkpt = lldbutil.run_to_name_breakpoint(self, "main")
+        frame = thread.GetFrameAtIndex(0)
+        lang_info = frame.GetLanguageSpecificData()
+        version = lang_info.GetValueForKey("Objective-C runtime version")
+        self.assertEqual(version.GetIntegerValue(), 2)

lldb/test/API/lang/objc/languageinfo/main.m

@@ -0,0 +1 @@
+int main(int argc, char const *argv[]) { return 0; }

lldb/test/API/lang/swift/async/frame/language_specific_data/Makefile

@@ -1,3 +1,4 @@
 SWIFT_SOURCES := main.swift
+SWIFT_ENABLE_EXPLICIT_MODULES := YES
 SWIFTFLAGS_EXTRAS := -parse-as-library
 include Makefile.rules

lldb/test/API/lang/swift/async/frame/language_specific_data/TestSwiftAsyncLanguageSpecificData.py

@@ -7,6 +7,7 @@ class TestCase(lldbtest.TestBase):
 
     mydir = lldbtest.TestBase.compute_mydir(__file__)
 
+    @no_debug_info_test
     @swiftTest
     @skipIf(oslist=['windows', 'linux'])
     def test(self):
@@ -27,9 +28,13 @@ def test(self):
         while process.state == lldb.eStateStopped:
             thread = process.GetSelectedThread()
             frame = thread.frames[0]
+            # Spin up the compiler so it can answer the explicit modules question.
+            self.expect("expression 1")
             data = frame.GetLanguageSpecificData()
             is_async = data.GetValueForKey("IsSwiftAsyncFunction").GetBooleanValue()
             self.assertTrue(is_async)
+            is_explicit = data.GetValueForKey("SwiftExplicitModules").GetBooleanValue()
+            self.assertTrue(is_explicit)
 
             process.Continue()