[Clang] Don't add `undef` for `operator new` under -fno-exceptions.

[DianQK]

Summary

Background: Committing patch D144319 resulted in a runtime error in the UB for libcxx.

The current implementation of operator new under -fno-exceptions returns nullptr. This is undefined behavior. D150610 may take longer to complete.
Removing the undef attribute may be a solution without changing libcxx.

I also tried other things like making -fno-exceptions implicit -fcheck-new. Removing nonnull can have a lot of unintended impacts, such as impacting Clang's static analysis. I gave up on a similar approach.

[nikic]

Removing noundef makes no sense to me, because the return value is noundef even under fno-exceptions. If we remove something, it should be the nonnull attribute, because that's what's actually being violated.

@ldionne Can you give us an ETA on D150610 please? Do we need to introduce a workaround for this libcxx bug in clang, or do you plan to fix this in the near future?

[DianQK]

In D157227#4564817, @nikic wrote:

Removing noundef makes no sense to me, because the return value is noundef even under fno-exceptions. If we remove something, it should be the nonnull attribute, because that's what's actually being violated.

Return null on nonnull is poison. So I can also think that the noundef attribute is violated. I think the reason for keeping nonnull is to match the semantics of operator new. But that probably doesn't make sense either.

[ldionne]

In D157227#4564817, @nikic wrote:

Removing noundef makes no sense to me, because the return value is noundef even under fno-exceptions. If we remove something, it should be the nonnull attribute, because that's what's actually being violated.

@ldionne Can you give us an ETA on D150610 please? Do we need to introduce a workaround for this libcxx bug in clang, or do you plan to fix this in the near future?

I'll try to do this for LLVM 18, sorry that's just a complicated change. I would recommend not working around this in Clang.

[DianQK]

Track this issue at https://github.com/llvm/llvm-project/issues/60717.

clang/include/clang/Basic/Attr.td

 }
 
 def ReturnsNonNull : InheritableAttr {
   let Spellings = [GCC<"returns_nonnull">];
   let Subjects = SubjectList<[ObjCMethod, Function]>;
   let Documentation = [ReturnsNonNullDocs];
 }
 
+def ReturnsMaybeUndef : InheritableAttr {
+  let Spellings = [];
+  let Subjects = SubjectList<[Function]>;
+  let Documentation = [InternalOnly];
+}
+
 def CalledOnce : Attr {
   let Spellings = [Clang<"called_once">];
   let Subjects = SubjectList<[ParmVar]>;
   let LangOpts = [ObjC];
   let Documentation = [CalledOnceDocs];
 }
 
 // pass_object_size(N) indicates that the parameter should have

clang/lib/CodeGen/CGCall.cpp

void CodeGenModule::ConstructAttributeList(StringRef Name,
   ClangToLLVMArgMapping IRFunctionArgs(getContext(), FI);
 
   QualType RetTy = FI.getReturnType();
   const ABIArgInfo &RetAI = FI.getReturnInfo();
   const llvm::DataLayout &DL = getDataLayout();
 
   // Determine if the return type could be partially undef
   if (CodeGenOpts.EnableNoundefAttrs &&
-      HasStrictReturn(*this, RetTy, TargetDecl)) {
+      HasStrictReturn(*this, RetTy, TargetDecl) &&
+      (!TargetDecl || !TargetDecl->hasAttr<ReturnsMaybeUndefAttr>())) {
     if (!RetTy->isVoidType() && RetAI.getKind() != ABIArgInfo::Indirect &&
         DetermineNoUndef(RetTy, getTypes(), DL, RetAI))
       RetAttrs.addAttribute(llvm::Attribute::NoUndef);
   }
 
   switch (RetAI.getKind()) {
   case ABIArgInfo::Extend:
     if (RetAI.isSignExt())

clang/lib/Sema/SemaDecl.cpp

void Sema::AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(
   //   An allocation function that has a non-throwing exception specification
   //   indicates failure by returning a null pointer value. Any other allocation
   //   function never returns a null pointer value and indicates failure only by
   //   throwing an exception [...]
   //
   // However, -fcheck-new invalidates this possible assumption, so don't add
   // NonNull when that is enabled.
   if (!IsNothrow && !FD->hasAttr<ReturnsNonNullAttr>() &&
-      !getLangOpts().CheckNew)
+      !getLangOpts().CheckNew) {
     FD->addAttr(ReturnsNonNullAttr::CreateImplicit(Context, FD->getLocation()));
+    // FIXME: The current implementation of `operator new` under -fno-exceptions
+    // invalidates this possible assumption. Add ReturnsMaybeUndefAttr to
+    // preserve the never return null semantics of `operator new`. This ensures
+    // that when `operator new` returns null, it is poison and not UB.
+    if (!getLangOpts().CXXExceptions)
+      FD->addAttr(
+          ReturnsMaybeUndefAttr::CreateImplicit(Context, FD->getLocation()));
+  }
 
   // C++2a [basic.stc.dynamic.allocation]p2:
   //   An allocation function attempts to allocate the requested amount of
   //   storage. [...] If the request succeeds, the value returned by a
   //   replaceable allocation function is a [...] pointer value p0 different
   //   from any previously returned value p1 [...]
   //
   // However, this particular information is being added in codegen,

clang/lib/Sema/SemaExprCXX.cpp

FunctionDecl *Alloc = FunctionDecl::Create(
         Context, GlobalCtx, SourceLocation(), SourceLocation(), Name, FnType,
         /*TInfo=*/nullptr, SC_None, getCurFPFeatures().isFPConstrained(), false,
         true);
     Alloc->setImplicit();
     // Global allocation functions should always be visible.
     Alloc->setVisibleDespiteOwningModule();
 
     if (HasBadAllocExceptionSpec && getLangOpts().NewInfallible &&
-        !getLangOpts().CheckNew)
+        !getLangOpts().CheckNew) {
       Alloc->addAttr(
           ReturnsNonNullAttr::CreateImplicit(Context, Alloc->getLocation()));
+      if (!getLangOpts().CXXExceptions)
+        Alloc->addAttr(ReturnsMaybeUndefAttr::CreateImplicit(
+            Context, Alloc->getLocation()));
+    }
 
     // C++ [basic.stc.dynamic.general]p2:
     //   The library provides default definitions for the global allocation
     //   and deallocation functions. Some global allocation and deallocation
     //   functions are replaceable ([new.delete]); these are attached to the
     //   global module ([module.unit]).
     //
     // In the language wording, these functions are attched to the global

clang/test/CodeGen/noundef-analysis.cpp

 // RUN: %clang_cc1 -triple arm64-darwin -enable-noundef-analysis -emit-llvm -o - %s | FileCheck %s -check-prefix ENABLED
+// RUN: %clang_cc1 -triple arm64-darwin -fcxx-exceptions -enable-noundef-analysis -emit-llvm -o - %s | FileCheck %s -check-prefix ENABLED-EXCEPTIONS
 // RUN: %clang_cc1 -triple arm64-darwin -no-enable-noundef-analysis -emit-llvm -o - %s | FileCheck %s -check-prefix DISABLED
 
 union u1 {
   int val;
 };
 
 struct s1 {
   int val;
 };
 
 int indirect_callee_int(int a) { return a; }
 union u1 indirect_callee_union(union u1 a) {
   return a;
 }
 
 static int sink;
 
 static void examineValue(int x) { sink = x; }
 
 // ENABLED-LABEL: @main(
 // ENABLED:    [[CALL:%.*]] = call noundef {{.*}}i32 @_Z19indirect_callee_inti(i32 noundef {{.*}}0)
 // ENABLED:    [[CALL1:%.*]] = call i32 @_Z21indirect_callee_union2u1(i64 {{.*}})
-// ENABLED:    [[CALL2:%.*]] = call noalias noundef nonnull ptr @_Znwm(i64 noundef 4) #[[ATTR4:[0-9]+]]
+// ENABLED:    [[CALL2:%.*]] = call noalias nonnull ptr @_Znwm(i64 noundef 4) #[[ATTR4:[0-9]+]]
 // ENABLED:    call void @_ZL12examineValuei(i32 noundef {{.*}})
+// ENABLED-EXCEPTIONS-LABEL: @main(
+// ENABLED-EXCEPTIONS:    [[CALL:%.*]] = call noundef {{.*}}i32 @_Z19indirect_callee_inti(i32 noundef {{.*}}0)
+// ENABLED-EXCEPTIONS:    [[CALL1:%.*]] = call i32 @_Z21indirect_callee_union2u1(i64 {{.*}})
+// ENABLED-EXCEPTIONS:    [[CALL2:%.*]] = call noalias noundef nonnull ptr @_Znwm(i64 noundef 4) #[[ATTR4:[0-9]+]]
+// ENABLED-EXCEPTIONS:    call void @_ZL12examineValuei(i32 noundef {{.*}})
 // DISABLED-LABEL: @main(
 // DISABLED:    [[CALL:%.*]] = call {{.*}}i32 @_Z19indirect_callee_inti(i32 {{.*}}0)
 // DISABLED:    [[CALL1:%.*]] = call i32 @_Z21indirect_callee_union2u1(i64 {{.*}})
 // DISABLED:    [[CALL2:%.*]] = call noalias nonnull ptr @_Znwm(i64 4) #[[ATTR4:[0-9]+]]
 // DISABLED:    call void @_ZL12examineValuei(i32 {{.*}})
 int main() {
   indirect_callee_int(0);
   indirect_callee_union((union u1){0});
 
   auto s = new s1;
   examineValue(s->val);
 
   return 0;
 }

clang/test/CodeGenCXX/aix-alignment.cpp

 // REQUIRES: powerpc-registered-target
 // RUN: %clang_cc1 -triple powerpc-unknown-aix \
 // RUN:     -emit-llvm -o - -x c++ %s | \
 // RUN:   FileCheck %s --check-prefixes=AIX,AIX32
 // RUN: %clang_cc1 -triple powerpc64-unknown-aix \
 // RUN:     -emit-llvm -o - %s -x c++| \
 // RUN:   FileCheck %s --check-prefixes=AIX,AIX64
 
 struct B {
   double d;
   ~B() {}
 };
 
-// AIX32: %call = call noalias noundef nonnull ptr @_Znam(i32 noundef 8)
-// AIX64: %call = call noalias noundef nonnull ptr @_Znam(i64 noundef 8)
+// AIX32: %call = call noalias nonnull ptr @_Znam(i32 noundef 8)
+// AIX64: %call = call noalias nonnull ptr @_Znam(i64 noundef 8)
 B *allocBp() { return new B[0]; }
 
 // AIX-LABEL: delete.notnull:
 // AIX32: %0 = getelementptr inbounds i8, ptr %call, i32 -8
 // AIX32: [[PTR:%.+]] = getelementptr inbounds i8, ptr %0, i32 4
 // AIX64: [[PTR:%.+]] = getelementptr inbounds i8, ptr %call, i64 -8
 // AIX:   %{{.+}} = load i{{[0-9]+}}, ptr [[PTR]]
 void bar() { delete[] allocBp(); }

clang/test/CodeGenCXX/align-avx-complete-objects.cpp

 {
        volatile AVX2Float *p = new AVX2Float;
         *p = *p;
         AVX2Float r = *p;
         return r[0];
 }
 
 // CHECK: [[R:%.*]] = alloca <8 x float>, align 32
-// PRE17-NEXT:  [[CALL:%.*]] = call noalias noundef nonnull ptr @_Znwm(i64 noundef 32)
-// CXX17-NEXT:  [[CALL:%.*]] = call noalias noundef nonnull align 32 ptr @_ZnwmSt11align_val_t(i64 noundef 32, i64 noundef 32)
+// PRE17-NEXT:  [[CALL:%.*]] = call noalias nonnull ptr @_Znwm(i64 noundef 32)
+// CXX17-NEXT:  [[CALL:%.*]] = call noalias nonnull align 32 ptr @_ZnwmSt11align_val_t(i64 noundef 32, i64 noundef 32)
 // CHECK-NEXT:  store ptr [[CALL]], ptr [[P:%.*]], align 8
 // CHECK-NEXT:  [[ONE:%.*]] = load ptr, ptr [[P]], align 8
 // CHECK-NEXT:  [[TWO:%.*]] = load volatile <8 x float>, ptr [[ONE]], align 16
 // CHECK-NEXT:  [[THREE:%.*]] = load ptr, ptr [[P]], align 8
 // CHECK-NEXT:  store volatile <8 x float> [[TWO]], ptr [[THREE]], align 16
 // CHECK-NEXT:  [[FOUR:%.*]] = load ptr, ptr [[P]], align 8
 // CHECK-NEXT:  [[FIVE:%.*]] = load volatile <8 x float>, ptr [[FOUR]], align 16
 // CHECK-NEXT:  store <8 x float> [[FIVE]], ptr [[R]], align 32

 {
        volatile AVX2Float_use_existing_align *p = new AVX2Float_use_existing_align;
         *p = *p;
         AVX2Float_use_existing_align r = *p;
         return r[0];
 }
 
 // CHECK: [[R:%.*]] = alloca <8 x float>, align 32
-// PRE17-NEXT:  [[CALL:%.*]] = call noalias noundef nonnull ptr @_Znwm(i64 noundef 32)
-// CXX17-NEXT:  [[CALL:%.*]] = call noalias noundef nonnull align 32 ptr @_ZnwmSt11align_val_t(i64 noundef 32, i64 noundef 32)
+// PRE17-NEXT:  [[CALL:%.*]] = call noalias nonnull ptr @_Znwm(i64 noundef 32)
+// CXX17-NEXT:  [[CALL:%.*]] = call noalias nonnull align 32 ptr @_ZnwmSt11align_val_t(i64 noundef 32, i64 noundef 32)
 // CHECK-NEXT:  store ptr [[CALL]], ptr [[P:%.*]], align 8
 // CHECK-NEXT:  [[ONE:%.*]] = load ptr, ptr [[P]], align 8
 // CHECK-NEXT:  [[TWO:%.*]] = load volatile <8 x float>, ptr [[ONE]], align 32
 // CHECK-NEXT:  [[THREE:%.*]] = load ptr, ptr [[P]], align 8
 // CHECK-NEXT:  store volatile <8 x float> [[TWO]], ptr [[THREE]], align 32
 // CHECK-NEXT:  [[FOUR:%.*]] = load ptr, ptr [[P]], align 8
 // CHECK-NEXT:  [[FIVE:%.*]] = load volatile <8 x float>, ptr [[FOUR]], align 32
 // CHECK-NEXT:  store <8 x float> [[FIVE]], ptr [[R]], align 32
 // CHECK-NEXT:  [[SIX:%.*]] = load <8 x float>, ptr [[R]], align 32
 // CHECK-NEXT:  [[VECEXT:%.*]] = extractelement <8 x float> [[SIX]], i32 0
 // CHECK-NEXT:  ret float [[VECEXT]]

clang/test/CodeGenCXX/builtin-calling-conv.cpp

 void user() {
   int i;
   ::operator new(5);
   (void)__builtin_atan2f(1.1, 2.2);
   foo();
 }
 
 // LINUX: define{{.*}} void @_Z4userv()
-// LINUX: call noalias noundef nonnull ptr @_Znwm
+// LINUX: call noalias nonnull ptr @_Znwm
 // LINUX: call float @atan2f
 // LINUX: call void @_Z3foov
-// LINUX: declare noundef nonnull ptr @_Znwm(i64 noundef)
+// LINUX: declare nonnull ptr @_Znwm(i64 noundef)
 // LINUX: declare float @atan2f(float noundef, float noundef)
 // LINUX: declare void @_Z3foov()
 
 // SPIR: define{{.*}} spir_func void @_Z4userv()
-// SPIR: call spir_func noalias noundef nonnull ptr @_Znwj
+// SPIR: call spir_func noalias nonnull ptr @_Znwj
 // SPIR: call spir_func float @atan2f
 // SPIR: call spir_func void @_Z3foov
-// SPIR: declare spir_func noundef nonnull ptr @_Znwj(i32 noundef)
+// SPIR: declare spir_func nonnull ptr @_Znwj(i32 noundef)
 // SPIR: declare spir_func float @atan2f(float noundef, float noundef)
 // SPIR: declare spir_func void @_Z3foov()
 
 // Note: Windows /G options should not change the platform default calling
 // convention of builtins.
 // WIN32: define dso_local x86_stdcallcc void @"?user@@YGXXZ"()
-// WIN32: call noalias noundef nonnull ptr @"??2@YAPAXI@Z"
+// WIN32: call noalias nonnull ptr @"??2@YAPAXI@Z"
 // WIN32: call float @atan2f
 // WIN32: call x86_stdcallcc void @"?foo@@YGXXZ"
-// WIN32: declare dso_local noundef nonnull ptr @"??2@YAPAXI@Z"(
+// WIN32: declare dso_local nonnull ptr @"??2@YAPAXI@Z"(
 // WIN32: declare dso_local float @atan2f(float noundef, float noundef)
 // WIN32: declare dso_local x86_stdcallcc void @"?foo@@YGXXZ"()

clang/test/CodeGenCXX/builtin-is-constant-evaluated.cpp

void test_arr_expr() {
 
   // CHECK-ARR: call ptr @llvm.stacksave()
   // CHECK-ARR: %vla = alloca i8, i64 13,
   char x3[std::is_constant_evaluated() || __builtin_is_constant_evaluated() ? RANDU() : 13];
 }
 
 // CHECK-ARR-LABEL: define{{.*}} void @_Z17test_new_arr_exprv
 void test_new_arr_expr() {
-  // CHECK-ARR: call noalias noundef nonnull ptr @_Znam(i64 noundef 17)
+  // CHECK-ARR: call noalias nonnull ptr @_Znam(i64 noundef 17)
   new char[std::is_constant_evaluated() || __builtin_is_constant_evaluated() ? 1 : 17];
 }
 
 // CHECK-FOLD-LABEL: @_Z31test_constant_initialized_locali(
 bool test_constant_initialized_local(int k) {
   // CHECK-FOLD: store i8 1, ptr %n,
   // CHECK-FOLD: store volatile ptr %n, ptr %p,
   const bool n = __builtin_is_constant_evaluated() && std::is_constant_evaluated();

clang/test/CodeGenCXX/builtin-operator-new-delete.cpp

 
 // Declare some other placement operators.
 void *operator new(size_t, void*, bool) throw();
 void *operator new[](size_t, void*, bool) throw();
 
 
 // CHECK-LABEL: define{{.*}} void @test_basic(
 extern "C" void test_basic() {
-  // CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 4) [[ATTR_BUILTIN_NEW:#[^ ]*]]
+  // CHECK: call noalias nonnull ptr @_Znwm(i64 noundef 4) [[ATTR_BUILTIN_NEW:#[^ ]*]]
   // CHECK: call void @_ZdlPv({{.*}}) [[ATTR_BUILTIN_DELETE:#[^ ]*]]
   // CHECK: ret void
   __builtin_operator_delete(__builtin_operator_new(4));
 }
-// CHECK: declare noundef nonnull ptr @_Znwm(i64 noundef) [[ATTR_NOBUILTIN:#[^ ]*]]
+// CHECK: declare nonnull ptr @_Znwm(i64 noundef) [[ATTR_NOBUILTIN:#[^ ]*]]
 // CHECK: declare void @_ZdlPv(ptr noundef) [[ATTR_NOBUILTIN_NOUNWIND:#[^ ]*]]
 
 // CHECK-LABEL: define{{.*}} void @test_aligned_alloc(
 extern "C" void test_aligned_alloc() {
-  // CHECK: call noalias noundef nonnull align 4 ptr @_ZnwmSt11align_val_t(i64 noundef 4, i64 noundef 4) [[ATTR_BUILTIN_NEW:#[^ ]*]]
+  // CHECK: call noalias nonnull align 4 ptr @_ZnwmSt11align_val_t(i64 noundef 4, i64 noundef 4) [[ATTR_BUILTIN_NEW:#[^ ]*]]
   // CHECK: call void @_ZdlPvSt11align_val_t({{.*}}, i64 noundef 4) [[ATTR_BUILTIN_DELETE:#[^ ]*]]
   __builtin_operator_delete(__builtin_operator_new(4, std::align_val_t(4)), std::align_val_t(4));
 }
-// CHECK: declare noundef nonnull ptr @_ZnwmSt11align_val_t(i64 noundef, i64 noundef) [[ATTR_NOBUILTIN:#[^ ]*]]
+// CHECK: declare nonnull ptr @_ZnwmSt11align_val_t(i64 noundef, i64 noundef) [[ATTR_NOBUILTIN:#[^ ]*]]
 // CHECK: declare void @_ZdlPvSt11align_val_t(ptr noundef, i64 noundef) [[ATTR_NOBUILTIN_NOUNWIND:#[^ ]*]]
 
 // CHECK-LABEL: define{{.*}} void @test_sized_delete(
 extern "C" void test_sized_delete() {
-  // CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 4) [[ATTR_BUILTIN_NEW:#[^ ]*]]
+  // CHECK: call noalias nonnull ptr @_Znwm(i64 noundef 4) [[ATTR_BUILTIN_NEW:#[^ ]*]]
   // CHECK: call void @_ZdlPvm({{.*}}, i64 noundef 4) [[ATTR_BUILTIN_DELETE:#[^ ]*]]
   __builtin_operator_delete(__builtin_operator_new(4), 4);
 }
 // CHECK: declare void @_ZdlPvm(ptr noundef, i64 noundef) [[ATTR_NOBUILTIN_UNWIND:#[^ ]*]]
 
 
 // CHECK-DAG: attributes [[ATTR_NOBUILTIN]] = {{[{].*}} nobuiltin {{.*[}]}}
 // CHECK-DAG: attributes [[ATTR_NOBUILTIN_NOUNWIND]] = {{[{].*}} nobuiltin nounwind {{.*[}]}}
 
 // CHECK-DAG: attributes [[ATTR_BUILTIN_NEW]] = {{[{].*}} builtin {{.*[}]}}
 // CHECK-DAG: attributes [[ATTR_BUILTIN_DELETE]] = {{[{].*}} builtin {{.*[}]}}

clang/test/CodeGenCXX/cxx11-initializer-array-new.cpp

 // RUN: %clang_cc1 -triple x86_64-linux-gnu -std=c++11 %s -emit-llvm -o - | FileCheck %s
 
 // PR10878
 
 struct S { S(); S(int); ~S(); int n; };
 
 void *p = new S[2][3]{ { 1, 2, 3 }, { 4, 5, 6 } };
 
 // CHECK-LABEL: define
-// CHECK: %[[ALLOC:.*]] = call noalias noundef nonnull ptr @_Znam(i64 noundef 32)
+// CHECK: %[[ALLOC:.*]] = call noalias nonnull ptr @_Znam(i64 noundef 32)
 // CHECK: store i64 6, ptr %[[ALLOC]]
 // CHECK: %[[START_AS_i8:.*]] = getelementptr inbounds i8, ptr %[[ALLOC]], i64 8
 //
 // Explicit initializers:
 //
 // { 1, 2, 3 }
 //
 //

 void *q = new S[n][3]{ { 1, 2, 3 }, { 4, 5, 6 } };
 
 // CHECK-LABEL: define
 //
 // CHECK: load i32, ptr @n
 // CHECK: call {{.*}} @llvm.umul.with.overflow.i64(i64 %[[N:.*]], i64 12)
 // CHECK: %[[ELTS:.*]] = mul i64 %[[N]], 3
 // CHECK: call {{.*}} @llvm.uadd.with.overflow.i64(i64 %{{.*}}, i64 8)
-// CHECK: %[[ALLOC:.*]] = call noalias noundef nonnull ptr @_Znam(i64 noundef %{{.*}})
+// CHECK: %[[ALLOC:.*]] = call noalias nonnull ptr @_Znam(i64 noundef %{{.*}})
 //
 // CHECK: store i64 %[[ELTS]], ptr %[[ALLOC]]
 // CHECK: %[[START_AS_i8:.*]] = getelementptr inbounds i8, ptr %[[ALLOC]], i64 8
 //
 // Explicit initializers:
 //
 // { 1, 2, 3 }
 //

 //
 // CHECK: load i32, ptr @n
 // CHECK: call {{.*}} @llvm.umul.with.overflow.i64(i64 %[[N:.*]], i64 12)
 // CHECK: %[[ELTS:.*]] = mul i64 %[[N]], 3
 //
 // No cookie.
 // CHECK-NOT: @llvm.uadd.with.overflow
 //
-// CHECK: %[[ALLOC:.*]] = call noalias noundef nonnull ptr @_Znam(i64 noundef %{{.*}})
+// CHECK: %[[ALLOC:.*]] = call noalias nonnull ptr @_Znam(i64 noundef %{{.*}})
 //
 //
 // Explicit initializers:
 //
 // { 1, 2, 3 }
 //
 //
 // CHECK: %[[T_0_0:.*]] = getelementptr inbounds [3 x %[[T:.*]]], ptr %[[ALLOC]], i64 0, i64 0

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: %[[ALLOC:.*]] = call noalias 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-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: %[[ALLOC:.*]] = call noalias 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)
 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)
+// CHECK: %[[ALLOC:.*]] = call noalias 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-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)
+// CHECK-MS: %[[ALLOC:.*]] = call noalias 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)
 void *a1(long n) { return new A[n]; }
 
 // CHECK-LABEL: define {{.*}} @_Z2a2P1A(

 };
 
 // CHECK-LABEL: define {{.*}} @_Z2b0v()
 // CHECK: %[[ALLOC:.*]] = call noundef ptr @_ZN1BnwEmSt11align_val_t(i64 noundef 512, i64 noundef 32)
 // CHECK: call void @_ZN1BdlEPvSt11align_val_t(ptr noundef %[[ALLOC]], i64 noundef 32)
 void *b0() { return new B; }
 
 // CHECK-LABEL: define {{.*}} @_Z2b1l(
-// CHECK: %[[ALLOC:.*]] = call noalias noundef nonnull align 32 ptr @_ZnamSt11align_val_t(i64 noundef %{{.*}}, i64 noundef 32)
+// CHECK: %[[ALLOC:.*]] = call noalias nonnull align 32 ptr @_ZnamSt11align_val_t(i64 noundef %{{.*}}, i64 noundef 32)
 // No array cookie.
 // CHECK-NOT: store
 // CHECK: invoke void @_ZN1BC1Ev(
 // CHECK: call void @_ZN1BdaEPvSt11align_val_t(ptr noundef %[[ALLOC]], i64 noundef 32)
 void *b1(long n) { return new B[n]; }
 
 // CHECK-LABEL: define {{.*}} @_Z2b2P1B(
 // CHECK: call void @_ZN1BdlEPvSt11align_val_t(ptr noundef %{{.*}}, i64 noundef 32)

 void *d0() { return new (q) D; }
 
 
 // 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: %[[ALLOC:.*]] = call noalias 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)
 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 {
   struct A {
     int x;
     void *operator new[](size_t);
     void operator delete[](void *, size_t);
   };
 
   // CHECK: define{{.*}} ptr @_ZN5test24testEv()
   A *test() {
-    // CHECK:      [[NEW:%.*]] = call noalias noundef nonnull ptr @_Znaj(i32 noundef 44)
+    // CHECK:      [[NEW:%.*]] = call noalias nonnull ptr @_Znaj(i32 noundef 44)
     // CHECK-NEXT: store i32 10, ptr [[NEW]]
     // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8, ptr [[NEW]], i32 4
     // CHECK-NEXT: ret ptr [[T1]]
     return ::new A[10];
   }
 
   // CHECK-LABEL: define{{.*}} void @_ZN5test24testEPNS_1AE(
   void test(A *p) {
namespace test3 {
   struct A {
     int x;
     void operator delete[](void *, size_t);
   };
   struct B : A {};
 
   // CHECK-LABEL: define{{.*}} void @_ZN5test34testEv()
   void test() {
-    // CHECK:      [[CALL:%.*]] = call noalias noundef nonnull ptr @_Znaj(i32 noundef 24)
+    // CHECK:      [[CALL:%.*]] = call noalias nonnull ptr @_Znaj(i32 noundef 24)
     // CHECK-NEXT: store i32 5
     (void) new B[5];
   }
 }

clang/test/CodeGenCXX/microsoft-abi-array-cookies.cpp

 // RUN: %clang_cc1 -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s
 
 struct ClassWithoutDtor {
   char x;
 };
 
 void check_array_no_cookies() {
 // CHECK: define dso_local void @"?check_array_no_cookies@@YAXXZ"() [[NUW:#[0-9]+]]
 
-// CHECK: call noalias noundef nonnull ptr @"??_U@YAPAXI@Z"(i32 noundef 42)
+// CHECK: call noalias nonnull ptr @"??_U@YAPAXI@Z"(i32 noundef 42)
   ClassWithoutDtor *array = new ClassWithoutDtor[42];
 
 // CHECK: call void @"??_V@YAXPAX@Z"(
   delete [] array;
 
 }
 
 struct ClassWithDtor {
   char x;
   ~ClassWithDtor() {}
 };
 
 void check_array_cookies_simple() {
 // CHECK: define {{.*}} @"?check_array_cookies_simple@@YAXXZ"()
 
   ClassWithDtor *array = new ClassWithDtor[42];
-// CHECK: [[ALLOCATED:%.*]] = call noalias noundef nonnull ptr @"??_U@YAPAXI@Z"(i32 noundef 46)
+// CHECK: [[ALLOCATED:%.*]] = call noalias nonnull ptr @"??_U@YAPAXI@Z"(i32 noundef 46)
 // 46 = 42 + size of cookie (4)
 // CHECK: store i32 42, ptr [[ALLOCATED]]
 // CHECK: [[ARRAY:%.*]] = getelementptr inbounds i8, ptr [[ALLOCATED]], i32 4
 
   delete [] array;
 // CHECK: getelementptr inbounds i8, ptr {{%.*}}, i32 -4
 }
 
 struct __attribute__((aligned(8))) ClassWithAlignment {
   // FIXME: replace __attribute__((aligned(8))) with __declspec(align(8)) once
   // http://llvm.org/bugs/show_bug.cgi?id=12631 is fixed.
   int *x, *y;
   ~ClassWithAlignment() {}
 };
 
 void check_array_cookies_aligned() {
 // CHECK: define {{.*}} @"?check_array_cookies_aligned@@YAXXZ"()
   ClassWithAlignment *array = new ClassWithAlignment[42];
-// CHECK: [[ALLOCATED:%.*]] = call noalias noundef nonnull ptr @"??_U@YAPAXI@Z"(i32 noundef 344)
+// CHECK: [[ALLOCATED:%.*]] = call noalias nonnull ptr @"??_U@YAPAXI@Z"(i32 noundef 344)
 //   344 = 42*8 + size of cookie (8, due to alignment)
 // CHECK: store i32 42, ptr [[ALLOCATED]]
 // CHECK: [[ARRAY:%.*]] = getelementptr inbounds i8, ptr [[ALLOCATED]], i32 8
 
   delete [] array;
 // CHECK: getelementptr inbounds i8, ptr {{.*}}, i32 -8
 }
 

clang/test/CodeGenCXX/mips-size_t-ptrdiff_t.cpp

 // RUN: %clang_cc1 -x c++ -emit-llvm -triple=mips-unknown-linux-gnu < %s | FileCheck --check-prefix=O32 %s
 // RUN: %clang_cc1 -x c++ -emit-llvm -triple=mips64-unknown-linux-gnu -target-abi n32 < %s | FileCheck --check-prefix=N32 %s
 // RUN: %clang_cc1 -x c++ -emit-llvm -triple=mips64-unknown-linux-gnu -target-abi n64 < %s | FileCheck --check-prefix=N64 %s
 
 // Test that the size_t is correct for the ABI. It's not sufficient to be the
 // correct size, it must be the same type for correct name mangling.
 
 long *alloc_long() {
   long *rv = new long; // size_t is implicit in the new operator
   return rv;
 }
 // O32-LABEL: define{{.*}} ptr @_Z10alloc_longv()
-// O32: call noalias noundef nonnull ptr @_Znwj(i32 noundef signext 4)
+// O32: call noalias nonnull ptr @_Znwj(i32 noundef signext 4)
 
 // N32-LABEL: define{{.*}} ptr @_Z10alloc_longv()
-// N32: call noalias noundef nonnull ptr @_Znwj(i32 noundef signext 4)
+// N32: call noalias nonnull ptr @_Znwj(i32 noundef signext 4)
 
 // N64-LABEL: define{{.*}} ptr @_Z10alloc_longv()
-// N64: call noalias noundef nonnull ptr @_Znwm(i64 noundef zeroext 8)
+// N64: call noalias nonnull ptr @_Znwm(i64 noundef zeroext 8)
 
 long *alloc_long_array() {
   long *rv = new long[2];
   return rv;
 }
 
 // O32-LABEL: define{{.*}} ptr @_Z16alloc_long_arrayv()
-// O32: call noalias noundef nonnull ptr @_Znaj(i32 noundef signext 8)
+// O32: call noalias nonnull ptr @_Znaj(i32 noundef signext 8)
 
 // N32-LABEL: define{{.*}} ptr @_Z16alloc_long_arrayv()
-// N32: call noalias noundef nonnull ptr @_Znaj(i32 noundef signext 8)
+// N32: call noalias nonnull ptr @_Znaj(i32 noundef signext 8)
 
 // N64-LABEL: define{{.*}} ptr @_Z16alloc_long_arrayv()
-// N64: call noalias noundef nonnull ptr @_Znam(i64 noundef zeroext 16)
+// N64: call noalias nonnull ptr @_Znam(i64 noundef zeroext 16)
 
 #include <stddef.h>
 
 void size_t_arg(size_t a) {
 }
 
 // O32-LABEL: _Z10size_t_argj
 // N32-LABEL: _Z10size_t_argj
 // N64-LABEL: _Z10size_t_argm
 
 void ptrdiff_t_arg(ptrdiff_t a) {
 }
 
 // O32-LABEL: _Z13ptrdiff_t_argi
 // N32-LABEL: _Z13ptrdiff_t_argi
 // N64-LABEL: _Z13ptrdiff_t_argl

clang/test/CodeGenCXX/multi-dim-operator-new.cpp

  pr(f);
 
  Foo * g = test();
  for (int i = 0; i < 5; i++)
  printf("%d\n", g[i].iFoo);
  return 0;
 }
 
-// CHECK: call noalias noundef nonnull ptr @_Znam
-// CHECK: call noalias noundef nonnull ptr @_Znam
-// CHECK: call noalias noundef nonnull ptr @_Znam
+// CHECK: call noalias nonnull ptr @_Znam
+// CHECK: call noalias nonnull ptr @_Znam
+// CHECK: call noalias nonnull ptr @_Znam

clang/test/CodeGenCXX/new-alias.cpp

 // RUN: %clang_cc1 -emit-llvm -triple x86_64-linux-gnu -std=c++11 -o - %s | FileCheck %s
 
 using size_t = decltype(sizeof(0));
 
 extern "C" char *something(long long x) {
 }
 
 // CHECK: @_Znwm ={{.*}} alias ptr (i64), ptr @something
 void *operator new(size_t) __attribute__((alias("something")));
 
 // PR16715: don't assert here.
-// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 4) #3{{$}}
+// CHECK: call noalias nonnull ptr @_Znwm(i64 noundef 4) #3{{$}}
 int *pr16715 = new int;

clang/test/CodeGenCXX/new-array-init.cpp

void const_sufficient() {
   // CHECK: ret void
 }
 
 // CHECK-LABEL: define{{.*}} void @_Z22check_array_value_initv
 void check_array_value_init() {
   struct S;
   new (int S::*[3][4][5]) ();
 
-  // CHECK: call noalias noundef nonnull ptr @_Zna{{.}}(i{{32 noundef 240|64 noundef 480}})
+  // CHECK: call noalias nonnull ptr @_Zna{{.}}(i{{32 noundef 240|64 noundef 480}})
   // CHECK: getelementptr inbounds i{{32|64}}, ptr {{.*}}, i{{32|64}} 60
 
   // CHECK: phi
   // CHECK: store i{{32|64}} -1,
   // CHECK: getelementptr inbounds i{{32|64}}, ptr {{.*}}, i{{32|64}} 1
   // CHECK: icmp eq
   // CHECK: br i1
 }
 
 // CHECK-LABEL: define{{.*}} void @_Z15string_nonconsti
 void string_nonconst(int n) {
   // CHECK: icmp slt i{{32|64}} %{{[^ ]+}}, 4
   // FIXME: Conditionally throw an exception rather than passing -1 to alloc function
   // CHECK: select
-  // CHECK: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}}
+  // CHECK: %[[PTR:.*]] = call noalias nonnull ptr @_Zna{{.}}(i{{32|64}}
   // CHECK: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
   // CHECK: %[[REST:.*]] = getelementptr inbounds i8, ptr %[[PTR]], i32 4
   // CHECK: %[[RESTSIZE:.*]] = sub {{.*}}, 4
   // CHECK: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[REST]], i8 0, i{{32|64}} %[[RESTSIZE]],
   new char[n] { "abc" };
 }
 
 // CHECK-LABEL: define{{.*}} void @_Z12string_exactv
 void string_exact() {
   // CHECK-NOT: icmp
-  // CHECK: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 4)
+  // CHECK: %[[PTR:.*]] = call noalias nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 4)
   // CHECK: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
   // CHECK-NOT: memset
   new char[4] { "abc" };
 }
 
 // CHECK-LABEL: define{{.*}} void @_Z17string_sufficientv
 void string_sufficient() {
   // CHECK-NOT: icmp
-  // CHECK: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 15)
+  // CHECK: %[[PTR:.*]] = call noalias nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 15)
   // FIXME: For very large arrays, it would be preferable to emit a small copy and a memset.
   // CHECK: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC15]], i32 15,
   // CHECK-NOT: memset
   new char[15] { "abc" };
 }
 
 // CHECK-LABEL: define{{.*}} void @_Z10aggr_exactv
 void aggr_exact() {
   // CHECK-NOT: icmp
-  // CHECK: %[[MEM:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 16)
+  // CHECK: %[[MEM:.*]] = call noalias nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 16)
   // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR:.*]], ptr %[[MEM]], i32 0, i32 0{{$}}
   // CHECK: store i32 1, ptr %[[FIELD]]
   // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 0, i32 1{{$}}
   // CHECK: store i32 2, ptr %[[FIELD]]
   // CHECK: %[[PTR1:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 1{{$}}
   // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 0, i32 0{{$}}
   // CHECK: store i32 3, ptr %[[FIELD]]
   // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 0, i32 1{{$}}
   // CHECK: store i32 0, ptr %[[FIELD]]
   // CHECK-NOT: store
   // CHECK-NOT: memset
   struct Aggr { int a, b; };
   new Aggr[2] { 1, 2, 3 };
 }
 
 // CHECK-LABEL: define{{.*}} void @_Z15aggr_sufficienti
 void aggr_sufficient(int n) {
   // CHECK: icmp ult i32 %{{.*}}, 2
-  // CHECK: %[[MEM:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(
+  // CHECK: %[[MEM:.*]] = call noalias nonnull ptr @_Zna{{.}}(
   // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR:.*]], ptr %[[MEM]], i32 0, i32 0{{$}}
   // CHECK: store i32 1, ptr %[[FIELD]]
   // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 0, i32 1{{$}}
   // CHECK: store i32 2, ptr %[[FIELD]]
   // CHECK: %[[PTR1:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 1{{$}}
   // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 0, i32 0{{$}}
   // CHECK: store i32 3, ptr %[[FIELD]]
   // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 0, i32 1{{$}}
   // CHECK: store i32 0, ptr %[[FIELD]]
   // CHECK: %[[PTR2:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 1{{$}}
   // CHECK: %[[REMAIN:.*]] = sub i32 {{.*}}, 16
   // CHECK: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[PTR2]], i8 0, i32 %[[REMAIN]],
   struct Aggr { int a, b; };
   new Aggr[n] { 1, 2, 3 };
 }
 
 // SIO-LABEL: define{{.*}} void @_Z14constexpr_testv
 void constexpr_test() {
-  // SIO: call noalias noundef nonnull ptr @_Zna{{.}}(i32 noundef 4)
+  // SIO: call noalias nonnull ptr @_Zna{{.}}(i32 noundef 4)
   new int[0+1]{0};
 }
 
 // CHECK-LABEL: define{{.*}} void @_Z13unknown_boundv
 void unknown_bound() {
   struct Aggr { int x, y, z; };
   new Aggr[]{1, 2, 3, 4};
   // CHECK: call {{.*}}_Znaj(i32 noundef 24)

clang/test/CodeGenCXX/new-infallible.cpp

 // RUN: %clang_cc1 -emit-llvm -triple x86_64-linux-gnu -fnew-infallible -o - %s | FileCheck %s
 // RUN: %clang_cc1 -emit-llvm -triple x86_64-linux-gnu -fno-new-infallible -fnew-infallible -o - %s | FileCheck %s
 // RUN: %clang_cc1 -emit-llvm -triple x86_64-linux-gnu -fno-new-infallible -o - %s | FileCheck %s --check-prefix=NO-NEW-INFALLIBLE
 // RUN: %clang_cc1 -emit-llvm -triple x86_64-linux-gnu -fnew-infallible -fno-new-infallible -o - %s | FileCheck %s --check-prefix=NO-NEW-INFALLIBLE
 
-// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 4)
+// CHECK: call noalias nonnull ptr @_Znwm(i64 noundef 4)
 
 // CHECK: ; Function Attrs: nobuiltin nounwind allocsize(0)
-// CHECK-NEXT: declare noundef nonnull ptr @_Znwm(i64 noundef)
+// CHECK-NEXT: declare nonnull ptr @_Znwm(i64 noundef)
 
-// NO-NEW-INFALLIBLE: call noalias noundef nonnull ptr @_Znwm(i64 noundef 4)
+// NO-NEW-INFALLIBLE: call noalias nonnull ptr @_Znwm(i64 noundef 4)
 
 // NO-NEW-INFALLIBLE: ; Function Attrs: nobuiltin allocsize(0)
-// NO-NEW-INFALLIBLE-NEXT: declare noundef nonnull ptr @_Znwm(i64 noundef)
+// NO-NEW-INFALLIBLE-NEXT: declare nonnull ptr @_Znwm(i64 noundef)
 
 int *new_infallible = new int;

clang/test/CodeGenCXX/new-overflow.cpp

namespace test0 {
   typedef A elt;
 
   // CHECK:    define{{.*}} ptr @_ZN5test04testEs(i16 noundef signext
   // CHECK:      [[N:%.*]] = sext i16 {{%.*}} to i32
   // CHECK-NEXT: [[T0:%.*]] = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 [[N]], i32 4)
   // CHECK-NEXT: [[T1:%.*]] = extractvalue { i32, i1 } [[T0]], 1
   // CHECK-NEXT: [[T2:%.*]] = extractvalue { i32, i1 } [[T0]], 0
   // CHECK-NEXT: [[T3:%.*]] = select i1 [[T1]], i32 -1, i32 [[T2]]
-  // CHECK-NEXT: call noalias noundef nonnull ptr @_Znaj(i32 noundef [[T3]])
+  // CHECK-NEXT: call noalias nonnull ptr @_Znaj(i32 noundef [[T3]])
   // CHECK:      getelementptr inbounds {{.*}}, i32 [[N]]
   elt *test(short s) {
     return new elt[s];
   }
 }
 
 // test0 with a nested array.
 namespace test1 {
   struct A {
     A();
     int x;
   };
 
   typedef A elt[100];
 
   // CHECK:    define{{.*}} ptr @_ZN5test14testEs(i16 noundef signext
   // CHECK:      [[N:%.*]] = sext i16 {{%.*}} to i32
   // CHECK-NEXT: [[T0:%.*]] = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 [[N]], i32 400)
   // CHECK-NEXT: [[T1:%.*]] = extractvalue { i32, i1 } [[T0]], 1
   // CHECK-NEXT: [[T2:%.*]] = extractvalue { i32, i1 } [[T0]], 0
   // CHECK-NEXT: [[T3:%.*]] = mul i32 [[N]], 100
   // CHECK-NEXT: [[T4:%.*]] = select i1 [[T1]], i32 -1, i32 [[T2]]
-  // CHECK-NEXT: call noalias noundef nonnull ptr @_Znaj(i32 noundef [[T4]])
+  // CHECK-NEXT: call noalias nonnull ptr @_Znaj(i32 noundef [[T4]])
   // CHECK:      getelementptr inbounds {{.*}}, i32 [[T3]]
   elt *test(short s) {
     return new elt[s];
   }
 }
 
 // test1 with an array cookie.
 namespace test2 {
namespace test2 {
   // CHECK-NEXT: [[T1:%.*]] = extractvalue { i32, i1 } [[T0]], 1
   // CHECK-NEXT: [[T2:%.*]] = extractvalue { i32, i1 } [[T0]], 0
   // CHECK-NEXT: [[T3:%.*]] = mul i32 [[N]], 100
   // CHECK-NEXT: [[T4:%.*]] = call { i32, i1 } @llvm.uadd.with.overflow.i32(i32 [[T2]], i32 4)
   // CHECK-NEXT: [[T5:%.*]] = extractvalue { i32, i1 } [[T4]], 1
   // CHECK-NEXT: [[T6:%.*]] = or i1 [[T1]], [[T5]]
   // CHECK-NEXT: [[T7:%.*]] = extractvalue { i32, i1 } [[T4]], 0
   // CHECK-NEXT: [[T8:%.*]] = select i1 [[T6]], i32 -1, i32 [[T7]]
-  // CHECK-NEXT: call noalias noundef nonnull ptr @_Znaj(i32 noundef [[T8]])
+  // CHECK-NEXT: call noalias nonnull ptr @_Znaj(i32 noundef [[T8]])
   // CHECK:      getelementptr inbounds {{.*}}, i32 [[T3]]
   elt *test(short s) {
     return new elt[s];
   }
 }
 
 // test0 with a 1-byte element.
 namespace test4 {
   struct A {
     A();
   };
 
   typedef A elt;
 
   // CHECK:    define{{.*}} ptr @_ZN5test44testEs(i16 noundef signext
   // CHECK:      [[N:%.*]] = sext i16 {{%.*}} to i32
-  // CHECK-NEXT: call noalias noundef nonnull ptr @_Znaj(i32 noundef [[N]])
+  // CHECK-NEXT: call noalias nonnull ptr @_Znaj(i32 noundef [[N]])
   // CHECK:      getelementptr inbounds {{.*}}, i32 [[N]]
   elt *test(short s) {
     return new elt[s];
   }
 }
 
 // test4 with no sext required.
 namespace test5 {
   struct A {
     A();
   };
 
   typedef A elt;
 
   // CHECK:    define{{.*}} ptr @_ZN5test54testEi(i32
   // CHECK:      [[N:%.*]] = load i32, ptr
-  // CHECK-NEXT: call noalias noundef nonnull ptr @_Znaj(i32 noundef [[N]])
+  // CHECK-NEXT: call noalias nonnull ptr @_Znaj(i32 noundef [[N]])
   // CHECK:      getelementptr inbounds {{.*}}, i32 [[N]]
   elt *test(int s) {
     return new elt[s];
   }
 }
 
 // test0 with an unsigned size.
 namespace test6 {
   struct A {
     A();
     int x;
   };
 
   typedef A elt;
 
   // CHECK:    define{{.*}} ptr @_ZN5test64testEt(i16 noundef zeroext
   // CHECK:      [[N:%.*]] = zext i16 {{%.*}} to i32
   // CHECK-NEXT: [[T0:%.*]] = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 [[N]], i32 4)
   // CHECK-NEXT: [[T1:%.*]] = extractvalue { i32, i1 } [[T0]], 1
   // CHECK-NEXT: [[T2:%.*]] = extractvalue { i32, i1 } [[T0]], 0
   // CHECK-NEXT: [[T3:%.*]] = select i1 [[T1]], i32 -1, i32 [[T2]]
-  // CHECK-NEXT: call noalias noundef nonnull ptr @_Znaj(i32 noundef [[T3]])
+  // CHECK-NEXT: call noalias nonnull ptr @_Znaj(i32 noundef [[T3]])
   // CHECK:      getelementptr inbounds {{.*}}, i32 [[N]]
   elt *test(unsigned short s) {
     return new elt[s];
   }
 }
 
 // test1 with an unsigned size.
 namespace test7 {
   struct A {
     A();
     int x;
   };
 
   typedef A elt[100];
 
   // CHECK:    define{{.*}} ptr @_ZN5test74testEt(i16 noundef zeroext
   // CHECK:      [[N:%.*]] = zext i16 {{%.*}} to i32
   // CHECK-NEXT: [[T0:%.*]] = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 [[N]], i32 400)
   // CHECK-NEXT: [[T1:%.*]] = extractvalue { i32, i1 } [[T0]], 1
   // CHECK-NEXT: [[T2:%.*]] = extractvalue { i32, i1 } [[T0]], 0
   // CHECK-NEXT: [[T3:%.*]] = mul i32 [[N]], 100
   // CHECK-NEXT: [[T4:%.*]] = select i1 [[T1]], i32 -1, i32 [[T2]]
-  // CHECK-NEXT: call noalias noundef nonnull ptr @_Znaj(i32 noundef [[T4]])
+  // CHECK-NEXT: call noalias nonnull ptr @_Znaj(i32 noundef [[T4]])
   // CHECK:      getelementptr inbounds {{.*}}, i32 [[T3]]
   elt *test(unsigned short s) {
     return new elt[s];
   }
 }
 
 // test0 with a signed type larger than size_t.
 namespace test8 {
   struct A {
     A();
     int x;
   };
 
   typedef A elt;
 
   // CHECK:    define{{.*}} ptr @_ZN5test84testEx(i64
   // CHECK:      [[N:%.*]] = load i64, ptr
   // CHECK-NEXT: [[T1:%.*]] = trunc i64 [[N]] to i32
   // CHECK-NEXT: [[T2:%.*]] = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 [[T1]], i32 4)
   // CHECK-NEXT: [[T3:%.*]] = extractvalue { i32, i1 } [[T2]], 1
   // CHECK-NEXT: [[T5:%.*]] = extractvalue { i32, i1 } [[T2]], 0
   // CHECK-NEXT: [[T6:%.*]] = select i1 [[T3]], i32 -1, i32 [[T5]]
-  // CHECK-NEXT: call noalias noundef nonnull ptr @_Znaj(i32 noundef [[T6]])
+  // CHECK-NEXT: call noalias nonnull ptr @_Znaj(i32 noundef [[T6]])
   // CHECK:      getelementptr inbounds {{.*}}, i32 [[T1]]
   elt *test(long long s) {
     return new elt[s];
   }
 }
 
 // test8 with an unsigned type.
 namespace test9 {
   struct A {
     A();
     int x;
   };
 
   typedef A elt;
 
   // CHECK:    define{{.*}} ptr @_ZN5test94testEy(i64
   // CHECK:      [[N:%.*]] = load i64, ptr
   // CHECK-NEXT: [[T1:%.*]] = trunc i64 [[N]] to i32
   // CHECK-NEXT: [[T2:%.*]] = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 [[T1]], i32 4)
   // CHECK-NEXT: [[T3:%.*]] = extractvalue { i32, i1 } [[T2]], 1
   // CHECK-NEXT: [[T5:%.*]] = extractvalue { i32, i1 } [[T2]], 0
   // CHECK-NEXT: [[T6:%.*]] = select i1 [[T3]], i32 -1, i32 [[T5]]
-  // CHECK-NEXT: call noalias noundef nonnull ptr @_Znaj(i32 noundef [[T6]])
+  // CHECK-NEXT: call noalias nonnull ptr @_Znaj(i32 noundef [[T6]])
   // CHECK:      getelementptr inbounds {{.*}}, i32 [[T1]]
   elt *test(unsigned long long s) {
     return new elt[s];
   }
 }

clang/test/CodeGenCXX/new.cpp

 // RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -emit-llvm -o - | FileCheck %s
 
 typedef __typeof__(sizeof(0)) size_t;
 
 // Declare an 'operator new' template to tickle a bug in __builtin_operator_new.
 template<typename T> void *operator new(size_t, int (*)(T));
 
 // Ensure that this declaration doesn't cause operator new to lose its
 // 'noalias' attribute.
 void *operator new[](size_t);
 
 void t1() {
   delete new int;
   delete [] new int [3];
 }
 
-// CHECK: declare noundef nonnull ptr @_Znwm(i64 noundef) [[ATTR_NOBUILTIN:#[^ ]*]]
+// CHECK: declare nonnull ptr @_Znwm(i64 noundef) [[ATTR_NOBUILTIN:#[^ ]*]]
 // CHECK: declare void @_ZdlPv(ptr noundef) [[ATTR_NOBUILTIN_NOUNWIND:#[^ ]*]]
-// CHECK: declare noundef nonnull ptr @_Znam(i64 noundef) [[ATTR_NOBUILTIN]]
+// CHECK: declare nonnull ptr @_Znam(i64 noundef) [[ATTR_NOBUILTIN]]
 // CHECK: declare void @_ZdaPv(ptr noundef) [[ATTR_NOBUILTIN_NOUNWIND]]
 
 namespace std {
   struct nothrow_t {};
 }
 std::nothrow_t nothrow;
 
 // Declare the reserved placement operators.
A* t10() {
   return new(1, 2, 3.45, 100) A;
 }
 
 // CHECK-LABEL: define{{.*}} void @_Z3t11i
 struct B { int a; };
 struct Bmemptr { int Bmemptr::* memptr; int a; };
 
 void t11(int n) {
-  // CHECK: call noalias noundef nonnull ptr @_Znwm
+  // CHECK: call noalias nonnull ptr @_Znwm
   // CHECK: call void @llvm.memset.p0.i64(
   B* b = new B();
 
-  // CHECK: call noalias noundef nonnull ptr @_Znam
+  // CHECK: call noalias nonnull ptr @_Znam
   // CHECK: {{call void.*llvm.memset.p0.i64.*i8 0, i64 %}}
   B *b2 = new B[n]();
 
-  // CHECK: call noalias noundef nonnull ptr @_Znam
+  // CHECK: call noalias nonnull ptr @_Znam
   // CHECK: call void @llvm.memcpy.p0.p0.i64
   // CHECK: br
   Bmemptr *b_memptr = new Bmemptr[n]();
 
   // CHECK: ret void
 }
 
 struct Empty { };
 
 // We don't need to initialize an empty class.
 // CHECK-LABEL: define{{.*}} void @_Z3t12v
 void t12() {
-  // CHECK: call noalias noundef nonnull ptr @_Znam
+  // CHECK: call noalias nonnull ptr @_Znam
   // CHECK-NOT: br
   (void)new Empty[10];
 
-  // CHECK: call noalias noundef nonnull ptr @_Znam
+  // CHECK: call noalias nonnull ptr @_Znam
   // CHECK-NOT: br
   (void)new Empty[10]();
 
   // CHECK: ret void
 }
 
 // Zero-initialization
 // CHECK-LABEL: define{{.*}} void @_Z3t13i
 void t13(int n) {
-  // CHECK: call noalias noundef nonnull ptr @_Znwm
+  // CHECK: call noalias nonnull ptr @_Znwm
   // CHECK: store i32 0, ptr
   (void)new int();
 
-  // CHECK: call noalias noundef nonnull ptr @_Znam
+  // CHECK: call noalias nonnull ptr @_Znam
   // CHECK: {{call void.*llvm.memset.p0.i64.*i8 0, i64 %}}
   (void)new int[n]();
 
   // CHECK-NEXT: ret void
 }
 
 struct Alloc{
   int x;
   void* operator new[](size_t size);
   __attribute__((returns_nonnull)) void *operator new[](size_t size, const std::nothrow_t &) throw();
   void operator delete[](void* p);
   ~Alloc();
 };
 
 void f() {
   // CHECK: call noundef ptr @_ZN5AllocnaEm(i64 noundef 808)
   // CHECK: store i64 200
   // CHECK: call void @_ZN5AllocD1Ev(
   // CHECK: call void @_ZN5AllocdaEPv(ptr
   delete[] new Alloc[10][20];
   // CHECK: [[P:%.*]] = call noundef nonnull ptr @_ZN5AllocnaEmRKSt9nothrow_t(i64 noundef 808, {{.*}}) [[ATTR_NOUNWIND:#[^ ]*]]
   // CHECK-NOT: icmp eq ptr [[P]], null
   // CHECK: store i64 200
   delete[] new (nothrow) Alloc[10][20];
-  // CHECK: call noalias noundef nonnull ptr @_Znwm
+  // CHECK: call noalias nonnull ptr @_Znwm
   // CHECK: call void @_ZdlPv(ptr
   delete new bool;
   // CHECK: ret void
 }
 
 namespace test15 {
   struct A { A(); ~A(); };
 
void test2(void *p, int n) {
     new (p) A[n];
   }
 }
 
 namespace PR10197 {
   // CHECK-LABEL: define weak_odr void @_ZN7PR101971fIiEEvv()
   template<typename T>
   void f() {
-    // CHECK: [[CALL:%.*]] = call noalias noundef nonnull ptr @_Znwm
+    // CHECK: [[CALL:%.*]] = call noalias nonnull ptr @_Znwm
     new T;
     // CHECK-NEXT: ret void
   }
 
   template void f<int>();
 }
 
 namespace PR11523 {
   class MyClass;
   typedef int MyClass::* NewTy;
   // CHECK-LABEL: define{{.*}} ptr @_ZN7PR115231fEv
   // CHECK: store i64 -1
   NewTy* f() { return new NewTy[2](); }
 }
 
 namespace PR11757 {
   // Make sure we elide the copy construction.
   struct X { X(); X(const X&); };
   X* a(X* x) { return new X(X()); }
   // CHECK: define {{.*}} @_ZN7PR117571aEPNS_1XE
-  // CHECK: [[CALL:%.*]] = call noalias noundef nonnull ptr @_Znwm
+  // CHECK: [[CALL:%.*]] = call noalias nonnull ptr @_Znwm
   // CHECK: ret {{.*}} [[CALL]]
 }
 
 namespace PR13380 {
   struct A { A() {} };
   struct B : public A { int x; };
   // CHECK-LABEL: define{{.*}} ptr @_ZN7PR133801fEv
-  // CHECK: call noalias noundef nonnull ptr @_Znam(
+  // CHECK: call noalias nonnull ptr @_Znam(
   // CHECK: call void @llvm.memset.p0
   // CHECK-NEXT: call void @_ZN7PR133801BC1Ev
   void* f() { return new B[2](); }
 }
 
 struct MyPlacementType {} mpt;
 void *operator new(size_t, MyPlacementType);
 
 namespace N3664 {
   struct S { S() throw(int); };
 
   // CHECK-LABEL: define{{.*}} void @_ZN5N36641fEv
   void f() {
-    // CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 4) [[ATTR_BUILTIN_NEW:#[^ ]*]]
+    // CHECK: call noalias nonnull ptr @_Znwm(i64 noundef 4) [[ATTR_BUILTIN_NEW:#[^ ]*]]
     int *p = new int; // expected-note {{allocated with 'new' here}}
     // CHECK: call void @_ZdlPv({{.*}}) [[ATTR_BUILTIN_DELETE:#[^ ]*]]
     delete p;
 
-    // CHECK: call noalias noundef nonnull ptr @_Znam(i64 noundef 12) [[ATTR_BUILTIN_NEW]]
+    // CHECK: call noalias nonnull ptr @_Znam(i64 noundef 12) [[ATTR_BUILTIN_NEW]]
     int *q = new int[3];
     // CHECK: call void @_ZdaPv({{.*}}) [[ATTR_BUILTIN_DELETE]]
     delete[] p; // expected-warning {{'delete[]' applied to a pointer that was allocated with 'new'; did you mean 'delete'?}}
 
     // CHECK: call noalias noundef ptr @_ZnamRKSt9nothrow_t(i64 noundef 3, {{.*}}) [[ATTR_NOBUILTIN_NOUNWIND_ALLOCSIZE:#[^ ]*]]
     (void) new (nothrow) S[3];
 
     // CHECK: call noundef ptr @_Znwm15MyPlacementType(i64 noundef 4){{$}}
     (void) new (mpt) int;
   }
 
   // CHECK: declare noundef ptr @_ZnamRKSt9nothrow_t(i64 noundef, {{.*}}) [[ATTR_NOBUILTIN_NOUNWIND_ALLOCSIZE:#[^ ]*]]
 
   // CHECK-LABEL: define{{.*}} void @_ZN5N36641gEv
   void g() {
     // It's OK for there to be attributes here, so long as we don't have a
     // 'builtin' attribute.
-    // CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 4) {{#[^ ]*}}{{$}}
+    // CHECK: call noalias nonnull ptr @_Znwm(i64 noundef 4) {{#[^ ]*}}{{$}}
     int *p = (int*)operator new(4);
     // CHECK: call void @_ZdlPv({{.*}}) [[ATTR_NOUNWIND:#[^ ]*]]
     operator delete(p);
 
-    // CHECK: call noalias noundef nonnull ptr @_Znam(i64 noundef 12) {{#[^ ]*}}{{$}}
+    // CHECK: call noalias nonnull ptr @_Znam(i64 noundef 12) {{#[^ ]*}}{{$}}
     int *q = (int*)operator new[](12);
     // CHECK: call void @_ZdaPv({{.*}}) [[ATTR_NOUNWIND]]
     operator delete [](p);
 
     // CHECK: call noalias noundef ptr @_ZnamRKSt9nothrow_t(i64 noundef 3, {{.*}}) [[ATTR_NOUNWIND_ALLOCSIZE:#[^ ]*]]
     (void) operator new[](3, nothrow);
   }
 }
 
 namespace builtins {
   // CHECK-LABEL: define{{.*}} void @_ZN8builtins1fEv
   void f() {
-    // CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 4) [[ATTR_BUILTIN_NEW]]
+    // CHECK: call noalias nonnull ptr @_Znwm(i64 noundef 4) [[ATTR_BUILTIN_NEW]]
     // CHECK: call void @_ZdlPv({{.*}}) [[ATTR_BUILTIN_DELETE]]
     __builtin_operator_delete(__builtin_operator_new(4));
   }
 }
 
 // CHECK-DAG: attributes [[ATTR_NOBUILTIN]] = {{[{].*}} nobuiltin allocsize(0) {{.*[}]}}
 // CHECK-DAG: attributes [[ATTR_NOBUILTIN_NOUNWIND]] = {{[{].*}} nobuiltin nounwind {{.*[}]}}
 // CHECK-DAG: attributes [[ATTR_NOBUILTIN_NOUNWIND_ALLOCSIZE]] = {{[{].*}} nobuiltin nounwind allocsize(0) {{.*[}]}}
 
 // CHECK-DAG: attributes [[ATTR_BUILTIN_NEW]] = {{[{].*}} builtin {{.*[}]}}
 // CHECK-DAG: attributes [[ATTR_BUILTIN_DELETE]] = {{[{].*}} builtin {{.*[}]}}
 
 // The ([^b}|...) monstrosity is matching a character that's not the start of 'builtin'.
 // Add more letters if this matches some other attribute.
 // CHECK-DAG: attributes [[ATTR_NOUNWIND]] = {{([^b]|b[^u]|bu[^i]|bui[^l])*}} nounwind {{([^b]|b[^u]|bu[^i]|bui[^l])*$}}
 // CHECK-DAG: attributes [[ATTR_NOUNWIND_ALLOCSIZE]] = {{([^b]|b[^u]|bu[^i]|bui[^l])*}} nounwind allocsize(0) {{([^b]|b[^u]|bu[^i]|bui[^l])*$}}

clang/test/CodeGenCXX/new_hot_cold.cpp

void *operator new[](size_t size, std::align_val_t alignment,
                      const std::nothrow_t &,
                      malloc_namespace::hot_cold_t hot_cold) noexcept;
 
 // All explicit operator new calls should not get any builtin attribute, whereas
 // all implicit new expressions should get builtin attributes. All of the
 // declarations should get nobuiltin attributes.
 
 void hot_cold_new() {
-  // CHECK: call noalias noundef nonnull ptr @_Znwm12__hot_cold_t(i64 noundef 1, i8 noundef zeroext 0) [[ATTR_NO_BUILTIN_CALL:#[^ ]*]]
+  // CHECK: call noalias nonnull ptr @_Znwm12__hot_cold_t(i64 noundef 1, i8 noundef zeroext 0) [[ATTR_NO_BUILTIN_CALL:#[^ ]*]]
   operator new(1, (__hot_cold_t)0);
-  // CHECK: call noalias noundef nonnull ptr @_Znwm12__hot_cold_t(i64 noundef 4, i8 noundef zeroext 0) [[ATTR_BUILTIN_CALL:#[^ ]*]]
+  // CHECK: call noalias nonnull ptr @_Znwm12__hot_cold_t(i64 noundef 4, i8 noundef zeroext 0) [[ATTR_BUILTIN_CALL:#[^ ]*]]
   new ((__hot_cold_t)0) int;
 }
 
-// CHECK: declare noundef nonnull ptr @_Znwm12__hot_cold_t(i64 noundef, i8 noundef zeroext) [[ATTR_NOBUILTIN:#[^ ]*]]
+// CHECK: declare nonnull ptr @_Znwm12__hot_cold_t(i64 noundef, i8 noundef zeroext) [[ATTR_NOBUILTIN:#[^ ]*]]
 
 void hot_cold_new_array() {
-  // CHECK: call noalias noundef nonnull ptr @_Znam12__hot_cold_t(i64 noundef 1, i8 noundef zeroext 0) [[ATTR_NO_BUILTIN_CALL:#[^ ]*]]
+  // CHECK: call noalias nonnull ptr @_Znam12__hot_cold_t(i64 noundef 1, i8 noundef zeroext 0) [[ATTR_NO_BUILTIN_CALL:#[^ ]*]]
   operator new[](1, (__hot_cold_t)0);
-  // CHECK: call noalias noundef nonnull ptr @_Znam12__hot_cold_t(i64 noundef 4, i8 noundef zeroext 0) [[ATTR_BUILTIN_CALL:#[^ ]*]]
+  // CHECK: call noalias nonnull ptr @_Znam12__hot_cold_t(i64 noundef 4, i8 noundef zeroext 0) [[ATTR_BUILTIN_CALL:#[^ ]*]]
   new ((__hot_cold_t)0) int[1];
 }
 
-// CHECK: declare noundef nonnull ptr @_Znam12__hot_cold_t(i64 noundef, i8 noundef zeroext) [[ATTR_NOBUILTIN:#[^ ]*]]
+// CHECK: declare nonnull ptr @_Znam12__hot_cold_t(i64 noundef, i8 noundef zeroext) [[ATTR_NOBUILTIN:#[^ ]*]]
 
 void hot_cold_new_nothrow() {
   // CHECK: call noalias noundef ptr @_ZnwmRKSt9nothrow_t12__hot_cold_t(i64 noundef 1, {{.*}} @nothrow, i8 noundef zeroext 0) [[ATTR_NO_BUILTIN_NOTHROW_CALL:#[^ ]*]]
   operator new(1, nothrow, (__hot_cold_t)0);
   // CHECK: call noalias noundef ptr @_ZnwmRKSt9nothrow_t12__hot_cold_t(i64 noundef 4, {{.*}} @nothrow, i8 noundef zeroext 0) [[ATTR_BUILTIN_NOTHROW_CALL:#[^ ]*]]
   new (nothrow, (__hot_cold_t)0) int;
 }
 
 // CHECK: declare noundef ptr @_ZnwmRKSt9nothrow_t12__hot_cold_t(i64 noundef, ptr noundef nonnull align 1 dereferenceable(1), i8 noundef zeroext) [[ATTR_NOBUILTIN_NOTHROW:#[^ ]*]]
 
 void hot_cold_new_nothrow_array() {
   // CHECK: call noalias noundef ptr @_ZnamRKSt9nothrow_t12__hot_cold_t(i64 noundef 1, {{.*}} @nothrow, i8 noundef zeroext 0) [[ATTR_NO_BUILTIN_NOTHROW_CALL:#[^ ]*]]
   operator new[](1, nothrow, (__hot_cold_t)0);
   // CHECK: call noalias noundef ptr @_ZnamRKSt9nothrow_t12__hot_cold_t(i64 noundef 4, {{.*}} @nothrow, i8 noundef zeroext 0) [[ATTR_BUILTIN_NOTHROW_CALL:#[^ ]*]]
   new (nothrow, (__hot_cold_t)0) int[1];
 }
 
 // CHECK: declare noundef ptr @_ZnamRKSt9nothrow_t12__hot_cold_t(i64 noundef, ptr noundef nonnull align 1 dereferenceable(1), i8 noundef zeroext) [[ATTR_NOBUILTIN_NOTHROW:#[^ ]*]]
 
 class alignas(32) alignedstruct {
   int x;
 };
 
 void hot_cold_new_align() {
-  // CHECK: call noalias noundef nonnull align 32 ptr @_ZnwmSt11align_val_t12__hot_cold_t(i64 noundef 1, i64 noundef 32, i8 noundef zeroext 0) [[ATTR_NO_BUILTIN_CALL:#[^ ]*]]
+  // CHECK: call noalias nonnull align 32 ptr @_ZnwmSt11align_val_t12__hot_cold_t(i64 noundef 1, i64 noundef 32, i8 noundef zeroext 0) [[ATTR_NO_BUILTIN_CALL:#[^ ]*]]
   operator new(1, (std::align_val_t)32, (__hot_cold_t)0);
-  // CHECK: call noalias noundef nonnull align 32 ptr @_ZnwmSt11align_val_t12__hot_cold_t(i64 noundef 32, i64 noundef 32, i8 noundef zeroext 0) [[ATTR_BUILTIN_CALL:#[^ ]*]]
+  // CHECK: call noalias nonnull align 32 ptr @_ZnwmSt11align_val_t12__hot_cold_t(i64 noundef 32, i64 noundef 32, i8 noundef zeroext 0) [[ATTR_BUILTIN_CALL:#[^ ]*]]
   new ((__hot_cold_t)0) alignedstruct;
 }
 
-// CHECK: declare noundef nonnull ptr @_ZnwmSt11align_val_t12__hot_cold_t(i64 noundef, i64 noundef, i8 noundef zeroext) [[ATTR_NOBUILTIN:#[^ ]*]]
+// CHECK: declare nonnull ptr @_ZnwmSt11align_val_t12__hot_cold_t(i64 noundef, i64 noundef, i8 noundef zeroext) [[ATTR_NOBUILTIN:#[^ ]*]]
 
 void hot_cold_new_align_array() {
-  // CHECK: call noalias noundef nonnull align 32 ptr @_ZnamSt11align_val_t12__hot_cold_t(i64 noundef 1, i64 noundef 32, i8 noundef zeroext 0) [[ATTR_NO_BUILTIN_CALL:#[^ ]*]]
+  // CHECK: call noalias nonnull align 32 ptr @_ZnamSt11align_val_t12__hot_cold_t(i64 noundef 1, i64 noundef 32, i8 noundef zeroext 0) [[ATTR_NO_BUILTIN_CALL:#[^ ]*]]
   operator new[](1, (std::align_val_t)32, (__hot_cold_t)0);
-  // CHECK: call noalias noundef nonnull align 32 ptr @_ZnamSt11align_val_t12__hot_cold_t(i64 noundef 32, i64 noundef 32, i8 noundef zeroext 0) [[ATTR_BUILTIN_CALL:#[^ ]*]]
+  // CHECK: call noalias nonnull align 32 ptr @_ZnamSt11align_val_t12__hot_cold_t(i64 noundef 32, i64 noundef 32, i8 noundef zeroext 0) [[ATTR_BUILTIN_CALL:#[^ ]*]]
   new ((__hot_cold_t)0) alignedstruct[1];
 }
 
-// CHECK: declare noundef nonnull ptr @_ZnamSt11align_val_t12__hot_cold_t(i64 noundef, i64 noundef, i8 noundef zeroext) [[ATTR_NOBUILTIN:#[^ ]*]]
+// CHECK: declare nonnull ptr @_ZnamSt11align_val_t12__hot_cold_t(i64 noundef, i64 noundef, i8 noundef zeroext) [[ATTR_NOBUILTIN:#[^ ]*]]
 
 void hot_cold_new_align_nothrow() {
   // CHECK: call noalias noundef align 32 ptr @_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64 noundef 1, i64 noundef 32, {{.*}} @nothrow, i8 noundef zeroext 0) [[ATTR_NO_BUILTIN_NOTHROW_CALL:#[^ ]*]]
   operator new(1, (std::align_val_t)32, nothrow, (__hot_cold_t)0);
   // CHECK: call noalias noundef align 32 ptr @_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64 noundef 32, i64 noundef 32, {{.*}} @nothrow, i8 noundef zeroext 0) [[ATTR_BUILTIN_NOTHROW_CALL:#[^ ]*]]
   new (nothrow, (__hot_cold_t)0) alignedstruct;
 }
 

clang/test/CodeGenCXX/operator-new.cpp

 // RUN: %clang_cc1 -triple i686-pc-linux-gnu -emit-llvm -o %t-1.ll %s
 // RUN: FileCheck --check-prefix=ALL -check-prefix SANE --input-file=%t-1.ll %s
 // RUN: %clang_cc1 -triple i686-pc-linux-gnu -emit-llvm -fno-assume-sane-operator-new -o %t-2.ll %s
 // RUN: FileCheck --check-prefix=ALL -check-prefix SANENOT --input-file=%t-2.ll %s
 
 class teste {
   int A;
 public:
   teste() : A(2) {}
 };
 
 void f1() {
-  // ALL: declare noundef nonnull ptr @_Znwj(
+  // ALL: declare nonnull ptr @_Znwj(
   new teste();
 }
 
 // rdar://5739832 - operator new should check for overflow in multiply.
 void *f2(long N) {
   return new int[N];
 
   // ALL:      [[UWO:%.*]] = call {{.*}} @llvm.umul.with.overflow
   // ALL-NEXT: [[OVER:%.*]] = extractvalue {{.*}} [[UWO]], 1
   // ALL-NEXT: [[SUM:%.*]] = extractvalue {{.*}} [[UWO]], 0
   // ALL-NEXT: [[RESULT:%.*]] = select i1 [[OVER]], i32 -1, i32 [[SUM]]
-  // SANE-NEXT: call noalias noundef nonnull ptr @_Znaj(i32 noundef [[RESULT]])
-  // SANENOT-NEXT: call noundef nonnull ptr @_Znaj(i32 noundef [[RESULT]])
+  // SANE-NEXT: call noalias nonnull ptr @_Znaj(i32 noundef [[RESULT]])
+  // SANENOT-NEXT: call nonnull ptr @_Znaj(i32 noundef [[RESULT]])
 }
 
-// ALL: declare noundef nonnull ptr @_Znaj(
+// ALL: declare nonnull ptr @_Znaj(

clang/test/CodeGenCXX/static-init.cpp

void f() {
   // CHECK: call i32 @__cxa_guard_acquire
   // CHECK: call void @_ZN1AC1Ev
   // CHECK: call i32 @__cxa_atexit(ptr @_ZN1AD1Ev, ptr @_ZZ1fvE1a, ptr @__dso_handle)
   // CHECK: call void @__cxa_guard_release
   static A a;
 }
 
 void g() {
-  // CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef 1)
+  // CHECK: call noalias nonnull ptr @_Znwm(i64 noundef 1)
   // CHECK: call void @_ZN1AC1Ev(
   static A& a = *new A;
 }
 
 int a();
 void h() {
   static const int i = a();
 }

clang/test/CodeGenCoroutines/coro-alloc.cpp

 // CHECK-LABEL: f0(
 extern "C" void f0(global_new_delete_tag) {
   // CHECK: %[[ID:.+]] = call token @llvm.coro.id(i32 16
   // CHECK: %[[NeedAlloc:.+]] = call i1 @llvm.coro.alloc(token %[[ID]])
   // CHECK: br i1 %[[NeedAlloc]], label %[[AllocBB:.+]], label %[[InitBB:.+]]
 
   // CHECK: [[AllocBB]]:
   // CHECK: %[[SIZE:.+]] = call i64 @llvm.coro.size.i64()
-  // CHECK: %[[MEM:.+]] = call noalias noundef nonnull ptr @_Znwm(i64 noundef %[[SIZE]])
+  // CHECK: %[[MEM:.+]] = call noalias nonnull ptr @_Znwm(i64 noundef %[[SIZE]])
   // CHECK: br label %[[InitBB]]
 
   // CHECK: [[InitBB]]:
   // CHECK: %[[PHI:.+]] = phi ptr [ null, %{{.+}} ], [ %call, %[[AllocBB]] ]
   // CHECK: %[[FRAME:.+]] = call ptr @llvm.coro.begin(token %[[ID]], ptr %[[PHI]])
 
   // CHECK: %[[MEM:.+]] = call ptr @llvm.coro.free(token %[[ID]], ptr %[[FRAME]])
   // CHECK: %[[NeedDealloc:.+]] = icmp ne ptr %[[MEM]], null

 };
 
 // A coroutine that takes a single pointer argument should not invoke this
 // placement form operator. [dcl.fct.def.coroutine]/7 dictates that lookup for
 // allocation functions matching the coroutine function's signature be done
 // within the scope of the promise type's class.
 // CHECK-LABEL: f1b(
 extern "C" void f1b(promise_matching_global_placement_new_tag, dummy *) {
-  // CHECK: call noalias noundef nonnull ptr @_Znwm(i64
+  // CHECK: call noalias nonnull ptr @_Znwm(i64
   co_return;
 }
 
 struct promise_delete_tag {};
 
 template <>
 struct std::coroutine_traits<void, promise_delete_tag> {
   struct promise_type {
     void operator delete(void*);
     void get_return_object() {}
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
     void return_void() {}
   };
 };
 
 // CHECK-LABEL: f2(
 extern "C" void f2(promise_delete_tag) {
   // CHECK: %[[ID:.+]] = call token @llvm.coro.id(i32 16
   // CHECK: %[[SIZE:.+]] = call i64 @llvm.coro.size.i64()
-  // CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef %[[SIZE]])
+  // CHECK: call noalias nonnull ptr @_Znwm(i64 noundef %[[SIZE]])
 
   // CHECK: %[[FRAME:.+]] = call ptr @llvm.coro.begin(
   // CHECK: %[[MEM:.+]] = call ptr @llvm.coro.free(token %[[ID]], ptr %[[FRAME]])
   // CHECK: call void @_ZNSt16coroutine_traitsIJv18promise_delete_tagEE12promise_typedlEPv(ptr noundef %[[MEM]])
   co_return;
 }
 
 struct promise_sized_delete_tag {};
 
 template <>
 struct std::coroutine_traits<void, promise_sized_delete_tag> {
   struct promise_type {
     void operator delete(void*, unsigned long);
     void get_return_object() {}
     suspend_always initial_suspend() { return {}; }
     suspend_always final_suspend() noexcept { return {}; }
     void return_void() {}
   };
 };
 
 // CHECK-LABEL: f3(
 extern "C" void f3(promise_sized_delete_tag) {
   // CHECK: %[[ID:.+]] = call token @llvm.coro.id(i32 16
   // CHECK: %[[SIZE:.+]] = call i64 @llvm.coro.size.i64()
-  // CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef %[[SIZE]])
+  // CHECK: call noalias nonnull ptr @_Znwm(i64 noundef %[[SIZE]])
 
   // CHECK: %[[FRAME:.+]] = call ptr @llvm.coro.begin(
   // CHECK: %[[MEM:.+]] = call ptr @llvm.coro.free(token %[[ID]], ptr %[[FRAME]])
   // CHECK: %[[SIZE2:.+]] = call i64 @llvm.coro.size.i64()
   // CHECK: call void @_ZNSt16coroutine_traitsIJv24promise_sized_delete_tagEE12promise_typedlEPvm(ptr noundef %[[MEM]], i64 noundef %[[SIZE2]])
   co_return;
 }
 
struct promise_type {
     void return_void() {}
   };
 };
 
 // CHECK-LABEL: f5(
 extern "C" void f5(promise_sized_delete_tag2) {
   // CHECK: %[[ID:.+]] = call token @llvm.coro.id(i32 16
   // CHECK: %[[SIZE:.+]] = call i64 @llvm.coro.size.i64()
-  // CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef %[[SIZE]])
+  // CHECK: call noalias nonnull ptr @_Znwm(i64 noundef %[[SIZE]])
 
   // CHECK: %[[FRAME:.+]] = call ptr @llvm.coro.begin(
   // CHECK: %[[MEM:.+]] = call ptr @llvm.coro.free(token %[[ID]], ptr %[[FRAME]])
   // CHECK: %[[SIZE2:.+]] = call i64 @llvm.coro.size.i64()
   // CHECK: call void @_ZNSt16coroutine_traitsIJv25promise_sized_delete_tag2EE12promise_typedlEPvm(ptr noundef %[[MEM]], i64 noundef %[[SIZE2]])
   co_return;
 }

clang/test/CodeGenCoroutines/coro-gro.cpp

 void doSomething() noexcept;
 
 // CHECK: define{{.*}} i32 @_Z1fv(
 int f() {
   // CHECK: %[[RetVal:.+]] = alloca i32
   // CHECK: %[[GroActive:.+]] = alloca i1
 
   // CHECK: %[[Size:.+]] = call i64 @llvm.coro.size.i64()
-  // CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef %[[Size]])
+  // CHECK: call noalias nonnull ptr @_Znwm(i64 noundef %[[Size]])
   // CHECK: store i1 false, ptr %[[GroActive]]
   // CHECK: call void @_ZNSt16coroutine_traitsIiJEE12promise_typeC1Ev(
   // CHECK: call void @_ZNSt16coroutine_traitsIiJEE12promise_type17get_return_objectEv(
   // CHECK: store i1 true, ptr %[[GroActive]]
 
   Cleanup cleanup;
   doSomething();
   co_return;

clang/test/CodeGenCoroutines/coro-gro2.cpp

struct coro {
   coro(coro const&);
   struct Impl;
   Impl *impl;
 };
 
 // Verify that the RVO is applied.
 // CHECK-LABEL: define{{.*}} void @_Z1fi(ptr noalias sret(%struct.coro) align 8 %agg.result, i32 noundef %0)
 coro f(int) {
-// CHECK: %call = call noalias noundef nonnull ptr @_Znwm(
+// CHECK: %call = call noalias nonnull ptr @_Znwm(
 // CHECK-NEXT: br label %[[CoroInit:.*]]
 
 // CHECK: {{.*}}[[CoroInit]]:
 // CHECK: call void @{{.*get_return_objectEv}}(ptr sret(%struct.coro) align 8 %agg.result
 co_return;
 }
 
 

clang/test/CodeGenCoroutines/coro-return.cpp

struct promise_type {
     suspend_always final_suspend() noexcept;
     void return_void();
   };
 };
 
 // CHECK-LABEL: f0(
 extern "C" void f0() {
   // CHECK: %__promise = alloca %"struct.std::coroutine_traits<void>::promise_type"
-  // CHECK: %call = call noalias noundef nonnull ptr @_Znwm(
+  // CHECK: %call = call noalias nonnull ptr @_Znwm(
   // CHECK: call void @_ZNSt16coroutine_traitsIJvEE12promise_type11return_voidEv(ptr {{[^,]*}} %__promise)
   // CHECK: call void @_ZdlPv
   co_return;
 }
 
 template <>
 struct std::coroutine_traits<int> {
   struct promise_type {
     int get_return_object();
     suspend_always initial_suspend();
     suspend_always final_suspend() noexcept;
     void return_value(int);
   };
 };
 
 // CHECK-LABEL: f1(
 extern "C" int f1() {
   // CHECK: %__promise = alloca %"struct.std::coroutine_traits<int>::promise_type"
-  // CHECK: %call = call noalias noundef nonnull ptr @_Znwm(
+  // CHECK: %call = call noalias nonnull ptr @_Znwm(
   // CHECK: call void @_ZNSt16coroutine_traitsIJiEE12promise_type12return_valueEi(ptr {{[^,]*}} %__promise, i32 noundef 42)
   // CHECK: call void @_ZdlPv
   co_return 42;
 }

clang/test/CodeGenObjCXX/arc-new-delete.mm

 // RUN: %clang_cc1 -fobjc-arc -fobjc-runtime-has-weak -fblocks -triple x86_64-apple-darwin10.0.0 -emit-llvm -o - %s | FileCheck %s -check-prefix=CHECK -check-prefix=UNOPT
 // RUN: %clang_cc1 -fobjc-arc -fobjc-runtime-has-weak -fblocks -triple x86_64-apple-darwin10.0.0 -emit-llvm -o - %s -O -disable-llvm-passes | FileCheck %s -check-prefix=CHECK -check-prefix=OPT
 
 typedef __strong id strong_id;
 typedef __weak id weak_id;
 
 // CHECK-LABEL: define{{.*}} void @_Z8test_newP11objc_object
 void test_new(id invalue) {
   // CHECK: [[INVALUEADDR:%.*]] = alloca ptr
   // UNOPT-NEXT: store ptr null, ptr [[INVALUEADDR]]
   // UNOPT-NEXT: call void @llvm.objc.storeStrong(ptr [[INVALUEADDR]], ptr [[INVALUE:%.*]])
   // OPT-NEXT: [[T0:%.*]] = call ptr @llvm.objc.retain(ptr [[INVALUE:%.*]])
   // OPT-NEXT: store ptr [[T0]], ptr [[INVALUEADDR]]
 
-  // CHECK: [[CALL:%.*]] = call noalias noundef nonnull ptr @_Znwm
+  // CHECK: [[CALL:%.*]] = call noalias nonnull ptr @_Znwm
   // CHECK-NEXT: store ptr null, ptr
   new strong_id;
-  // CHECK: [[CALL:%.*]] = call noalias noundef nonnull ptr @_Znwm
+  // CHECK: [[CALL:%.*]] = call noalias nonnull ptr @_Znwm
   // UNOPT-NEXT: store ptr null, ptr
   // OPT-NEXT: call ptr @llvm.objc.initWeak(ptr {{.*}}, ptr null)
   new weak_id;
 
-  // CHECK: [[CALL:%.*]] = call noalias noundef nonnull ptr @_Znwm
+  // CHECK: [[CALL:%.*]] = call noalias nonnull ptr @_Znwm
   // CHECK-NEXT: store ptr null, ptr
   new __strong id;
-  // CHECK: [[CALL:%.*]] = call noalias noundef nonnull ptr @_Znwm
+  // CHECK: [[CALL:%.*]] = call noalias nonnull ptr @_Znwm
   // UNOPT-NEXT: store ptr null, ptr
   // OPT-NEXT: call ptr @llvm.objc.initWeak(ptr {{.*}}, ptr null)
   new __weak id;
 
-  // CHECK: [[CALL:%.*]] = call noalias noundef nonnull ptr @_Znwm
+  // CHECK: [[CALL:%.*]] = call noalias nonnull ptr @_Znwm
   // CHECK: call ptr @llvm.objc.retain
   // CHECK: store ptr
   new __strong id(invalue);
 
-  // CHECK: [[CALL:%.*]] = call noalias noundef nonnull ptr @_Znwm
+  // CHECK: [[CALL:%.*]] = call noalias nonnull ptr @_Znwm
   // CHECK: call ptr @llvm.objc.initWeak
   new __weak id(invalue);
 
   // UNOPT: call void @llvm.objc.storeStrong
   // OPT: call void @llvm.objc.release
   // CHECK: ret void
 }
 
 // CHECK-LABEL: define{{.*}} void @_Z14test_array_new
 void test_array_new() {
-  // CHECK: call noalias noundef nonnull ptr @_Znam
+  // CHECK: call noalias nonnull ptr @_Znam
   // CHECK: store i64 17, ptr
   // CHECK: call void @llvm.memset.p0.i64
   new strong_id[17];
 
-  // CHECK: call noalias noundef nonnull ptr @_Znam
+  // CHECK: call noalias nonnull ptr @_Znam
   // CHECK: store i64 17, ptr
   // CHECK: call void @llvm.memset.p0.i64
   new weak_id[17];
   // CHECK: ret void
 }
 
 // CHECK-LABEL: define{{.*}} void @_Z11test_deletePU8__strongP11objc_objectPU6__weakS0_
 void test_delete(__strong id *sptr, __weak id *wptr) {

clang/test/CodeGenObjCXX/copy.mm

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fobjc-runtime=macosx-fragile-10.5 -emit-llvm -o - %s | FileCheck %s
 
 // rdar://problem/9158302
 // This should not use a memmove_collectable in non-GC mode.
 namespace test0 {
   struct A {
     id x;
   };
 
   // CHECK:    define{{.*}} ptr @_ZN5test04testENS_1AE(
   // CHECK:      alloca
   // CHECK-NEXT: getelementptr
   // CHECK-NEXT: store
-  // CHECK-NEXT: [[CALL:%.*]] = call noalias noundef nonnull ptr @_Znwm(
+  // CHECK-NEXT: [[CALL:%.*]] = call noalias nonnull ptr @_Znwm(
   // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(
   // CHECK-NEXT: ret
   A *test(A a) {
     return new A(a);
   }
 }
 
 

clang/test/OpenMP/reduction_implicit_map.cpp

 // CHECK2-SAME: () #[[ATTR7:[0-9]+]] {
 // CHECK2-NEXT:  entry:
 // CHECK2-NEXT:    [[RETVAL:%.*]] = alloca i32, align 4
 // CHECK2-NEXT:    [[SIZE:%.*]] = alloca i32, align 4
 // CHECK2-NEXT:    [[ARRAY:%.*]] = alloca ptr, align 4
 // CHECK2-NEXT:    [[RESULT:%.*]] = alloca i32, align 4
 // CHECK2-NEXT:    store i32 0, ptr [[RETVAL]], align 4
 // CHECK2-NEXT:    store i32 100, ptr [[SIZE]], align 4
-// CHECK2-NEXT:    [[CALL:%.*]] = call noalias noundef nonnull ptr @_Znaj(i32 noundef 400) #[[ATTR10:[0-9]+]]
+// CHECK2-NEXT:    [[CALL:%.*]] = call noalias nonnull ptr @_Znaj(i32 noundef 400) #[[ATTR10:[0-9]+]]
 // CHECK2-NEXT:    store ptr [[CALL]], ptr [[ARRAY]], align 4
 // CHECK2-NEXT:    store i32 0, ptr [[RESULT]], align 4
 // CHECK2-NEXT:    [[TMP0:%.*]] = load ptr, ptr [[ARRAY]], align 4
 // CHECK2-NEXT:    call void @_Z3sumPiiS_(ptr noundef [[TMP0]], i32 noundef 100, ptr noundef [[RESULT]])
 // CHECK2-NEXT:    ret i32 0
 //
 //
 // CHECK2-LABEL: define {{[^@]+}}@.omp_offloading.requires_reg
 // CHECK2-SAME: () #[[ATTR9:[0-9]+]] {
 // CHECK2-NEXT:  entry:
 // CHECK2-NEXT:    call void @__tgt_register_requires(i64 1)
 // CHECK2-NEXT:    ret void
 //