CGExprCXX: emit allocptr attributes for operator delete

[durin42]

Summary

With this change, we're almost ready to drop the entire table out of
MemoryBuiltins.cpp and rely solely on attributes to detect allocator
functions.

[durin42]

I'll hold off on this one until the other LLVM patches are done, then mail out the clang work as its own logical unit.

[durin42]

FYI: this is ready for review.

[jyknight]

clang/lib/CodeGen/CGExprCXX.cpp

1333

Perhaps we should add this attribute to the fn decl and all calls? I think that unlike "alloc-family" in the future patch, this attribute probably doesn't need to be only applied to these "builtin" uses?

clang/lib/CodeGen/CGExprCXX.cpp

RValue RV =
                    Callee, ReturnValueSlot(), Args, &CallOrInvoke);
 
   /// C++1y [expr.new]p10:
   ///   [In a new-expression,] an implementation is allowed to omit a call
   ///   to a replaceable global allocation function.
   ///
   /// We model such elidable calls with the 'builtin' attribute.
   llvm::Function *Fn = dyn_cast<llvm::Function>(CalleePtr);
-  if (CalleeDecl->isReplaceableGlobalAllocationFunction() &&
-      Fn && Fn->hasFnAttribute(llvm::Attribute::NoBuiltin)) {
+  if (CalleeDecl->isReplaceableGlobalAllocationFunction()) {
+    if (Fn && Fn->hasFnAttribute(llvm::Attribute::NoBuiltin)) {
       CallOrInvoke->addFnAttr(llvm::Attribute::Builtin);
     }
 
+    if (CalleeDecl->getOverloadedOperator() == OO_Array_Delete ||
+        CalleeDecl->getOverloadedOperator() == OO_Delete) {
+      CallOrInvoke->addParamAttr(0, llvm::Attribute::AllocatedPointer);
+    }
+  }
+
   return RV;
 }
 
 RValue CodeGenFunction::EmitBuiltinNewDeleteCall(const FunctionProtoType *Type,
                                                  const CallExpr *TheCall,
                                                  bool IsDelete) {
   CallArgList Args;
   EmitCallArgs(Args, Type, TheCall->arguments());

clang/test/CodeGen/pr53127.cpp

 // CHECK-NEXT:    call void @llvm.eh.unwind.init()
 // CHECK-NEXT:    br label [[COND_END23:%.*]]
 // CHECK:       cond.false22:
 // CHECK-NEXT:    br label [[COND_END23]]
 // CHECK:       cond.end23:
 // CHECK-NEXT:    [[CALL24:%.*]] = call noundef zeroext i1 @_Z1ev()
 // CHECK-NEXT:    [[TMP2:%.*]] = zext i1 [[CALL24]] to i64
 // CHECK-NEXT:    [[TMP3:%.*]] = load ptr, ptr [[P_ADDR]], align 8
-// CHECK-NEXT:    call void @_ZdlPv(ptr noundef [[TMP3]]) #[[ATTR8:[0-9]+]]
+// CHECK-NEXT:    call void @_ZdlPv(ptr allocptr noundef [[TMP3]]) #[[ATTR8:[0-9]+]]
 // CHECK-NEXT:    ret void
 //
 void f(int* p, ...)
 {
   e() ? __builtin_trap() : void();
   e() ? __builtin_debugtrap() : void();
   e() ? __builtin_assume(true) : void();
   __builtin_va_list l;
   e() ? __builtin_va_start(l, p) : void();
   __builtin_va_list l2;
   e() ? __builtin_va_copy(l, l2) : void();
   e() ? __builtin_prefetch(p) : void();
   e() ? __builtin_unwind_init() : void();
   e() ? __builtin_operator_delete(p) : void();
 }

clang/test/CodeGenCXX/cxx1y-sized-deallocation.cpp

 template void del<C>();
 template void del<D>();
 template void del<E>();
 template void del<F>();
 
 D::D() {}
 
 // CHECK-LABEL: define weak_odr void @_Z3delIiEvv()
-// CHECK: call void @_ZdlPvm(ptr noundef %{{[^ ]*}}, i64 noundef 4)
-// CHECK: call void @_ZdaPv(ptr noundef %{{[^ ]*}})
+// CHECK: call void @_ZdlPvm(ptr allocptr noundef %{{[^ ]*}}, i64 noundef 4)
+// CHECK: call void @_ZdaPv(ptr allocptr noundef %{{[^ ]*}})
 //
-// CHECK: call void @_ZdlPvm(ptr noundef %{{[^ ]*}}, i64 noundef 4)
-// CHECK: call void @_ZdaPv(ptr noundef %{{[^ ]*}})
+// CHECK: call void @_ZdlPvm(ptr allocptr noundef %{{[^ ]*}}, i64 noundef 4)
+// CHECK: call void @_ZdaPv(ptr allocptr noundef %{{[^ ]*}})
 
 // CHECK-LABEL: declare void @_ZdlPvm(ptr
 
 // CHECK-LABEL: define weak_odr void @_Z3delI1BEvv()
-// CHECK: call void @_ZdlPvm(ptr noundef %{{[^ ]*}}, i64 noundef 4)
-// CHECK: call void @_ZdaPv(ptr noundef %{{[^ ]*}})
+// CHECK: call void @_ZdlPvm(ptr allocptr noundef %{{[^ ]*}}, i64 noundef 4)
+// CHECK: call void @_ZdaPv(ptr allocptr noundef %{{[^ ]*}})
 //
-// CHECK: call void @_ZdlPvm(ptr noundef %{{[^ ]*}}, i64 noundef 4)
-// CHECK: call void @_ZdaPv(ptr noundef %{{[^ ]*}})
+// CHECK: call void @_ZdlPvm(ptr allocptr noundef %{{[^ ]*}}, i64 noundef 4)
+// CHECK: call void @_ZdaPv(ptr allocptr noundef %{{[^ ]*}})
 
 // CHECK-LABEL: define weak_odr void @_Z3delI1CEvv()
-// CHECK: call void @_ZdlPvm(ptr noundef %{{[^ ]*}}, i64 noundef 1)
+// CHECK: call void @_ZdlPvm(ptr allocptr noundef %{{[^ ]*}}, i64 noundef 1)
 // CHECK: mul i64 1, %{{[^ ]*}}
 // CHECK: add i64 %{{[^ ]*}}, 8
-// CHECK: call void @_ZdaPvm(ptr noundef %{{[^ ]*}}, i64 noundef %{{[^ ]*}})
+// CHECK: call void @_ZdaPvm(ptr allocptr noundef %{{[^ ]*}}, i64 noundef %{{[^ ]*}})
 //
-// CHECK: call void @_ZdlPvm(ptr noundef %{{[^ ]*}}, i64 noundef 1)
+// CHECK: call void @_ZdlPvm(ptr allocptr noundef %{{[^ ]*}}, i64 noundef 1)
 // CHECK: mul i64 1, %{{[^ ]*}}
 // CHECK: add i64 %{{[^ ]*}}, 8
-// CHECK: call void @_ZdaPvm(ptr noundef %{{[^ ]*}}, i64 noundef %{{[^ ]*}})
+// CHECK: call void @_ZdaPvm(ptr allocptr noundef %{{[^ ]*}}, i64 noundef %{{[^ ]*}})
 
 // CHECK-LABEL: declare void @_ZdaPvm(ptr
 
 // CHECK-LABEL: define weak_odr void @_Z3delI1DEvv()
-// CHECK: call void @_ZdlPvm(ptr noundef %{{[^ ]*}}, i64 noundef 8)
+// CHECK: call void @_ZdlPvm(ptr allocptr noundef %{{[^ ]*}}, i64 noundef 8)
 // CHECK: mul i64 8, %{{[^ ]*}}
 // CHECK: add i64 %{{[^ ]*}}, 8
-// CHECK: call void @_ZdaPvm(ptr noundef %{{[^ ]*}}, i64 noundef %{{[^ ]*}})
+// CHECK: call void @_ZdaPvm(ptr allocptr noundef %{{[^ ]*}}, i64 noundef %{{[^ ]*}})
 //
 // CHECK-NOT: Zdl
 // CHECK: call void %{{.*}}
 // CHECK-NOT: Zdl
 // CHECK: mul i64 8, %{{[^ ]*}}
 // CHECK: add i64 %{{[^ ]*}}, 8
-// CHECK: call void @_ZdaPvm(ptr noundef %{{[^ ]*}}, i64 noundef %{{[^ ]*}})
+// CHECK: call void @_ZdaPvm(ptr allocptr noundef %{{[^ ]*}}, i64 noundef %{{[^ ]*}})
 
 // CHECK-LABEL: define weak_odr void @_Z3delI1EEvv()
-// CHECK: call void @_ZdlPvm(ptr noundef %{{[^ ]*}}, i64 noundef 1)
-// CHECK: call void @_ZdaPv(ptr noundef %{{[^ ]*}})
+// CHECK: call void @_ZdlPvm(ptr allocptr noundef %{{[^ ]*}}, i64 noundef 1)
+// CHECK: call void @_ZdaPv(ptr allocptr noundef %{{[^ ]*}})
 //
 // CHECK: call void @_ZN1EdlEPv(ptr noundef %{{[^ ]*}})
 // CHECK: call void @_ZN1EdaEPv(ptr noundef %{{[^ ]*}})
 
 // CHECK-LABEL: define weak_odr void @_Z3delI1FEvv()
-// CHECK: call void @_ZdlPvm(ptr noundef %{{[^ ]*}}, i64 noundef 1)
+// CHECK: call void @_ZdlPvm(ptr allocptr noundef %{{[^ ]*}}, i64 noundef 1)
 // CHECK: mul i64 1, %{{[^ ]*}}
 // CHECK: add i64 %{{[^ ]*}}, 8
-// CHECK: call void @_ZdaPvm(ptr noundef %{{[^ ]*}}, i64 noundef %{{[^ ]*}})
+// CHECK: call void @_ZdaPvm(ptr allocptr noundef %{{[^ ]*}}, i64 noundef %{{[^ ]*}})
 //
 // CHECK: call void @_ZN1FdlEPvm(ptr noundef %{{[^ ]*}}, i64 noundef 1)
 // CHECK: mul i64 1, %{{[^ ]*}}
 // CHECK: add i64 %{{[^ ]*}}, 8
 // CHECK: call void @_ZN1FdaEPvm(ptr noundef %{{[^ ]*}}, i64 noundef %{{[^ ]*}})
 
 
 // CHECK-LABEL: define linkonce_odr void @_ZN1DD0Ev(ptr {{[^,]*}} %this)
-// CHECK: call void @_ZdlPvm(ptr noundef %{{[^ ]*}}, i64 noundef 8)
+// CHECK: call void @_ZdlPvm(ptr allocptr noundef %{{[^ ]*}}, i64 noundef 8)

clang/test/CodeGenCXX/cxx1z-aligned-allocation.cpp

 #define OVERALIGNED alignas(__STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2)
 
 // Global new and delete.
 // ======================
 struct OVERALIGNED A { A(); int n[128]; };
 
 // CHECK-LABEL: define {{.*}} @_Z2a0v()
 // CHECK: %[[ALLOC:.*]] = call noalias noundef nonnull align 32 ptr @_ZnwmSt11align_val_t(i64 noundef 512, i64 noundef 32)
-// CHECK: call void @_ZdlPvSt11align_val_t(ptr noundef %[[ALLOC]], i64 noundef 32)
+// CHECK: call void @_ZdlPvSt11align_val_t(ptr allocptr noundef %[[ALLOC]], i64 noundef 32)
 // CHECK-MS-LABEL: define {{.*}} @"?a0@@YAPEAXXZ"()
 // CHECK-MS: %[[ALLOC:.*]] = call noalias noundef nonnull align 32 ptr @"??2@YAPEAX_KW4align_val_t@std@@@Z"(i64 noundef 512, i64 noundef 32)
 // CHECK-MS: cleanuppad
-// CHECK-MS: call void @"??3@YAXPEAXW4align_val_t@std@@@Z"(ptr noundef %[[ALLOC]], i64 noundef 32)
+// CHECK-MS: call void @"??3@YAXPEAXW4align_val_t@std@@@Z"(ptr allocptr noundef %[[ALLOC]], i64 noundef 32)
 void *a0() { return new A; }
 
 // FIXME: Why don't we call the sized array deallocation overload in this case?
 // The size is known.
 //
 // CHECK-LABEL: define {{.*}} @_Z2a1l(
 // CHECK: %[[ALLOC:.*]] = call noalias noundef nonnull align 32 ptr @_ZnamSt11align_val_t(i64 noundef %{{.*}}, i64 noundef 32)
 // No array cookie.
 // CHECK-NOT: store
 // CHECK: invoke void @_ZN1AC1Ev(
-// CHECK: call void @_ZdaPvSt11align_val_t(ptr noundef %[[ALLOC]], i64 noundef 32)
+// CHECK: call void @_ZdaPvSt11align_val_t(ptr allocptr noundef %[[ALLOC]], i64 noundef 32)
 // CHECK-MS-LABEL: define {{.*}} @"?a1@@YAPEAXJ@Z"(
 // CHECK-MS: %[[ALLOC:.*]] = call noalias noundef nonnull align 32 ptr @"??_U@YAPEAX_KW4align_val_t@std@@@Z"(i64 noundef %{{.*}}, i64 noundef 32)
 // No array cookie.
 // CHECK-MS-NOT: store
 // CHECK-MS: invoke noundef ptr @"??0A@@QEAA@XZ"(
 // CHECK-MS: cleanuppad
-// CHECK-MS: call void @"??_V@YAXPEAXW4align_val_t@std@@@Z"(ptr noundef %[[ALLOC]], i64 noundef 32)
+// CHECK-MS: call void @"??_V@YAXPEAXW4align_val_t@std@@@Z"(ptr allocptr noundef %[[ALLOC]], i64 noundef 32)
 void *a1(long n) { return new A[n]; }
 
 // CHECK-LABEL: define {{.*}} @_Z2a2P1A(
-// CHECK: call void @_ZdlPvmSt11align_val_t(ptr noundef %{{.*}}, i64 noundef 512, i64 noundef 32) #9
+// CHECK: call void @_ZdlPvmSt11align_val_t(ptr allocptr noundef %{{.*}}, i64 noundef 512, i64 noundef 32) #9
 void a2(A *p) { delete p; }
 
 // CHECK-LABEL: define {{.*}} @_Z2a3P1A(
-// CHECK: call void @_ZdaPvSt11align_val_t(ptr noundef %{{.*}}, i64 noundef 32) #9
+// CHECK: call void @_ZdaPvSt11align_val_t(ptr allocptr noundef %{{.*}}, i64 noundef 32) #9
 void a3(A *p) { delete[] p; }
 
 
 // Class-specific usual new and delete.
 // ====================================
 struct OVERALIGNED B {
   B();
   // These are just a distraction. We should ignore them.

 
 
 // Calling aligned new with placement syntax.
 // ==========================================
 
 #ifndef UNALIGNED
 // CHECK-LABEL: define {{.*}} @_Z2e0v(
 // CHECK: %[[ALLOC:.*]] = call noalias noundef nonnull align 4 ptr @_ZnwmSt11align_val_t(i64 noundef 512, i64 noundef 4)
-// CHECK: call void @_ZdlPvSt11align_val_t(ptr noundef %[[ALLOC]], i64 noundef 4)
+// CHECK: call void @_ZdlPvSt11align_val_t(ptr allocptr noundef %[[ALLOC]], i64 noundef 4)
 void *e0() { return new (std::align_val_t(4)) A; }
 
 // CHECK-LABEL: define {{.*}} @_Z2e1v(
 // CHECK: %[[ALLOC:.*]] = call noundef ptr @_ZN1BnwEmSt11align_val_t(i64 noundef 512, i64 noundef 4)
 // CHECK: call void @_ZN1BdlEPvSt11align_val_t(ptr noundef %[[ALLOC]], i64 noundef 4)
 void *e1() { return new (std::align_val_t(4)) B; }
 #endif
 

clang/test/CodeGenCXX/delete-two-arg.cpp

namespace test2 {
   void test(A *p) {
     // CHECK:      [[P:%.*]] = alloca ptr, align 4
     // CHECK-NEXT: store ptr {{%.*}}, ptr [[P]], align 4
     // CHECK-NEXT: [[T0:%.*]] = load ptr, ptr [[P]], align 4
     // CHECK-NEXT: [[T1:%.*]] = icmp eq ptr [[T0]], null
     // CHECK-NEXT: br i1 [[T1]],
     // CHECK: [[T3:%.*]] = getelementptr inbounds i8, ptr [[T0]], i32 -4
     // CHECK-NEXT: [[T5:%.*]] = load i32, ptr [[T3]]
-    // CHECK-NEXT: call void @_ZdaPv(ptr noundef [[T3]])
+    // CHECK-NEXT: call void @_ZdaPv(ptr allocptr noundef [[T3]])
     // CHECK-NEXT: br label
     ::delete[] p;
   }
 }
 
 // rdar://problem/8913519
 namespace test3 {
   struct A {

clang/test/CodeGenCXX/delete.cpp

void test(A (*arr)[10][20]) {
     // CHECK:      [[END:%.*]] = getelementptr inbounds [[A]], ptr [[BEGIN]], i64 [[COUNT]]
     // CHECK-NEXT: [[ISEMPTY:%.*]] = icmp eq ptr [[BEGIN]], [[END]]
     // CHECK-NEXT: br i1 [[ISEMPTY]],
     // CHECK:      [[PAST:%.*]] = phi ptr [ [[END]], {{%.*}} ], [ [[CUR:%.*]], {{%.*}} ]
     // CHECK-NEXT: [[CUR:%.*]] = getelementptr inbounds [[A]], ptr [[PAST]], i64 -1
     // CHECK-NEXT: call void @_ZN5test11AD1Ev(ptr {{[^,]*}} [[CUR]])
     // CHECK-NEXT: [[ISDONE:%.*]] = icmp eq ptr [[CUR]], [[BEGIN]]
     // CHECK-NEXT: br i1 [[ISDONE]]
-    // CHECK:      call void @_ZdaPv(ptr noundef [[ALLOC]])
+    // CHECK:      call void @_ZdaPv(ptr allocptr noundef [[ALLOC]])
   }
 }
 
 namespace test2 {
   // CHECK-LABEL: define{{.*}} void @_ZN5test21fEPb
   void f(bool *b) {
     // CHECK: call void @_ZdlPv(ptr
     delete b;
void global_delete_virtual(X *xp) {
     // CHECK-NEXT: [[ALLOCATED:%.*]] = getelementptr inbounds i8, ptr [[XP]], i64 [[OFFSET]]
     //   Load the complete-object destructor (not the deleting destructor)
     //   and call noundef it.
     // CHECK-NEXT: [[VTABLE:%.*]] = load ptr, ptr [[XP:%.*]]
     // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds ptr, ptr [[VTABLE]], i64 0
     // CHECK-NEXT: [[DTOR:%.*]] = load ptr, ptr [[T0]]
     // CHECK-NEXT: call void [[DTOR]](ptr {{[^,]*}} [[OBJ:%.*]])
     //   Call the global operator delete.
-    // CHECK-NEXT: call void @_ZdlPv(ptr noundef [[ALLOCATED]]) [[NUW:#[0-9]+]]
+    // CHECK-NEXT: call void @_ZdlPv(ptr allocptr noundef [[ALLOCATED]]) [[NUW:#[0-9]+]]
     ::delete xp;
   }
 }
 
 namespace test5 {
   struct Incomplete;
   // CHECK-LABEL: define{{.*}} void @_ZN5test523array_delete_incompleteEPNS_10IncompleteES1_
   void array_delete_incomplete(Incomplete *p1, Incomplete *p2) {
     // CHECK: call void @_ZdlPv
     delete p1;
     // CHECK: call void @_ZdaPv
     delete [] p2;
   }
 }
 
 // CHECK: attributes [[NUW]] = {{[{].*}} nounwind {{.*[}]}}

clang/test/CodeGenCXX/exceptions.cpp

 namespace test1 {
   struct A { A(int); A(int, int); ~A(); void *p; };
 
   A *a() {
     // CHECK:    define{{( dso_local)?}} ptr @_ZN5test11aEv()
     // CHECK:      [[NEW:%.*]] = call noalias nonnull ptr @_Znwm(i64 8)
     // CHECK-NEXT: invoke void @_ZN5test11AC1Ei(ptr {{[^,]*}} [[NEW]], i32 5)
     // CHECK:      ret ptr [[NEW]]
-    // CHECK:      call void @_ZdlPv(ptr [[NEW]])
+    // CHECK:      call void @_ZdlPv(ptr allocptr [[NEW]])
     return new A(5);
   }
 
   A *b() {
     // CHECK:    define{{( dso_local)?}} ptr @_ZN5test11bEv()
     // CHECK:      [[NEW:%.*]] = call noalias nonnull ptr @_Znwm(i64 8)
     // CHECK-NEXT: [[FOO:%.*]] = invoke i32 @_ZN5test13fooEv()
     // CHECK:      invoke void @_ZN5test11AC1Ei(ptr {{[^,]*}} [[NEW]], i32 [[FOO]])
     // CHECK:      ret ptr [[NEW]]
-    // CHECK:      call void @_ZdlPv(ptr [[NEW]])
+    // CHECK:      call void @_ZdlPv(ptr allocptr [[NEW]])
     extern int foo();
     return new A(foo());
   }
 
   struct B { B(); ~B(); operator int(); int x; };
   B makeB();
 
   A *c() {
     // CHECK:    define{{( dso_local)?}} ptr @_ZN5test11cEv()
     // CHECK:      [[ACTIVE:%.*]] = alloca i1
     // CHECK-NEXT: [[NEW:%.*]] = call noalias nonnull ptr @_Znwm(i64 8)
     // CHECK-NEXT: store i1 true, ptr [[ACTIVE]]
     // CHECK-NEXT: invoke void @_ZN5test11BC1Ev(ptr {{[^,]*}} [[T0:%.*]])
     // CHECK:      [[T1:%.*]] = getelementptr inbounds [[B:%.*]], ptr [[T0]], i32 0, i32 0
     // CHECK-NEXT: [[T2:%.*]] = load i32, ptr [[T1]], align 4
     // CHECK-NEXT: invoke void @_ZN5test11AC1Ei(ptr {{[^,]*}} [[NEW]], i32 [[T2]])
     // CHECK:      store i1 false, ptr [[ACTIVE]]
 
     // CHECK98-NEXT: invoke void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T0]])
     // CHECK11-NEXT: call void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T0]])
 
     // CHECK:      ret ptr [[NEW]]
     // CHECK:      [[ISACTIVE:%.*]] = load i1, ptr [[ACTIVE]]
     // CHECK-NEXT: br i1 [[ISACTIVE]]
-    // CHECK:      call void @_ZdlPv(ptr [[NEW]])
+    // CHECK:      call void @_ZdlPv(ptr allocptr [[NEW]])
     return new A(B().x);
   }
 
   //   rdar://11904428
   //   Terminate landing pads should call __cxa_begin_catch first.
   // CHECK98:      define linkonce_odr hidden void @__clang_call_terminate(ptr %0) [[NI_NR_NUW:#[0-9]+]] comdat
   // CHECK98-NEXT:   [[T0:%.*]] = call ptr @__cxa_begin_catch(ptr %0) [[NUW:#[0-9]+]]
   // CHECK98-NEXT:   call void @_ZSt9terminatev() [[NR_NUW:#[0-9]+]]
A *d() {
     // CHECK:      store i1 false, ptr [[ACTIVE]]
 
     // CHECK98-NEXT: invoke void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T0]])
     // CHECK11-NEXT: call void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T0]])
 
     // CHECK:      ret ptr [[NEW]]
     // CHECK:      [[ISACTIVE:%.*]] = load i1, ptr [[ACTIVE]]
     // CHECK-NEXT: br i1 [[ISACTIVE]]
-    // CHECK:      call void @_ZdlPv(ptr [[NEW]])
+    // CHECK:      call void @_ZdlPv(ptr allocptr [[NEW]])
     return new A(B());
   }
 
   A *e() {
     // CHECK:    define{{( dso_local)?}} ptr @_ZN5test11eEv()
     // CHECK:      [[ACTIVE:%.*]] = alloca i1
     // CHECK-NEXT: [[NEW:%.*]] = call noalias nonnull ptr @_Znwm(i64 8)
     // CHECK-NEXT: store i1 true, ptr [[ACTIVE]]
     // CHECK-NEXT: invoke void @_ZN5test11BC1Ev(ptr {{[^,]*}} [[T0:%.*]])
     // CHECK:      [[T1:%.*]] = invoke i32 @_ZN5test11BcviEv(ptr {{[^,]*}} [[T0]])
     // CHECK:      invoke void @_ZN5test11BC1Ev(ptr {{[^,]*}} [[T2:%.*]])
     // CHECK:      [[T3:%.*]] = invoke i32 @_ZN5test11BcviEv(ptr {{[^,]*}} [[T2]])
     // CHECK:      invoke void @_ZN5test11AC1Eii(ptr {{[^,]*}} [[NEW]], i32 [[T1]], i32 [[T3]])
     // CHECK:      store i1 false, ptr [[ACTIVE]]
 
     // CHECK98-NEXT: invoke void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T2]])
     // CHECK11-NEXT: call void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T2]])
 
     // CHECK98:      invoke void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T0]])
     // CHECK11:      call void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T0]])
 
     // CHECK:      ret ptr [[NEW]]
     // CHECK:      [[ISACTIVE:%.*]] = load i1, ptr [[ACTIVE]]
     // CHECK-NEXT: br i1 [[ISACTIVE]]
-    // CHECK:      call void @_ZdlPv(ptr [[NEW]])
+    // CHECK:      call void @_ZdlPv(ptr allocptr [[NEW]])
     return new A(B(), B());
   }
   A *f() {
     return new A(makeB().x);
   }
   A *g() {
     return new A(makeB());
   }
A *i() {
     // CHECK11:      call void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T2]])
 
     // CHECK98:      invoke void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T0]])
     // CHECK11:      call void @_ZN5test11BD1Ev(ptr {{[^,]*}} [[T0]])
 
     // CHECK:      ret ptr [[RET]]
     // CHECK:      [[ISACTIVE:%.*]] = load i1, ptr [[ACTIVE]]
     // CHECK-NEXT: br i1 [[ISACTIVE]]
-    // CHECK:      call void @_ZdlPv(ptr [[NEW]])
+    // CHECK:      call void @_ZdlPv(ptr allocptr [[NEW]])
     A *x;
     return (x = new A(makeB()), makeB(), x);
   }
 }
 
 namespace test2 {
   struct A {
     A(int); A(int, int); ~A();
struct A {
     A();
     ~A();
   };
   A* test() {
     return new A[10];
   }
   // CHECK: define{{.*}} ptr @_ZN5test94testEv
   // CHECK: [[TEST9_NEW:%.*]] = call noalias nonnull ptr @_Znam
-  // CHECK: call void @_ZdaPv(ptr [[TEST9_NEW]])
+  // CHECK: call void @_ZdaPv(ptr allocptr [[TEST9_NEW]])
 }
 
 // In a destructor with a function-try-block, a return statement in a
 // catch handler behaves differently from running off the end of the
 // catch handler.  PR13102.
 namespace test10 {
   extern void cleanup();
   extern bool suppress;

clang/test/CodeGenCXX/microsoft-abi-structors.cpp

 // DTORS:        store i32 %should_call_delete, ptr %[[SHOULD_DELETE_VAR:[0-9a-z._]+]], align 4
 // DTORS:        store ptr %{{.*}}, ptr %[[RETVAL:retval]]
 // DTORS:        %[[SHOULD_DELETE_VALUE:[0-9a-z._]+]] = load i32, ptr %[[SHOULD_DELETE_VAR]]
 // DTORS:        call x86_thiscallcc void @"??1C@basic@@UAE@XZ"(ptr {{[^,]*}} %[[THIS:[0-9a-z]+]])
 // DTORS-NEXT:   %[[CONDITION:[0-9]+]] = icmp eq i32 %[[SHOULD_DELETE_VALUE]], 0
 // DTORS-NEXT:   br i1 %[[CONDITION]], label %[[CONTINUE_LABEL:[0-9a-z._]+]], label %[[CALL_DELETE_LABEL:[0-9a-z._]+]]
 //
 // DTORS:      [[CALL_DELETE_LABEL]]
-// DTORS-NEXT:   call void @"??3@YAXPAX@Z"(ptr %[[THIS]])
+// DTORS-NEXT:   call void @"??3@YAXPAX@Z"(ptr allocptr %[[THIS]])
 // DTORS-NEXT:   br label %[[CONTINUE_LABEL]]
 //
 // DTORS:      [[CONTINUE_LABEL]]
 // DTORS-NEXT:   %[[RET:.*]] = load ptr, ptr %[[RETVAL]]
 // DTORS-NEXT:   ret ptr %[[RET]]
 
 // Check that we do the mangling correctly on x64.
 // DTORS-X64:  @"??_GC@basic@@UEAAPEAXI@Z"

 // CHECK:      %[[OBJ_PTR_VALUE:.*]] = load ptr, ptr %{{.*}}, align 4
 // CHECK:      br i1 {{.*}}, label %[[DELETE_NULL:.*]], label %[[DELETE_NOTNULL:.*]]
 
 // CHECK:      [[DELETE_NOTNULL]]
 // CHECK-NEXT:   %[[VTABLE:.*]] = load ptr, ptr %[[OBJ_PTR_VALUE]]
 // CHECK-NEXT:   %[[PVDTOR:.*]] = getelementptr inbounds ptr, ptr %[[VTABLE]], i64 0
 // CHECK-NEXT:   %[[VDTOR:.*]] = load ptr, ptr %[[PVDTOR]]
 // CHECK-NEXT:   %[[CALL:.*]] = call x86_thiscallcc ptr %[[VDTOR]](ptr {{[^,]*}} %[[OBJ_PTR_VALUE]], i32 0)
-// CHECK-NEXT:   call void @"??3@YAXPAX@Z"(ptr %[[CALL]])
+// CHECK-NEXT:   call void @"??3@YAXPAX@Z"(ptr allocptr %[[CALL]])
 // CHECK:      ret void
 }
 
 struct D {
   static int foo();
 
   D() {
     static int ctor_static = foo();