IRGen: initial pass to support async inheritance on Windows

compnerd · compnerd · commit 68bc33fed325 · 2021-11-01T11:23:51.000-07:00
With PE/COFF, one cannot reference a data symbol directly across the binary module boundary. Instead, the reference must be indirected through the Import Address Table (IAT) to allow for position independence. When generating a reference to a AsyncFunctionPointer ({i8*, i32}), we tag the pointer as being indirected by tagging bit 1 (with the assumption that native alignment will ensure 4/8 byte alignment, freeing the bottom 2 bits at least for bit-packing). We tweak the v-table/witness table emission such that all references to the AsyncFunctionPointer are replaced with the linker synthetic import symbol with the bit packing: ~~~ .quad __imp_$s1L1CC1yyYaKFTu+1 ~~~ rather than ~~~ .quad $s1L1CC1yyYaKFTu ~~~ Upon access of the async function pointer reference, we open-code the check for the following: ~~~ pointer = (pointer & 1) ? *(void **)(pointer & ~1) : pointer; ~~~ Thanks to @DougGregor for the discussion and the suggestion for the pointer tagging. Thanks to @aschwaighofer for pointers to the code that I had missed. Also, thanks to @SeanROlszewski for the original code sample that led to the reduced test case. Fixes: SR-15399
diff --git a/include/swift/AST/IRGenOptions.h b/include/swift/AST/IRGenOptions.h
@@ -311,6 +311,7 @@ class IRGenOptions {
   /// Used on Windows to avoid cross-module references.
   unsigned LazyInitializeClassMetadata : 1;
   unsigned LazyInitializeProtocolConformances : 1;
+  unsigned IndirectAsyncFunctionPointer : 1;
 
   /// Normally if the -read-legacy-type-info flag is not specified, we look for
   /// a file named "legacy-<arch>.yaml" in SearchPathOpts.RuntimeLibraryPath.
@@ -417,7 +418,8 @@ class IRGenOptions {
         ValueNames(false), EnableReflectionMetadata(true),
         EnableReflectionNames(true), EnableAnonymousContextMangledNames(false),
         ForcePublicLinkage(false), LazyInitializeClassMetadata(false),
-        LazyInitializeProtocolConformances(false), DisableLegacyTypeInfo(false),
+        LazyInitializeProtocolConformances(false),
+        IndirectAsyncFunctionPointer(false), DisableLegacyTypeInfo(false),
         PrespecializeGenericMetadata(false), UseIncrementalLLVMCodeGen(true),
         UseTypeLayoutValueHandling(true), ForceStructTypeLayouts(false),
         GenerateProfile(false), EnableDynamicReplacementChaining(false),
diff --git a/lib/Frontend/CompilerInvocation.cpp b/lib/Frontend/CompilerInvocation.cpp
@@ -1876,6 +1876,11 @@ static bool ParseIRGenArgs(IRGenOptions &Opts, ArgList &Args,
   // witness.
   Opts.LazyInitializeProtocolConformances = Triple.isOSBinFormatCOFF();
 
+  // PE/COFF cannot deal with the cross-module reference to the
+  // AsyncFunctionPointer data block.  Force the use of indirect
+  // AsyncFunctionPointer access.
+  Opts.IndirectAsyncFunctionPointer = Triple.isOSBinFormatCOFF();
+
   if (Args.hasArg(OPT_disable_legacy_type_info)) {
     Opts.DisableLegacyTypeInfo = true;
   }
diff --git a/lib/IRGen/GenCall.cpp b/lib/IRGen/GenCall.cpp
@@ -1986,6 +1986,46 @@ void IRGenFunction::emitAllExtractValues(llvm::Value *value,
     out.add(Builder.CreateExtractValue(value, i));
 }
 
+namespace {
+// TODO(compnerd) analyze if this should be out-lined via a runtime call rather
+// than be open-coded.  This needs to account for the fact that we are able to
+// statically optimize this often times due to CVP changing the select to a
+// `select i1 true, ...`.
+llvm::Value *emitIndirectAsyncFunctionPointer(IRGenFunction &IGF,
+                                              llvm::Value *pointer) {
+  llvm::IntegerType *IntPtrTy = IGF.IGM.IntPtrTy;
+  llvm::Type *AsyncFunctionPointerPtrTy = IGF.IGM.AsyncFunctionPointerPtrTy;
+  llvm::Constant *Zero =
+      llvm::Constant::getIntegerValue(IntPtrTy, APInt(IntPtrTy->getBitWidth(),
+                                                      0));
+  llvm::Constant *One =
+      llvm::Constant::getIntegerValue(IntPtrTy, APInt(IntPtrTy->getBitWidth(),
+                                                      1));
+  llvm::Constant *NegativeOne =
+      llvm::Constant::getIntegerValue(IntPtrTy, APInt(IntPtrTy->getBitWidth(),
+                                                      -2));
+  swift::irgen::Alignment PointerAlignment = IGF.IGM.getPointerAlignment();
+
+  llvm::Value *PtrToInt = IGF.Builder.CreatePtrToInt(pointer, IntPtrTy);
+  llvm::Value *And = IGF.Builder.CreateAnd(PtrToInt, One);
+  llvm::Value *ICmp = IGF.Builder.CreateICmpEQ(And, Zero);
+
+  llvm::Value *BitCast =
+      IGF.Builder.CreateBitCast(pointer, AsyncFunctionPointerPtrTy);
+
+  llvm::Value *UntaggedPointer = IGF.Builder.CreateAnd(PtrToInt, NegativeOne);
+  llvm::Value *IntToPtr =
+      IGF.Builder.CreateIntToPtr(UntaggedPointer,
+                                 AsyncFunctionPointerPtrTy->getPointerTo());
+  llvm::Value *Load = IGF.Builder.CreateLoad(IntToPtr, PointerAlignment);
+
+  // (select (icmp eq, (and (ptrtoint %AsyncFunctionPointer), 1), 0),
+  //         (%AsyncFunctionPointer),
+  //         (inttoptr (and (ptrtoint %AsyncFunctionPointer), -2)))
+  return IGF.Builder.CreateSelect(ICmp, BitCast, Load);
+}
+}
+
 std::pair<llvm::Value *, llvm::Value *> irgen::getAsyncFunctionAndSize(
     IRGenFunction &IGF, SILFunctionTypeRepresentation representation,
     FunctionPointer functionPointer, llvm::Value *thickContext,
@@ -2007,9 +2047,11 @@ std::pair<llvm::Value *, llvm::Value *> irgen::getAsyncFunctionAndSize(
       if (auto authInfo = functionPointer.getAuthInfo()) {
         ptr = emitPointerAuthAuth(IGF, ptr, authInfo);
       }
-      auto *afpPtr =
-          IGF.Builder.CreateBitCast(ptr, IGF.IGM.AsyncFunctionPointerPtrTy);
-      afpPtrValue = afpPtr;
+      afpPtrValue =
+          (IGF.IGM.getOptions().IndirectAsyncFunctionPointer)
+              ? emitIndirectAsyncFunctionPointer(IGF, ptr)
+              : IGF.Builder.CreateBitCast(ptr,
+                                          IGF.IGM.AsyncFunctionPointerPtrTy);
     }
     return *afpPtrValue;
   };
@@ -4831,6 +4873,8 @@ llvm::Value *FunctionPointer::getPointer(IRGenFunction &IGF) const {
     auto *fnPtr = Value;
     if (auto authInfo = AuthInfo) {
       fnPtr = emitPointerAuthAuth(IGF, fnPtr, authInfo);
+      if (IGF.IGM.getOptions().IndirectAsyncFunctionPointer)
+        fnPtr = emitIndirectAsyncFunctionPointer(IGF, fnPtr);
     }
     auto *descriptorPtr =
         IGF.Builder.CreateBitCast(fnPtr, IGF.IGM.AsyncFunctionPointerPtrTy);
diff --git a/lib/IRGen/GenThunk.cpp b/lib/IRGen/GenThunk.cpp
@@ -344,9 +344,34 @@ void IRGenModule::emitDispatchThunk(SILDeclRef declRef) {
 
 llvm::Constant *
 IRGenModule::getAddrOfAsyncFunctionPointer(LinkEntity entity) {
-  return getAddrOfLLVMVariable(
-    LinkEntity::forAsyncFunctionPointer(entity),
-    NotForDefinition, DebugTypeInfo());
+  llvm::Constant *Pointer =
+      getAddrOfLLVMVariable(LinkEntity::forAsyncFunctionPointer(entity),
+                            NotForDefinition, DebugTypeInfo());
+  if (!getOptions().IndirectAsyncFunctionPointer)
+    return Pointer;
+
+  // When the symbol does not have DLL Import storage, we must directly address
+  // it. Otherwise, we will form an invalid reference.
+  if (!Pointer->isDLLImportDependent())
+    return Pointer;
+
+  llvm::Constant *PointerPointer =
+      getOrCreateGOTEquivalent(Pointer,
+                               LinkEntity::forAsyncFunctionPointer(entity));
+  llvm::Constant *PointerPointerConstant =
+      llvm::ConstantExpr::getPtrToInt(PointerPointer, IntPtrTy);
+  llvm::Constant *Marker =
+      llvm::Constant::getIntegerValue(IntPtrTy, APInt(IntPtrTy->getBitWidth(),
+                                                      1));
+  // TODO(compnerd) ensure that the pointer alignment guarantees that bit-0 is
+  // cleared. We cannot use an `getOr` here as it does not form a relocatable
+  // expression.
+  llvm::Constant *Address =
+      llvm::ConstantExpr::getAdd(PointerPointerConstant, Marker);
+
+  IndirectAsyncFunctionPointers[entity] = Address;
+  return llvm::ConstantExpr::getIntToPtr(Address,
+                                         AsyncFunctionPointerTy->getPointerTo());
 }
 
 llvm::Constant *
@@ -373,6 +398,15 @@ IRGenModule::getSILFunctionForAsyncFunctionPointer(llvm::Constant *afp) {
       return entity.getSILFunction();
     }
   }
+  for (auto &entry : IndirectAsyncFunctionPointers) {
+    if (entry.getSecond() == afp) {
+      auto entity = entry.getFirst();
+      assert(getOptions().IndirectAsyncFunctionPointer &&
+             "indirect async function found for non-indirect async function"
+             " target?");
+      return entity.getSILFunction();
+    }
+  }
   return nullptr;
 }
 
diff --git a/lib/IRGen/IRGenModule.h b/lib/IRGen/IRGenModule.h
@@ -1105,6 +1105,7 @@ class IRGenModule {
                                            LinkEntity entity);
                                            
   llvm::DenseMap<LinkEntity, llvm::Constant*> GlobalVars;
+  llvm::DenseMap<LinkEntity, llvm::Constant*> IndirectAsyncFunctionPointers;
   llvm::DenseMap<LinkEntity, llvm::Constant*> GlobalGOTEquivalents;
   llvm::DenseMap<LinkEntity, llvm::Function*> GlobalFuncs;
   llvm::DenseSet<const clang::Decl *> GlobalClangDecls;
diff --git a/test/IRGen/async-inheritance.swift b/test/IRGen/async-inheritance.swift
@@ -0,0 +1,27 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift-dylib(%t/%target-library-name(L)) -module-name L -emit-module -emit-module-path %t/L.swiftmodule %s -DL
+// RUN: %target-build-swift -I%t -L%t -lL -parse-as-library %s -module-name E -o %t/E %target-rpath(%t)
+// RUN: %target-codesign %t/E
+// RUN: %target-run %t/E %t/%target-library-name(L) | %FileCheck %s
+
+#if L
+open class C {
+  public init() {}
+  open func f() async {
+    print("\(#function)")
+  }
+}
+#else
+import L
+class D: C {
+}
+
+@main
+struct S {
+  public static func main() async {
+    await D().f()
+  }
+}
+#endif
+
+// CHECK: f()
diff --git a/test/IRGen/async/class_resilience.swift b/test/IRGen/async/class_resilience.swift
@@ -1,6 +1,6 @@
 // RUN: %empty-directory(%t)
 // RUN: %target-swift-frontend -emit-module  -disable-availability-checking -enable-library-evolution -emit-module-path=%t/resilient_class.swiftmodule -module-name=resilient_class %S/Inputs/resilient_class.swift
-// RUN: %target-swift-frontend -I %t -emit-ir  -disable-availability-checking -enable-library-evolution %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-%target-cpu %s
+// RUN: %target-swift-frontend -I %t -emit-ir  -disable-availability-checking -enable-library-evolution %s | %FileCheck -check-prefix CHECK -check-prefix CHECK-%target-cpu -check-prefix CHECK-%target-import-type %s
 // REQUIRES: concurrency
 
 import resilient_class
@@ -42,7 +42,11 @@ open class MyBaseClass<T> {
 // CHECK-SAME: %swift.async_func_pointer* @"$s16class_resilience9MyDerivedC4waitSiyYaF010resilient_A09BaseClassCADxyYaFTVTu"
 
 // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swift{{(tail)?}}cc void @"$s16class_resilience14callsAwaitableyx010resilient_A09BaseClassCyxGYalF"(%swift.opaque* noalias nocapture %0, %swift.context* swiftasync %1{{.*}})
-// CHECK: %swift.async_func_pointer* @"$s15resilient_class9BaseClassC4waitxyYaFTjTu"
+// CHECK-DIRECT: %swift.async_func_pointer* @"$s15resilient_class9BaseClassC4waitxyYaFTjTu"
+// CHECK-INDIRECT: [[LOAD:%[0-9]+]] = load %swift.async_func_pointer*, %swift.async_func_pointer** inttoptr (i64 and (i64 add (i64 ptrtoint (%swift.async_func_pointer** @"\01__imp_$s15resilient_class9BaseClassC4waitxyYaFTjTu" to i64), i64 1), i64 -2) to %swift.async_func_pointer**), align {{4|8}}
+// CHECK-INDIRECT-NEXT: %14 = select i1 icmp eq (i64 and (i64 add (i64 ptrtoint (%swift.async_func_pointer** @"\01__imp_$s15resilient_class9BaseClassC4waitxyYaFTjTu" to i64), i64 1), i64 1), i64 0),
+// CHECK-INDIRECT-SAME: %swift.async_func_pointer* inttoptr (i64 add (i64 ptrtoint (%swift.async_func_pointer** @"\01__imp_$s15resilient_class9BaseClassC4waitxyYaFTjTu" to i64), i64 1) to %swift.async_func_pointer*),
+// CHECK-INDIRECT-SAME: %swift.async_func_pointer* [[LOAD]]
 // CHECK: ret void
 public func callsAwaitable<T>(_ c: BaseClass<T>) async -> T {
   return await c.wait()
diff --git a/test/IRGen/async/protocol_resilience.swift b/test/IRGen/async/protocol_resilience.swift
@@ -1,6 +1,6 @@
 // RUN: %empty-directory(%t)
 // RUN: %target-swift-frontend -emit-module  -disable-availability-checking -g -enable-library-evolution -emit-module-path=%t/resilient_protocol.swiftmodule -module-name=resilient_protocol %S/Inputs/resilient_protocol.swift
-// RUN: %target-swift-frontend -I %t -emit-ir  -disable-availability-checking -g -enable-library-evolution %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-%target-cpu %s
+// RUN: %target-swift-frontend -I %t -emit-ir  -disable-availability-checking -g -enable-library-evolution %s | %FileCheck -check-prefix CHECK -check-prefix CHECK-%target-cpu -check-prefix CHECK-%target-import-type %s
 // REQUIRES: concurrency
 
 import resilient_protocol
@@ -27,7 +27,11 @@ public protocol MyAwaitable {
 // CHECK-SAME: %swift.async_func_pointer* @"$s19protocol_resilience19ConformsToAwaitableVyxG010resilient_A00E0AaeFP4wait6ResultQzyYaFTWTu"
 
 // CHECK-LABEL: define {{(dllexport )?}}{{(protected )?}}swift{{(tail)?}}cc void @"$s19protocol_resilience14callsAwaitabley6ResultQzxYa010resilient_A00D0RzlF"(%swift.opaque* noalias nocapture %0, %swift.context* swiftasync %1, %swift.opaque* noalias nocapture %2, %swift.type* %T, i8** %T.Awaitable)
-// CHECK: %swift.async_func_pointer* @"$s18resilient_protocol9AwaitableP4wait6ResultQzyYaFTjTu"
+// CHECK-DIRECT: %swift.async_func_pointer* @"$s18resilient_protocol9AwaitableP4wait6ResultQzyYaFTjTu"
+// CHECK-INDIRECT: [[LOAD:%[0-9]+]] = load %swift.async_func_pointer*, %swift.async_func_pointer** inttoptr (i64 and (i64 add (i64 ptrtoint (%swift.async_func_pointer** @"\01__imp_$s18resilient_protocol9AwaitableP4wait6ResultQzyYaFTjTu" to i64), i64 1), i64 -2) to %swift.async_func_pointer**), align {{4|8}}
+// CHECK-INDIRECT: select i1 icmp eq (i64 and (i64 add (i64 ptrtoint (%swift.async_func_pointer** @"\01__imp_$s18resilient_protocol9AwaitableP4wait6ResultQzyYaFTjTu" to i64), i64 1), i64 1), i64 0),
+// CHECK-INDIRECT-SAME: %swift.async_func_pointer* inttoptr (i64 add (i64 ptrtoint (%swift.async_func_pointer** @"\01__imp_$s18resilient_protocol9AwaitableP4wait6ResultQzyYaFTjTu" to i64), i64 1) to %swift.async_func_pointer*),
+// CHECK-INDIRECT-SAME: %swift.async_func_pointer* [[LOAD]]
 // CHECK: ret void
 public func callsAwaitable<T : Awaitable>(_ t: T) async -> T.Result {
   return await t.wait()
diff --git a/test/IRGen/async/run-call-nonresilient-classinstance-void-to-void.swift b/test/IRGen/async/run-call-nonresilient-classinstance-void-to-void.swift
@@ -11,7 +11,6 @@
 // REQUIRES: concurrency
 // REQUIRES: concurrency_runtime
 // UNSUPPORTED: back_deployment_runtime
-// XFAIL: windows
 
 import _Concurrency
 import NonresilientClass
