[NFC] Destructure AsyncFunctionPointer in getAsyncFunctionAndSize.

In irgen::getAsyncFunctionAndSize, an AsyncFunctionPointer is
destructured into one or both of (1) the underlying function pointer and
(2) the async context size.

Previously, the underlying function pointer was obtained via calling
FunctionPointer::getPointer, which function did the work of casting the
function pointer to an AsyncFunctionPointer, loading the relative
function address from it, and using that relative address to obtain the
function pointer.  The size, then, if it was also obtained, was obtained
by again casting the function pointer to an AsyncFunctionPointer and
loading a field from it.

To avoid this repetition, here, the relevant portion of the body of
FunctionPointer::getPointer is inlined.  Now only a single cast to
AsyncFunctionPointerPtrTy is required and one or both fields can be
loaded from it.

The real benefit of this change is as follows: when these function
pointers are authenticated as is required to dereference it on arm64e,
the authentication will only need to be performed once rather than once
for the function pointer and once for the size.

Author: nate-chandler

lib/IRGen/GenCall.cpp

@@ -1941,16 +1941,19 @@ std::pair<llvm::Value *, llvm::Value *> irgen::getAsyncFunctionAndSize(
     SmallVector<std::pair<llvm::BasicBlock *, llvm::Value *>, 2> sizePhiValues;
     { // thin
       IGF.Builder.emitBlock(thinBlock);
+      auto *ptr = functionPointer.getRawPointer();
+      auto *afpPtr =
+          IGF.Builder.CreateBitCast(ptr, IGF.IGM.AsyncFunctionPointerPtrTy);
       if (emitFunction) {
-        auto *uncastFnPtr = functionPointer.getPointer(IGF);
+        llvm::Value *addrPtr = IGF.Builder.CreateStructGEP(afpPtr, 0);
+        auto *uncastFnPtr = IGF.emitLoadOfRelativePointer(
+            Address(addrPtr, IGF.IGM.getPointerAlignment()), /*isFar*/ false,
+            /*expectedType*/ functionPointer.getFunctionType()->getPointerTo());
         auto *fnPtr = IGF.Builder.CreateBitCast(uncastFnPtr, IGF.IGM.Int8PtrTy);
         fnPhiValues.push_back({thinBlock, fnPtr});
       }
       if (emitSize) {
-        auto *ptr = functionPointer.getRawPointer();
-        auto *descriptorPtr =
-            IGF.Builder.CreateBitCast(ptr, IGF.IGM.AsyncFunctionPointerPtrTy);
-        auto *sizePtr = IGF.Builder.CreateStructGEP(descriptorPtr, 1);
+        auto *sizePtr = IGF.Builder.CreateStructGEP(afpPtr, 1);
         auto *size =
             IGF.Builder.CreateLoad(sizePtr, IGF.IGM.getPointerAlignment());
         sizePhiValues.push_back({thinBlock, size});
@@ -2026,20 +2029,23 @@ std::pair<llvm::Value *, llvm::Value *> irgen::getAsyncFunctionAndSize(
   case SILFunctionTypeRepresentation::WitnessMethod:
   case SILFunctionTypeRepresentation::Closure:
   case SILFunctionTypeRepresentation::Block: {
+    auto *ptr = functionPointer.getRawPointer();
+    auto *afpPtr =
+        IGF.Builder.CreateBitCast(ptr, IGF.IGM.AsyncFunctionPointerPtrTy);
     llvm::Value *fn = nullptr;
     if (emitFunction) {
-      fn = functionPointer.getPointer(IGF);
+      llvm::Value *addrPtr = IGF.Builder.CreateStructGEP(afpPtr, 0);
+      fn = IGF.emitLoadOfRelativePointer(
+          Address(addrPtr, IGF.IGM.getPointerAlignment()), /*isFar*/ false,
+          /*expectedType*/ functionPointer.getFunctionType()->getPointerTo());
     }
     llvm::Value *size = nullptr;
     if (emitSize) {
       if (functionPointer.useStaticContextSize()) {
         size = llvm::ConstantInt::get(IGF.IGM.Int32Ty,
                                       initialContextSize.getValue());
       }  else {
-        auto *ptr = functionPointer.getRawPointer();
-        auto *descriptorPtr =
-            IGF.Builder.CreateBitCast(ptr, IGF.IGM.AsyncFunctionPointerPtrTy);
-        auto *sizePtr = IGF.Builder.CreateStructGEP(descriptorPtr, 1);
+        auto *sizePtr = IGF.Builder.CreateStructGEP(afpPtr, 1);
         size = IGF.Builder.CreateLoad(sizePtr, IGF.IGM.getPointerAlignment());
       }
     }