[llvm] 5554451 - [Attributor] Allow IR-attr deduction for non-IPO amendable functions
Johannes Doerfert via llvm-commits
llvm-commits at lists.llvm.org
Fri Jul 14 13:55:00 PDT 2023
Author: Johannes Doerfert
Date: 2023-07-14T13:54:04-07:00
New Revision: 55544518c6020b98e12a31c0c7d13bb0e549d850
URL: https://github.com/llvm/llvm-project/commit/55544518c6020b98e12a31c0c7d13bb0e549d850
DIFF: https://github.com/llvm/llvm-project/commit/55544518c6020b98e12a31c0c7d13bb0e549d850.diff
LOG: [Attributor] Allow IR-attr deduction for non-IPO amendable functions
If the function is non-IPO amendable we do skip most attributes/AAs.
However, if an AA has a isImpliedByIR that can deduce the attribute from
other attributes, we can run those. For now, we manually enable them,
if we have more later we can use some automation/flag.
Added:
Modified:
llvm/include/llvm/Transforms/IPO/Attributor.h
llvm/lib/Transforms/IPO/Attributor.cpp
llvm/test/Transforms/Attributor/ArgumentPromotion/array.ll
llvm/test/Transforms/Attributor/ArgumentPromotion/musttail.ll
llvm/test/Transforms/Attributor/ArgumentPromotion/variadic.ll
llvm/test/Transforms/Attributor/align.ll
llvm/test/Transforms/Attributor/depgraph.ll
llvm/test/Transforms/Attributor/memory_locations.ll
llvm/test/Transforms/Attributor/nocapture-1.ll
llvm/test/Transforms/Attributor/nofree.ll
llvm/test/Transforms/Attributor/nonnull.ll
llvm/test/Transforms/Attributor/readattrs.ll
llvm/test/Transforms/Attributor/value-simplify-instances.ll
llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll
llvm/test/Transforms/Attributor/willreturn.ll
Removed:
################################################################################
diff --git a/llvm/include/llvm/Transforms/IPO/Attributor.h b/llvm/include/llvm/Transforms/IPO/Attributor.h
index 31ce9baf62fa86..9cb8cf9926376a 100644
--- a/llvm/include/llvm/Transforms/IPO/Attributor.h
+++ b/llvm/include/llvm/Transforms/IPO/Attributor.h
@@ -3522,6 +3522,15 @@ struct AAMustProgress
AAMustProgress> {
AAMustProgress(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
+ static bool isImpliedByIR(Attributor &A, const IRPosition &IRP,
+ Attribute::AttrKind ImpliedAttributeKind,
+ bool IgnoreSubsumingPositions = false) {
+ // Note: This is also run for non-IPO amendable functions.
+ assert(ImpliedAttributeKind == Attribute::MustProgress);
+ return A.hasAttr(IRP, {Attribute::MustProgress, Attribute::WillReturn},
+ IgnoreSubsumingPositions, Attribute::MustProgress);
+ }
+
/// Return true if we assume that the underlying value is nonnull.
bool isAssumedMustProgress() const { return getAssumed(); }
@@ -3640,6 +3649,8 @@ struct AAWillReturn
static bool isImpliedByIR(Attributor &A, const IRPosition &IRP,
Attribute::AttrKind ImpliedAttributeKind,
bool IgnoreSubsumingPositions = false) {
+ // Note: This is also run for non-IPO amendable functions.
+ assert(ImpliedAttributeKind == Attribute::WillReturn);
if (IRAttribute::isImpliedByIR(A, IRP, ImpliedAttributeKind,
IgnoreSubsumingPositions))
return true;
@@ -3816,6 +3827,17 @@ struct AANoFree
AANoFree> {
AANoFree(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
+ /// See IRAttribute::isImpliedByIR
+ static bool isImpliedByIR(Attributor &A, const IRPosition &IRP,
+ Attribute::AttrKind ImpliedAttributeKind,
+ bool IgnoreSubsumingPositions = false) {
+ // Note: This is also run for non-IPO amendable functions.
+ assert(ImpliedAttributeKind == Attribute::NoFree);
+ return A.hasAttr(
+ IRP, {Attribute::ReadNone, Attribute::ReadOnly, Attribute::NoFree},
+ IgnoreSubsumingPositions, Attribute::NoFree);
+ }
+
/// See AbstractAttribute::isValidIRPositionForInit
static bool isValidIRPositionForInit(Attributor &A, const IRPosition &IRP) {
if (!IRP.isFunctionScope() &&
diff --git a/llvm/lib/Transforms/IPO/Attributor.cpp b/llvm/lib/Transforms/IPO/Attributor.cpp
index 0c342feb13e482..102293b1960aa4 100644
--- a/llvm/lib/Transforms/IPO/Attributor.cpp
+++ b/llvm/lib/Transforms/IPO/Attributor.cpp
@@ -3270,26 +3270,26 @@ void Attributor::identifyDefaultAbstractAttributes(Function &F) {
if (EnableHeapToStack)
getOrCreateAAFor<AAHeapToStack>(FPos);
+ // Every function might be "must-progress".
+ checkAndQueryIRAttr<Attribute::MustProgress, AAMustProgress>(FPos, FnAttrs);
+
+ // Every function might be "no-free".
+ checkAndQueryIRAttr<Attribute::NoFree, AANoFree>(FPos, FnAttrs);
+
+ // Every function might be "will-return".
+ checkAndQueryIRAttr<Attribute::WillReturn, AAWillReturn>(FPos, FnAttrs);
+
// Everything that is visible from the outside (=function, argument, return
// positions), cannot be changed if the function is not IPO amendable. We can
// however analyse the code inside.
if (IsIPOAmendable) {
- // Every function might be "will-return".
- checkAndQueryIRAttr<Attribute::WillReturn, AAWillReturn>(FPos, FnAttrs);
-
- // Every function might be "must-progress".
- checkAndQueryIRAttr<Attribute::MustProgress, AAMustProgress>(FPos, FnAttrs);
-
// Every function can be nounwind.
checkAndQueryIRAttr<Attribute::NoUnwind, AANoUnwind>(FPos, FnAttrs);
// Every function might be marked "nosync"
checkAndQueryIRAttr<Attribute::NoSync, AANoSync>(FPos, FnAttrs);
- // Every function might be "no-free".
- checkAndQueryIRAttr<Attribute::NoFree, AANoFree>(FPos, FnAttrs);
-
// Every function might be "no-return".
checkAndQueryIRAttr<Attribute::NoReturn, AANoReturn>(FPos, FnAttrs);
@@ -3348,55 +3348,61 @@ void Attributor::identifyDefaultAbstractAttributes(Function &F) {
getOrCreateAAFor<AANoFPClass>(RetPos);
}
}
+ }
- for (Argument &Arg : F.args()) {
- IRPosition ArgPos = IRPosition::argument(Arg);
- auto ArgNo = Arg.getArgNo();
- AttributeSet ArgAttrs = Attrs.getParamAttrs(ArgNo);
+ for (Argument &Arg : F.args()) {
+ IRPosition ArgPos = IRPosition::argument(Arg);
+ auto ArgNo = Arg.getArgNo();
+ AttributeSet ArgAttrs = Attrs.getParamAttrs(ArgNo);
- // Every argument might be simplified. We have to go through the
- // Attributor interface though as outside AAs can register custom
- // simplification callbacks.
- bool UsedAssumedInformation = false;
- getAssumedSimplified(ArgPos, /* AA */ nullptr, UsedAssumedInformation,
- AA::Intraprocedural);
+ if (!IsIPOAmendable) {
+ if (Arg.getType()->isPointerTy())
+ // Every argument with pointer type might be marked nofree.
+ checkAndQueryIRAttr<Attribute::NoFree, AANoFree>(ArgPos, ArgAttrs);
+ continue;
+ }
+
+ // Every argument might be simplified. We have to go through the
+ // Attributor interface though as outside AAs can register custom
+ // simplification callbacks.
+ bool UsedAssumedInformation = false;
+ getAssumedSimplified(ArgPos, /* AA */ nullptr, UsedAssumedInformation,
+ AA::Intraprocedural);
- // Every argument might be dead.
- getOrCreateAAFor<AAIsDead>(ArgPos);
+ // Every argument might be dead.
+ getOrCreateAAFor<AAIsDead>(ArgPos);
- // Every argument might be marked noundef.
- checkAndQueryIRAttr<Attribute::NoUndef, AANoUndef>(ArgPos, ArgAttrs);
+ // Every argument might be marked noundef.
+ checkAndQueryIRAttr<Attribute::NoUndef, AANoUndef>(ArgPos, ArgAttrs);
- if (Arg.getType()->isPointerTy()) {
- // Every argument with pointer type might be marked nonnull.
- checkAndQueryIRAttr<Attribute::NonNull, AANonNull>(ArgPos, ArgAttrs);
+ if (Arg.getType()->isPointerTy()) {
+ // Every argument with pointer type might be marked nonnull.
+ checkAndQueryIRAttr<Attribute::NonNull, AANonNull>(ArgPos, ArgAttrs);
- // Every argument with pointer type might be marked noalias.
- checkAndQueryIRAttr<Attribute::NoAlias, AANoAlias>(ArgPos, ArgAttrs);
+ // Every argument with pointer type might be marked noalias.
+ checkAndQueryIRAttr<Attribute::NoAlias, AANoAlias>(ArgPos, ArgAttrs);
- // Every argument with pointer type might be marked dereferenceable.
- getOrCreateAAFor<AADereferenceable>(ArgPos);
+ // Every argument with pointer type might be marked dereferenceable.
+ getOrCreateAAFor<AADereferenceable>(ArgPos);
- // Every argument with pointer type might be marked align.
- getOrCreateAAFor<AAAlign>(ArgPos);
+ // Every argument with pointer type might be marked align.
+ getOrCreateAAFor<AAAlign>(ArgPos);
- // Every argument with pointer type might be marked nocapture.
- checkAndQueryIRAttr<Attribute::NoCapture, AANoCapture>(ArgPos,
- ArgAttrs);
+ // Every argument with pointer type might be marked nocapture.
+ checkAndQueryIRAttr<Attribute::NoCapture, AANoCapture>(ArgPos, ArgAttrs);
- // Every argument with pointer type might be marked
- // "readnone/readonly/writeonly/..."
- getOrCreateAAFor<AAMemoryBehavior>(ArgPos);
+ // Every argument with pointer type might be marked
+ // "readnone/readonly/writeonly/..."
+ getOrCreateAAFor<AAMemoryBehavior>(ArgPos);
- // Every argument with pointer type might be marked nofree.
- checkAndQueryIRAttr<Attribute::NoFree, AANoFree>(ArgPos, ArgAttrs);
+ // Every argument with pointer type might be marked nofree.
+ checkAndQueryIRAttr<Attribute::NoFree, AANoFree>(ArgPos, ArgAttrs);
- // Every argument with pointer type might be privatizable (or
- // promotable)
- getOrCreateAAFor<AAPrivatizablePtr>(ArgPos);
- } else if (AttributeFuncs::isNoFPClassCompatibleType(Arg.getType())) {
- getOrCreateAAFor<AANoFPClass>(ArgPos);
- }
+ // Every argument with pointer type might be privatizable (or
+ // promotable)
+ getOrCreateAAFor<AAPrivatizablePtr>(ArgPos);
+ } else if (AttributeFuncs::isNoFPClassCompatibleType(Arg.getType())) {
+ getOrCreateAAFor<AANoFPClass>(ArgPos);
}
}
diff --git a/llvm/test/Transforms/Attributor/ArgumentPromotion/array.ll b/llvm/test/Transforms/Attributor/ArgumentPromotion/array.ll
index e8ed3b07881053..a14e163f8c76bd 100644
--- a/llvm/test/Transforms/Attributor/ArgumentPromotion/array.ll
+++ b/llvm/test/Transforms/Attributor/ArgumentPromotion/array.ll
@@ -39,7 +39,7 @@ define internal void @callee(ptr noalias %arg) {
; CHECK-NEXT: store i32 [[TMP1]], ptr [[ARG_PRIV_0_1]], align 4
; CHECK-NEXT: [[ARG_PRIV_0_2:%.*]] = getelementptr [3 x i32], ptr [[ARG_PRIV]], i64 0, i64 2
; CHECK-NEXT: store i32 [[TMP2]], ptr [[ARG_PRIV_0_2]], align 4
-; CHECK-NEXT: call void @use(ptr noalias nocapture noundef nonnull readonly align 4 dereferenceable(12) [[ARG_PRIV]])
+; CHECK-NEXT: call void @use(ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(12) [[ARG_PRIV]])
; CHECK-NEXT: ret void
;
entry:
diff --git a/llvm/test/Transforms/Attributor/ArgumentPromotion/musttail.ll b/llvm/test/Transforms/Attributor/ArgumentPromotion/musttail.ll
index 0bb8298aa5719e..efa8e856096b54 100644
--- a/llvm/test/Transforms/Attributor/ArgumentPromotion/musttail.ll
+++ b/llvm/test/Transforms/Attributor/ArgumentPromotion/musttail.ll
@@ -68,7 +68,7 @@ define internal i32 @test2(ptr %p, i32 %p2) {
; CGSCC-NEXT: [[A:%.*]] = load i32, ptr [[A_GEP]], align 4
; CGSCC-NEXT: [[B:%.*]] = load i32, ptr [[B_GEP]], align 4
; CGSCC-NEXT: [[V:%.*]] = add i32 [[A]], [[B]]
-; CGSCC-NEXT: [[CA:%.*]] = musttail call noundef i32 @foo(ptr undef, i32 [[V]]) #[[ATTR6:[0-9]+]]
+; CGSCC-NEXT: [[CA:%.*]] = musttail call noundef i32 @foo(ptr nofree undef, i32 [[V]]) #[[ATTR6:[0-9]+]]
; CGSCC-NEXT: ret i32 [[CA]]
;
%a.gep = getelementptr %T, ptr %p, i64 0, i32 3
@@ -138,7 +138,7 @@ define internal i32 @test2b(ptr %p, i32 %p2) {
; CGSCC-NEXT: [[A:%.*]] = load i32, ptr [[A_GEP]], align 4
; CGSCC-NEXT: [[B:%.*]] = load i32, ptr [[B_GEP]], align 4
; CGSCC-NEXT: [[V:%.*]] = add i32 [[A]], [[B]]
-; CGSCC-NEXT: [[CA:%.*]] = musttail call noundef i32 @bar(ptr nonnull undef, i32 [[V]]) #[[ATTR7:[0-9]+]]
+; CGSCC-NEXT: [[CA:%.*]] = musttail call noundef i32 @bar(ptr nofree nonnull undef, i32 [[V]]) #[[ATTR7:[0-9]+]]
; CGSCC-NEXT: ret i32 [[CA]]
;
%a.gep = getelementptr %T, ptr %p, i64 0, i32 3
diff --git a/llvm/test/Transforms/Attributor/ArgumentPromotion/variadic.ll b/llvm/test/Transforms/Attributor/ArgumentPromotion/variadic.ll
index e70e0a5f7431ea..967dbc0ab5dc44 100644
--- a/llvm/test/Transforms/Attributor/ArgumentPromotion/variadic.ll
+++ b/llvm/test/Transforms/Attributor/ArgumentPromotion/variadic.ll
@@ -22,7 +22,7 @@ define i32 @main(i32 %argc, ptr nocapture readnone %argv) #0 {
; CHECK-LABEL: define {{[^@]+}}@main
; CHECK-SAME: (i32 [[ARGC:%.*]], ptr nocapture nofree readnone [[ARGV:%.*]]) {
; CHECK-NEXT: entry:
-; CHECK-NEXT: tail call void (ptr, ptr, ptr, ptr, ptr, ...) @callee_t0f(ptr undef, ptr undef, ptr undef, ptr undef, ptr undef, ptr noalias noundef nonnull byval([[STRUCT_TT0:%.*]]) align 8 dereferenceable(16) @t45)
+; CHECK-NEXT: tail call void (ptr, ptr, ptr, ptr, ptr, ...) @callee_t0f(ptr nofree undef, ptr nofree undef, ptr nofree undef, ptr nofree undef, ptr nofree undef, ptr noalias noundef nonnull byval([[STRUCT_TT0:%.*]]) align 8 dereferenceable(16) @t45)
; CHECK-NEXT: ret i32 0
;
entry:
diff --git a/llvm/test/Transforms/Attributor/align.ll b/llvm/test/Transforms/Attributor/align.ll
index 2156273b165bf3..6544ca491144d4 100644
--- a/llvm/test/Transforms/Attributor/align.ll
+++ b/llvm/test/Transforms/Attributor/align.ll
@@ -335,18 +335,18 @@ define void @test8_helper() {
; TUNIT-NEXT: [[PTR0:%.*]] = tail call ptr @unknown()
; TUNIT-NEXT: [[PTR1:%.*]] = tail call align 4 ptr @unknown()
; TUNIT-NEXT: [[PTR2:%.*]] = tail call align 8 ptr @unknown()
-; TUNIT-NEXT: tail call void @test8(ptr noalias nocapture readnone align 4 [[PTR1]], ptr noalias nocapture readnone align 4 [[PTR1]], ptr noalias nocapture readnone [[PTR0]]) #[[ATTR2:[0-9]+]]
-; TUNIT-NEXT: tail call void @test8(ptr noalias nocapture readnone align 8 [[PTR2]], ptr noalias nocapture readnone align 4 [[PTR1]], ptr noalias nocapture readnone align 4 [[PTR1]]) #[[ATTR2]]
-; TUNIT-NEXT: tail call void @test8(ptr noalias nocapture readnone align 8 [[PTR2]], ptr noalias nocapture readnone align 4 [[PTR1]], ptr noalias nocapture readnone align 4 [[PTR1]]) #[[ATTR2]]
+; TUNIT-NEXT: tail call void @test8(ptr noalias nocapture nofree readnone align 4 [[PTR1]], ptr noalias nocapture nofree readnone align 4 [[PTR1]], ptr noalias nocapture nofree readnone [[PTR0]]) #[[ATTR2:[0-9]+]]
+; TUNIT-NEXT: tail call void @test8(ptr noalias nocapture nofree readnone align 8 [[PTR2]], ptr noalias nocapture nofree readnone align 4 [[PTR1]], ptr noalias nocapture nofree readnone align 4 [[PTR1]]) #[[ATTR2]]
+; TUNIT-NEXT: tail call void @test8(ptr noalias nocapture nofree readnone align 8 [[PTR2]], ptr noalias nocapture nofree readnone align 4 [[PTR1]], ptr noalias nocapture nofree readnone align 4 [[PTR1]]) #[[ATTR2]]
; TUNIT-NEXT: ret void
;
; CGSCC-LABEL: define {{[^@]+}}@test8_helper() {
; CGSCC-NEXT: [[PTR0:%.*]] = tail call ptr @unknown()
; CGSCC-NEXT: [[PTR1:%.*]] = tail call align 4 ptr @unknown()
; CGSCC-NEXT: [[PTR2:%.*]] = tail call align 8 ptr @unknown()
-; CGSCC-NEXT: tail call void @test8(ptr noalias nocapture readnone align 4 [[PTR1]], ptr noalias nocapture readnone align 4 [[PTR1]], ptr noalias nocapture readnone [[PTR0]]) #[[ATTR3:[0-9]+]]
-; CGSCC-NEXT: tail call void @test8(ptr noalias nocapture readnone align 8 [[PTR2]], ptr noalias nocapture readnone align 4 [[PTR1]], ptr noalias nocapture readnone align 4 [[PTR1]]) #[[ATTR3]]
-; CGSCC-NEXT: tail call void @test8(ptr noalias nocapture readnone align 8 [[PTR2]], ptr noalias nocapture readnone align 4 [[PTR1]], ptr noalias nocapture readnone align 4 [[PTR1]]) #[[ATTR3]]
+; CGSCC-NEXT: tail call void @test8(ptr noalias nocapture nofree readnone align 4 [[PTR1]], ptr noalias nocapture nofree readnone align 4 [[PTR1]], ptr noalias nocapture nofree readnone [[PTR0]]) #[[ATTR3:[0-9]+]]
+; CGSCC-NEXT: tail call void @test8(ptr noalias nocapture nofree readnone align 8 [[PTR2]], ptr noalias nocapture nofree readnone align 4 [[PTR1]], ptr noalias nocapture nofree readnone align 4 [[PTR1]]) #[[ATTR3]]
+; CGSCC-NEXT: tail call void @test8(ptr noalias nocapture nofree readnone align 8 [[PTR2]], ptr noalias nocapture nofree readnone align 4 [[PTR1]], ptr noalias nocapture nofree readnone align 4 [[PTR1]]) #[[ATTR3]]
; CGSCC-NEXT: ret void
;
%ptr0 = tail call ptr @unknown()
@@ -363,18 +363,18 @@ declare void @user_i32_ptr(ptr nocapture readnone) nounwind
define internal void @test8(ptr %a, ptr %b, ptr %c) {
; TUNIT: Function Attrs: nounwind
; TUNIT-LABEL: define {{[^@]+}}@test8
-; TUNIT-SAME: (ptr noalias nocapture readnone align 4 [[A:%.*]], ptr noalias nocapture readnone align 4 [[B:%.*]], ptr noalias nocapture readnone [[C:%.*]]) #[[ATTR2]] {
-; TUNIT-NEXT: call void @user_i32_ptr(ptr noalias nocapture readnone align 4 [[A]]) #[[ATTR2]]
-; TUNIT-NEXT: call void @user_i32_ptr(ptr noalias nocapture readnone align 4 [[B]]) #[[ATTR2]]
-; TUNIT-NEXT: call void @user_i32_ptr(ptr noalias nocapture readnone [[C]]) #[[ATTR2]]
+; TUNIT-SAME: (ptr noalias nocapture nofree readnone align 4 [[A:%.*]], ptr noalias nocapture nofree readnone align 4 [[B:%.*]], ptr noalias nocapture nofree readnone [[C:%.*]]) #[[ATTR2]] {
+; TUNIT-NEXT: call void @user_i32_ptr(ptr noalias nocapture nofree readnone align 4 [[A]]) #[[ATTR2]]
+; TUNIT-NEXT: call void @user_i32_ptr(ptr noalias nocapture nofree readnone align 4 [[B]]) #[[ATTR2]]
+; TUNIT-NEXT: call void @user_i32_ptr(ptr noalias nocapture nofree readnone [[C]]) #[[ATTR2]]
; TUNIT-NEXT: ret void
;
; CGSCC: Function Attrs: nounwind
; CGSCC-LABEL: define {{[^@]+}}@test8
-; CGSCC-SAME: (ptr noalias nocapture readnone align 4 [[A:%.*]], ptr noalias nocapture readnone align 4 [[B:%.*]], ptr noalias nocapture readnone [[C:%.*]]) #[[ATTR3]] {
-; CGSCC-NEXT: call void @user_i32_ptr(ptr noalias nocapture readnone align 4 [[A]]) #[[ATTR3]]
-; CGSCC-NEXT: call void @user_i32_ptr(ptr noalias nocapture readnone align 4 [[B]]) #[[ATTR3]]
-; CGSCC-NEXT: call void @user_i32_ptr(ptr noalias nocapture readnone [[C]]) #[[ATTR3]]
+; CGSCC-SAME: (ptr noalias nocapture nofree readnone align 4 [[A:%.*]], ptr noalias nocapture nofree readnone align 4 [[B:%.*]], ptr noalias nocapture nofree readnone [[C:%.*]]) #[[ATTR3]] {
+; CGSCC-NEXT: call void @user_i32_ptr(ptr noalias nocapture nofree readnone align 4 [[A]]) #[[ATTR3]]
+; CGSCC-NEXT: call void @user_i32_ptr(ptr noalias nocapture nofree readnone align 4 [[B]]) #[[ATTR3]]
+; CGSCC-NEXT: call void @user_i32_ptr(ptr noalias nocapture nofree readnone [[C]]) #[[ATTR3]]
; CGSCC-NEXT: ret void
;
call void @user_i32_ptr(ptr %a)
@@ -961,34 +961,34 @@ exit:
define ptr @checkAndAdvance(ptr align(16) %p) {
; TUNIT: Function Attrs: nounwind
; TUNIT-LABEL: define {{[^@]+}}@checkAndAdvance
-; TUNIT-SAME: (ptr noundef nonnull readonly align 16 dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR2]] {
+; TUNIT-SAME: (ptr nofree noundef nonnull readonly align 16 dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR2]] {
; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[TMP0:%.*]] = load i32, ptr [[P]], align 16
; TUNIT-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], 0
; TUNIT-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[RETURN:%.*]]
; TUNIT: if.then:
; TUNIT-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i32, ptr [[P]], i64 4
-; TUNIT-NEXT: [[CALL:%.*]] = call ptr @checkAndAdvance(ptr noundef nonnull readonly align 16 "no-capture-maybe-returned" [[ADD_PTR]]) #[[ATTR2]]
+; TUNIT-NEXT: [[CALL:%.*]] = call ptr @checkAndAdvance(ptr nofree noundef nonnull readonly align 16 "no-capture-maybe-returned" [[ADD_PTR]]) #[[ATTR2]]
; TUNIT-NEXT: br label [[RETURN]]
; TUNIT: return:
; TUNIT-NEXT: [[RETVAL_0:%.*]] = phi ptr [ [[ADD_PTR]], [[IF_THEN]] ], [ [[P]], [[ENTRY:%.*]] ]
-; TUNIT-NEXT: call void @user_i32_ptr(ptr noalias nocapture nonnull readnone align 16 [[RETVAL_0]]) #[[ATTR2]]
+; TUNIT-NEXT: call void @user_i32_ptr(ptr noalias nocapture nofree nonnull readnone align 16 [[RETVAL_0]]) #[[ATTR2]]
; TUNIT-NEXT: ret ptr [[RETVAL_0]]
;
; CGSCC: Function Attrs: nounwind
; CGSCC-LABEL: define {{[^@]+}}@checkAndAdvance
-; CGSCC-SAME: (ptr noundef nonnull readonly align 16 dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR3]] {
+; CGSCC-SAME: (ptr nofree noundef nonnull readonly align 16 dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[TMP0:%.*]] = load i32, ptr [[P]], align 16
; CGSCC-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP0]], 0
; CGSCC-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[RETURN:%.*]]
; CGSCC: if.then:
; CGSCC-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i32, ptr [[P]], i64 4
-; CGSCC-NEXT: [[CALL:%.*]] = call ptr @checkAndAdvance(ptr noundef nonnull readonly align 16 "no-capture-maybe-returned" [[ADD_PTR]]) #[[ATTR3]]
+; CGSCC-NEXT: [[CALL:%.*]] = call ptr @checkAndAdvance(ptr nofree noundef nonnull readonly align 16 "no-capture-maybe-returned" [[ADD_PTR]]) #[[ATTR3]]
; CGSCC-NEXT: br label [[RETURN]]
; CGSCC: return:
; CGSCC-NEXT: [[RETVAL_0:%.*]] = phi ptr [ [[ADD_PTR]], [[IF_THEN]] ], [ [[P]], [[ENTRY:%.*]] ]
-; CGSCC-NEXT: call void @user_i32_ptr(ptr noalias nocapture nonnull readnone align 16 [[RETVAL_0]]) #[[ATTR3]]
+; CGSCC-NEXT: call void @user_i32_ptr(ptr noalias nocapture nofree nonnull readnone align 16 [[RETVAL_0]]) #[[ATTR3]]
; CGSCC-NEXT: ret ptr [[RETVAL_0]]
;
entry:
diff --git a/llvm/test/Transforms/Attributor/depgraph.ll b/llvm/test/Transforms/Attributor/depgraph.ll
index fa97cf3caec26b..f9180eae42d640 100644
--- a/llvm/test/Transforms/Attributor/depgraph.ll
+++ b/llvm/test/Transforms/Attributor/depgraph.ll
@@ -141,20 +141,14 @@ define ptr @checkAndAdvance(ptr align 16 %0) {
; GRAPH-EMPTY:
; GRAPH-NEXT: [AAHeapToStack] for CtxI ' %2 = load i32, ptr %0, align 4' at position {fn:checkAndAdvance [checkAndAdvance at -1]} with state [H2S] Mallocs Good/Bad: 0/0
; GRAPH-EMPTY:
+; GRAPH-NEXT: [AAMustProgress] for CtxI ' %2 = load i32, ptr %0, align 4' at position {fn:checkAndAdvance [checkAndAdvance at -1]} with state may-not-progress
+; GRAPH-EMPTY:
; GRAPH-NEXT: [AAWillReturn] for CtxI ' %2 = load i32, ptr %0, align 4' at position {fn:checkAndAdvance [checkAndAdvance at -1]} with state may-noreturn
; GRAPH-EMPTY:
; GRAPH-NEXT: [AAWillReturn] for CtxI ' %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs: [@-1]} with state may-noreturn
; GRAPH-EMPTY:
; GRAPH-NEXT: [AANoRecurse] for CtxI ' %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs: [@-1]} with state may-recurse
; GRAPH-EMPTY:
-; GRAPH-NEXT: [AAMustProgress] for CtxI ' %2 = load i32, ptr %0, align 4' at position {fn:checkAndAdvance [checkAndAdvance at -1]} with state may-not-progress
-; GRAPH-EMPTY:
-; GRAPH-NEXT: [AANoSync] for CtxI ' %2 = load i32, ptr %0, align 4' at position {fn:checkAndAdvance [checkAndAdvance at -1]} with state nosync
-; GRAPH-NEXT: updates [AANoSync] for CtxI ' %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs: [@-1]} with state nosync
-; GRAPH-EMPTY:
-; GRAPH-NEXT: [AANoSync] for CtxI ' %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs: [@-1]} with state nosync
-; GRAPH-NEXT: updates [AANoSync] for CtxI ' %2 = load i32, ptr %0, align 4' at position {fn:checkAndAdvance [checkAndAdvance at -1]} with state nosync
-; GRAPH-EMPTY:
; GRAPH-NEXT: [AANoFree] for CtxI ' %2 = load i32, ptr %0, align 4' at position {fn:checkAndAdvance [checkAndAdvance at -1]} with state nofree
; GRAPH-NEXT: updates [AANoFree] for CtxI ' %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs: [@-1]} with state nofree
; GRAPH-NEXT: updates [AANoFree] for CtxI ' %2 = load i32, ptr %0, align 4' at position {arg: [@0]} with state nofree
@@ -162,6 +156,12 @@ define ptr @checkAndAdvance(ptr align 16 %0) {
; GRAPH-NEXT: [AANoFree] for CtxI ' %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs: [@-1]} with state nofree
; GRAPH-NEXT: updates [AANoFree] for CtxI ' %2 = load i32, ptr %0, align 4' at position {fn:checkAndAdvance [checkAndAdvance at -1]} with state nofree
; GRAPH-EMPTY:
+; GRAPH-NEXT: [AANoSync] for CtxI ' %2 = load i32, ptr %0, align 4' at position {fn:checkAndAdvance [checkAndAdvance at -1]} with state nosync
+; GRAPH-NEXT: updates [AANoSync] for CtxI ' %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs: [@-1]} with state nosync
+; GRAPH-EMPTY:
+; GRAPH-NEXT: [AANoSync] for CtxI ' %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs: [@-1]} with state nosync
+; GRAPH-NEXT: updates [AANoSync] for CtxI ' %2 = load i32, ptr %0, align 4' at position {fn:checkAndAdvance [checkAndAdvance at -1]} with state nosync
+; GRAPH-EMPTY:
; GRAPH-NEXT: [AAMemoryLocation] for CtxI ' %2 = load i32, ptr %0, align 4' at position {fn:checkAndAdvance [checkAndAdvance at -1]} with state memory:argument
; GRAPH-NEXT: updates [AAMemoryLocation] for CtxI ' %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs: [@-1]} with state memory:argument
; GRAPH-EMPTY:
diff --git a/llvm/test/Transforms/Attributor/memory_locations.ll b/llvm/test/Transforms/Attributor/memory_locations.ll
index 737833eab6b78e..c5340cdcc28967 100644
--- a/llvm/test/Transforms/Attributor/memory_locations.ll
+++ b/llvm/test/Transforms/Attributor/memory_locations.ll
@@ -618,7 +618,7 @@ define i8 @readnone_caller2(i1 %c) {
; CGSCC: Function Attrs: nofree nosync nounwind memory(none)
; CGSCC-LABEL: define {{[^@]+}}@readnone_caller2
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR10]] {
-; CGSCC-NEXT: [[R:%.*]] = call i8 @recursive_readnone_internal2(ptr undef, i1 noundef [[C]]) #[[ATTR14]]
+; CGSCC-NEXT: [[R:%.*]] = call i8 @recursive_readnone_internal2(ptr nofree undef, i1 noundef [[C]]) #[[ATTR14]]
; CGSCC-NEXT: ret i8 [[R]]
;
%r = call i8 @recursive_readnone_internal2(ptr undef, i1 %c)
diff --git a/llvm/test/Transforms/Attributor/nocapture-1.ll b/llvm/test/Transforms/Attributor/nocapture-1.ll
index 1d9aeb9ae1e4b9..8147eb1d3abb00 100644
--- a/llvm/test/Transforms/Attributor/nocapture-1.ll
+++ b/llvm/test/Transforms/Attributor/nocapture-1.ll
@@ -323,14 +323,14 @@ declare void @external(ptr readonly) nounwind argmemonly
define void @nc4(ptr %p) {
; TUNIT: Function Attrs: nounwind memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@nc4
-; TUNIT-SAME: (ptr [[P:%.*]]) #[[ATTR5:[0-9]+]] {
-; TUNIT-NEXT: call void @external(ptr readonly [[P]]) #[[ATTR17:[0-9]+]]
+; TUNIT-SAME: (ptr nofree [[P:%.*]]) #[[ATTR5:[0-9]+]] {
+; TUNIT-NEXT: call void @external(ptr nofree readonly [[P]]) #[[ATTR17:[0-9]+]]
; TUNIT-NEXT: ret void
;
; CGSCC: Function Attrs: nounwind memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@nc4
-; CGSCC-SAME: (ptr [[P:%.*]]) #[[ATTR8:[0-9]+]] {
-; CGSCC-NEXT: call void @external(ptr readonly [[P]]) #[[ATTR20:[0-9]+]]
+; CGSCC-SAME: (ptr nofree [[P:%.*]]) #[[ATTR8:[0-9]+]] {
+; CGSCC-NEXT: call void @external(ptr nofree readonly [[P]]) #[[ATTR20:[0-9]+]]
; CGSCC-NEXT: ret void
;
call void @external(ptr %p)
@@ -802,13 +802,13 @@ declare void @val_use(i8 %ptr) readonly nounwind willreturn
define void @ptr_uses(ptr %ptr, ptr %wptr) {
; TUNIT: Function Attrs: mustprogress nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@ptr_uses
-; TUNIT-SAME: (ptr [[PTR:%.*]], ptr nocapture nofree noundef nonnull writeonly dereferenceable(1) [[WPTR:%.*]]) #[[ATTR11:[0-9]+]] {
+; TUNIT-SAME: (ptr nofree [[PTR:%.*]], ptr nocapture nofree noundef nonnull writeonly dereferenceable(1) [[WPTR:%.*]]) #[[ATTR11:[0-9]+]] {
; TUNIT-NEXT: store i8 0, ptr [[WPTR]], align 1
; TUNIT-NEXT: ret void
;
; CGSCC: Function Attrs: mustprogress nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@ptr_uses
-; CGSCC-SAME: (ptr [[PTR:%.*]], ptr nocapture nofree noundef nonnull writeonly dereferenceable(1) [[WPTR:%.*]]) #[[ATTR14:[0-9]+]] {
+; CGSCC-SAME: (ptr nofree [[PTR:%.*]], ptr nocapture nofree noundef nonnull writeonly dereferenceable(1) [[WPTR:%.*]]) #[[ATTR14:[0-9]+]] {
; CGSCC-NEXT: store i8 0, ptr [[WPTR]], align 1
; CGSCC-NEXT: ret void
;
diff --git a/llvm/test/Transforms/Attributor/nofree.ll b/llvm/test/Transforms/Attributor/nofree.ll
index 68f0e5b06cc223..68958afb24ecb0 100644
--- a/llvm/test/Transforms/Attributor/nofree.ll
+++ b/llvm/test/Transforms/Attributor/nofree.ll
@@ -258,7 +258,7 @@ define float @call_floor2(float %a) #0 {
; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@call_floor2
; CHECK-SAME: (float [[A:%.*]]) #[[ATTR3]] {
-; CHECK-NEXT: [[C:%.*]] = tail call nofpclass(sub) float @llvm.floor.f32(float [[A]]) #[[ATTR11:[0-9]+]]
+; CHECK-NEXT: [[C:%.*]] = tail call nofpclass(sub) float @llvm.floor.f32(float [[A]]) #[[ATTR14:[0-9]+]]
; CHECK-NEXT: ret float [[C]]
;
%c = tail call float @llvm.floor.f32(float %a)
@@ -355,7 +355,7 @@ define void @nonnull_assume_pos(ptr %arg1, ptr %arg2, ptr %arg3, ptr %arg4) {
;
; CHECK-LABEL: define {{[^@]+}}@nonnull_assume_pos
; CHECK-SAME: (ptr nofree [[ARG1:%.*]], ptr [[ARG2:%.*]], ptr nofree [[ARG3:%.*]], ptr [[ARG4:%.*]]) {
-; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR11]] [ "nofree"(ptr [[ARG1]]), "nofree"(ptr [[ARG3]]) ]
+; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR14]] [ "nofree"(ptr [[ARG1]]), "nofree"(ptr [[ARG3]]) ]
; CHECK-NEXT: call void @unknown(ptr nofree [[ARG1]], ptr [[ARG2]], ptr nofree [[ARG3]], ptr [[ARG4]])
; CHECK-NEXT: ret void
;
@@ -399,13 +399,13 @@ define void @nonnull_assume_call(ptr %arg1, ptr %arg2, ptr %arg3, ptr %arg4) {
; CHECK-LABEL: define {{[^@]+}}@nonnull_assume_call
; CHECK-SAME: (ptr [[ARG1:%.*]], ptr [[ARG2:%.*]], ptr [[ARG3:%.*]], ptr [[ARG4:%.*]]) {
; CHECK-NEXT: call void @unknown(ptr [[ARG1]], ptr [[ARG2]], ptr [[ARG3]], ptr [[ARG4]])
-; CHECK-NEXT: call void @use_i8_ptr(ptr noalias nocapture readnone [[ARG1]]) #[[ATTR0]]
-; CHECK-NEXT: call void @use_i8_ptr(ptr noalias nocapture readnone [[ARG2]]) #[[ATTR0]]
+; CHECK-NEXT: call void @use_i8_ptr(ptr noalias nocapture nofree readnone [[ARG1]]) #[[ATTR0]]
+; CHECK-NEXT: call void @use_i8_ptr(ptr noalias nocapture nofree readnone [[ARG2]]) #[[ATTR0]]
; CHECK-NEXT: call void @llvm.assume(i1 noundef true) [ "nofree"(ptr [[ARG1]]), "nofree"(ptr [[ARG3]]) ]
; CHECK-NEXT: call void @use_i8_ptr(ptr noalias nocapture nofree readnone [[ARG3]]) #[[ATTR0]]
-; CHECK-NEXT: call void @use_i8_ptr(ptr noalias nocapture readnone [[ARG4]]) #[[ATTR0]]
+; CHECK-NEXT: call void @use_i8_ptr(ptr noalias nocapture nofree readnone [[ARG4]]) #[[ATTR0]]
; CHECK-NEXT: call void @use_i8_ptr_ret(ptr noalias nocapture nofree readnone [[ARG1]]) #[[ATTR0]]
-; CHECK-NEXT: call void @use_i8_ptr_ret(ptr noalias nocapture readnone [[ARG2]]) #[[ATTR0]]
+; CHECK-NEXT: call void @use_i8_ptr_ret(ptr noalias nocapture nofree readnone [[ARG2]]) #[[ATTR0]]
; CHECK-NEXT: call void @llvm.assume(i1 noundef true) [ "nofree"(ptr [[ARG1]]), "nofree"(ptr [[ARG4]]) ]
; CHECK-NEXT: call void @use_i8_ptr_ret(ptr noalias nocapture nofree readnone [[ARG3]]) #[[ATTR0]]
; CHECK-NEXT: call void @use_i8_ptr_ret(ptr noalias nocapture nofree readnone [[ARG4]]) #[[ATTR0]]
@@ -424,6 +424,57 @@ define void @nonnull_assume_call(ptr %arg1, ptr %arg2, ptr %arg3, ptr %arg4) {
call void @use_i8_ptr_ret(ptr %arg4)
ret void
}
+
+; FIXME: function is nofree
+define weak void @implied_nofree1() readnone {
+; CHECK: Function Attrs: memory(none)
+; CHECK-LABEL: define {{[^@]+}}@implied_nofree1
+; CHECK-SAME: () #[[ATTR9:[0-9]+]] {
+; CHECK-NEXT: ret void
+;
+ ret void
+}
+; FIXME: function is nofree
+define weak void @implied_nofree2() readonly {
+; CHECK: Function Attrs: memory(read)
+; CHECK-LABEL: define {{[^@]+}}@implied_nofree2
+; CHECK-SAME: () #[[ATTR10:[0-9]+]] {
+; CHECK-NEXT: ret void
+;
+ ret void
+}
+define weak void @implied_nofree3(ptr readnone %a) {
+; CHECK-LABEL: define {{[^@]+}}@implied_nofree3
+; CHECK-SAME: (ptr nofree readnone [[A:%.*]]) {
+; CHECK-NEXT: ret void
+;
+ ret void
+}
+define weak void @implied_nofree4(ptr readonly %a) {
+; CHECK-LABEL: define {{[^@]+}}@implied_nofree4
+; CHECK-SAME: (ptr nofree readonly [[A:%.*]]) {
+; CHECK-NEXT: ret void
+;
+ ret void
+}
+; FIXME: %a is nofree
+define weak void @implied_nofree5(ptr %a) readonly {
+; CHECK: Function Attrs: memory(read)
+; CHECK-LABEL: define {{[^@]+}}@implied_nofree5
+; CHECK-SAME: (ptr [[A:%.*]]) #[[ATTR10]] {
+; CHECK-NEXT: ret void
+;
+ ret void
+}
+define weak void @implied_nofree6(ptr %a) nofree {
+; CHECK: Function Attrs: nofree
+; CHECK-LABEL: define {{[^@]+}}@implied_nofree6
+; CHECK-SAME: (ptr nofree [[A:%.*]]) #[[ATTR11:[0-9]+]] {
+; CHECK-NEXT: ret void
+;
+ ret void
+}
+
declare void @llvm.assume(i1)
declare void @unknown(ptr, ptr, ptr, ptr)
declare void @use_i8_ptr(ptr nocapture readnone) nounwind
@@ -444,9 +495,12 @@ attributes #2 = { nobuiltin nounwind }
; TUNIT: attributes #[[ATTR6:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
; TUNIT: attributes #[[ATTR7]] = { nofree nounwind }
; TUNIT: attributes #[[ATTR8]] = { nobuiltin nofree nounwind }
-; TUNIT: attributes #[[ATTR9:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
-; TUNIT: attributes #[[ATTR10:[0-9]+]] = { nounwind willreturn }
-; TUNIT: attributes #[[ATTR11]] = { nofree willreturn }
+; TUNIT: attributes #[[ATTR9]] = { memory(none) }
+; TUNIT: attributes #[[ATTR10]] = { memory(read) }
+; TUNIT: attributes #[[ATTR11]] = { nofree }
+; TUNIT: attributes #[[ATTR12:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
+; TUNIT: attributes #[[ATTR13:[0-9]+]] = { nounwind willreturn }
+; TUNIT: attributes #[[ATTR14]] = { nofree willreturn }
;.
; CGSCC: attributes #[[ATTR0]] = { nounwind }
; CGSCC: attributes #[[ATTR1]] = { noinline nounwind uwtable }
@@ -457,7 +511,10 @@ attributes #2 = { nobuiltin nounwind }
; CGSCC: attributes #[[ATTR6:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
; CGSCC: attributes #[[ATTR7]] = { nofree nounwind }
; CGSCC: attributes #[[ATTR8]] = { nobuiltin nofree nounwind }
-; CGSCC: attributes #[[ATTR9:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
-; CGSCC: attributes #[[ATTR10:[0-9]+]] = { nounwind willreturn }
-; CGSCC: attributes #[[ATTR11]] = { nofree willreturn }
+; CGSCC: attributes #[[ATTR9]] = { memory(none) }
+; CGSCC: attributes #[[ATTR10]] = { memory(read) }
+; CGSCC: attributes #[[ATTR11]] = { nofree }
+; CGSCC: attributes #[[ATTR12:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
+; CGSCC: attributes #[[ATTR13:[0-9]+]] = { nounwind willreturn }
+; CGSCC: attributes #[[ATTR14]] = { nofree willreturn }
;.
diff --git a/llvm/test/Transforms/Attributor/nonnull.ll b/llvm/test/Transforms/Attributor/nonnull.ll
index fe74147e08c39e..ac907ef2668f0e 100644
--- a/llvm/test/Transforms/Attributor/nonnull.ll
+++ b/llvm/test/Transforms/Attributor/nonnull.ll
@@ -993,14 +993,14 @@ declare void @use_i32_ptr(ptr readnone nocapture) nounwind
define internal void @called_by_weak(ptr %a) {
; TUNIT: Function Attrs: nounwind
; TUNIT-LABEL: define {{[^@]+}}@called_by_weak
-; TUNIT-SAME: (ptr noalias nocapture nonnull readnone [[A:%.*]]) #[[ATTR5]] {
-; TUNIT-NEXT: call void @use_i32_ptr(ptr noalias nocapture nonnull readnone [[A]]) #[[ATTR5]]
+; TUNIT-SAME: (ptr noalias nocapture nofree nonnull readnone [[A:%.*]]) #[[ATTR5]] {
+; TUNIT-NEXT: call void @use_i32_ptr(ptr noalias nocapture nofree nonnull readnone [[A]]) #[[ATTR5]]
; TUNIT-NEXT: ret void
;
; CGSCC: Function Attrs: nounwind
; CGSCC-LABEL: define {{[^@]+}}@called_by_weak
-; CGSCC-SAME: (ptr noalias nocapture nonnull readnone [[A:%.*]]) #[[ATTR4]] {
-; CGSCC-NEXT: call void @use_i32_ptr(ptr noalias nocapture nonnull readnone [[A]]) #[[ATTR4]]
+; CGSCC-SAME: (ptr noalias nocapture nofree nonnull readnone [[A:%.*]]) #[[ATTR4]] {
+; CGSCC-NEXT: call void @use_i32_ptr(ptr noalias nocapture nofree nonnull readnone [[A]]) #[[ATTR4]]
; CGSCC-NEXT: ret void
;
call void @use_i32_ptr(ptr %a)
@@ -1012,12 +1012,12 @@ define weak_odr void @weak_caller(ptr nonnull %a) {
;
; TUNIT-LABEL: define {{[^@]+}}@weak_caller
; TUNIT-SAME: (ptr nonnull [[A:%.*]]) {
-; TUNIT-NEXT: call void @called_by_weak(ptr noalias nocapture nonnull readnone [[A]]) #[[ATTR5]]
+; TUNIT-NEXT: call void @called_by_weak(ptr noalias nocapture nofree nonnull readnone [[A]]) #[[ATTR5]]
; TUNIT-NEXT: ret void
;
; CGSCC-LABEL: define {{[^@]+}}@weak_caller
; CGSCC-SAME: (ptr nonnull [[A:%.*]]) {
-; CGSCC-NEXT: call void @called_by_weak(ptr noalias nocapture nonnull readnone [[A]]) #[[ATTR4]]
+; CGSCC-NEXT: call void @called_by_weak(ptr noalias nocapture nofree nonnull readnone [[A]]) #[[ATTR4]]
; CGSCC-NEXT: ret void
;
call void @called_by_weak(ptr %a)
@@ -1028,14 +1028,14 @@ define weak_odr void @weak_caller(ptr nonnull %a) {
define internal void @control(ptr dereferenceable(4) %a) {
; TUNIT: Function Attrs: nounwind
; TUNIT-LABEL: define {{[^@]+}}@control
-; TUNIT-SAME: (ptr noalias nocapture noundef nonnull readnone align 16 dereferenceable(8) [[A:%.*]]) #[[ATTR5]] {
-; TUNIT-NEXT: call void @use_i32_ptr(ptr noalias nocapture noundef nonnull readnone align 16 dereferenceable(8) [[A]]) #[[ATTR5]]
+; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull readnone align 16 dereferenceable(8) [[A:%.*]]) #[[ATTR5]] {
+; TUNIT-NEXT: call void @use_i32_ptr(ptr noalias nocapture nofree noundef nonnull readnone align 16 dereferenceable(8) [[A]]) #[[ATTR5]]
; TUNIT-NEXT: ret void
;
; CGSCC: Function Attrs: nounwind
; CGSCC-LABEL: define {{[^@]+}}@control
-; CGSCC-SAME: (ptr noalias nocapture noundef nonnull readnone align 16 dereferenceable(8) [[A:%.*]]) #[[ATTR4]] {
-; CGSCC-NEXT: call void @use_i32_ptr(ptr noalias nocapture noundef nonnull readnone align 16 dereferenceable(8) [[A]]) #[[ATTR4]]
+; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull readnone align 16 dereferenceable(8) [[A:%.*]]) #[[ATTR4]] {
+; CGSCC-NEXT: call void @use_i32_ptr(ptr noalias nocapture nofree noundef nonnull readnone align 16 dereferenceable(8) [[A]]) #[[ATTR4]]
; CGSCC-NEXT: ret void
;
call void @use_i32_ptr(ptr %a)
@@ -1046,7 +1046,7 @@ define internal void @naked(ptr dereferenceable(4) %a) naked {
; CHECK: Function Attrs: naked
; CHECK-LABEL: define {{[^@]+}}@naked
; CHECK-SAME: (ptr noundef nonnull dereferenceable(4) [[A:%.*]]) #[[ATTR11:[0-9]+]] {
-; CHECK-NEXT: call void @use_i32_ptr(ptr nocapture noundef nonnull [[A]])
+; CHECK-NEXT: call void @use_i32_ptr(ptr nocapture nofree noundef nonnull [[A]])
; CHECK-NEXT: ret void
;
call void @use_i32_ptr(ptr %a)
@@ -1058,7 +1058,7 @@ define internal void @optnone(ptr dereferenceable(4) %a) optnone noinline {
; CHECK: Function Attrs: noinline optnone
; CHECK-LABEL: define {{[^@]+}}@optnone
; CHECK-SAME: (ptr noundef nonnull dereferenceable(4) [[A:%.*]]) #[[ATTR12:[0-9]+]] {
-; CHECK-NEXT: call void @use_i32_ptr(ptr nocapture noundef nonnull [[A]])
+; CHECK-NEXT: call void @use_i32_ptr(ptr nocapture nofree noundef nonnull [[A]])
; CHECK-NEXT: ret void
;
call void @use_i32_ptr(ptr %a)
@@ -1068,14 +1068,14 @@ define void @make_live(ptr nonnull dereferenceable(8) %a) {
; TUNIT-LABEL: define {{[^@]+}}@make_live
; TUNIT-SAME: (ptr noundef nonnull align 16 dereferenceable(8) [[A:%.*]]) {
; TUNIT-NEXT: call void @naked(ptr noundef nonnull align 16 dereferenceable(8) [[A]])
-; TUNIT-NEXT: call void @control(ptr noalias nocapture noundef nonnull readnone align 16 dereferenceable(8) [[A]]) #[[ATTR5]]
+; TUNIT-NEXT: call void @control(ptr noalias nocapture nofree noundef nonnull readnone align 16 dereferenceable(8) [[A]]) #[[ATTR5]]
; TUNIT-NEXT: call void @optnone(ptr noundef nonnull align 16 dereferenceable(8) [[A]])
; TUNIT-NEXT: ret void
;
; CGSCC-LABEL: define {{[^@]+}}@make_live
; CGSCC-SAME: (ptr noundef nonnull align 16 dereferenceable(8) [[A:%.*]]) {
; CGSCC-NEXT: call void @naked(ptr noundef nonnull align 16 dereferenceable(8) [[A]])
-; CGSCC-NEXT: call void @control(ptr noalias nocapture noundef nonnull readnone align 16 dereferenceable(8) [[A]]) #[[ATTR4]]
+; CGSCC-NEXT: call void @control(ptr noalias nocapture nofree noundef nonnull readnone align 16 dereferenceable(8) [[A]]) #[[ATTR4]]
; CGSCC-NEXT: call void @optnone(ptr noundef nonnull align 16 dereferenceable(8) [[A]])
; CGSCC-NEXT: ret void
;
diff --git a/llvm/test/Transforms/Attributor/readattrs.ll b/llvm/test/Transforms/Attributor/readattrs.ll
index a97acd654a733f..93e4eb93687959 100644
--- a/llvm/test/Transforms/Attributor/readattrs.ll
+++ b/llvm/test/Transforms/Attributor/readattrs.ll
@@ -15,8 +15,8 @@ declare void @test1_1(ptr %x1_1, ptr readonly %y1_1, ...)
;.
define void @test1_2(ptr %x1_2, ptr %y1_2, ptr %z1_2) {
; CHECK-LABEL: define {{[^@]+}}@test1_2
-; CHECK-SAME: (ptr [[X1_2:%.*]], ptr [[Y1_2:%.*]], ptr [[Z1_2:%.*]]) {
-; CHECK-NEXT: call void (ptr, ptr, ...) @test1_1(ptr [[X1_2]], ptr readonly [[Y1_2]], ptr [[Z1_2]])
+; CHECK-SAME: (ptr [[X1_2:%.*]], ptr nofree [[Y1_2:%.*]], ptr [[Z1_2:%.*]]) {
+; CHECK-NEXT: call void (ptr, ptr, ...) @test1_1(ptr [[X1_2]], ptr nofree readonly [[Y1_2]], ptr [[Z1_2]])
; CHECK-NEXT: store i32 0, ptr @x, align 4
; CHECK-NEXT: ret void
;
@@ -235,9 +235,9 @@ declare void @escape_readonly_ptr(ptr %addr, ptr readonly %ptr)
;
define void @unsound_readnone(ptr %ignored, ptr %escaped_then_written) {
; CHECK-LABEL: define {{[^@]+}}@unsound_readnone
-; CHECK-SAME: (ptr nocapture nofree readnone [[IGNORED:%.*]], ptr [[ESCAPED_THEN_WRITTEN:%.*]]) {
+; CHECK-SAME: (ptr nocapture nofree readnone [[IGNORED:%.*]], ptr nofree [[ESCAPED_THEN_WRITTEN:%.*]]) {
; CHECK-NEXT: [[ADDR:%.*]] = alloca ptr, align 8
-; CHECK-NEXT: call void @escape_readnone_ptr(ptr noundef nonnull align 8 dereferenceable(8) [[ADDR]], ptr noalias readnone [[ESCAPED_THEN_WRITTEN]])
+; CHECK-NEXT: call void @escape_readnone_ptr(ptr noundef nonnull align 8 dereferenceable(8) [[ADDR]], ptr noalias nofree readnone [[ESCAPED_THEN_WRITTEN]])
; CHECK-NEXT: [[ADDR_LD:%.*]] = load ptr, ptr [[ADDR]], align 8
; CHECK-NEXT: store i8 0, ptr [[ADDR_LD]], align 1
; CHECK-NEXT: ret void
@@ -251,9 +251,9 @@ define void @unsound_readnone(ptr %ignored, ptr %escaped_then_written) {
define void @unsound_readonly(ptr %ignored, ptr %escaped_then_written) {
; CHECK-LABEL: define {{[^@]+}}@unsound_readonly
-; CHECK-SAME: (ptr nocapture nofree readnone [[IGNORED:%.*]], ptr [[ESCAPED_THEN_WRITTEN:%.*]]) {
+; CHECK-SAME: (ptr nocapture nofree readnone [[IGNORED:%.*]], ptr nofree [[ESCAPED_THEN_WRITTEN:%.*]]) {
; CHECK-NEXT: [[ADDR:%.*]] = alloca ptr, align 8
-; CHECK-NEXT: call void @escape_readonly_ptr(ptr noundef nonnull align 8 dereferenceable(8) [[ADDR]], ptr readonly [[ESCAPED_THEN_WRITTEN]])
+; CHECK-NEXT: call void @escape_readonly_ptr(ptr noundef nonnull align 8 dereferenceable(8) [[ADDR]], ptr nofree readonly [[ESCAPED_THEN_WRITTEN]])
; CHECK-NEXT: [[ADDR_LD:%.*]] = load ptr, ptr [[ADDR]], align 8
; CHECK-NEXT: store i8 0, ptr [[ADDR_LD]], align 1
; CHECK-NEXT: ret void
@@ -362,15 +362,15 @@ declare void @val_use(i8 %ptr) readonly nounwind
define void @ptr_uses(ptr %ptr) {
; TUNIT: Function Attrs: nounwind memory(read)
; TUNIT-LABEL: define {{[^@]+}}@ptr_uses
-; TUNIT-SAME: (ptr nocapture readonly [[PTR:%.*]]) #[[ATTR11]] {
-; TUNIT-NEXT: [[CALL_PTR:%.*]] = call ptr @maybe_returned_ptr(ptr readonly [[PTR]]) #[[ATTR11]]
+; TUNIT-SAME: (ptr nocapture nofree readonly [[PTR:%.*]]) #[[ATTR11]] {
+; TUNIT-NEXT: [[CALL_PTR:%.*]] = call ptr @maybe_returned_ptr(ptr nofree readonly [[PTR]]) #[[ATTR11]]
; TUNIT-NEXT: [[CALL_VAL:%.*]] = call i8 @maybe_returned_val(ptr readonly [[CALL_PTR]]) #[[ATTR11]]
; TUNIT-NEXT: ret void
;
; CGSCC: Function Attrs: nounwind memory(read)
; CGSCC-LABEL: define {{[^@]+}}@ptr_uses
-; CGSCC-SAME: (ptr nocapture readonly [[PTR:%.*]]) #[[ATTR12]] {
-; CGSCC-NEXT: [[CALL_PTR:%.*]] = call ptr @maybe_returned_ptr(ptr readonly [[PTR]]) #[[ATTR12]]
+; CGSCC-SAME: (ptr nocapture nofree readonly [[PTR:%.*]]) #[[ATTR12]] {
+; CGSCC-NEXT: [[CALL_PTR:%.*]] = call ptr @maybe_returned_ptr(ptr nofree readonly [[PTR]]) #[[ATTR12]]
; CGSCC-NEXT: [[CALL_VAL:%.*]] = call i8 @maybe_returned_val(ptr readonly [[CALL_PTR]]) #[[ATTR12]]
; CGSCC-NEXT: ret void
;
diff --git a/llvm/test/Transforms/Attributor/value-simplify-instances.ll b/llvm/test/Transforms/Attributor/value-simplify-instances.ll
index c02a2a63bd458b..f46dfa303eb82e 100644
--- a/llvm/test/Transforms/Attributor/value-simplify-instances.ll
+++ b/llvm/test/Transforms/Attributor/value-simplify-instances.ll
@@ -58,10 +58,15 @@ f:
; FIXME: This should *not* return true.
define i1 @recursive_inst_generator_caller(i1 %c) {
-; CHECK-LABEL: define {{[^@]+}}@recursive_inst_generator_caller
-; CHECK-SAME: (i1 [[C:%.*]]) {
-; CHECK-NEXT: [[CALL:%.*]] = call i1 @recursive_inst_generator(i1 [[C]], ptr undef)
-; CHECK-NEXT: ret i1 [[CALL]]
+; TUNIT-LABEL: define {{[^@]+}}@recursive_inst_generator_caller
+; TUNIT-SAME: (i1 [[C:%.*]]) {
+; TUNIT-NEXT: [[CALL:%.*]] = call i1 @recursive_inst_generator(i1 [[C]], ptr undef)
+; TUNIT-NEXT: ret i1 [[CALL]]
+;
+; CGSCC-LABEL: define {{[^@]+}}@recursive_inst_generator_caller
+; CGSCC-SAME: (i1 [[C:%.*]]) {
+; CGSCC-NEXT: [[CALL:%.*]] = call i1 @recursive_inst_generator(i1 [[C]], ptr nofree undef)
+; CGSCC-NEXT: ret i1 [[CALL]]
;
%call = call i1 @recursive_inst_generator(i1 %c, ptr undef)
ret i1 %call
@@ -136,7 +141,7 @@ define i1 @recursive_alloca_compare_caller(i1 %c) {
; CGSCC: Function Attrs: nofree nosync nounwind memory(none)
; CGSCC-LABEL: define {{[^@]+}}@recursive_alloca_compare_caller
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] {
-; CGSCC-NEXT: [[CALL:%.*]] = call i1 @recursive_alloca_compare(i1 noundef [[C]], ptr undef) #[[ATTR5:[0-9]+]]
+; CGSCC-NEXT: [[CALL:%.*]] = call i1 @recursive_alloca_compare(i1 noundef [[C]], ptr nofree undef) #[[ATTR5:[0-9]+]]
; CGSCC-NEXT: ret i1 [[CALL]]
;
%call = call i1 @recursive_alloca_compare(i1 %c, ptr undef)
@@ -195,7 +200,7 @@ define i8 @recursive_alloca_load_return_caller(i1 %c) {
; CGSCC: Function Attrs: nofree nosync nounwind memory(none)
; CGSCC-LABEL: define {{[^@]+}}@recursive_alloca_load_return_caller
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] {
-; CGSCC-NEXT: [[CALL:%.*]] = call i8 @recursive_alloca_load_return(i1 noundef [[C]], ptr undef, i8 noundef 42) #[[ATTR6:[0-9]+]]
+; CGSCC-NEXT: [[CALL:%.*]] = call i8 @recursive_alloca_load_return(i1 noundef [[C]], ptr nofree undef, i8 noundef 42) #[[ATTR6:[0-9]+]]
; CGSCC-NEXT: ret i8 [[CALL]]
;
%call = call i8 @recursive_alloca_load_return(i1 %c, ptr undef, i8 42)
diff --git a/llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll b/llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll
index 7f4da0ea5eaaa1..a8bc7ab4f78f4e 100644
--- a/llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll
+++ b/llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll
@@ -2950,7 +2950,7 @@ define i1 @alloca_non_unique_caller(i32 %in, i1 %c) {
; CGSCC: Function Attrs: nofree nosync nounwind memory(none)
; CGSCC-LABEL: define {{[^@]+}}@alloca_non_unique_caller
; CGSCC-SAME: (i32 [[IN:%.*]], i1 noundef [[C:%.*]]) #[[ATTR15:[0-9]+]] {
-; CGSCC-NEXT: [[R:%.*]] = call i1 @alloca_non_unique(ptr undef, i32 [[IN]], i1 noundef [[C]]) #[[ATTR25:[0-9]+]]
+; CGSCC-NEXT: [[R:%.*]] = call i1 @alloca_non_unique(ptr nofree undef, i32 [[IN]], i1 noundef [[C]]) #[[ATTR25:[0-9]+]]
; CGSCC-NEXT: ret i1 [[R]]
;
%r = call i1 @alloca_non_unique(ptr undef, i32 %in, i1 %c)
diff --git a/llvm/test/Transforms/Attributor/willreturn.ll b/llvm/test/Transforms/Attributor/willreturn.ll
index 9a2ae719ede63c..d7994bb831f881 100644
--- a/llvm/test/Transforms/Attributor/willreturn.ll
+++ b/llvm/test/Transforms/Attributor/willreturn.ll
@@ -35,9 +35,9 @@ define i32 @fib(i32 %0) local_unnamed_addr #0 {
; TUNIT-NEXT: br i1 [[TMP2]], label [[TMP9:%.*]], label [[TMP3:%.*]]
; TUNIT: 3:
; TUNIT-NEXT: [[TMP4:%.*]] = add nsw i32 [[TMP0]], -1
-; TUNIT-NEXT: [[TMP5:%.*]] = tail call i32 @fib(i32 [[TMP4]]) #[[ATTR25:[0-9]+]]
+; TUNIT-NEXT: [[TMP5:%.*]] = tail call i32 @fib(i32 [[TMP4]]) #[[ATTR27:[0-9]+]]
; TUNIT-NEXT: [[TMP6:%.*]] = add nsw i32 [[TMP0]], -2
-; TUNIT-NEXT: [[TMP7:%.*]] = tail call i32 @fib(i32 [[TMP6]]) #[[ATTR25]]
+; TUNIT-NEXT: [[TMP7:%.*]] = tail call i32 @fib(i32 [[TMP6]]) #[[ATTR27]]
; TUNIT-NEXT: [[TMP8:%.*]] = add nsw i32 [[TMP7]], [[TMP5]]
; TUNIT-NEXT: ret i32 [[TMP8]]
; TUNIT: 9:
@@ -181,8 +181,8 @@ define void @mutual_recursion1(i1 %c) #0 {
; CHECK-SAME: (i1 noundef [[C:%.*]]) #[[ATTR4:[0-9]+]] {
; CHECK-NEXT: br i1 [[C]], label [[REC:%.*]], label [[END:%.*]]
; CHECK: rec:
-; CHECK-NEXT: call void @sink() #[[ATTR26:[0-9]+]]
-; CHECK-NEXT: call void @mutual_recursion2(i1 noundef [[C]]) #[[ATTR27:[0-9]+]]
+; CHECK-NEXT: call void @sink() #[[ATTR28:[0-9]+]]
+; CHECK-NEXT: call void @mutual_recursion2(i1 noundef [[C]]) #[[ATTR29:[0-9]+]]
; CHECK-NEXT: br label [[END]]
; CHECK: end:
; CHECK-NEXT: ret void
@@ -201,7 +201,7 @@ define void @mutual_recursion2(i1 %c) #0 {
; CHECK: Function Attrs: nofree noinline nosync nounwind uwtable
; CHECK-LABEL: define {{[^@]+}}@mutual_recursion2
; CHECK-SAME: (i1 [[C:%.*]]) #[[ATTR4]] {
-; CHECK-NEXT: call void @mutual_recursion1(i1 noundef [[C]]) #[[ATTR27]]
+; CHECK-NEXT: call void @mutual_recursion1(i1 noundef [[C]]) #[[ATTR29]]
; CHECK-NEXT: ret void
;
call void @mutual_recursion1(i1 %c)
@@ -295,7 +295,7 @@ define float @call_floor2(float %a) #0 {
; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@call_floor2
; CHECK-SAME: (float [[A:%.*]]) #[[ATTR0]] {
-; CHECK-NEXT: [[C:%.*]] = tail call nofpclass(sub) float @llvm.floor.f32(float [[A]]) #[[ATTR28:[0-9]+]]
+; CHECK-NEXT: [[C:%.*]] = tail call nofpclass(sub) float @llvm.floor.f32(float [[A]]) #[[ATTR30:[0-9]+]]
; CHECK-NEXT: ret float [[C]]
;
%c = tail call float @llvm.floor.f32(float %a)
@@ -315,7 +315,7 @@ define void @call_maybe_noreturn() #0 {
; CHECK: Function Attrs: noinline nounwind uwtable
; CHECK-LABEL: define {{[^@]+}}@call_maybe_noreturn
; CHECK-SAME: () #[[ATTR7]] {
-; CHECK-NEXT: tail call void @maybe_noreturn() #[[ATTR29:[0-9]+]]
+; CHECK-NEXT: tail call void @maybe_noreturn() #[[ATTR31:[0-9]+]]
; CHECK-NEXT: ret void
;
tail call void @maybe_noreturn()
@@ -334,7 +334,7 @@ define void @f1() #0 {
; CHECK: Function Attrs: mustprogress noinline nounwind willreturn uwtable
; CHECK-LABEL: define {{[^@]+}}@f1
; CHECK-SAME: () #[[ATTR10:[0-9]+]] {
-; CHECK-NEXT: tail call void @will_return() #[[ATTR30:[0-9]+]]
+; CHECK-NEXT: tail call void @will_return() #[[ATTR32:[0-9]+]]
; CHECK-NEXT: ret void
;
tail call void @will_return()
@@ -345,7 +345,7 @@ define void @f2() #0 {
; CHECK: Function Attrs: mustprogress noinline nounwind willreturn uwtable
; CHECK-LABEL: define {{[^@]+}}@f2
; CHECK-SAME: () #[[ATTR10]] {
-; CHECK-NEXT: tail call void @f1() #[[ATTR31:[0-9]+]]
+; CHECK-NEXT: tail call void @f1() #[[ATTR33:[0-9]+]]
; CHECK-NEXT: ret void
;
tail call void @f1()
@@ -387,7 +387,7 @@ define void @invoke_test() personality ptr @__gxx_personality_v0 {
; CHECK: Function Attrs: mustprogress nounwind willreturn
; CHECK-LABEL: define {{[^@]+}}@invoke_test
; CHECK-SAME: () #[[ATTR12:[0-9]+]] personality ptr @__gxx_personality_v0 {
-; CHECK-NEXT: [[TMP1:%.*]] = invoke i1 @maybe_raise_exception() #[[ATTR30]]
+; CHECK-NEXT: [[TMP1:%.*]] = invoke i1 @maybe_raise_exception() #[[ATTR32]]
; CHECK-NEXT: to label [[N:%.*]] unwind label [[F:%.*]]
; CHECK: N:
; CHECK-NEXT: ret void
@@ -589,7 +589,7 @@ define void @unreachable_exit_positive1() #0 {
; CHECK: Function Attrs: mustprogress noinline nounwind willreturn uwtable
; CHECK-LABEL: define {{[^@]+}}@unreachable_exit_positive1
; CHECK-SAME: () #[[ATTR10]] {
-; CHECK-NEXT: tail call void @will_return() #[[ATTR30]]
+; CHECK-NEXT: tail call void @will_return() #[[ATTR32]]
; CHECK-NEXT: ret void
; CHECK: unreachable_label:
; CHECK-NEXT: unreachable
@@ -691,8 +691,8 @@ declare void @llvm.eh.sjlj.longjmp(ptr)
define void @call_longjmp(ptr nocapture readnone %0) local_unnamed_addr #0 {
; CHECK: Function Attrs: noinline nounwind uwtable
; CHECK-LABEL: define {{[^@]+}}@call_longjmp
-; CHECK-SAME: (ptr nocapture readnone [[TMP0:%.*]]) local_unnamed_addr #[[ATTR7]] {
-; CHECK-NEXT: tail call void @llvm.eh.sjlj.longjmp(ptr noalias readnone [[TMP0]]) #[[ATTR5]]
+; CHECK-SAME: (ptr nocapture nofree readnone [[TMP0:%.*]]) local_unnamed_addr #[[ATTR7]] {
+; CHECK-NEXT: tail call void @llvm.eh.sjlj.longjmp(ptr noalias nofree readnone [[TMP0]]) #[[ATTR5]]
; CHECK-NEXT: unreachable
;
tail call void @llvm.eh.sjlj.longjmp(ptr %0)
@@ -1027,7 +1027,7 @@ define void @non_loop_cycle(i32 %n) {
; TUNIT-LABEL: define {{[^@]+}}@non_loop_cycle
; TUNIT-SAME: (i32 [[N:%.*]]) #[[ATTR17]] {
; TUNIT-NEXT: entry:
-; TUNIT-NEXT: [[CALL:%.*]] = call i32 @fact_loop(i32 [[N]]) #[[ATTR25]]
+; TUNIT-NEXT: [[CALL:%.*]] = call i32 @fact_loop(i32 [[N]]) #[[ATTR27]]
; TUNIT-NEXT: [[CMP:%.*]] = icmp sgt i32 [[CALL]], 5
; TUNIT-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; TUNIT: if.then:
@@ -1035,7 +1035,7 @@ define void @non_loop_cycle(i32 %n) {
; TUNIT: if.else:
; TUNIT-NEXT: br label [[ENTRY2:%.*]]
; TUNIT: entry1:
-; TUNIT-NEXT: [[CALL1:%.*]] = call i32 @fact_loop(i32 [[N]]) #[[ATTR25]]
+; TUNIT-NEXT: [[CALL1:%.*]] = call i32 @fact_loop(i32 [[N]]) #[[ATTR27]]
; TUNIT-NEXT: [[CMP2:%.*]] = icmp sgt i32 [[CALL1]], 5
; TUNIT-NEXT: br i1 [[CMP2]], label [[IF_THEN3:%.*]], label [[IF_ELSE4:%.*]]
; TUNIT: if.then3:
@@ -1043,7 +1043,7 @@ define void @non_loop_cycle(i32 %n) {
; TUNIT: if.else4:
; TUNIT-NEXT: br label [[ENTRY2]]
; TUNIT: entry2:
-; TUNIT-NEXT: [[CALL5:%.*]] = call i32 @fact_loop(i32 [[N]]) #[[ATTR25]]
+; TUNIT-NEXT: [[CALL5:%.*]] = call i32 @fact_loop(i32 [[N]]) #[[ATTR27]]
; TUNIT-NEXT: [[CMP6:%.*]] = icmp sgt i32 [[CALL5]], 5
; TUNIT-NEXT: br i1 [[CMP6]], label [[IF_THEN7:%.*]], label [[IF_ELSE8:%.*]]
; TUNIT: if.then7:
@@ -1057,7 +1057,7 @@ define void @non_loop_cycle(i32 %n) {
; CGSCC-LABEL: define {{[^@]+}}@non_loop_cycle
; CGSCC-SAME: (i32 [[N:%.*]]) #[[ATTR19]] {
; CGSCC-NEXT: entry:
-; CGSCC-NEXT: [[CALL:%.*]] = call i32 @fact_loop(i32 [[N]]) #[[ATTR32:[0-9]+]]
+; CGSCC-NEXT: [[CALL:%.*]] = call i32 @fact_loop(i32 [[N]]) #[[ATTR34:[0-9]+]]
; CGSCC-NEXT: [[CMP:%.*]] = icmp sgt i32 [[CALL]], 5
; CGSCC-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; CGSCC: if.then:
@@ -1065,7 +1065,7 @@ define void @non_loop_cycle(i32 %n) {
; CGSCC: if.else:
; CGSCC-NEXT: br label [[ENTRY2:%.*]]
; CGSCC: entry1:
-; CGSCC-NEXT: [[CALL1:%.*]] = call i32 @fact_loop(i32 [[N]]) #[[ATTR32]]
+; CGSCC-NEXT: [[CALL1:%.*]] = call i32 @fact_loop(i32 [[N]]) #[[ATTR34]]
; CGSCC-NEXT: [[CMP2:%.*]] = icmp sgt i32 [[CALL1]], 5
; CGSCC-NEXT: br i1 [[CMP2]], label [[IF_THEN3:%.*]], label [[IF_ELSE4:%.*]]
; CGSCC: if.then3:
@@ -1073,7 +1073,7 @@ define void @non_loop_cycle(i32 %n) {
; CGSCC: if.else4:
; CGSCC-NEXT: br label [[ENTRY2]]
; CGSCC: entry2:
-; CGSCC-NEXT: [[CALL5:%.*]] = call i32 @fact_loop(i32 [[N]]) #[[ATTR32]]
+; CGSCC-NEXT: [[CALL5:%.*]] = call i32 @fact_loop(i32 [[N]]) #[[ATTR34]]
; CGSCC-NEXT: [[CMP6:%.*]] = icmp sgt i32 [[CALL5]], 5
; CGSCC-NEXT: br i1 [[CMP6]], label [[IF_THEN7:%.*]], label [[IF_ELSE8:%.*]]
; CGSCC: if.then7:
@@ -1186,13 +1186,13 @@ define void @willreturn_mustprogress_callee_2() {
; TUNIT: Function Attrs: mustprogress willreturn memory(read)
; TUNIT-LABEL: define {{[^@]+}}@willreturn_mustprogress_callee_2
; TUNIT-SAME: () #[[ATTR23]] {
-; TUNIT-NEXT: call void @readonly_mustprogress() #[[ATTR32:[0-9]+]]
+; TUNIT-NEXT: call void @readonly_mustprogress() #[[ATTR34:[0-9]+]]
; TUNIT-NEXT: ret void
;
; CGSCC: Function Attrs: mustprogress willreturn memory(read)
; CGSCC-LABEL: define {{[^@]+}}@willreturn_mustprogress_callee_2
; CGSCC-SAME: () #[[ATTR24]] {
-; CGSCC-NEXT: call void @readonly_mustprogress() #[[ATTR33:[0-9]+]]
+; CGSCC-NEXT: call void @readonly_mustprogress() #[[ATTR35:[0-9]+]]
; CGSCC-NEXT: ret void
;
call void @readonly_mustprogress()
@@ -1210,19 +1210,85 @@ define void @willreturn_mustprogress_callee_4() {
; TUNIT: Function Attrs: mustprogress willreturn memory(read)
; TUNIT-LABEL: define {{[^@]+}}@willreturn_mustprogress_callee_4
; TUNIT-SAME: () #[[ATTR23]] {
-; TUNIT-NEXT: call void @willreturn_mustprogress_callee_2() #[[ATTR32]]
+; TUNIT-NEXT: call void @willreturn_mustprogress_callee_2() #[[ATTR34]]
; TUNIT-NEXT: ret void
;
; CGSCC: Function Attrs: mustprogress willreturn memory(read)
; CGSCC-LABEL: define {{[^@]+}}@willreturn_mustprogress_callee_4
; CGSCC-SAME: () #[[ATTR24]] {
-; CGSCC-NEXT: call void @willreturn_mustprogress_callee_2() #[[ATTR33]]
+; CGSCC-NEXT: call void @willreturn_mustprogress_callee_2() #[[ATTR35]]
; CGSCC-NEXT: ret void
;
call void @willreturn_mustprogress_callee_2()
ret void
}
+define weak void @implied_mustprogress1() willreturn {
+; TUNIT: Function Attrs: mustprogress willreturn
+; TUNIT-LABEL: define {{[^@]+}}@implied_mustprogress1
+; TUNIT-SAME: () #[[ATTR25:[0-9]+]] {
+; TUNIT-NEXT: ret void
+;
+; CGSCC: Function Attrs: mustprogress willreturn
+; CGSCC-LABEL: define {{[^@]+}}@implied_mustprogress1
+; CGSCC-SAME: () #[[ATTR26:[0-9]+]] {
+; CGSCC-NEXT: ret void
+;
+ ret void
+}
+define weak void @implied_willreturn1() readnone mustprogress {
+; TUNIT: Function Attrs: mustprogress willreturn memory(none)
+; TUNIT-LABEL: define {{[^@]+}}@implied_willreturn1
+; TUNIT-SAME: () #[[ATTR26:[0-9]+]] {
+; TUNIT-NEXT: ret void
+;
+; CGSCC: Function Attrs: mustprogress willreturn memory(none)
+; CGSCC-LABEL: define {{[^@]+}}@implied_willreturn1
+; CGSCC-SAME: () #[[ATTR27:[0-9]+]] {
+; CGSCC-NEXT: ret void
+;
+ ret void
+}
+define weak void @implied_willreturn2() readonly mustprogress {
+; TUNIT: Function Attrs: mustprogress willreturn memory(read)
+; TUNIT-LABEL: define {{[^@]+}}@implied_willreturn2
+; TUNIT-SAME: () #[[ATTR23]] {
+; TUNIT-NEXT: ret void
+;
+; CGSCC: Function Attrs: mustprogress willreturn memory(read)
+; CGSCC-LABEL: define {{[^@]+}}@implied_willreturn2
+; CGSCC-SAME: () #[[ATTR24]] {
+; CGSCC-NEXT: ret void
+;
+ ret void
+}
+define weak void @not_implied_willreturn1() mustprogress {
+; TUNIT: Function Attrs: mustprogress
+; TUNIT-LABEL: define {{[^@]+}}@not_implied_willreturn1
+; TUNIT-SAME: () #[[ATTR21]] {
+; TUNIT-NEXT: ret void
+;
+; CGSCC: Function Attrs: mustprogress
+; CGSCC-LABEL: define {{[^@]+}}@not_implied_willreturn1
+; CGSCC-SAME: () #[[ATTR22]] {
+; CGSCC-NEXT: ret void
+;
+ ret void
+}
+define weak void @not_implied_willreturn2() readnone {
+; TUNIT: Function Attrs: memory(none)
+; TUNIT-LABEL: define {{[^@]+}}@not_implied_willreturn2
+; TUNIT-SAME: () #[[ATTR20:[0-9]+]] {
+; TUNIT-NEXT: ret void
+;
+; CGSCC: Function Attrs: memory(none)
+; CGSCC-LABEL: define {{[^@]+}}@not_implied_willreturn2
+; CGSCC-SAME: () #[[ATTR21:[0-9]+]] {
+; CGSCC-NEXT: ret void
+;
+ ret void
+}
+
attributes #0 = { nounwind uwtable noinline }
attributes #1 = { uwtable noinline }
;.
@@ -1246,19 +1312,21 @@ attributes #1 = { uwtable noinline }
; TUNIT: attributes #[[ATTR17]] = { nofree norecurse nosync nounwind memory(none) }
; TUNIT: attributes #[[ATTR18]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR19]] = { memory(read) }
-; TUNIT: attributes #[[ATTR20:[0-9]+]] = { memory(none) }
+; TUNIT: attributes #[[ATTR20]] = { memory(none) }
; TUNIT: attributes #[[ATTR21]] = { mustprogress }
; TUNIT: attributes #[[ATTR22:[0-9]+]] = { mustprogress memory(read) }
; TUNIT: attributes #[[ATTR23]] = { mustprogress willreturn memory(read) }
; TUNIT: attributes #[[ATTR24]] = { mustprogress nosync willreturn memory(none) }
-; TUNIT: attributes #[[ATTR25]] = { nofree nosync nounwind memory(none) }
-; TUNIT: attributes #[[ATTR26]] = { nofree nounwind willreturn }
-; TUNIT: attributes #[[ATTR27]] = { nofree nosync nounwind }
-; TUNIT: attributes #[[ATTR28]] = { nofree willreturn }
-; TUNIT: attributes #[[ATTR29]] = { nounwind }
-; TUNIT: attributes #[[ATTR30]] = { willreturn }
-; TUNIT: attributes #[[ATTR31]] = { nounwind willreturn }
-; TUNIT: attributes #[[ATTR32]] = { willreturn memory(read) }
+; TUNIT: attributes #[[ATTR25]] = { mustprogress willreturn }
+; TUNIT: attributes #[[ATTR26]] = { mustprogress willreturn memory(none) }
+; TUNIT: attributes #[[ATTR27]] = { nofree nosync nounwind memory(none) }
+; TUNIT: attributes #[[ATTR28]] = { nofree nounwind willreturn }
+; TUNIT: attributes #[[ATTR29]] = { nofree nosync nounwind }
+; TUNIT: attributes #[[ATTR30]] = { nofree willreturn }
+; TUNIT: attributes #[[ATTR31]] = { nounwind }
+; TUNIT: attributes #[[ATTR32]] = { willreturn }
+; TUNIT: attributes #[[ATTR33]] = { nounwind willreturn }
+; TUNIT: attributes #[[ATTR34]] = { willreturn memory(read) }
;.
; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable }
; CGSCC: attributes #[[ATTR1]] = { nofree noinline nosync nounwind memory(none) uwtable }
@@ -1281,17 +1349,19 @@ attributes #1 = { uwtable noinline }
; CGSCC: attributes #[[ATTR18]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR19]] = { nofree nosync nounwind memory(none) }
; CGSCC: attributes #[[ATTR20]] = { memory(read) }
-; CGSCC: attributes #[[ATTR21:[0-9]+]] = { memory(none) }
+; CGSCC: attributes #[[ATTR21]] = { memory(none) }
; CGSCC: attributes #[[ATTR22]] = { mustprogress }
; CGSCC: attributes #[[ATTR23:[0-9]+]] = { mustprogress memory(read) }
; CGSCC: attributes #[[ATTR24]] = { mustprogress willreturn memory(read) }
; CGSCC: attributes #[[ATTR25]] = { mustprogress nosync willreturn memory(none) }
-; CGSCC: attributes #[[ATTR26]] = { nofree nounwind willreturn }
-; CGSCC: attributes #[[ATTR27]] = { nofree nosync nounwind }
-; CGSCC: attributes #[[ATTR28]] = { nofree willreturn }
-; CGSCC: attributes #[[ATTR29]] = { nounwind }
-; CGSCC: attributes #[[ATTR30]] = { willreturn }
-; CGSCC: attributes #[[ATTR31]] = { nounwind willreturn }
-; CGSCC: attributes #[[ATTR32]] = { nofree }
-; CGSCC: attributes #[[ATTR33]] = { willreturn memory(read) }
+; CGSCC: attributes #[[ATTR26]] = { mustprogress willreturn }
+; CGSCC: attributes #[[ATTR27]] = { mustprogress willreturn memory(none) }
+; CGSCC: attributes #[[ATTR28]] = { nofree nounwind willreturn }
+; CGSCC: attributes #[[ATTR29]] = { nofree nosync nounwind }
+; CGSCC: attributes #[[ATTR30]] = { nofree willreturn }
+; CGSCC: attributes #[[ATTR31]] = { nounwind }
+; CGSCC: attributes #[[ATTR32]] = { willreturn }
+; CGSCC: attributes #[[ATTR33]] = { nounwind willreturn }
+; CGSCC: attributes #[[ATTR34]] = { nofree }
+; CGSCC: attributes #[[ATTR35]] = { willreturn memory(read) }
;.
More information about the llvm-commits
mailing list