Merge branch 'stable/20240723' into lldb-remove-bounds-safety-recognizer

Author: Michael137

clang/include/clang/Frontend/CompilerInvocation.h

@@ -304,6 +304,10 @@ class CompilerInvocation : public CompilerInvocationBase {
     return PPOpts;
   }
   std::shared_ptr<LangOptions> getLangOptsPtr() { return LangOpts; }
+  std::shared_ptr<CASOptions> getCASOptsPtr() { return CASOpts; }
+  void setCASOption(std::shared_ptr<CASOptions> CASOpts) {
+    this->CASOpts = CASOpts;
+  }
   /// @}
 
   /// Create a compiler invocation from a list of input options.

clang/lib/Serialization/ASTReaderDecl.cpp

@@ -3192,7 +3192,7 @@ bool ASTReader::isConsumerInterestedIn(Decl *D) {
   // emitted when we import the relevant module.
   if (isPartOfPerModuleInitializer(D)) {
     auto *M = D->getImportedOwningModule();
-    if (M && M->Kind == Module::ModuleMapModule &&
+    if (M && M->isModuleMapModule() &&
         getContext().DeclMustBeEmitted(D))
       return false;
   }

clang/test/CAS/modules-include-tree-unimported-impl.c

@@ -0,0 +1,50 @@
+// Check that a definition for a symbol in an unimported submodule is not
+// visible for codegen.
+
+// REQUIRES: ondisk_cas
+
+// RUN: rm -rf %t
+// RUN: split-file %s %t
+// RUN: sed "s|DIR|%/t|g" %t/cdb.json.template > %t/cdb.json
+
+// RUN: clang-scan-deps -compilation-database %t/cdb.json -j 1 \
+// RUN:   -cas-path %t/cas -module-files-dir %t/outputs \
+// RUN:   -format experimental-include-tree-full -mode preprocess-dependency-directives \
+// RUN:   > %t/deps.json
+
+// RUN: %deps-to-rsp %t/deps.json --module Mod > %t/Mod.rsp
+// RUN: %deps-to-rsp %t/deps.json --tu-index 0 > %t/tu.rsp
+// RUN: %clang @%t/Mod.rsp
+// RUN: %clang @%t/tu.rsp -o - | FileCheck %s
+
+// CHECK-NOT: @record = global
+// CHECK: @record = external global
+
+//--- cdb.json.template
+[{
+  "file": "DIR/tu.c",
+  "directory": "DIR",
+  "command": "clang -S -emit-llvm DIR/tu.c -fmodules -fimplicit-modules -fimplicit-module-maps -fmodules-cache-path=DIR/module-cache"
+}]
+
+//--- module.modulemap
+module Mod {
+  module A {
+    header "A.h"
+  }
+  explicit module B {
+    header "B.h"
+  }
+}
+
+//--- A.h
+extern int record;
+
+//--- B.h
+int record = 7;
+
+//--- tu.c
+#include "A.h"
+int tu(void) {
+  return record;
+}

lldb/source/Plugins/ExpressionParser/Swift/SwiftExpressionParser.cpp

@@ -12,6 +12,7 @@
 
 #include "SwiftExpressionParser.h"
 
+#include "Plugins/TypeSystem/Swift/SwiftASTContext.h"
 #include "SwiftASTManipulator.h"
 #include "SwiftDiagnostic.h"
 #include "SwiftExpressionSourceCode.h"
@@ -1181,8 +1182,9 @@ AddArchetypeTypeAliases(std::unique_ptr<SwiftASTManipulator> &code_manipulator,
     llvm::StringRef &type_name = pair.getFirst();
     MetadataPointerInfo &info = pair.getSecond();
 
-    auto dependent_type =
-        typeref_typesystem->CreateGenericTypeParamType(info.depth, info.index);
+    auto flavor = SwiftLanguageRuntime::GetManglingFlavor(type_name);
+    auto dependent_type = typeref_typesystem->CreateGenericTypeParamType(
+        info.depth, info.index, flavor);
     auto bound_type =
         runtime->BindGenericTypeParameters(stack_frame, dependent_type);
     if (!bound_type) {

lldb/source/Plugins/ExpressionParser/Swift/SwiftExpressionSourceCode.cpp

@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "SwiftExpressionSourceCode.h"
+#include "Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.h"
 #include "SwiftPersistentExpressionState.h"
 
 #include "Plugins/ExpressionParser/Swift/SwiftASTManipulator.h"
@@ -60,10 +61,14 @@ static llvm::Expected<std::string> TransformPackType(
   if (!ts)
     return llvm::createStringError(llvm::errc::not_supported,
                                    "no typeref typesystem");
+
+  auto mangled_name = type.GetMangledTypeName().GetStringRef();
+  auto flavor = SwiftLanguageRuntime::GetManglingFlavor(mangled_name);
+
   using namespace swift::Demangle;
   Demangler dem;
-  NodePointer node = ts->GetCanonicalDemangleTree(
-      dem, type.GetMangledTypeName().GetStringRef());
+
+  NodePointer node = ts->GetCanonicalDemangleTree(dem, mangled_name);
 
   node = TypeSystemSwiftTypeRef::Transform(dem, node, [](NodePointer n) {
     if (n->getKind() == Node::Kind::SILPackIndirect &&
@@ -76,7 +81,8 @@ static llvm::Expected<std::string> TransformPackType(
   });
 
   bool error = false;
-  ConstString type_name = ts->RemangleAsType(dem, node).GetMangledTypeName();
+  ConstString type_name =
+      ts->RemangleAsType(dem, node, flavor).GetMangledTypeName();
   swift::Demangle::DemangleOptions options;
   options = swift::Demangle::DemangleOptions::SimplifiedUIDemangleOptions();
   options.DisplayStdlibModule = false;

lldb/source/Plugins/Language/Swift/SwiftFormatters.cpp

@@ -257,6 +257,8 @@ static bool makeStringGutsSummary(
   │ Immortal, Small     ║  1  │ASCII│  1  │  0  │
   ├─────────────────────╫─────┼─────┼─────┼─────┤
   │ Immortal, Large     ║  1  │  0  │  0  │  0  │
+  ├─────────────────────╫─────┼─────┼─────┼─────┤
+  │ Immortal, Bridged   ║  1  │  1  │  0  │  0  │
   ╞═════════════════════╬═════╪═════╪═════╪═════╡
   │ Native              ║  0  │  0  │  0  │  0  │
   ├─────────────────────╫─────┼─────┼─────┼─────┤
@@ -373,7 +375,7 @@ static bool makeStringGutsSummary(
   if ((discriminator & 0b0111'0000) == 0)
     return error("unexpected discriminator");
 
-  if ((discriminator & 0b1110'0000) == 0b0100'0000) { // 010xxxxx: Bridged
+  if ((discriminator & 0b0110'0000) == 0b0100'0000) { // x10xxxxx: Bridged
     TypeSystemClangSP clang_ts_sp =
         ScratchTypeSystemClang::GetForTarget(process->GetTarget());
     if (!clang_ts_sp)
@@ -805,6 +807,8 @@ class TaskSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
       ThreadSafeReflectionContext reflection_ctx =
           runtime->GetReflectionContext();
       ValueObjectSP task_obj_sp = m_backend.GetChildMemberWithName("_task");
+      if (!task_obj_sp)
+        return ChildCacheState::eRefetch;
       uint64_t task_ptr = task_obj_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
       if (task_ptr != LLDB_INVALID_ADDRESS) {
         llvm::Expected<ReflectionContextInterface::AsyncTaskInfo> task_info =

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

@@ -20,6 +20,7 @@
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/lldb-private.h"
+#include "swift/Demangling/ManglingFlavor.h"
 
 #include <optional>
 #include "llvm/ADT/StringSet.h"
@@ -132,6 +133,12 @@ class SwiftLanguageRuntime : public LanguageRuntime {
   /// since some day we may want to support more than one swift variant.
   static bool IsSwiftMangledName(llvm::StringRef name);
 
+  static swift::Mangle::ManglingFlavor
+  GetManglingFlavor(llvm::StringRef mangledName) {
+    if (mangledName.starts_with("$e") || mangledName.starts_with("_$e"))
+      return swift::Mangle::ManglingFlavor::Embedded;
+    return swift::Mangle::ManglingFlavor::Default;
+  }
   enum class FuncletComparisonResult {
     NotBothFunclets,
     DifferentAsyncFunctions,
@@ -271,6 +278,7 @@ class SwiftLanguageRuntime : public LanguageRuntime {
   /// context.
   static void GetGenericParameterNamesForFunction(
       const SymbolContext &sc, const ExecutionContext *exe_ctx,
+      swift::Mangle::ManglingFlavor flavor,
       llvm::DenseMap<ArchetypePath, llvm::StringRef> &dict);
 
   /// Invoke callback for each DependentGenericParamType.

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

@@ -36,6 +36,7 @@
 #include "swift/AST/ASTMangler.h"
 #include "swift/AST/ASTWalker.h"
 #include "swift/Demangling/Demangle.h"
+#include "swift/Demangling/ManglingFlavor.h"
 #include "swift/RemoteInspection/ReflectionContext.h"
 #include "swift/RemoteInspection/TypeRefBuilder.h"
 #include "swift/Strings.h"
@@ -318,8 +319,11 @@ class LLDBTypeInfoProvider : public swift::remote::TypeInfoProvider {
     auto *node = dem.demangleSymbol(wrapped);
     if (!node) {
       // Try `mangledName` as plain ObjC class name. Ex: NSObject, NSView, etc.
+      // Since this looking up an ObjC type, the default mangling falvor should
+      // be used.
       auto maybeMangled = swift_demangle::mangleClass(
-          dem, swift::MANGLING_MODULE_OBJC, mangledName);
+          dem, swift::MANGLING_MODULE_OBJC, mangledName,
+          swift::Mangle::ManglingFlavor::Default);
       if (!maybeMangled.isSuccess()) {
         LLDB_LOG(GetLog(LLDBLog::Types),
                  "[LLDBTypeInfoProvider] invalid mangled name: {0}",
@@ -641,7 +645,9 @@ CompilerType GetWeakReferent(TypeSystemSwiftTypeRef &ts, CompilerType type) {
   if (!n || n->getKind() != Node::Kind::SugaredOptional || !n->hasChildren())
     return {};
   n = n->getFirstChild();
-  return ts.RemangleAsType(dem, n);
+  return ts.RemangleAsType(
+      dem, n,
+      SwiftLanguageRuntime::GetManglingFlavor(type.GetMangledTypeName()));
 }
 
 CompilerType GetTypeFromTypeRef(TypeSystemSwiftTypeRef &ts,
@@ -650,7 +656,8 @@ CompilerType GetTypeFromTypeRef(TypeSystemSwiftTypeRef &ts,
     return {};
   swift::Demangle::Demangler dem;
   swift::Demangle::NodePointer node = type_ref->getDemangling(dem);
-  return ts.RemangleAsType(dem, node);
+  // TODO: the mangling flavor should come from the TypeRef.
+  return ts.RemangleAsType(dem, node, ts.GetManglingFlavor());
 }
 
 struct ExistentialSyntheticChild {
@@ -1567,8 +1574,9 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_Pack(
 
   swift::Demangle::Demangler dem;
 
-  auto expand_pack_type = [&](ConstString mangled_pack_type,
-                              bool indirect) -> swift::Demangle::NodePointer {
+  auto expand_pack_type = [&](ConstString mangled_pack_type, bool indirect,
+                              swift::Mangle::ManglingFlavor flavor)
+      -> swift::Demangle::NodePointer {
     // Find pack_type in the pack_expansions.
     unsigned i = 0;
     SwiftLanguageRuntime::GenericSignature::PackExpansion *pack_expansion =
@@ -1698,7 +1706,7 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_Pack(
       auto bound_typeref = reflection_ctx->ApplySubstitutions(
           type_ref, substitutions, ts->GetDescriptorFinder());
       swift::Demangle::NodePointer node = bound_typeref->getDemangling(dem);
-      CompilerType type = ts->RemangleAsType(dem, node);
+      CompilerType type = ts->RemangleAsType(dem, node, flavor);
 
       // Add the substituted type to the tuple.
       elements.push_back({{}, type});
@@ -1724,6 +1732,9 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_Pack(
   auto node = dem_ctx.demangleSymbolAsNode(
       pack_type.GetMangledTypeName().GetStringRef());
 
+  auto flavor =
+      SwiftLanguageRuntime::GetManglingFlavor(pack_type.GetMangledTypeName());
+
   // Expand all the pack types that appear in the incoming type,
   // either at the root level or as arguments of bound generic types.
   bool indirect = false;
@@ -1739,18 +1750,18 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_Pack(
         if (node->getNumChildren() != 1)
           return node;
         node = node->getChild(0);
-        CompilerType pack_type = ts->RemangleAsType(dem, node);
+        CompilerType pack_type = ts->RemangleAsType(dem, node, flavor);
         ConstString mangled_pack_type = pack_type.GetMangledTypeName();
         LLDB_LOG(log, "decoded pack_expansion type: {0}", mangled_pack_type);
-        auto result = expand_pack_type(mangled_pack_type, indirect);
+        auto result = expand_pack_type(mangled_pack_type, indirect, flavor);
         if (!result) {
           LLDB_LOG(log, "failed to expand pack type: {0}", mangled_pack_type);
           return node;
         }
         return result;
       });
 
-  CompilerType expanded_type = ts->RemangleAsType(dem, transformed);
+  CompilerType expanded_type = ts->RemangleAsType(dem, transformed, flavor);
   pack_type_or_name.SetCompilerType(expanded_type);
 
   AddressType address_type;
@@ -1824,7 +1835,8 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_Class(
             // useful to users.
             if (IsPrivateNSClass(node))
               return false;
-            class_type_or_name.SetCompilerType(ts->RemangleAsType(dem, node));
+            class_type_or_name.SetCompilerType(ts->RemangleAsType(
+                dem, node, swift::Mangle::ManglingFlavor::Default));
             found = true;
             return true;
           }
@@ -1854,9 +1866,13 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_Class(
                class_type.GetMangledTypeName(), instance_ptr);
     return false;
   }
+
+  auto flavor =
+      SwiftLanguageRuntime::GetManglingFlavor(class_type.GetMangledTypeName());
+
   swift::Demangle::Demangler dem;
   swift::Demangle::NodePointer node = typeref->getDemangling(dem);
-  CompilerType dynamic_type = ts->RemangleAsType(dem, node);
+  CompilerType dynamic_type = ts->RemangleAsType(dem, node, flavor);
   LLDB_LOG(log, "dynamic type of instance_ptr {0:x} is {1}", instance_ptr,
            class_type.GetMangledTypeName());
   class_type_or_name.SetCompilerType(dynamic_type);
@@ -2022,7 +2038,10 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_Existential(
     return false;
   swift::Demangle::Demangler dem;
   swift::Demangle::NodePointer node = typeref->getDemangling(dem);
-  class_type_or_name.SetCompilerType(ts->RemangleAsType(dem, node));
+  auto flavor = SwiftLanguageRuntime::GetManglingFlavor(
+      existential_type.GetMangledTypeName());
+
+  class_type_or_name.SetCompilerType(ts->RemangleAsType(dem, node, flavor));
   address.SetRawAddress(out_address.getAddressData());
 
 #ifndef NDEBUG
@@ -2087,7 +2106,10 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_ExistentialMetatype(
   meta->addChild(node, dem);
   wrapped->addChild(meta,dem);
 
-  meta_type = tr_ts->RemangleAsType(dem, wrapped);
+  auto flavor =
+      SwiftLanguageRuntime::GetManglingFlavor(meta_type.GetMangledTypeName());
+  meta_type =
+      tss->GetTypeSystemSwiftTypeRef()->RemangleAsType(dem, wrapped, flavor);
   class_type_or_name.SetCompilerType(meta_type);
   address.SetRawAddress(ptr);
   return true;
@@ -2113,7 +2135,9 @@ CompilerType SwiftLanguageRuntimeImpl::GetTypeFromMetadata(TypeSystemSwift &ts,
   using namespace swift::Demangle;
   Demangler dem;
   NodePointer node = type_ref->getDemangling(dem);
-  return tr_ts->RemangleAsType(dem, node);
+  // TODO: the mangling flavor should come from the TypeRef.
+  return ts.GetTypeSystemSwiftTypeRef()->RemangleAsType(
+      dem, node, ts.GetTypeSystemSwiftTypeRef()->GetManglingFlavor());
 }
 
 std::optional<lldb::addr_t>
@@ -2236,7 +2260,10 @@ CompilerType SwiftLanguageRuntimeImpl::BindGenericTypeParameters(
           type_ref, substitutions,
           tr_ts->GetDescriptorFinder());
   NodePointer node = bound_type_ref->getDemangling(dem);
-  return tr_ts->RemangleAsType(dem, node);
+  return ts->GetTypeSystemSwiftTypeRef()->RemangleAsType(
+      dem, node,
+      SwiftLanguageRuntime::GetManglingFlavor(
+          unbound_type.GetMangledTypeName()));
 }
 
 CompilerType
@@ -2278,10 +2305,12 @@ SwiftLanguageRuntimeImpl::BindGenericTypeParameters(StackFrame &stack_frame,
       return;
     substitutions.insert({{depth, index}, type_ref});
   });
+  auto flavor =
+      SwiftLanguageRuntime::GetManglingFlavor(mangled_name.GetStringRef());
 
   // Nothing to do if there are no type parameters.
   auto get_canonical = [&]() {
-    auto mangling = mangleNode(canonical);
+    auto mangling = mangleNode(canonical, flavor);
     if (!mangling.isSuccess())
       return CompilerType();
     return ts.GetTypeFromMangledTypename(ConstString(mangling.result()));
@@ -2315,7 +2344,7 @@ SwiftLanguageRuntimeImpl::BindGenericTypeParameters(StackFrame &stack_frame,
              "No scratch context available.");
     return ts.GetTypeFromMangledTypename(mangled_name);
   }
-  CompilerType bound_type = scratch_ctx->RemangleAsType(dem, node);
+  CompilerType bound_type = scratch_ctx->RemangleAsType(dem, node, flavor);
   LLDB_LOG(GetLog(LLDBLog::Expressions | LLDBLog::Types), "Bound {0} -> {1}.",
            mangled_name, bound_type.GetMangledTypeName());
   return bound_type;
@@ -2640,6 +2669,13 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_ClangType(
 
   std::string remangled;
   {
+    auto type = in_value.GetCompilerType();
+    std::optional<swift::Mangle::ManglingFlavor> mangling_flavor =
+        SwiftLanguageRuntime::GetManglingFlavor(
+            type.GetMangledTypeName().GetStringRef());
+    if (!mangling_flavor)
+      return false;
+
     // Create a mangle tree for Swift.Optional<$module.$class>
     using namespace swift::Demangle;
     NodeFactory factory;
@@ -2668,7 +2704,7 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_ClangType(
         factory);
     cty->addChild(c, factory);
 
-    auto mangling = mangleNode(global);
+    auto mangling = mangleNode(global, *mangling_flavor);
     if (!mangling.isSuccess())
       return false;
     remangled = mangling.result();