Merge remote-tracking branch 'apple/release/5.3' into katei-merge-5.3

Author: kateinoigakukun

include/swift/AST/DiagnosticsFrontend.def

@@ -301,6 +301,9 @@ ERROR(error_optimization_remark_pattern, none, "%0 in '%1'",
 ERROR(error_invalid_debug_prefix_map, none,
       "invalid argument '%0' to -debug-prefix-map; it must be of the form "
       "'original=remapped'", (StringRef))
+ERROR(error_invalid_coverage_prefix_map, none,
+      "invalid argument '%0' to -coverage-prefix-map; it must be of the form "
+      "'original=remapped'", (StringRef))
 
 
 ERROR(error_unable_to_write_swift_ranges_file, none,

include/swift/AST/IRGenOptions.h

@@ -169,6 +169,9 @@ class IRGenOptions {
   /// Path prefixes that should be rewritten in debug info.
   PathRemapper DebugPrefixMap;
 
+  /// Path prefixes that should be rewritten in coverage info.
+  PathRemapper CoveragePrefixMap;
+
   /// What level of debug info to generate.
   IRGenDebugInfoLevel DebugInfoLevel : 2;
 

include/swift/Option/Options.td

@@ -708,6 +708,9 @@ def gdwarf_types : Flag<["-"], "gdwarf-types">,
 def debug_prefix_map : Separate<["-"], "debug-prefix-map">,
     Flags<[FrontendOption]>,
     HelpText<"Remap source paths in debug info">;
+def coverage_prefix_map : Separate<["-"], "coverage-prefix-map">,
+  Flags<[FrontendOption]>,
+  HelpText<"Remap source paths in coverage info">;
 
 def debug_info_format : Joined<["-"], "debug-info-format=">,
   Flags<[FrontendOption]>,

lib/AST/Type.cpp

@@ -3059,8 +3059,8 @@ operator()(SubstitutableType *maybeOpaqueType) const {
           }))
     return maybeOpaqueType;
 
-  // If the type still contains opaque types, recur.
-  if (substTy->hasOpaqueArchetype()) {
+  // If the type changed, but still contains opaque types, recur.
+  if (!substTy->isEqual(maybeOpaqueType) && substTy->hasOpaqueArchetype()) {
     return ::substOpaqueTypesWithUnderlyingTypes(
         substTy, inContext, contextExpansion, isContextWholeModule);
   }

lib/Driver/Driver.cpp

@@ -179,6 +179,12 @@ static void validateDebugInfoArgs(DiagnosticEngine &diags,
   for (auto A : args.getAllArgValues(options::OPT_debug_prefix_map))
     if (A.find('=') == StringRef::npos)
       diags.diagnose(SourceLoc(), diag::error_invalid_debug_prefix_map, A);
+
+  // Check for any -coverage-prefix-map options that aren't of the form
+  // 'original=remapped' (either side can be empty, however).
+  for (auto A : args.getAllArgValues(options::OPT_coverage_prefix_map))
+    if (A.find('=') == StringRef::npos)
+      diags.diagnose(SourceLoc(), diag::error_invalid_coverage_prefix_map, A);
 }
 
 static void validateVerifyIncrementalDependencyArgs(DiagnosticEngine &diags,

lib/Driver/ToolChains.cpp

@@ -265,6 +265,7 @@ void ToolChain::addCommonFrontendArgs(const OutputInfo &OI,
 
   // Pass on file paths that should be remapped in debug info.
   inputArgs.AddAllArgs(arguments, options::OPT_debug_prefix_map);
+  inputArgs.AddAllArgs(arguments, options::OPT_coverage_prefix_map);
 
   // Pass through the values passed to -Xfrontend.
   inputArgs.AddAllArgValues(arguments, options::OPT_Xfrontend);

lib/Frontend/CompilerInvocation.cpp

@@ -1267,6 +1267,11 @@ static bool ParseIRGenArgs(IRGenOptions &Opts, ArgList &Args,
     Opts.DebugPrefixMap.addMapping(SplitMap.first, SplitMap.second);
   }
 
+  for (auto A : Args.getAllArgValues(options::OPT_coverage_prefix_map)) {
+    auto SplitMap = StringRef(A).split('=');
+    Opts.CoveragePrefixMap.addMapping(SplitMap.first, SplitMap.second);
+  }
+
   for (const Arg *A : Args.filtered(OPT_Xcc)) {
     StringRef Opt = A->getValue();
     if (Opt.startswith("-D") || Opt.startswith("-U"))

lib/IRGen/GenClangDecl.cpp

@@ -34,18 +34,43 @@ class ClangDeclRefFinder
     return true;
   }
 };
+
+// If any (re)declaration of `decl` contains executable code, returns that
+// redeclaration; otherwise, returns nullptr.
+// In the case of a function, executable code is contained in the function
+// definition. In the case of a variable, executable code can be contained in
+// the initializer of the variable.
+clang::Decl *getDeclWithExecutableCode(clang::Decl *decl) {
+  if (auto fd = dyn_cast<clang::FunctionDecl>(decl)) {
+    const clang::FunctionDecl *definition;
+    if (fd->hasBody(definition)) {
+      return const_cast<clang::FunctionDecl *>(definition);
+    }
+  } else if (auto vd = dyn_cast<clang::VarDecl>(decl)) {
+    clang::VarDecl *initializingDecl = vd->getInitializingDeclaration();
+    if (initializingDecl) {
+      return initializingDecl;
+    }
+  }
+
+  return nullptr;
+}
+
 } // end anonymous namespace
 
 void IRGenModule::emitClangDecl(const clang::Decl *decl) {
-  auto valueDecl = dyn_cast<clang::ValueDecl>(decl);
-  if (!valueDecl || valueDecl->isExternallyVisible()) {
+  // Ignore this decl if we've seen it before.
+  if (!GlobalClangDecls.insert(decl->getCanonicalDecl()).second)
+    return;
+
+  // Fast path for the case where `decl` doesn't contain executable code, so it
+  // can't reference any other declarations that we would need to emit.
+  if (getDeclWithExecutableCode(const_cast<clang::Decl *>(decl)) == nullptr) {
     ClangCodeGen->HandleTopLevelDecl(
                           clang::DeclGroupRef(const_cast<clang::Decl*>(decl)));
     return;
   }
 
-  if (!GlobalClangDecls.insert(decl->getCanonicalDecl()).second)
-    return;
   SmallVector<const clang::Decl *, 8> stack;
   stack.push_back(decl);
 
@@ -69,13 +94,15 @@ void IRGenModule::emitClangDecl(const clang::Decl *decl) {
 
   while (!stack.empty()) {
     auto *next = const_cast<clang::Decl *>(stack.pop_back_val());
-    if (auto fn = dyn_cast<clang::FunctionDecl>(next)) {
-      const clang::FunctionDecl *definition;
-      if (fn->hasBody(definition)) {
-        refFinder.TraverseDecl(const_cast<clang::FunctionDecl *>(definition));
-        next = const_cast<clang::FunctionDecl *>(definition);
-      }
+    if (clang::Decl *executableDecl = getDeclWithExecutableCode(next)) {
+        refFinder.TraverseDecl(executableDecl);
+        next = executableDecl;
     }
+
+    if (auto var = dyn_cast<clang::VarDecl>(next))
+      if (!var->isFileVarDecl())
+        continue;
+
     ClangCodeGen->HandleTopLevelDecl(clang::DeclGroupRef(next));
   }
 }

lib/IRGen/GenCoverage.cpp

@@ -18,6 +18,7 @@
 #include "IRGenModule.h"
 #include "SwiftTargetInfo.h"
 
+#include "swift/AST/IRGenOptions.h"
 #include "swift/SIL/SILModule.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Module.h"
@@ -60,6 +61,7 @@ void IRGenModule::emitCoverageMapping() {
     if (std::find(Files.begin(), Files.end(), M->getFile()) == Files.end())
       Files.push_back(M->getFile());
 
+  auto remapper = getOptions().CoveragePrefixMap;
   // Awkwardly munge absolute filenames into a vector of StringRefs.
   // TODO: This is heinous - the same thing is happening in clang, but the API
   // really needs to be cleaned up for both.
@@ -68,7 +70,7 @@ void IRGenModule::emitCoverageMapping() {
   for (StringRef Name : Files) {
     llvm::SmallString<256> Path(Name);
     llvm::sys::fs::make_absolute(Path);
-    FilenameStrs.push_back(std::string(Path.begin(), Path.end()));
+    FilenameStrs.push_back(remapper.remapPath(Path));
     FilenameRefs.push_back(FilenameStrs.back());
   }
 

lib/IRGen/GenDecl.cpp

@@ -1104,8 +1104,11 @@ void IRGenerator::emitGlobalTopLevel(llvm::StringSet<> *linkerDirectives) {
     IGM->emitSILDifferentiabilityWitness(&dw);
   }
 
-  // Emit code coverage mapping data.
-  PrimaryIGM->emitCoverageMapping();
+  // Emit code coverage mapping data for all modules
+  for (auto Iter : *this) {
+    IRGenModule *IGM = Iter.second;
+    IGM->emitCoverageMapping();
+  }
 
   for (auto Iter : *this) {
     IRGenModule *IGM = Iter.second;

test/Driver/coverage-prefix-map.swift

@@ -0,0 +1,9 @@
+// RUN: not %target-swiftc_driver -coverage-prefix-map old %s 2>&1 | %FileCheck %s -check-prefix CHECK-INVALID
+// RUN: %target-swiftc_driver -### -coverage-prefix-map old=new %s 2>&1 | %FileCheck %s -check-prefix CHECK-SIMPLE
+// RUN: %target-swiftc_driver -### -coverage-prefix-map old=n=ew %s 2>&1 | %FileCheck %s -check-prefix CHECK-COMPLEX
+// RUN: %target-swiftc_driver -### -coverage-prefix-map old= %s 2>&1 | %FileCheck %s -check-prefix CHECK-EMPTY
+
+// CHECK-INVALID: error: invalid argument 'old' to -coverage-prefix-map
+// CHECK-SIMPLE: coverage-prefix-map old=new
+// CHECK-COMPLEX: coverage-prefix-map old=n=ew
+// CHECK-EMPTY: coverage-prefix-map old=

test/IRGen/Inputs/local_extern.h

@@ -0,0 +1,21 @@
+static inline int _no_prior_var() {
+  extern int var;
+  return var;
+}
+
+static inline int _no_prior_func() {
+  extern int func();
+  return func();
+}
+
+static int prior_var = 1;
+static inline int _prior_var() {
+  extern int prior_var;
+  return prior_var;
+}
+
+static inline int prior_func() { return 1; }
+static inline int _prior_func() {
+  extern int prior_func();
+  return prior_func();
+}

test/IRGen/local_extern.swift

@@ -0,0 +1,10 @@
+// RUN: %target-swift-frontend -import-objc-header %S/Inputs/local_extern.h %s -emit-ir | %FileCheck %s
+// CHECK: @var = external {{(dso_local )?}}global i32
+// CHECK: @prior_var = internal global i32
+// CHECK: declare {{(dso_local )?}}i32 @func
+// CHECK: define internal i32 @prior_func
+
+print("\(_no_prior_var())")
+print("\(_no_prior_func())")
+print("\(_prior_var())")
+print("\(_prior_func())")

test/Interop/C/function/Inputs/emit-called-inline-function.h

@@ -0,0 +1,49 @@
+#ifdef __cplusplus
+#define INLINE inline
+#else
+// When compiling as C, make the functions `static inline`. This is the flavor
+// of inline functions for which we require the behavior checked by this test.
+// Non-static C inline functions don't require Swift to emit LLVM IR for them
+// because the idea is that there will we one `.c` file that declares them
+// `extern inline`, causing an out-of-line definition to be emitted to the
+// corresponding .o file.
+#define INLINE static inline
+#endif
+
+INLINE int notCalled() {
+  return 42;
+}
+
+INLINE int calledTransitively() {
+  return 42;
+}
+
+#ifdef __cplusplus
+class C {
+ public:
+  int memberFunctionCalledTransitively() {
+    return 42;
+  }
+};
+
+inline int calledTransitivelyFromVarInit() {
+  return 42;
+}
+
+inline int varUsedFromSwift = calledTransitivelyFromVarInit();
+#else
+// C only allows constant initializers for variables with static storage
+// duration, so there's no way to initialize this with the result of a call to
+// an inline method. Just provide _some_ definition of `varImportedToSwift` so
+// we can import it in the test.
+static int varUsedFromSwift = 42;
+#endif
+
+INLINE int calledFromSwift() {
+#ifdef __cplusplus
+  C c;
+  return calledTransitively() + c.memberFunctionCalledTransitively();
+#else
+  return calledTransitively();
+#endif
+}

test/Interop/C/function/Inputs/module.modulemap

@@ -0,0 +1,4 @@
+module EmitCalledInlineFunction {
+  header "emit-called-inline-function.h"
+  export *
+}

test/Interop/C/function/emit-called-inline-function-irgen.swift

@@ -0,0 +1,23 @@
+// Test that we emit LLVM IR for inline functions that are called directly or
+// transitively from Swift.
+//
+// Test that we don't emit LLVM IR for inline functions that are not called from
+// Swift.
+
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend %s -I %S/Inputs -Xcc -std=c99 -emit-ir -o - | %FileCheck %s -check-prefix C99 --implicit-check-not notCalled
+// RUN: %target-swift-frontend %s -I %S/Inputs -enable-cxx-interop -emit-ir -o - | %FileCheck %s -check-prefix CXX --implicit-check-not notCalled
+
+import EmitCalledInlineFunction
+
+// C99-DAG: define internal i32 @calledFromSwift()
+// C99-DAG: define internal i32 @calledTransitively()
+
+// CXX-DAG: define linkonce_odr{{( dso_local)?}} i32 @{{_Z15calledFromSwiftv|"\?calledFromSwift@@YAHXZ"}}()
+// CXX-DAG: define linkonce_odr{{( dso_local)?}} i32 @{{_Z18calledTransitivelyv|"\?calledTransitively@@YAHXZ"}}()
+// CXX-DAG: define linkonce_odr{{( dso_local)?}} i32 @{{_ZN1C32memberFunctionCalledTransitivelyEv|"\?memberFunctionCalledTransitively@C@@QEAAHXZ"}}(%class.C* %this)
+// CXX-DAG: define linkonce_odr{{( dso_local)?}} i32 @{{_Z29calledTransitivelyFromVarInitv|"\?calledTransitivelyFromVarInit@@YAHXZ"}}()
+
+calledFromSwift()
+
+let _ = varUsedFromSwift

test/Profiler/Inputs/coverage_num_threads1.swift

@@ -0,0 +1 @@
+func func1() {}

test/Profiler/Inputs/coverage_num_threads2.swift

@@ -0,0 +1 @@
+func func2() {}

test/Profiler/coverage_num_threads.swift

@@ -0,0 +1,13 @@
+// RUN: %target-swift-frontend -profile-generate -profile-coverage-mapping -num-threads 0 -emit-ir %S/Inputs/coverage_num_threads1.swift | %FileCheck %s -check-prefix=SINGLE-SOURCE --implicit-check-not="llvm_coverage_mapping ="
+
+// SINGLE-SOURCE: llvm_coverage_mapping =
+
+// RUN: %target-swift-frontend -profile-generate -profile-coverage-mapping -num-threads 0 -emit-ir %S/Inputs/coverage_num_threads1.swift %S/Inputs/coverage_num_threads2.swift | %FileCheck %s -check-prefix=SINGLE-OBJECT --implicit-check-not="llvm_coverage_mapping ="
+
+// SINGLE-OBJECT: llvm_coverage_mapping =
+
+// Using 1 goes down the multithreaded codepath but only operates with a single thread to work around an issue on Windows where the output of both IR modules is interleaved and therefore the output is invalid
+// RUN: %target-swift-frontend -profile-generate -profile-coverage-mapping -num-threads 1 -emit-ir %S/Inputs/coverage_num_threads1.swift %S/Inputs/coverage_num_threads2.swift | %FileCheck %s -check-prefix=MULTIPLE-OBJECTS --implicit-check-not="llvm_coverage_mapping ="
+
+// MULTIPLE-OBJECTS: llvm_coverage_mapping =
+// MULTIPLE-OBJECTS: llvm_coverage_mapping =

test/Profiler/coverage_relative_path.swift

@@ -0,0 +1,16 @@
+// %s expands to an absolute path, so to test relative paths we need to create a
+// clean directory, put the source there, and cd into it.
+// RUN: rm -rf %t
+// RUN: mkdir -p %t/foo/bar/baz
+// RUN: echo "func coverage() {}" > %t/foo/bar/baz/coverage_relative_path.swift
+// RUN: cd %t/foo/bar
+
+// RUN: %target-swift-frontend -profile-generate -profile-coverage-mapping -Xllvm -enable-name-compression=false -emit-ir %/t/foo/bar/baz/coverage_relative_path.swift | %FileCheck -check-prefix=ABSOLUTE %s
+//
+// ABSOLUTE: @__llvm_coverage_mapping = {{.*"\\01.*foo.*bar.*baz.*coverage_relative_path\.swift}}
+
+// RUN: %target-swift-frontend -profile-generate -profile-coverage-mapping -Xllvm -enable-name-compression=false -coverage-prefix-map %/t/foo/bar=. -emit-ir %/t/foo/bar/baz/coverage_relative_path.swift | %FileCheck -check-prefix=RELATIVE %s
+//
+// RELATIVE: @__llvm_coverage_mapping = {{.*"\\01[^/]*}}.{{/|\\}}baz{{.*coverage_relative_path\.swift}}
+
+func coverage() {}

test/SILGen/Inputs/replace_opaque_type_public_assoc_type_m.swift

@@ -0,0 +1,11 @@
+public protocol Gesture {
+    associatedtype Body: Gesture
+    var body: Body { get }
+
+    associatedtype Value
+    var value: Value { get }
+}
+
+extension Gesture {
+    public var value: Body.Value { return body.value }
+}

test/SILGen/replace_opaque_type_public_assoc_type.swift

@@ -0,0 +1,14 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -disable-availability-checking -emit-module-path %t/replace_opaque_type_public_assoc_type_m.swiftmodule %S/Inputs/replace_opaque_type_public_assoc_type_m.swift
+// RUN: %target-swift-emit-silgen -disable-availability-checking -I %t %s -verify
+
+import replace_opaque_type_public_assoc_type_m
+
+struct PiggyBack: Gesture {
+    var action: () -> Void
+
+    var body: some Gesture {
+        action()
+        return self
+    }
+}

utils/build-presets.ini

@@ -1214,13 +1214,21 @@ compiler-vendor=apple
 
 dash-dash
 
+# Cross compile for Apple Silicon
+cross-compile-hosts=macosx-arm64
+
 lldb-no-debugserver
 lldb-use-system-debugserver
 lldb-build-type=Release
 verbose-build
 build-ninja
 build-swift-stdlib-unittest-extra
 
+# When producing a package, don't copy the Swift Resource/ directory.
+# This is mainly a space optimization.
+extra-cmake-options=
+   -DLLDB_FRAMEWORK_COPY_SWIFT_RESOURCES=0
+
 install-swift
 install-lldb
 install-llbuild