[NFC][Clang][OpaquePtr] Remove calls to Address::deprecated in CGBlocks.cpp

[rjmccall]

LGTM

clang/lib/CodeGen/CGBlocks.cpp

Address CodeGenFunction::GetAddrOfBlockDecl(const VarDecl *variable) {
   Address addr = Builder.CreateStructGEP(LoadBlockStruct(), capture.getIndex(),
                                          "block.capture.addr");
 
   if (variable->isEscapingByref()) {
     // addr should be a void** right now.  Load, then cast the result
     // to byref*.
 
     auto &byrefInfo = getBlockByrefInfo(variable);
-    addr =
-        Address::deprecated(Builder.CreateLoad(addr), byrefInfo.ByrefAlignment);
+    addr = Address(Builder.CreateLoad(addr), Int8Ty, byrefInfo.ByrefAlignment);
 
     addr = Builder.CreateElementBitCast(addr, byrefInfo.Type, "byref.addr");
 
     addr = emitBlockByrefAddress(addr, byrefInfo, /*follow*/ true,
                                  variable->getName());
   }
 
   assert((!variable->isNonEscapingByref() ||
BlockPointer = Builder.CreatePointerCast(
               ? getContext().getTargetAddressSpace(LangAS::opencl_generic)
               : 0),
       "block");
 }
 
 Address CodeGenFunction::LoadBlockStruct() {
   assert(BlockInfo && "not in a block invocation function!");
   assert(BlockPointer && "no block pointer set!");
-  return Address::deprecated(BlockPointer, BlockInfo->BlockAlign);
+  return Address(BlockPointer, BlockInfo->StructureType, BlockInfo->BlockAlign);
 }
 
 llvm::Function *CodeGenFunction::GenerateBlockFunction(
     GlobalDecl GD, const CGBlockInfo &blockInfo, const DeclMapTy &ldm,
     bool IsLambdaConversionToBlock, bool BuildGlobalBlock) {
   const BlockDecl *blockDecl = blockInfo.getBlockDecl();
 
   CurGD = GD;
CodeGenFunction::GenerateCopyHelperFunction(const CGBlockInfo &blockInfo) {
   ArgTys.push_back(C.VoidPtrTy);
 
   setBlockHelperAttributesVisibility(blockInfo.CapturesNonExternalType, Fn, FI,
                                      CGM);
   StartFunction(GlobalDecl(), ReturnTy, Fn, FI, args);
   auto AL = ApplyDebugLocation::CreateArtificial(*this);
 
   Address src = GetAddrOfLocalVar(&SrcDecl);
-  src = Address::deprecated(Builder.CreateLoad(src), blockInfo.BlockAlign);
+  src = Address(Builder.CreateLoad(src), Int8Ty, blockInfo.BlockAlign);
   src = Builder.CreateElementBitCast(src, blockInfo.StructureType,
                                      "block.source");
 
   Address dst = GetAddrOfLocalVar(&DstDecl);
-  dst = Address::deprecated(Builder.CreateLoad(dst), blockInfo.BlockAlign);
+  dst = Address(Builder.CreateLoad(dst), Int8Ty, blockInfo.BlockAlign);
   dst =
       Builder.CreateElementBitCast(dst, blockInfo.StructureType, "block.dest");
 
   for (auto &capture : blockInfo.SortedCaptures) {
     if (capture.isConstantOrTrivial())
       continue;
 
     const BlockDecl::Capture &CI = *capture.Cap;
CodeGenFunction::GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo) {
   setBlockHelperAttributesVisibility(blockInfo.CapturesNonExternalType, Fn, FI,
                                      CGM);
   StartFunction(GlobalDecl(), ReturnTy, Fn, FI, args);
   markAsIgnoreThreadCheckingAtRuntime(Fn);
 
   auto AL = ApplyDebugLocation::CreateArtificial(*this);
 
   Address src = GetAddrOfLocalVar(&SrcDecl);
-  src = Address::deprecated(Builder.CreateLoad(src), blockInfo.BlockAlign);
+  src = Address(Builder.CreateLoad(src), Int8Ty, blockInfo.BlockAlign);
   src = Builder.CreateElementBitCast(src, blockInfo.StructureType, "block");
 
   CodeGenFunction::RunCleanupsScope cleanups(*this);
 
   for (auto &capture : blockInfo.SortedCaptures) {
     if (capture.isConstantOrTrivial())
       continue;
 
generateByrefCopyHelper(CodeGenFunction &CGF, const BlockByrefInfo &byrefInfo,
 
   CGF.StartFunction(GlobalDecl(), ReturnTy, Fn, FI, args);
     // Create a scope with an artificial location for the body of this function.
   auto AL = ApplyDebugLocation::CreateArtificial(CGF);
 
   if (generator.needsCopy()) {
     // dst->x
     Address destField = CGF.GetAddrOfLocalVar(&Dst);
-    destField = Address::deprecated(CGF.Builder.CreateLoad(destField),
-                                    byrefInfo.ByrefAlignment);
+    destField = Address(CGF.Builder.CreateLoad(destField), CGF.Int8Ty,
     destField = CGF.Builder.CreateElementBitCast(destField, byrefInfo.Type);
     destField =
         CGF.emitBlockByrefAddress(destField, byrefInfo, false, "dest-object");
 
     // src->x
     Address srcField = CGF.GetAddrOfLocalVar(&Src);
-    srcField = Address::deprecated(CGF.Builder.CreateLoad(srcField),
-                                   byrefInfo.ByrefAlignment);
+    srcField = Address(CGF.Builder.CreateLoad(srcField), CGF.Int8Ty,
     srcField = CGF.Builder.CreateElementBitCast(srcField, byrefInfo.Type);
     srcField =
         CGF.emitBlockByrefAddress(srcField, byrefInfo, false, "src-object");
 
     generator.emitCopy(CGF, destField, srcField);
   }
 
   CGF.FinishFunction();
generateByrefDisposeHelper(CodeGenFunction &CGF,
   CGF.CGM.SetInternalFunctionAttributes(GlobalDecl(), Fn, FI);
 
   CGF.StartFunction(GlobalDecl(), R, Fn, FI, args);
     // Create a scope with an artificial location for the body of this function.
   auto AL = ApplyDebugLocation::CreateArtificial(CGF);
 
   if (generator.needsDispose()) {
     Address addr = CGF.GetAddrOfLocalVar(&Src);
-    addr = Address::deprecated(CGF.Builder.CreateLoad(addr),
-                               byrefInfo.ByrefAlignment);
+    addr = Address(CGF.Builder.CreateLoad(addr), CGF.Int8Ty,
     addr = CGF.Builder.CreateElementBitCast(addr, byrefInfo.Type);
     addr = CGF.emitBlockByrefAddress(addr, byrefInfo, false, "object");
 
     generator.emitDispose(CGF, addr);
   }
 
   CGF.FinishFunction();
 

 
 Address CodeGenFunction::emitBlockByrefAddress(Address baseAddr,
                                                const BlockByrefInfo &info,
                                                bool followForward,
                                                const llvm::Twine &name) {
   // Chase the forwarding address if requested.
   if (followForward) {
     Address forwardingAddr = Builder.CreateStructGEP(baseAddr, 1, "forwarding");
-    baseAddr = Address::deprecated(Builder.CreateLoad(forwardingAddr),
-                                   info.ByrefAlignment);
+    baseAddr = Address(Builder.CreateLoad(forwardingAddr), info.Type,
   }
 
   return Builder.CreateStructGEP(baseAddr, info.FieldIndex, name);
 }
 
 /// BuildByrefInfo - This routine changes a __block variable declared as T x
 ///   into:
 ///