Coroutines: avoid use of deprecated CreateLoad and CreateCall methods

[nhaehnle]

Summary

Patch originally by Tim Northover

[modocache]

This seems like a straightforward improvement to me (assuming all the tests still pass of course). Thanks for cleaning this up!

llvm/lib/Transforms/Coroutines/CoroEarly.cpp

void Lowerer::lowerCoroDone(IntrinsicInst *II) {
   // ResumeFnAddr is the first pointer sized element of the coroutine frame.
   static_assert(coro::Shape::SwitchFieldIndex::Resume == 0,
                 "resume function not at offset zero");
   auto *FrameTy = Int8Ptr;
   PointerType *FramePtrTy = FrameTy->getPointerTo();
 
   Builder.SetInsertPoint(II);
   auto *BCI = Builder.CreateBitCast(Operand, FramePtrTy);
-  auto *Load = Builder.CreateLoad(BCI);
+  auto *Load = Builder.CreateLoad(FrameTy, BCI);
   auto *Cond = Builder.CreateICmpEQ(Load, NullPtr);
 
   II->replaceAllUsesWith(Cond);
   II->eraseFromParent();
 }
 
 void Lowerer::lowerCoroNoop(IntrinsicInst *II) {
   if (!NoopCoro) {

llvm/lib/Transforms/Coroutines/CoroFrame.cpp

if (MightNeedToCopy) {
     for (auto &P : Allocas) {
       AllocaInst *const A = P.first;
       if (mightWriteIntoAllocaPtr(*A, DT, *CB)) {
         if (A->isArrayAllocation())
           report_fatal_error(
               "Coroutines cannot handle copying of array allocas yet");
 
         auto *G = GetFramePointer(P.second, A);
-        auto *Value = Builder.CreateLoad(A);
+        auto *Value = Builder.CreateLoad(A->getAllocatedType(), A);
         Builder.CreateStore(Value, G);
       }
     }
   }
   return FramePtr;
 }
 
 // Sets the unwind edge of an instruction to a particular successor.

 
 /// Get the current swifterror value.
 static Value *emitGetSwiftErrorValue(IRBuilder<> &Builder, Type *ValueTy,
                                      coro::Shape &Shape) {
   // Make a fake function pointer as a sort of intrinsic.
   auto FnTy = FunctionType::get(ValueTy, {}, false);
   auto Fn = ConstantPointerNull::get(FnTy->getPointerTo());
 
-  auto Call = Builder.CreateCall(Fn, {});
+  auto Call = Builder.CreateCall(FnTy, Fn, {});
   Shape.SwiftErrorOps.push_back(Call);
 
   return Call;
 }
 
 /// Set the given value as the current swifterror value.
 ///
 /// Returns a slot that can be used as a swifterror slot.
 static Value *emitSetSwiftErrorValue(IRBuilder<> &Builder, Value *V,
                                      coro::Shape &Shape) {
   // Make a fake function pointer as a sort of intrinsic.
   auto FnTy = FunctionType::get(V->getType()->getPointerTo(),
                                 {V->getType()}, false);
   auto Fn = ConstantPointerNull::get(FnTy->getPointerTo());
 
-  auto Call = Builder.CreateCall(Fn, { V });
+  auto Call = Builder.CreateCall(FnTy, Fn, { V });
   Shape.SwiftErrorOps.push_back(Call);
 
   return Call;
 }
 
 /// Set the swifterror value from the given alloca before a call,
 /// then put in back in the alloca afterwards.
 ///

llvm/lib/Transforms/Coroutines/CoroSplit.cpp

case coro::ABI::RetconOnce: {
 
     // If the storage is inline, just bitcast to the storage to the frame type.
     if (Shape.RetconLowering.IsFrameInlineInStorage)
       return Builder.CreateBitCast(NewStorage, FramePtrTy);
 
     // Otherwise, load the real frame from the opaque storage.
     auto FramePtrPtr =
       Builder.CreateBitCast(NewStorage, FramePtrTy->getPointerTo());
-    return Builder.CreateLoad(FramePtrPtr);
+    return Builder.CreateLoad(FramePtrTy, FramePtrPtr);
   }
   }
   llvm_unreachable("bad ABI");
 }
 
 /// Clone the body of the original function into a resume function of
 /// some sort.
 void CoroCloner::create() {