IRGen: More refactoring in preparation for emitting async function pointers for dispatch thunks

include/swift/IRGen/Linking.h

@@ -130,8 +130,8 @@ class LinkEntity {
     /// is a ConstructorDecl* inside a class.
     DispatchThunkInitializer,
 
-    /// A method dispatch thunk for an allocating constructor.  The pointer is a
+    /// A method dispatch thunk for an allocating constructor.  The pointer is
-    /// ConstructorDecl* inside a protocol or a class.
+    /// a ConstructorDecl* inside a protocol or a class.
     DispatchThunkAllocator,
 
     /// A method descriptor.  The pointer is a FuncDecl* inside a protocol
@@ -295,7 +295,7 @@ class LinkEntity {
 
     /// The same as AsyncFunctionPointer but with a different stored value, for
     /// use by TBDGen.
-    /// The pointer is a AbstractStorageDecl*.
+    /// The pointer is an AbstractFunctionDecl*.
     AsyncFunctionPointerAST,
 
     /// The pointer is a SILFunction*.
@@ -861,7 +861,8 @@ public:
   }
 
   static LinkEntity
-  forSILFunction(SILFunction *F, bool IsDynamicallyReplaceableImplementation) {
+  forSILFunction(SILFunction *F,
+                 bool IsDynamicallyReplaceableImplementation=false) {
     LinkEntity entity;
     entity.Pointer = F;
     entity.SecondaryPointer = nullptr;
@@ -1100,12 +1101,21 @@ public:
     return entity;
   }
 
-  static LinkEntity forAsyncFunctionPointer(SILFunction *silFunction) {
+  static LinkEntity forAsyncFunctionPointer(LinkEntity other) {
     LinkEntity entity;
-    entity.Pointer = silFunction;
+
-    entity.SecondaryPointer = nullptr;
+    switch (other.getKind()) {
-    entity.Data = LINKENTITY_SET_FIELD(
+    case LinkEntity::Kind::SILFunction:
-        Kind, unsigned(LinkEntity::Kind::AsyncFunctionPointer));
+      entity.Pointer = other.getSILFunction();
+      entity.SecondaryPointer = nullptr;
+      entity.Data = LINKENTITY_SET_FIELD(
+          Kind, unsigned(LinkEntity::Kind::AsyncFunctionPointer));
+      break;
+
+    default:
+      llvm_unreachable("Link entity kind cannot have an async function pointer");
+    }
+
     return entity;
   }
 

lib/IRGen/Callee.h

@@ -174,8 +174,8 @@ namespace irgen {
 
     // Temporary only!
     explicit FunctionPointer(KindTy kind, llvm::Value *value,
-                             const Signature &signature, bool
+                             const Signature &signature,
-                             isWithoutCtxt = false)
+                             bool isWithoutCtxt = false)
         : FunctionPointer(kind, value, PointerAuthInfo(), signature, isWithoutCtxt) {}
 
     static FunctionPointer forDirect(IRGenModule &IGM,

lib/IRGen/GenKeyPath.cpp

@@ -920,7 +920,7 @@ emitKeyPathComponent(IRGenModule &IGM,
       idKind = KeyPathComponentHeader::Pointer;
       // FIXME: Does this need to be signed?
       auto idRef = IGM.getAddrOfLLVMVariableOrGOTEquivalent(
-        LinkEntity::forSILFunction(id.getFunction(), false));
+        LinkEntity::forSILFunction(id.getFunction()));
       
       idValue = idRef.getValue();
       // If we got an indirect reference, we'll need to resolve it at

lib/IRGen/GenMeta.cpp

@@ -5353,14 +5353,14 @@ bool irgen::methodRequiresReifiedVTableEntry(IRGenModule &IGM,
 }
 
 llvm::GlobalValue *irgen::emitAsyncFunctionPointer(IRGenModule &IGM,
-                                                   SILFunction *function,
+                                                   llvm::Function *function,
+                                                   LinkEntity entity,
                                                    Size size) {
   ConstantInitBuilder initBuilder(IGM);
   ConstantStructBuilder builder(
       initBuilder.beginStruct(IGM.AsyncFunctionPointerTy));
-  builder.addRelativeAddress(
+  builder.addRelativeAddress(function);
-      IGM.getAddrOfSILFunction(function, NotForDefinition));
   builder.addInt32(size.getValue());
   return cast<llvm::GlobalValue>(IGM.defineAsyncFunctionPointer(
-      function, builder.finishAndCreateFuture()));
+      entity, builder.finishAndCreateFuture()));
 }

lib/IRGen/GenMeta.h

@@ -47,6 +47,7 @@ namespace irgen {
   class Size;
   class StructLayout;
   class ClassLayout;
+  class LinkEntity;
 
   bool requiresForeignTypeMetadata(CanType type);
   bool requiresForeignTypeMetadata(NominalTypeDecl *decl);
@@ -183,7 +184,9 @@ namespace irgen {
                                           ArrayRef<Requirement> requirements);
 
   llvm::GlobalValue *emitAsyncFunctionPointer(IRGenModule &IGM,
-                                              SILFunction *function, Size size);
+                                              llvm::Function *function,
+                                              LinkEntity entity,
+                                              Size size);
 } // end namespace irgen
 } // end namespace swift
 

lib/IRGen/GenThunk.cpp

@@ -165,15 +165,16 @@ void IRGenModule::emitDispatchThunk(SILDeclRef declRef) {
 llvm::Constant *
 IRGenModule::getAddrOfAsyncFunctionPointer(SILFunction *function) {
   (void)getAddrOfSILFunction(function, NotForDefinition);
-  auto entity = LinkEntity::forAsyncFunctionPointer(function);
+  auto entity = LinkEntity::forAsyncFunctionPointer(
+      LinkEntity::forSILFunction(function));
   return getAddrOfLLVMVariable(entity, NotForDefinition, DebugTypeInfo());
 }
 
-llvm::Constant *IRGenModule::defineAsyncFunctionPointer(SILFunction *function,
+llvm::Constant *IRGenModule::defineAsyncFunctionPointer(LinkEntity entity,
                                                         ConstantInit init) {
-  auto entity = LinkEntity::forAsyncFunctionPointer(function);
+  auto asyncEntity = LinkEntity::forAsyncFunctionPointer(entity);
   auto *var = cast<llvm::GlobalVariable>(
-      getAddrOfLLVMVariable(entity, init, DebugTypeInfo()));
+      getAddrOfLLVMVariable(asyncEntity, init, DebugTypeInfo()));
   setTrueConstGlobal(var);
   return var;
 }

lib/IRGen/IRGenModule.h

@@ -1397,7 +1397,7 @@ public:
   llvm::Constant *getOpaquePtr(llvm::Constant *pointer);
 
   llvm::Constant *getAddrOfAsyncFunctionPointer(SILFunction *function);
-  llvm::Constant *defineAsyncFunctionPointer(SILFunction *function,
+  llvm::Constant *defineAsyncFunctionPointer(LinkEntity entity,
                                              ConstantInit init);
   SILFunction *getSILFunctionForAsyncFunctionPointer(llvm::Constant *afp);
 

lib/IRGen/IRGenSIL.cpp

@@ -26,6 +26,7 @@
 #include "swift/Basic/ExternalUnion.h"
 #include "swift/Basic/Range.h"
 #include "swift/Basic/STLExtras.h"
+#include "swift/IRGen/Linking.h"
 #include "swift/SIL/ApplySite.h"
 #include "swift/SIL/Dominance.h"
 #include "swift/SIL/InstructionUtils.h"
@@ -1943,9 +1944,12 @@ void IRGenSILFunction::emitSILFunction() {
     IGM.IRGen.addDynamicReplacement(CurSILFn);
 
   auto funcTy = CurSILFn->getLoweredFunctionType();
-  if (funcTy->isAsync() && funcTy->getLanguage() == SILFunctionLanguage::Swift)
+  if (funcTy->isAsync() && funcTy->getLanguage() == SILFunctionLanguage::Swift) {
-    emitAsyncFunctionPointer(IGM, CurSILFn,
+    emitAsyncFunctionPointer(IGM,
+                             CurFn,
+                             LinkEntity::forSILFunction(CurSILFn),
                              getAsyncContextLayout(*this).getSize());
+  }
 
   // Configure the dominance resolver.
   // TODO: consider re-using a dom analysis from the PassManager
@@ -2278,14 +2282,14 @@ void IRGenSILFunction::visitFunctionRefBaseInst(FunctionRefBaseInst *i) {
   auto *fnPtr = IGM.getAddrOfSILFunction(
       fn, NotForDefinition, false /*isDynamicallyReplaceableImplementation*/,
       isa<PreviousDynamicFunctionRefInst>(i));
-  llvm::Value *value;
+  llvm::Constant *value;
   auto isSpecialAsyncWithoutCtxtSize =
       fn->isAsync() && (
           fn->getName().equals("swift_task_future_wait") ||
           fn->getName().equals("swift_task_group_wait_next"));
   if (fn->isAsync() && !isSpecialAsyncWithoutCtxtSize) {
     value = IGM.getAddrOfAsyncFunctionPointer(fn);
-    value = Builder.CreateBitCast(value, fnPtr->getType());
+    value = llvm::ConstantExpr::getBitCast(value, fnPtr->getType());
   } else {
     value = fnPtr;
   }