IRGen: More fixes for LLVM's opaque pointers

lib/IRGen/Callee.h

@@ -317,6 +317,7 @@ namespace irgen {
     // If this is an await function pointer contains the signature of the await
     // call (without return values).
     llvm::Type *awaitSignature = nullptr;
+    bool useSignature = false;
 
     explicit FunctionPointer(Kind kind, llvm::Value *value,
                              const Signature &signature)
@@ -364,14 +365,28 @@ namespace irgen {
     }
 
     static FunctionPointer createSigned(Kind kind, llvm::Value *value,
+                                        PointerAuthInfo authInfo,
+                                        const Signature &signature,
+                                        bool useSignature = false) {
+      auto res = FunctionPointer(kind, value, authInfo, signature);
+      res.useSignature = useSignature;
+      return res;
+    }
+    static FunctionPointer createSignedClosure(Kind kind, llvm::Value *value,
                                         PointerAuthInfo authInfo,
                                         const Signature &signature) {
-      return FunctionPointer(kind, value, authInfo, signature);
+      auto res = FunctionPointer(kind, value, authInfo, signature);
+      res.useSignature = true;
+      return res;
     }
 
+
     static FunctionPointer createUnsigned(Kind kind, llvm::Value *value,
-                                          const Signature &signature) {
-      return FunctionPointer(kind, value, signature);
+                                          const Signature &signature,
+                                          bool useSignature = false) {
+      auto res = FunctionPointer(kind, value, signature);
+      res.useSignature = useSignature;
+      return res;
     }
 
     static FunctionPointer forDirect(IRGenModule &IGM, llvm::Constant *value,
@@ -380,9 +395,12 @@ namespace irgen {
 
     static FunctionPointer forDirect(Kind kind, llvm::Constant *value,
                                      llvm::Constant *secondaryValue,
-                                     const Signature &signature) {
-      return FunctionPointer(kind, value, secondaryValue, PointerAuthInfo(),
+                                     const Signature &signature,
+                                     bool useSignature = false) {
+      auto res = FunctionPointer(kind, value, secondaryValue, PointerAuthInfo(),
                              signature);
+      res.useSignature = useSignature;
+      return res;
     }
 
     static FunctionPointer forExplosionValue(IRGenFunction &IGF,

lib/IRGen/GenCall.cpp

@@ -5014,13 +5014,13 @@ Callee irgen::getBlockPointerCallee(IRGenFunction &IGF,
 
 Callee irgen::getSwiftFunctionPointerCallee(
     IRGenFunction &IGF, llvm::Value *fnPtr, llvm::Value *dataPtr,
-    CalleeInfo &&calleeInfo, bool castOpaqueToRefcountedContext) {
+    CalleeInfo &&calleeInfo, bool castOpaqueToRefcountedContext, bool isClosure) {
   auto sig = emitCastOfFunctionPointer(IGF, fnPtr, calleeInfo.OrigFnType);
   auto authInfo =
     PointerAuthInfo::forFunctionPointer(IGF.IGM, calleeInfo.OrigFnType);
 
-  auto fn = FunctionPointer::createSigned(calleeInfo.OrigFnType, fnPtr,
-                                          authInfo, sig);
+  auto fn = isClosure ? FunctionPointer::createSignedClosure(calleeInfo.OrigFnType, fnPtr, authInfo, sig) :
+    FunctionPointer::createSigned(calleeInfo.OrigFnType, fnPtr, authInfo, sig);
   if (castOpaqueToRefcountedContext) {
     assert(dataPtr && dataPtr->getType() == IGF.IGM.OpaquePtrTy &&
            "Expecting trivial closure context");
@@ -5054,11 +5054,18 @@ StringRef FunctionPointer::getName(IRGenModule &IGM) const {
   switch (getBasicKind()) {
   case BasicKind::Function:
     return getRawPointer()->getName();
-  case BasicKind::AsyncFunctionPointer:
+  case BasicKind::AsyncFunctionPointer: {
+    auto *asyncFnPtr = getDirectPointer();
+    // Handle windows style async function pointers.
+    if (auto *ce = dyn_cast<llvm::ConstantExpr>(asyncFnPtr)) {
+      if (ce->getOpcode() == llvm::Instruction::IntToPtr) {
+        asyncFnPtr = cast<llvm::Constant>(asyncFnPtr->getOperand(0));
+      }
+    }
+    asyncFnPtr = cast<llvm::Constant>(asyncFnPtr->stripPointerCasts());
     return IGM
-        .getSILFunctionForAsyncFunctionPointer(
-            cast<llvm::Constant>(getDirectPointer()->getOperand(0)))
-        ->getName();
+        .getSILFunctionForAsyncFunctionPointer(asyncFnPtr)->getName();
+  }
   }
   llvm_unreachable("unhandled case");
 }
@@ -5341,6 +5348,13 @@ void irgen::forwardAsyncCallResult(IRGenFunction &IGF,
 }
 
 llvm::FunctionType *FunctionPointer::getFunctionType() const {
+  // Static async function pointers can read the type off the secondary value
+  // (the function definition.
+  if (SecondaryValue) {
+    assert(kind == FunctionPointer::Kind::AsyncFunctionPointer);
+    return cast<llvm::Function>(SecondaryValue)->getFunctionType();
+  }
+
   // Read the function type off the global or else from the Signature.
   if (auto *constant = dyn_cast<llvm::Constant>(Value)) {
     auto *gv = dyn_cast<llvm::GlobalValue>(Value);
@@ -5349,6 +5363,15 @@ llvm::FunctionType *FunctionPointer::getFunctionType() const {
                  ->isOpaqueOrPointeeTypeMatches(Sig.getType()));
       return Sig.getType();
     }
+
+    if (useSignature) { // Because of various casting (e.g thin_to_thick) the
+                      // signature of the function Value might mismatch
+                      // (e.g no context argument).
+      assert(llvm::cast<llvm::PointerType>(Value->getType())
+                 ->isOpaqueOrPointeeTypeMatches(Sig.getType()));
+      return Sig.getType();
+    }
+
     assert(llvm::cast<llvm::PointerType>(Value->getType())
                ->isOpaqueOrPointeeTypeMatches(gv->getValueType()));
     return cast<llvm::FunctionType>(gv->getValueType());

lib/IRGen/GenCall.h

@@ -198,7 +198,8 @@ namespace irgen {
                                        llvm::Value *fnPtr,
                                        llvm::Value *contextPtr,
                                        CalleeInfo &&info,
-                                       bool castOpaqueToRefcountedContext);
+                                       bool castOpaqueToRefcountedContext,
+                                       bool isClosure);
 
   Address emitAllocYieldOnceCoroutineBuffer(IRGenFunction &IGF);
   void emitDeallocYieldOnceCoroutineBuffer(IRGenFunction &IGF, Address buffer);

lib/IRGen/GenClass.cpp

@@ -2798,7 +2798,7 @@ FunctionPointer irgen::emitVirtualMethodValue(IRGenFunction &IGF,
     auto authInfo =
       PointerAuthInfo::emit(IGF, schema, slot.getAddress(), method);
     return FunctionPointer::createSigned(methodType, fnPtr, authInfo,
-                                         signature);
+                                         signature, true);
   }
   case ClassMetadataLayout::MethodInfo::Kind::DirectImpl: {
     auto fnPtr = llvm::ConstantExpr::getBitCast(methodInfo.getDirectImpl(),
@@ -2811,7 +2811,7 @@ FunctionPointer irgen::emitVirtualMethodValue(IRGenFunction &IGF,
           IGF.IGM.getAddrOfSILFunction(silFn, NotForDefinition));
     }
     return FunctionPointer::forDirect(methodType, fnPtr, secondaryValue,
-                                      signature);
+                                      signature, true);
   }
   }
   llvm_unreachable("covered switch");

lib/IRGen/GenEnum.cpp

@@ -183,7 +183,7 @@ unsigned EnumImplStrategy::getPayloadSizeForMetadata() const {
   llvm_unreachable("don't need payload size for this enum kind");
 }
 
-llvm::Value *EnumImplStrategy::
+LoadedRef EnumImplStrategy::
 loadRefcountedPtr(IRGenFunction &IGF, SourceLoc loc, Address addr) const {
   IGF.IGM.error(loc, "Can only load from an address of an optional "
                 "reference.");
@@ -2803,13 +2803,11 @@ namespace {
       }
     }
 
-    llvm::Value *loadRefcountedPtr(IRGenFunction &IGF, SourceLoc loc,
+    LoadedRef loadRefcountedPtr(IRGenFunction &IGF, SourceLoc loc,
                                    Address addr) const override {
       // There is no need to bitcast from the enum address. Loading from the
       // reference type emits a bitcast to the proper reference type first.
-      return getLoadablePayloadTypeInfo()
-        .loadRefcountedPtr(IGF, loc, addr)
-        .getValue();
+      return getLoadablePayloadTypeInfo().loadRefcountedPtr(IGF, loc, addr);
     }
   private:
     llvm::ConstantInt *getZeroExtraTagConstant(IRGenModule &IGM) const {

lib/IRGen/GenEnum.h

@@ -14,6 +14,7 @@
 #define SWIFT_IRGEN_GENENUM_H
 
 #include "TypeInfo.h"
+#include "LoadableTypeInfo.h"
 
 namespace llvm {
   class BasicBlock;
@@ -441,8 +442,8 @@ class EnumImplStrategy {
   virtual bool needsPayloadSizeInMetadata() const = 0;
   virtual unsigned getPayloadSizeForMetadata() const;
 
-  virtual llvm::Value *loadRefcountedPtr(IRGenFunction &IGF, SourceLoc loc,
-                                         Address addr) const;
+  virtual LoadedRef loadRefcountedPtr(IRGenFunction &IGF, SourceLoc loc,
+                                      Address addr) const;
 
   void callOutlinedCopy(IRGenFunction &IGF, Address dest, Address src,
                         SILType T, IsInitialization_t isInit,

lib/IRGen/GenExistential.cpp

@@ -1266,7 +1266,7 @@ class ClassExistentialTypeInfo final
   LoadedRef loadRefcountedPtr(IRGenFunction &IGF, SourceLoc loc,
                               Address existential) const override {
     Address valueAddr = projectValue(IGF, existential);
-    return LoadedRef(IGF.emitLoadRefcountedPtr(valueAddr, Refcounting), true);
+    return LoadedRef(IGF.emitLoadRefcountedPtr(valueAddr, Refcounting), true, Refcounting);
   }
 
   llvm::StructType *buildReferenceStorageType(IRGenModule &IGM,

lib/IRGen/GenHeap.cpp

@@ -1345,17 +1345,31 @@ llvm::Value *IRGenFunction::emitLoadRefcountedPtr(Address addr,
 }
 
 llvm::Value *IRGenFunction::
-emitIsUniqueCall(llvm::Value *value, SourceLoc loc, bool isNonNull) {
+emitIsUniqueCall(llvm::Value *value, ReferenceCounting style, SourceLoc loc, bool isNonNull) {
   FunctionPointer fn;
   bool nonObjC = !IGM.getAvailabilityContext().isContainedIn(
       IGM.Context.getObjCIsUniquelyReferencedAvailability());
-
-  if (value->getType() == IGM.RefCountedPtrTy) {
+  switch (style) {
+  case ReferenceCounting::Native: {
     if (isNonNull)
       fn = IGM.getIsUniquelyReferenced_nonNull_nativeFunctionPointer();
     else
       fn = IGM.getIsUniquelyReferenced_nativeFunctionPointer();
-  } else if (value->getType() == IGM.UnknownRefCountedPtrTy) {
+  }
+  break;
+  case ReferenceCounting::Bridge: {
+    if (!isNonNull)
+      unimplemented(loc, "optional bridge ref");
+
+    if (nonObjC)
+      fn =
+          IGM.getIsUniquelyReferencedNonObjC_nonNull_bridgeObjectFunctionPointer();
+    else
+      fn = IGM.getIsUniquelyReferenced_nonNull_bridgeObjectFunctionPointer();
+  }
+  break;
+  case ReferenceCounting::ObjC:
+  case ReferenceCounting::Unknown: {
     if (nonObjC) {
       if (isNonNull)
         fn = IGM.getIsUniquelyReferencedNonObjC_nonNullFunctionPointer();
@@ -1367,18 +1381,15 @@ emitIsUniqueCall(llvm::Value *value, SourceLoc loc, bool isNonNull) {
       else
         fn = IGM.getIsUniquelyReferencedFunctionPointer();
     }
-  } else if (value->getType() == IGM.BridgeObjectPtrTy) {
-    if (!isNonNull)
-      unimplemented(loc, "optional bridge ref");
-
-    if (nonObjC)
-      fn =
-          IGM.getIsUniquelyReferencedNonObjC_nonNull_bridgeObjectFunctionPointer();
-    else
-      fn = IGM.getIsUniquelyReferenced_nonNull_bridgeObjectFunctionPointer();
-  } else {
+  }
+  break;
+  case ReferenceCounting::Error:
+  case ReferenceCounting::Block:
+  case ReferenceCounting::Custom:
+  case ReferenceCounting::None:
     llvm_unreachable("Unexpected LLVM type for a refcounted pointer.");
   }
+
   llvm::CallInst *call = Builder.CreateCall(fn, value);
   call->setDoesNotThrow();
   return call;

lib/IRGen/GenObjC.cpp

@@ -664,7 +664,8 @@ Callee irgen::getObjCMethodCallee(IRGenFunction &IGF,
 
   auto fn =
       FunctionPointer::forDirect(FunctionPointer::Kind::Function, messenger,
-                                 /*secondaryValue*/ nullptr, sig);
+                                 /*secondaryValue*/ nullptr, sig,
+                                 /*useSignature*/ true);
   return Callee(std::move(info), fn, receiverValue, selectorValue);
 }
 

lib/IRGen/GenStruct.cpp

@@ -480,10 +480,12 @@ namespace {
       clangFnAddr = emitCXXConstructorThunkIfNeeded(
           IGF.IGM, signature, copyConstructor, name, clangFnAddr);
       callee = cast<llvm::Function>(clangFnAddr);
-      dest = IGF.coerceValue(dest, callee->getFunctionType()->getParamType(0),
-                             IGF.IGM.DataLayout);
-      src = IGF.coerceValue(src, callee->getFunctionType()->getParamType(1),
-                            IGF.IGM.DataLayout);
+      if (IGF.IGM.getLLVMContext().supportsTypedPointers()) {
+        dest = IGF.coerceValue(dest, callee->getFunctionType()->getParamType(0),
+                               IGF.IGM.DataLayout);
+        src = IGF.coerceValue(src, callee->getFunctionType()->getParamType(1),
+                              IGF.IGM.DataLayout);
+      }
       IGF.Builder.CreateCall(callee->getFunctionType(), callee, {dest, src});
     }
 
@@ -532,9 +534,11 @@ namespace {
               destructorGlobalDecl, NotForDefinition));
 
       SmallVector<llvm::Value *, 2> args;
-      auto *thisArg = IGF.coerceValue(address.getAddress(),
-                                      destructorFnAddr->getArg(0)->getType(),
-                                      IGF.IGM.DataLayout);
+      auto *thisArg = address.getAddress();
+      if (IGF.IGM.getLLVMContext().supportsTypedPointers())
+        thisArg = IGF.coerceValue(address.getAddress(),
+                                  destructorFnAddr->getArg(0)->getType(),
+                                  IGF.IGM.DataLayout);
       args.push_back(thisArg);
       llvm::Value *implicitParam =
           clang::CodeGen::getCXXDestructorImplicitParam(

lib/IRGen/HeapTypeInfo.h

@@ -234,9 +234,10 @@ class HeapTypeInfo
 
   LoadedRef loadRefcountedPtr(IRGenFunction &IGF, SourceLoc loc,
                               Address addr) const override {
+    auto style = asDerived().getReferenceCounting();
     llvm::Value *ptr =
-      IGF.emitLoadRefcountedPtr(addr, asDerived().getReferenceCounting());
-    return LoadedRef(ptr, true);
+      IGF.emitLoadRefcountedPtr(addr, style);
+    return LoadedRef(ptr, true, style);
   }
 
   ReferenceCounting getReferenceCountingType() const override {

lib/IRGen/IRGenFunction.h

@@ -522,8 +522,8 @@ class IRGenFunction {
   void emitErrorStrongRetain(llvm::Value *value);
   void emitErrorStrongRelease(llvm::Value *value);
 
-  llvm::Value *emitIsUniqueCall(llvm::Value *value, SourceLoc loc,
-                                bool isNonNull);
+  llvm::Value *emitIsUniqueCall(llvm::Value *value, ReferenceCounting style,
+                                SourceLoc loc, bool isNonNull);
 
   llvm::Value *emitIsEscapingClosureCall(llvm::Value *value, SourceLoc loc,
                                          unsigned verificationType);