This is an archive of the discontinued LLVM Phabricator instance.

Differential D94740

[Attributor] Create `AAMustProgress` for the `mustprogress` attribute
ClosedPublic

Authored by jdoerfert on Jan 14 2021, 7:13 PM.

Details

Reviewers
nikic
efriedma
xbolva00
fhahn
sstefan1
uenoku
homerdin
baziotis
atmnpatel
bollu
jhuber6
Commits
rGdbbe9b37765c: [Attributor] Create `AAMustProgress` for the `mustprogress` attribute
Summary

Derive the mustprogress attribute based on the willreturn attribute
or the fact that all callers are mustprogress.

Diff Detail

Unit TestsFailed

TimeTest
450 msx64 debian > LLVM.tools/UpdateTestChecks/update_test_checks::check_attrs.test

Event Timeline

jdoerfert created this revision.Jan 14 2021, 7:13 PM
Herald added a reviewer: homerdin. · View Herald TranscriptJan 14 2021, 7:13 PM
Herald added subscribers: okura, kuter, arphaman and 2 others. · View Herald Transcript
jdoerfert requested review of this revision.Jan 14 2021, 7:13 PM
Herald added a reviewer: baziotis. · View Herald TranscriptJan 14 2021, 7:13 PM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added a subscriber: bbn. · View Herald Transcript
Harbormaster completed remote builds in B85284: Diff 316831.Jan 14 2021, 7:47 PM
jdoerfert added a reviewer: atmnpatel.Jan 14 2021, 8:01 PM
jdoerfert mentioned this in D94743: [Attributor][FIX] Do not delete non`-mustprogress` calls.Jan 15 2021, 12:31 PM
uenoku added a comment.EditedJan 26 2021, 1:11 AM

Basically it looks good to me.
However, it's not obvious to me that (known) willreturn can derive mustprogress.
(It seems correct to me though)

llvm/lib/Transforms/IPO/AttributorAttributes.cpp
3547–3551

This initialization is already done by AAMustProgress::initialize(A) so I think initialize function can be removed.

Herald added a reviewer: bollu. · View Herald TranscriptJan 26 2021, 1:11 AM
jdoerfert added a comment.Mar 3 2021, 5:54 PM

However, it's not obvious to me that (known) willreturn can derive mustprogress.

Given that we know we will return or throw, the function will make progress, so it's not going to get stuck. Arguably, it's a bit backwards but it might help down the road.

jdoerfert updated this revision to Diff 528029.Jun 2 2023, 3:53 PM

rebase

Herald added a project: Restricted Project. · View Herald TranscriptJun 2 2023, 3:53 PM
Herald added subscribers: hoy, ormris, StephenFan. · View Herald Transcript
jdoerfert edited the summary of this revision. (Show Details)Jun 2 2023, 3:53 PM
Harbormaster completed remote builds in B236308: Diff 528029.Jun 2 2023, 4:44 PM
jdoerfert added a comment.Jun 2 2023, 6:05 PM

I'll fix LLVM.tools/UpdateTestChecks/update_test_checks::check_attrs.test before committing.

fhahn mentioned this in D152081: [Attributor] Add lightweight version for attribute deduction only.Jun 3 2023, 1:21 PM
jhuber6 accepted this revision.Jun 5 2023, 10:45 AM
jhuber6 added a subscriber: jhuber6.

LG

This revision is now accepted and ready to land.Jun 5 2023, 10:45 AM
This revision was landed with ongoing or failed builds.Jun 5 2023, 4:34 PM
Closed by commit rGdbbe9b37765c: [Attributor] Create `AAMustProgress` for the `mustprogress` attribute (authored by jdoerfert). · Explain Why
This revision was automatically updated to reflect the committed changes.
jdoerfert added a commit: rGdbbe9b37765c: [Attributor] Create `AAMustProgress` for the `mustprogress` attribute.
Herald added a subscriber: arichardson. · View Herald TranscriptJun 5 2023, 4:34 PM

Revision Contents

PathSize
llvm/
include/
llvm/
Transforms/
IPO/
32 lines
lib/
Transforms/
IPO/
3 lines
74 lines
test/
Transforms/
Attributor/
ArgumentPromotion/
12 lines
12 lines
12 lines
6 lines
X86/
20 lines
64 lines
12 lines
16 lines
12 lines
16 lines
12 lines
16 lines
12 lines
12 lines
12 lines
30 lines
16 lines
22 lines
6 lines
14 lines
20 lines
46 lines
14 lines
8 lines
12 lines
16 lines
IPConstantProp/
6 lines
20 lines
8 lines
12 lines
12 lines
4 lines
6 lines
8 lines
4 lines
6 lines
18 lines
4 lines
10 lines
10 lines
12 lines
20 lines
18 lines
18 lines
14 lines
4 lines
208 lines
14 lines
50 lines
6 lines
6 lines
6 lines
6 lines
20 lines
2 lines
174 lines
64 lines
64 lines
48 lines
4 lines
938 lines
4 lines
6 lines
4 lines
40 lines
6 lines
6 lines
12 lines
30 lines
76 lines
184 lines
50 lines
18 lines
272 lines
34 lines
206 lines
36 lines
30 lines
44 lines
16 lines
14 lines
104 lines
178 lines
6 lines
56 lines
reduced/
4 lines
4 lines
50 lines
192 lines
104 lines
16 lines
14 lines
72 lines
10 lines
8 lines
178 lines
8 lines
206 lines
122 lines
4 lines
OpenMP/
8 lines

Diff 528029

llvm/include/llvm/Transforms/IPO/Attributor.h

Show First 20 Lines • Show All 3,399 Lines • ▼ Show 20 Lines static bool classof(const AbstractAttribute *AA) {
return (AA->getIdAddr() == &ID); return (AA->getIdAddr() == &ID);
} }
/// Unique ID (due to the unique address) /// Unique ID (due to the unique address)
static const char ID; static const char ID;
}; };
/// An abstract interface for all nonnull attributes. /// An abstract interface for all nonnull attributes.
struct AAMustProgress
: public IRAttribute<Attribute::MustProgress,
StateWrapper<BooleanState, AbstractAttribute>> {
AAMustProgress(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
/// Return true if we assume that the underlying value is nonnull.
bool isAssumedMustProgress() const { return getAssumed(); }
/// Return true if we know that underlying value is nonnull.
bool isKnownMustProgress() const { return getKnown(); }
/// Create an abstract attribute view for the position \p IRP.
static AAMustProgress &createForPosition(const IRPosition &IRP,
Attributor &A);
/// See AbstractAttribute::getName()
const std::string getName() const override { return "AAMustProgress"; }
/// See AbstractAttribute::getIdAddr()
const char *getIdAddr() const override { return &ID; }
/// This function should return true if the type of the \p AA is
/// AAMustProgress
static bool classof(const AbstractAttribute *AA) {
return (AA->getIdAddr() == &ID);
}
/// Unique ID (due to the unique address)
static const char ID;
};
/// An abstract interface for all nonnull attributes.
struct AANonNull struct AANonNull
: public IRAttribute<Attribute::NonNull, : public IRAttribute<Attribute::NonNull,
StateWrapper<BooleanState, AbstractAttribute>> { StateWrapper<BooleanState, AbstractAttribute>> {
AANonNull(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {} AANonNull(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
/// Return true if we assume that the underlying value is nonnull. /// Return true if we assume that the underlying value is nonnull.
bool isAssumedNonNull() const { return getAssumed(); } bool isAssumedNonNull() const { return getAssumed(); }
▲ Show 20 Lines • Show All 2,276 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/Attributor.cpp

Show First 20 Lines • Show All 3,187 Lines • ▼ Show 20 Linesvoid Attributor::identifyDefaultAbstractAttributes(Function &F) {
// Check for dead BasicBlocks in every function. // Check for dead BasicBlocks in every function.
// We need dead instruction detection because we do not want to deal with // We need dead instruction detection because we do not want to deal with
// broken IR in which SSA rules do not apply. // broken IR in which SSA rules do not apply.
getOrCreateAAFor<AAIsDead>(FPos); getOrCreateAAFor<AAIsDead>(FPos);
// Every function might be "will-return". // Every function might be "will-return".
getOrCreateAAFor<AAWillReturn>(FPos); getOrCreateAAFor<AAWillReturn>(FPos);
// Every function might be "must-progress".
getOrCreateAAFor<AAMustProgress>(FPos);
// Every function might contain instructions that cause "undefined behavior". // Every function might contain instructions that cause "undefined behavior".
getOrCreateAAFor<AAUndefinedBehavior>(FPos); getOrCreateAAFor<AAUndefinedBehavior>(FPos);
// Every function can be nounwind. // Every function can be nounwind.
getOrCreateAAFor<AANoUnwind>(FPos); getOrCreateAAFor<AANoUnwind>(FPos);
// Every function might be marked "nosync" // Every function might be marked "nosync"
getOrCreateAAFor<AANoSync>(FPos); getOrCreateAAFor<AANoSync>(FPos);
▲ Show 20 Lines • Show All 580 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 155 Lines • ▼ Show 20 Lines
PIPE_OPERATOR(AANoUnwind) PIPE_OPERATOR(AANoUnwind)
PIPE_OPERATOR(AANoSync) PIPE_OPERATOR(AANoSync)
PIPE_OPERATOR(AANoRecurse) PIPE_OPERATOR(AANoRecurse)
PIPE_OPERATOR(AANonConvergent) PIPE_OPERATOR(AANonConvergent)
PIPE_OPERATOR(AAWillReturn) PIPE_OPERATOR(AAWillReturn)
PIPE_OPERATOR(AANoReturn) PIPE_OPERATOR(AANoReturn)
PIPE_OPERATOR(AAReturnedValues) PIPE_OPERATOR(AAReturnedValues)
PIPE_OPERATOR(AANonNull) PIPE_OPERATOR(AANonNull)
PIPE_OPERATOR(AAMustProgress)
PIPE_OPERATOR(AANoAlias) PIPE_OPERATOR(AANoAlias)
PIPE_OPERATOR(AADereferenceable) PIPE_OPERATOR(AADereferenceable)
PIPE_OPERATOR(AAAlign) PIPE_OPERATOR(AAAlign)
PIPE_OPERATOR(AAInstanceInfo) PIPE_OPERATOR(AAInstanceInfo)
PIPE_OPERATOR(AANoCapture) PIPE_OPERATOR(AANoCapture)
PIPE_OPERATOR(AAValueSimplify) PIPE_OPERATOR(AAValueSimplify)
PIPE_OPERATOR(AANoFree) PIPE_OPERATOR(AANoFree)
PIPE_OPERATOR(AAHeapToStack) PIPE_OPERATOR(AAHeapToStack)
▲ Show 20 Lines • Show All 2,677 Lines • ▼ Show 20 Linesstruct AANonNullCallSiteReturned final
AANonNullCallSiteReturned(const IRPosition &IRP, Attributor &A) AANonNullCallSiteReturned(const IRPosition &IRP, Attributor &A)
: AACallSiteReturnedFromReturned<AANonNull, AANonNullImpl>(IRP, A) {} : AACallSiteReturnedFromReturned<AANonNull, AANonNullImpl>(IRP, A) {}
/// See AbstractAttribute::trackStatistics() /// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CSRET_ATTR(nonnull) } void trackStatistics() const override { STATS_DECLTRACK_CSRET_ATTR(nonnull) }
}; };
} // namespace } // namespace
/// ------------------------ Must-Progress Attributes --------------------------
namespace {
struct AAMustProgressImpl : public AAMustProgress {
AAMustProgressImpl(const IRPosition &IRP, Attributor &A)
: AAMustProgress(IRP, A) {}
/// See AbstractAttribute::getAsStr()
const std::string getAsStr() const override {
return getAssumed() ? "mustprogress" : "may-not-progress";
}
};
struct AAMustProgressFunction final : AAMustProgressImpl {
AAMustProgressFunction(const IRPosition &IRP, Attributor &A)
: AAMustProgressImpl(IRP, A) {}
/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
const auto &WillReturnAA =
A.getAAFor<AAWillReturn>(*this, getIRPosition(), DepClassTy::OPTIONAL);
if (WillReturnAA.isKnownWillReturn())
return indicateOptimisticFixpoint();
if (WillReturnAA.isAssumedWillReturn())
return ChangeStatus::UNCHANGED;
auto CheckForMustProgress = [&](AbstractCallSite ACS) {
IRPosition IPos = IRPosition::callsite_function(*ACS.getInstruction());
const auto &MustProgressAA =
A.getAAFor<AAMustProgress>(*this, IPos, DepClassTy::OPTIONAL);
return MustProgressAA.isAssumedMustProgress();
};
bool AllCallSitesKnown = true;
if (!A.checkForAllCallSites(CheckForMustProgress, *this,
/* RequireAllCallSites */ true,
AllCallSitesKnown))
return indicatePessimisticFixpoint();
return ChangeStatus::UNCHANGED;
}
/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
STATS_DECLTRACK_FN_ATTR(mustprogress)
}
};
/// MustProgress attribute deduction for a call sites.
struct AAMustProgressCallSite final : AAMustProgressImpl {
AAMustProgressCallSite(const IRPosition &IRP, Attributor &A)
: AAMustProgressImpl(IRP, A) {}
/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
// TODO: Once we have call site specific value information we can provide
// call site specific liveness information and then it makes
// sense to specialize attributes for call sites arguments instead of
// redirecting requests to the callee argument.
const IRPosition &FnPos = IRPosition::function(*getAnchorScope());
const auto &FnAA =
A.getAAFor<AAMustProgress>(*this, FnPos, DepClassTy::OPTIONAL);
return clampStateAndIndicateChange(getState(), FnAA.getState());
}
/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
STATS_DECLTRACK_CS_ATTR(mustprogress);
}
};
} // namespace
/// ------------------------ No-Recurse Attributes ---------------------------- /// ------------------------ No-Recurse Attributes ----------------------------
namespace { namespace {
struct AANoRecurseImpl : public AANoRecurse { struct AANoRecurseImpl : public AANoRecurse {
AANoRecurseImpl(const IRPosition &IRP, Attributor &A) : AANoRecurse(IRP, A) {} AANoRecurseImpl(const IRPosition &IRP, Attributor &A) : AANoRecurse(IRP, A) {}
/// See AbstractAttribute::getAsStr() /// See AbstractAttribute::getAsStr()
const std::string getAsStr() const override { const std::string getAsStr() const override {
▲ Show 20 Lines • Show All 602 Lines • ▼ Show 20 Lines
/// All information associated with a reachability query. This boilerplate code /// All information associated with a reachability query. This boilerplate code
/// is used by both AAIntraFnReachability and AAInterFnReachability, with /// is used by both AAIntraFnReachability and AAInterFnReachability, with
/// different \p ToTy values. /// different \p ToTy values.
template <typename ToTy> struct ReachabilityQueryInfo { template <typename ToTy> struct ReachabilityQueryInfo {
enum class Reachable { enum class Reachable {
No, No,
Yes, Yes,
}; };
/// Start here, /// Start here,
const Instruction *From = nullptr; const Instruction *From = nullptr;
/// reach this place, /// reach this place,
const ToTy *To = nullptr; const ToTy *To = nullptr;
uenokuUnsubmitted
Not Done
ReplyInline Actions

This initialization is already done by AAMustProgress::initialize(A) so I think initialize function can be removed.

uenoku: This initialization is already done by `AAMustProgress::initialize(A)` so I think `initialize`…
/// without going through any of these instructions, /// without going through any of these instructions,
const AA::InstExclusionSetTy *ExclusionSet = nullptr; const AA::InstExclusionSetTy *ExclusionSet = nullptr;
/// and remember if it worked: /// and remember if it worked:
Reachable Result = Reachable::No; Reachable Result = Reachable::No;
ReachabilityQueryInfo(const Instruction *From, const ToTy *To) ReachabilityQueryInfo(const Instruction *From, const ToTy *To)
: From(From), To(To) {} : From(From), To(To) {}
▲ Show 20 Lines • Show All 8,386 Lines • ▼ Show 20 Lines
}; };
} }
const char AAReturnedValues::ID = 0; const char AAReturnedValues::ID = 0;
const char AANoUnwind::ID = 0; const char AANoUnwind::ID = 0;
const char AANoSync::ID = 0; const char AANoSync::ID = 0;
const char AANoFree::ID = 0; const char AANoFree::ID = 0;
const char AANonNull::ID = 0; const char AANonNull::ID = 0;
const char AAMustProgress::ID = 0;
const char AANoRecurse::ID = 0; const char AANoRecurse::ID = 0;
const char AANonConvergent::ID = 0; const char AANonConvergent::ID = 0;
const char AAWillReturn::ID = 0; const char AAWillReturn::ID = 0;
const char AAUndefinedBehavior::ID = 0; const char AAUndefinedBehavior::ID = 0;
const char AANoAlias::ID = 0; const char AANoAlias::ID = 0;
const char AAIntraFnReachability::ID = 0; const char AAIntraFnReachability::ID = 0;
const char AANoReturn::ID = 0; const char AANoReturn::ID = 0;
const char AAIsDead::ID = 0; const char AAIsDead::ID = 0;
▲ Show 20 Lines • Show All 114 Lines • ▼ Show 20 Lines
CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoSync) CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoSync)
CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoRecurse) CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoRecurse)
CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAWillReturn) CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAWillReturn)
CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoReturn) CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoReturn)
CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAReturnedValues) CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAReturnedValues)
CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAMemoryLocation) CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAMemoryLocation)
CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AACallEdges) CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AACallEdges)
CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAAssumptionInfo) CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAAssumptionInfo)
CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAMustProgress)
CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANonNull) CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANonNull)
CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoAlias) CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoAlias)
CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAPrivatizablePtr) CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAPrivatizablePtr)
CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AADereferenceable) CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AADereferenceable)
CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAAlign) CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAAlign)
CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAInstanceInfo) CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAInstanceInfo)
CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoCapture) CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoCapture)
Show All 27 Lines

llvm/test/Transforms/Attributor/ArgumentPromotion/2008-02-01-ReturnAttrs.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=11 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=11 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
define internal i32 @deref(ptr %x) nounwind { define internal i32 @deref(ptr %x) nounwind {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@deref ; CGSCC-LABEL: define {{[^@]+}}@deref
; CGSCC-SAME: (i32 [[TMP0:%.*]]) #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: (i32 [[TMP0:%.*]]) #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[X_PRIV:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[X_PRIV:%.*]] = alloca i32, align 4
; CGSCC-NEXT: store i32 [[TMP0]], ptr [[X_PRIV]], align 4 ; CGSCC-NEXT: store i32 [[TMP0]], ptr [[X_PRIV]], align 4
; CGSCC-NEXT: [[TMP2:%.*]] = load i32, ptr [[X_PRIV]], align 4 ; CGSCC-NEXT: [[TMP2:%.*]] = load i32, ptr [[X_PRIV]], align 4
; CGSCC-NEXT: ret i32 [[TMP2]] ; CGSCC-NEXT: ret i32 [[TMP2]]
; ;
entry: entry:
%tmp2 = load i32, ptr %x, align 4 %tmp2 = load i32, ptr %x, align 4
ret i32 %tmp2 ret i32 %tmp2
} }
define i32 @f(i32 %x) { define i32 @f(i32 %x) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@f ; TUNIT-LABEL: define {{[^@]+}}@f
; TUNIT-SAME: (i32 returned [[X:%.*]]) #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: (i32 returned [[X:%.*]]) #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[X_ADDR:%.*]] = alloca i32, align 4 ; TUNIT-NEXT: [[X_ADDR:%.*]] = alloca i32, align 4
; TUNIT-NEXT: store i32 [[X]], ptr [[X_ADDR]], align 4 ; TUNIT-NEXT: store i32 [[X]], ptr [[X_ADDR]], align 4
; TUNIT-NEXT: ret i32 [[X]] ; TUNIT-NEXT: ret i32 [[X]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@f ; CGSCC-LABEL: define {{[^@]+}}@f
; CGSCC-SAME: (i32 [[X:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (i32 [[X:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[X_ADDR:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[X_ADDR:%.*]] = alloca i32, align 4
; CGSCC-NEXT: store i32 [[X]], ptr [[X_ADDR]], align 4 ; CGSCC-NEXT: store i32 [[X]], ptr [[X_ADDR]], align 4
; CGSCC-NEXT: [[TMP1:%.*]] = call i32 @deref(i32 [[X]]) #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: [[TMP1:%.*]] = call i32 @deref(i32 [[X]]) #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: ret i32 [[TMP1]] ; CGSCC-NEXT: ret i32 [[TMP1]]
; ;
entry: entry:
%x_addr = alloca i32 %x_addr = alloca i32
store i32 %x, ptr %x_addr, align 4 store i32 %x, ptr %x_addr, align 4
%tmp1 = call i32 @deref( ptr %x_addr ) nounwind %tmp1 = call i32 @deref( ptr %x_addr ) nounwind
ret i32 %tmp1 ret i32 %tmp1
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/ArgumentPromotion/2008-07-02-array-indexing.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; PR2498 ; PR2498
; This test tries to convince CHECK about promoting the load from %A + 2, ; This test tries to convince CHECK about promoting the load from %A + 2,
; because there is a load of %A in the entry block ; because there is a load of %A in the entry block
define internal i32 @callee(i1 %C, ptr %A) { define internal i32 @callee(i1 %C, ptr %A) {
; ;
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define {{[^@]+}}@callee ; CHECK-LABEL: define {{[^@]+}}@callee
; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_0:%.*]] = load i32, ptr [[A]], align 4 ; CHECK-NEXT: [[A_0:%.*]] = load i32, ptr [[A]], align 4
; CHECK-NEXT: br label [[F:%.*]] ; CHECK-NEXT: br label [[F:%.*]]
; CHECK: T: ; CHECK: T:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; CHECK: F: ; CHECK: F:
Show All 12 Lines
F: F:
; Load the element at offset two from %A. This should not be promoted! ; Load the element at offset two from %A. This should not be promoted!
%A.2 = getelementptr i32, ptr %A, i32 2 %A.2 = getelementptr i32, ptr %A, i32 2
%R = load i32, ptr %A.2 %R = load i32, ptr %A.2
ret i32 %R ret i32 %R
} }
define i32 @foo(ptr %A) { define i32 @foo(ptr %A) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; TUNIT-LABEL: define {{[^@]+}}@foo ; TUNIT-LABEL: define {{[^@]+}}@foo
; TUNIT-SAME: (ptr nocapture nofree readonly [[A:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr nocapture nofree readonly [[A:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[X:%.*]] = call i32 @callee(ptr nocapture nofree readonly align 4 [[A]]) #[[ATTR1:[0-9]+]] ; TUNIT-NEXT: [[X:%.*]] = call i32 @callee(ptr nocapture nofree readonly align 4 [[A]]) #[[ATTR1:[0-9]+]]
; TUNIT-NEXT: ret i32 [[X]] ; TUNIT-NEXT: ret i32 [[X]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@foo ; CGSCC-LABEL: define {{[^@]+}}@foo
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: [[X:%.*]] = call i32 @callee(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A]]) #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: [[X:%.*]] = call i32 @callee(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A]]) #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: ret i32 [[X]] ; CGSCC-NEXT: ret i32 [[X]]
; ;
%X = call i32 @callee(i1 false, ptr %A) ; <i32> [#uses=1] %X = call i32 @callee(i1 false, ptr %A) ; <i32> [#uses=1]
ret i32 %X ret i32 %X
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR2]] = { willreturn } ; CGSCC: attributes #[[ATTR2]] = { willreturn }
;. ;.

llvm/test/Transforms/Attributor/ArgumentPromotion/2008-09-07-CGUpdate.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
define internal fastcc i32 @hash(ptr %ts, i32 %mod) nounwind { define internal fastcc i32 @hash(ptr %ts, i32 %mod) nounwind {
; CGSCC: Function Attrs: nofree norecurse noreturn nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@hash ; CGSCC-LABEL: define {{[^@]+}}@hash
; CGSCC-SAME: () #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
entry: entry:
unreachable unreachable
} }
define void @encode(ptr %m, ptr %ts, ptr %new) nounwind { define void @encode(ptr %m, ptr %ts, ptr %new) nounwind {
; TUNIT: Function Attrs: nofree norecurse noreturn nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@encode ; TUNIT-LABEL: define {{[^@]+}}@encode
; TUNIT-SAME: (ptr nocapture nofree readnone [[M:%.*]], ptr nocapture nofree readnone [[TS:%.*]], ptr nocapture nofree readnone [[NEW:%.*]]) #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree readnone [[M:%.*]], ptr nocapture nofree readnone [[TS:%.*]], ptr nocapture nofree readnone [[NEW:%.*]]) #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree noreturn nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree noreturn nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@encode ; CGSCC-LABEL: define {{[^@]+}}@encode
; CGSCC-SAME: (ptr nocapture nofree readnone [[M:%.*]], ptr nocapture nofree readnone [[TS:%.*]], ptr nocapture nofree readnone [[NEW:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree readnone [[M:%.*]], ptr nocapture nofree readnone [[TS:%.*]], ptr nocapture nofree readnone [[NEW:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
entry: entry:
%0 = call fastcc i32 @hash( ptr %ts, i32 0 ) nounwind ; <i32> [#uses=0] %0 = call fastcc i32 @hash( ptr %ts, i32 0 ) nounwind ; <i32> [#uses=0]
unreachable unreachable
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse noreturn nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse noreturn nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree noreturn nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree noreturn nosync nounwind willreturn memory(none) }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/ArgumentPromotion/2008-09-08-CGUpdateSelfEdge.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
define internal fastcc i32 @term_SharingList(ptr %Term, ptr %List) nounwind { define internal fastcc i32 @term_SharingList(ptr %Term, ptr %List) nounwind {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@term_SharingList ; CGSCC-LABEL: define {{[^@]+}}@term_SharingList
; CGSCC-SAME: () #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: br i1 false, label [[BB:%.*]], label [[BB5:%.*]] ; CGSCC-NEXT: br i1 false, label [[BB:%.*]], label [[BB5:%.*]]
; CGSCC: bb: ; CGSCC: bb:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: bb5: ; CGSCC: bb5:
; CGSCC-NEXT: ret i32 undef ; CGSCC-NEXT: ret i32 undef
; ;
entry: entry:
br i1 false, label %bb, label %bb5 br i1 false, label %bb, label %bb5
bb: ; preds = %entry bb: ; preds = %entry
%0 = call fastcc i32 @term_SharingList( ptr null, ptr %List ) nounwind ; <i32> [#uses=0] %0 = call fastcc i32 @term_SharingList( ptr null, ptr %List ) nounwind ; <i32> [#uses=0]
unreachable unreachable
bb5: ; preds = %entry bb5: ; preds = %entry
ret i32 0 ret i32 0
} }
define i32 @term_Sharing(ptr %Term) nounwind { define i32 @term_Sharing(ptr %Term) nounwind {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@term_Sharing ; CHECK-LABEL: define {{[^@]+}}@term_Sharing
; CHECK-SAME: (ptr nocapture nofree readnone [[TERM:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree readnone [[TERM:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 false, label [[BB_I:%.*]], label [[BB14:%.*]] ; CHECK-NEXT: br i1 false, label [[BB_I:%.*]], label [[BB14:%.*]]
; CHECK: bb.i: ; CHECK: bb.i:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; CHECK: bb14: ; CHECK: bb14:
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
entry: entry:
br i1 false, label %bb.i, label %bb14 br i1 false, label %bb.i, label %bb14
bb.i: ; preds = %entry bb.i: ; preds = %entry
%0 = call fastcc i32 @term_SharingList( ptr null, ptr null ) nounwind ; <i32> [#uses=0] %0 = call fastcc i32 @term_SharingList( ptr null, ptr null ) nounwind ; <i32> [#uses=0]
ret i32 1 ret i32 1
bb14: ; preds = %entry bb14: ; preds = %entry
ret i32 0 ret i32 0
} }
;. ;.
; CHECK: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CHECK: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; TUNIT: {{.*}} ; TUNIT: {{.*}}

llvm/test/Transforms/Attributor/ArgumentPromotion/X86/attributes.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=10 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=10 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; Test that we only promote arguments when the caller/callee have compatible ; Test that we only promote arguments when the caller/callee have compatible
; function attrubtes. ; function attrubtes.
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define internal fastcc void @no_promote_avx2(ptr %arg, ptr readonly %arg1) #0 { define internal fastcc void @no_promote_avx2(ptr %arg, ptr readonly %arg1) #0 {
; CHECK: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CHECK: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CHECK-LABEL: define {{[^@]+}}@no_promote_avx2 ; CHECK-LABEL: define {{[^@]+}}@no_promote_avx2
; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[ARG:%.*]], ptr noalias nocapture nofree noundef nonnull readonly align 32 dereferenceable(32) [[ARG1:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[ARG:%.*]], ptr noalias nocapture nofree noundef nonnull readonly align 32 dereferenceable(32) [[ARG1:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: [[TMP:%.*]] = load <4 x i64>, ptr [[ARG1]], align 32 ; CHECK-NEXT: [[TMP:%.*]] = load <4 x i64>, ptr [[ARG1]], align 32
; CHECK-NEXT: store <4 x i64> [[TMP]], ptr [[ARG]], align 32 ; CHECK-NEXT: store <4 x i64> [[TMP]], ptr [[ARG]], align 32
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
bb: bb:
%tmp = load <4 x i64>, ptr %arg1 %tmp = load <4 x i64>, ptr %arg1
store <4 x i64> %tmp, ptr %arg store <4 x i64> %tmp, ptr %arg
ret void ret void
} }
define void @no_promote(ptr %arg) #1 { define void @no_promote(ptr %arg) #1 {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; TUNIT-LABEL: define {{[^@]+}}@no_promote ; TUNIT-LABEL: define {{[^@]+}}@no_promote
; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR1:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR1:[0-9]+]] {
; TUNIT-NEXT: bb: ; TUNIT-NEXT: bb:
; TUNIT-NEXT: [[TMP:%.*]] = alloca <4 x i64>, align 32 ; TUNIT-NEXT: [[TMP:%.*]] = alloca <4 x i64>, align 32
; TUNIT-NEXT: [[TMP2:%.*]] = alloca <4 x i64>, align 32 ; TUNIT-NEXT: [[TMP2:%.*]] = alloca <4 x i64>, align 32
; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR3:[0-9]+]] ; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR3:[0-9]+]]
; TUNIT-NEXT: call fastcc void @no_promote_avx2(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[TMP2]], ptr noalias nocapture nofree noundef nonnull readonly align 32 dereferenceable(32) [[TMP]]) #[[ATTR4:[0-9]+]] ; TUNIT-NEXT: call fastcc void @no_promote_avx2(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[TMP2]], ptr noalias nocapture nofree noundef nonnull readonly align 32 dereferenceable(32) [[TMP]]) #[[ATTR4:[0-9]+]]
; TUNIT-NEXT: [[TMP4:%.*]] = load <4 x i64>, ptr [[TMP2]], align 32 ; TUNIT-NEXT: [[TMP4:%.*]] = load <4 x i64>, ptr [[TMP2]], align 32
; TUNIT-NEXT: store <4 x i64> [[TMP4]], ptr [[ARG]], align 2 ; TUNIT-NEXT: store <4 x i64> [[TMP4]], ptr [[ARG]], align 2
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CGSCC-LABEL: define {{[^@]+}}@no_promote ; CGSCC-LABEL: define {{[^@]+}}@no_promote
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(32) [[ARG:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(32) [[ARG:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: [[TMP:%.*]] = alloca <4 x i64>, align 32 ; CGSCC-NEXT: [[TMP:%.*]] = alloca <4 x i64>, align 32
; CGSCC-NEXT: [[TMP2:%.*]] = alloca <4 x i64>, align 32 ; CGSCC-NEXT: [[TMP2:%.*]] = alloca <4 x i64>, align 32
; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR3:[0-9]+]] ; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR3:[0-9]+]]
; CGSCC-NEXT: call fastcc void @no_promote_avx2(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[TMP2]], ptr noalias nocapture nofree noundef nonnull readonly align 32 dereferenceable(32) [[TMP]]) #[[ATTR4:[0-9]+]] ; CGSCC-NEXT: call fastcc void @no_promote_avx2(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[TMP2]], ptr noalias nocapture nofree noundef nonnull readonly align 32 dereferenceable(32) [[TMP]]) #[[ATTR4:[0-9]+]]
; CGSCC-NEXT: [[TMP4:%.*]] = load <4 x i64>, ptr [[TMP2]], align 32 ; CGSCC-NEXT: [[TMP4:%.*]] = load <4 x i64>, ptr [[TMP2]], align 32
; CGSCC-NEXT: store <4 x i64> [[TMP4]], ptr [[ARG]], align 2 ; CGSCC-NEXT: store <4 x i64> [[TMP4]], ptr [[ARG]], align 2
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
bb: bb:
%tmp = alloca <4 x i64>, align 32 %tmp = alloca <4 x i64>, align 32
%tmp2 = alloca <4 x i64>, align 32 %tmp2 = alloca <4 x i64>, align 32
call void @llvm.memset.p0.i64(ptr align 32 %tmp, i8 0, i64 32, i1 false) call void @llvm.memset.p0.i64(ptr align 32 %tmp, i8 0, i64 32, i1 false)
call fastcc void @no_promote_avx2(ptr %tmp2, ptr %tmp) call fastcc void @no_promote_avx2(ptr %tmp2, ptr %tmp)
%tmp4 = load <4 x i64>, ptr %tmp2, align 32 %tmp4 = load <4 x i64>, ptr %tmp2, align 32
store <4 x i64> %tmp4, ptr %arg, align 2 store <4 x i64> %tmp4, ptr %arg, align 2
ret void ret void
} }
define internal fastcc void @promote_avx2(ptr %arg, ptr readonly %arg1) #0 { define internal fastcc void @promote_avx2(ptr %arg, ptr readonly %arg1) #0 {
; CHECK: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CHECK: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CHECK-LABEL: define {{[^@]+}}@promote_avx2 ; CHECK-LABEL: define {{[^@]+}}@promote_avx2
; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[ARG:%.*]], <4 x i64> [[TMP0:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[ARG:%.*]], <4 x i64> [[TMP0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: [[ARG1_PRIV:%.*]] = alloca <4 x i64>, align 32 ; CHECK-NEXT: [[ARG1_PRIV:%.*]] = alloca <4 x i64>, align 32
; CHECK-NEXT: store <4 x i64> [[TMP0]], ptr [[ARG1_PRIV]], align 32 ; CHECK-NEXT: store <4 x i64> [[TMP0]], ptr [[ARG1_PRIV]], align 32
; CHECK-NEXT: [[TMP:%.*]] = load <4 x i64>, ptr [[ARG1_PRIV]], align 32 ; CHECK-NEXT: [[TMP:%.*]] = load <4 x i64>, ptr [[ARG1_PRIV]], align 32
; CHECK-NEXT: store <4 x i64> [[TMP]], ptr [[ARG]], align 32 ; CHECK-NEXT: store <4 x i64> [[TMP]], ptr [[ARG]], align 32
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
bb: bb:
%tmp = load <4 x i64>, ptr %arg1 %tmp = load <4 x i64>, ptr %arg1
store <4 x i64> %tmp, ptr %arg store <4 x i64> %tmp, ptr %arg
ret void ret void
} }
define void @promote(ptr %arg) #0 { define void @promote(ptr %arg) #0 {
; TUNIT: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; TUNIT: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; TUNIT-LABEL: define {{[^@]+}}@promote ; TUNIT-LABEL: define {{[^@]+}}@promote
; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: bb: ; TUNIT-NEXT: bb:
; TUNIT-NEXT: [[TMP:%.*]] = alloca <4 x i64>, align 32 ; TUNIT-NEXT: [[TMP:%.*]] = alloca <4 x i64>, align 32
; TUNIT-NEXT: [[TMP2:%.*]] = alloca <4 x i64>, align 32 ; TUNIT-NEXT: [[TMP2:%.*]] = alloca <4 x i64>, align 32
; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR3]] ; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR3]]
; TUNIT-NEXT: [[TMP0:%.*]] = load <4 x i64>, ptr [[TMP]], align 32 ; TUNIT-NEXT: [[TMP0:%.*]] = load <4 x i64>, ptr [[TMP]], align 32
; TUNIT-NEXT: call fastcc void @promote_avx2(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[TMP2]], <4 x i64> [[TMP0]]) #[[ATTR4]] ; TUNIT-NEXT: call fastcc void @promote_avx2(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[TMP2]], <4 x i64> [[TMP0]]) #[[ATTR4]]
; TUNIT-NEXT: [[TMP4:%.*]] = load <4 x i64>, ptr [[TMP2]], align 32 ; TUNIT-NEXT: [[TMP4:%.*]] = load <4 x i64>, ptr [[TMP2]], align 32
; TUNIT-NEXT: store <4 x i64> [[TMP4]], ptr [[ARG]], align 2 ; TUNIT-NEXT: store <4 x i64> [[TMP4]], ptr [[ARG]], align 2
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CGSCC: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CGSCC-LABEL: define {{[^@]+}}@promote ; CGSCC-LABEL: define {{[^@]+}}@promote
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(32) [[ARG:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(32) [[ARG:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: [[TMP:%.*]] = alloca <4 x i64>, align 32 ; CGSCC-NEXT: [[TMP:%.*]] = alloca <4 x i64>, align 32
; CGSCC-NEXT: [[TMP2:%.*]] = alloca <4 x i64>, align 32 ; CGSCC-NEXT: [[TMP2:%.*]] = alloca <4 x i64>, align 32
; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR3]] ; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR3]]
; CGSCC-NEXT: [[TMP0:%.*]] = load <4 x i64>, ptr [[TMP]], align 32 ; CGSCC-NEXT: [[TMP0:%.*]] = load <4 x i64>, ptr [[TMP]], align 32
; CGSCC-NEXT: call fastcc void @promote_avx2(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[TMP2]], <4 x i64> [[TMP0]]) #[[ATTR4]] ; CGSCC-NEXT: call fastcc void @promote_avx2(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(32) [[TMP2]], <4 x i64> [[TMP0]]) #[[ATTR4]]
Show All 13 Lines
; Function Attrs: argmemonly nounwind ; Function Attrs: argmemonly nounwind
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1) #2 declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1) #2
attributes #0 = { inlinehint norecurse nounwind uwtable "target-features"="+avx2" } attributes #0 = { inlinehint norecurse nounwind uwtable "target-features"="+avx2" }
attributes #1 = { nounwind uwtable } attributes #1 = { nounwind uwtable }
attributes #2 = { argmemonly nounwind } attributes #2 = { argmemonly nounwind }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "target-features"="+avx2" } ; TUNIT: attributes #[[ATTR0]] = { inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "target-features"="+avx2" }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable }
; TUNIT: attributes #[[ATTR2:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR2:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR3]] = { willreturn } ; TUNIT: attributes #[[ATTR3]] = { willreturn }
; TUNIT: attributes #[[ATTR4]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR4]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "target-features"="+avx2" } ; CGSCC: attributes #[[ATTR0]] = { inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "target-features"="+avx2" }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(argmem: readwrite) uwtable } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite) uwtable }
; CGSCC: attributes #[[ATTR2:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR2:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR3]] = { willreturn } ; CGSCC: attributes #[[ATTR3]] = { willreturn }
; CGSCC: attributes #[[ATTR4]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR4]] = { nounwind willreturn }
;. ;.

llvm/test/Transforms/Attributor/ArgumentPromotion/X86/min-legal-vector-width.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=10 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=10 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; Test that we only promote arguments when the caller/callee have compatible ; Test that we only promote arguments when the caller/callee have compatible
; function attrubtes. ; function attrubtes.
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; This should promote ; This should promote
define internal fastcc void @callee_avx512_legal512_prefer512_call_avx512_legal512_prefer512(ptr %arg, ptr readonly %arg1) #0 { define internal fastcc void @callee_avx512_legal512_prefer512_call_avx512_legal512_prefer512(ptr %arg, ptr readonly %arg1) #0 {
; ;
; CHECK: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CHECK: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CHECK-LABEL: define {{[^@]+}}@callee_avx512_legal512_prefer512_call_avx512_legal512_prefer512 ; CHECK-LABEL: define {{[^@]+}}@callee_avx512_legal512_prefer512_call_avx512_legal512_prefer512
; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[ARG:%.*]], <8 x i64> [[TMP0:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[ARG:%.*]], <8 x i64> [[TMP0:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: [[ARG1_PRIV:%.*]] = alloca <8 x i64>, align 64 ; CHECK-NEXT: [[ARG1_PRIV:%.*]] = alloca <8 x i64>, align 64
; CHECK-NEXT: store <8 x i64> [[TMP0]], ptr [[ARG1_PRIV]], align 64 ; CHECK-NEXT: store <8 x i64> [[TMP0]], ptr [[ARG1_PRIV]], align 64
; CHECK-NEXT: [[TMP:%.*]] = load <8 x i64>, ptr [[ARG1_PRIV]], align 64 ; CHECK-NEXT: [[TMP:%.*]] = load <8 x i64>, ptr [[ARG1_PRIV]], align 64
; CHECK-NEXT: store <8 x i64> [[TMP]], ptr [[ARG]], align 64 ; CHECK-NEXT: store <8 x i64> [[TMP]], ptr [[ARG]], align 64
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
bb: bb:
%tmp = load <8 x i64>, ptr %arg1 %tmp = load <8 x i64>, ptr %arg1
store <8 x i64> %tmp, ptr %arg store <8 x i64> %tmp, ptr %arg
ret void ret void
} }
define void @avx512_legal512_prefer512_call_avx512_legal512_prefer512(ptr %arg) #0 { define void @avx512_legal512_prefer512_call_avx512_legal512_prefer512(ptr %arg) #0 {
; ;
; TUNIT: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; TUNIT: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; TUNIT-LABEL: define {{[^@]+}}@avx512_legal512_prefer512_call_avx512_legal512_prefer512 ; TUNIT-LABEL: define {{[^@]+}}@avx512_legal512_prefer512_call_avx512_legal512_prefer512
; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: bb: ; TUNIT-NEXT: bb:
; TUNIT-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32 ; TUNIT-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32
; TUNIT-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32 ; TUNIT-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32
; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5:[0-9]+]] ; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5:[0-9]+]]
; TUNIT-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64 ; TUNIT-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64
; TUNIT-NEXT: call fastcc void @callee_avx512_legal512_prefer512_call_avx512_legal512_prefer512(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6:[0-9]+]] ; TUNIT-NEXT: call fastcc void @callee_avx512_legal512_prefer512_call_avx512_legal512_prefer512(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6:[0-9]+]]
; TUNIT-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64 ; TUNIT-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64
; TUNIT-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2 ; TUNIT-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CGSCC: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CGSCC-LABEL: define {{[^@]+}}@avx512_legal512_prefer512_call_avx512_legal512_prefer512 ; CGSCC-LABEL: define {{[^@]+}}@avx512_legal512_prefer512_call_avx512_legal512_prefer512
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(64) [[ARG:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(64) [[ARG:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32 ; CGSCC-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32
; CGSCC-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32 ; CGSCC-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32
; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5:[0-9]+]] ; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5:[0-9]+]]
; CGSCC-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64 ; CGSCC-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64
; CGSCC-NEXT: call fastcc void @callee_avx512_legal512_prefer512_call_avx512_legal512_prefer512(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6:[0-9]+]] ; CGSCC-NEXT: call fastcc void @callee_avx512_legal512_prefer512_call_avx512_legal512_prefer512(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6:[0-9]+]]
Show All 9 Linesbb:
%tmp4 = load <8 x i64>, ptr %tmp2, align 32 %tmp4 = load <8 x i64>, ptr %tmp2, align 32
store <8 x i64> %tmp4, ptr %arg, align 2 store <8 x i64> %tmp4, ptr %arg, align 2
ret void ret void
} }
; This should promote ; This should promote
define internal fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal512_prefer256(ptr %arg, ptr readonly %arg1) #1 { define internal fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal512_prefer256(ptr %arg, ptr readonly %arg1) #1 {
; ;
; CHECK: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CHECK: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CHECK-LABEL: define {{[^@]+}}@callee_avx512_legal512_prefer256_call_avx512_legal512_prefer256 ; CHECK-LABEL: define {{[^@]+}}@callee_avx512_legal512_prefer256_call_avx512_legal512_prefer256
; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[ARG:%.*]], <8 x i64> [[TMP0:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[ARG:%.*]], <8 x i64> [[TMP0:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: [[ARG1_PRIV:%.*]] = alloca <8 x i64>, align 64 ; CHECK-NEXT: [[ARG1_PRIV:%.*]] = alloca <8 x i64>, align 64
; CHECK-NEXT: store <8 x i64> [[TMP0]], ptr [[ARG1_PRIV]], align 64 ; CHECK-NEXT: store <8 x i64> [[TMP0]], ptr [[ARG1_PRIV]], align 64
; CHECK-NEXT: [[TMP:%.*]] = load <8 x i64>, ptr [[ARG1_PRIV]], align 64 ; CHECK-NEXT: [[TMP:%.*]] = load <8 x i64>, ptr [[ARG1_PRIV]], align 64
; CHECK-NEXT: store <8 x i64> [[TMP]], ptr [[ARG]], align 64 ; CHECK-NEXT: store <8 x i64> [[TMP]], ptr [[ARG]], align 64
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
bb: bb:
%tmp = load <8 x i64>, ptr %arg1 %tmp = load <8 x i64>, ptr %arg1
store <8 x i64> %tmp, ptr %arg store <8 x i64> %tmp, ptr %arg
ret void ret void
} }
define void @avx512_legal512_prefer256_call_avx512_legal512_prefer256(ptr %arg) #1 { define void @avx512_legal512_prefer256_call_avx512_legal512_prefer256(ptr %arg) #1 {
; ;
; TUNIT: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; TUNIT: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; TUNIT-LABEL: define {{[^@]+}}@avx512_legal512_prefer256_call_avx512_legal512_prefer256 ; TUNIT-LABEL: define {{[^@]+}}@avx512_legal512_prefer256_call_avx512_legal512_prefer256
; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: bb: ; TUNIT-NEXT: bb:
; TUNIT-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32 ; TUNIT-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32
; TUNIT-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32 ; TUNIT-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32
; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]] ; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]]
; TUNIT-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64 ; TUNIT-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64
; TUNIT-NEXT: call fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal512_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]] ; TUNIT-NEXT: call fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal512_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]]
; TUNIT-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64 ; TUNIT-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64
; TUNIT-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2 ; TUNIT-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CGSCC: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CGSCC-LABEL: define {{[^@]+}}@avx512_legal512_prefer256_call_avx512_legal512_prefer256 ; CGSCC-LABEL: define {{[^@]+}}@avx512_legal512_prefer256_call_avx512_legal512_prefer256
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(64) [[ARG:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(64) [[ARG:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32 ; CGSCC-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32
; CGSCC-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32 ; CGSCC-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32
; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]] ; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]]
; CGSCC-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64 ; CGSCC-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64
; CGSCC-NEXT: call fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal512_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]] ; CGSCC-NEXT: call fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal512_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]]
Show All 9 Linesbb:
%tmp4 = load <8 x i64>, ptr %tmp2, align 32 %tmp4 = load <8 x i64>, ptr %tmp2, align 32
store <8 x i64> %tmp4, ptr %arg, align 2 store <8 x i64> %tmp4, ptr %arg, align 2
ret void ret void
} }
; This should promote ; This should promote
define internal fastcc void @callee_avx512_legal512_prefer512_call_avx512_legal512_prefer256(ptr %arg, ptr readonly %arg1) #1 { define internal fastcc void @callee_avx512_legal512_prefer512_call_avx512_legal512_prefer256(ptr %arg, ptr readonly %arg1) #1 {
; ;
; CHECK: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CHECK: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CHECK-LABEL: define {{[^@]+}}@callee_avx512_legal512_prefer512_call_avx512_legal512_prefer256 ; CHECK-LABEL: define {{[^@]+}}@callee_avx512_legal512_prefer512_call_avx512_legal512_prefer256
; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[ARG:%.*]], <8 x i64> [[TMP0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[ARG:%.*]], <8 x i64> [[TMP0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: [[ARG1_PRIV:%.*]] = alloca <8 x i64>, align 64 ; CHECK-NEXT: [[ARG1_PRIV:%.*]] = alloca <8 x i64>, align 64
; CHECK-NEXT: store <8 x i64> [[TMP0]], ptr [[ARG1_PRIV]], align 64 ; CHECK-NEXT: store <8 x i64> [[TMP0]], ptr [[ARG1_PRIV]], align 64
; CHECK-NEXT: [[TMP:%.*]] = load <8 x i64>, ptr [[ARG1_PRIV]], align 64 ; CHECK-NEXT: [[TMP:%.*]] = load <8 x i64>, ptr [[ARG1_PRIV]], align 64
; CHECK-NEXT: store <8 x i64> [[TMP]], ptr [[ARG]], align 64 ; CHECK-NEXT: store <8 x i64> [[TMP]], ptr [[ARG]], align 64
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
bb: bb:
%tmp = load <8 x i64>, ptr %arg1 %tmp = load <8 x i64>, ptr %arg1
store <8 x i64> %tmp, ptr %arg store <8 x i64> %tmp, ptr %arg
ret void ret void
} }
define void @avx512_legal512_prefer512_call_avx512_legal512_prefer256(ptr %arg) #0 { define void @avx512_legal512_prefer512_call_avx512_legal512_prefer256(ptr %arg) #0 {
; ;
; TUNIT: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; TUNIT: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; TUNIT-LABEL: define {{[^@]+}}@avx512_legal512_prefer512_call_avx512_legal512_prefer256 ; TUNIT-LABEL: define {{[^@]+}}@avx512_legal512_prefer512_call_avx512_legal512_prefer256
; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: bb: ; TUNIT-NEXT: bb:
; TUNIT-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32 ; TUNIT-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32
; TUNIT-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32 ; TUNIT-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32
; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]] ; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]]
; TUNIT-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64 ; TUNIT-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64
; TUNIT-NEXT: call fastcc void @callee_avx512_legal512_prefer512_call_avx512_legal512_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]] ; TUNIT-NEXT: call fastcc void @callee_avx512_legal512_prefer512_call_avx512_legal512_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]]
; TUNIT-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64 ; TUNIT-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64
; TUNIT-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2 ; TUNIT-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CGSCC: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CGSCC-LABEL: define {{[^@]+}}@avx512_legal512_prefer512_call_avx512_legal512_prefer256 ; CGSCC-LABEL: define {{[^@]+}}@avx512_legal512_prefer512_call_avx512_legal512_prefer256
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(64) [[ARG:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(64) [[ARG:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32 ; CGSCC-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32
; CGSCC-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32 ; CGSCC-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32
; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]] ; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]]
; CGSCC-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64 ; CGSCC-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64
; CGSCC-NEXT: call fastcc void @callee_avx512_legal512_prefer512_call_avx512_legal512_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]] ; CGSCC-NEXT: call fastcc void @callee_avx512_legal512_prefer512_call_avx512_legal512_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]]
Show All 9 Linesbb:
%tmp4 = load <8 x i64>, ptr %tmp2, align 32 %tmp4 = load <8 x i64>, ptr %tmp2, align 32
store <8 x i64> %tmp4, ptr %arg, align 2 store <8 x i64> %tmp4, ptr %arg, align 2
ret void ret void
} }
; This should promote ; This should promote
define internal fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal512_prefer512(ptr %arg, ptr readonly %arg1) #0 { define internal fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal512_prefer512(ptr %arg, ptr readonly %arg1) #0 {
; ;
; CHECK: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CHECK: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CHECK-LABEL: define {{[^@]+}}@callee_avx512_legal512_prefer256_call_avx512_legal512_prefer512 ; CHECK-LABEL: define {{[^@]+}}@callee_avx512_legal512_prefer256_call_avx512_legal512_prefer512
; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[ARG:%.*]], <8 x i64> [[TMP0:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[ARG:%.*]], <8 x i64> [[TMP0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: [[ARG1_PRIV:%.*]] = alloca <8 x i64>, align 64 ; CHECK-NEXT: [[ARG1_PRIV:%.*]] = alloca <8 x i64>, align 64
; CHECK-NEXT: store <8 x i64> [[TMP0]], ptr [[ARG1_PRIV]], align 64 ; CHECK-NEXT: store <8 x i64> [[TMP0]], ptr [[ARG1_PRIV]], align 64
; CHECK-NEXT: [[TMP:%.*]] = load <8 x i64>, ptr [[ARG1_PRIV]], align 64 ; CHECK-NEXT: [[TMP:%.*]] = load <8 x i64>, ptr [[ARG1_PRIV]], align 64
; CHECK-NEXT: store <8 x i64> [[TMP]], ptr [[ARG]], align 64 ; CHECK-NEXT: store <8 x i64> [[TMP]], ptr [[ARG]], align 64
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
bb: bb:
%tmp = load <8 x i64>, ptr %arg1 %tmp = load <8 x i64>, ptr %arg1
store <8 x i64> %tmp, ptr %arg store <8 x i64> %tmp, ptr %arg
ret void ret void
} }
define void @avx512_legal512_prefer256_call_avx512_legal512_prefer512(ptr %arg) #1 { define void @avx512_legal512_prefer256_call_avx512_legal512_prefer512(ptr %arg) #1 {
; ;
; TUNIT: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; TUNIT: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; TUNIT-LABEL: define {{[^@]+}}@avx512_legal512_prefer256_call_avx512_legal512_prefer512 ; TUNIT-LABEL: define {{[^@]+}}@avx512_legal512_prefer256_call_avx512_legal512_prefer512
; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: bb: ; TUNIT-NEXT: bb:
; TUNIT-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32 ; TUNIT-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32
; TUNIT-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32 ; TUNIT-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32
; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]] ; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]]
; TUNIT-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64 ; TUNIT-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64
; TUNIT-NEXT: call fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal512_prefer512(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]] ; TUNIT-NEXT: call fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal512_prefer512(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]]
; TUNIT-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64 ; TUNIT-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64
; TUNIT-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2 ; TUNIT-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CGSCC: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CGSCC-LABEL: define {{[^@]+}}@avx512_legal512_prefer256_call_avx512_legal512_prefer512 ; CGSCC-LABEL: define {{[^@]+}}@avx512_legal512_prefer256_call_avx512_legal512_prefer512
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(64) [[ARG:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(64) [[ARG:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32 ; CGSCC-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32
; CGSCC-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32 ; CGSCC-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32
; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]] ; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]]
; CGSCC-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64 ; CGSCC-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64
; CGSCC-NEXT: call fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal512_prefer512(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]] ; CGSCC-NEXT: call fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal512_prefer512(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]]
Show All 9 Linesbb:
%tmp4 = load <8 x i64>, ptr %tmp2, align 32 %tmp4 = load <8 x i64>, ptr %tmp2, align 32
store <8 x i64> %tmp4, ptr %arg, align 2 store <8 x i64> %tmp4, ptr %arg, align 2
ret void ret void
} }
; This should not promote ; This should not promote
define internal fastcc void @callee_avx512_legal256_prefer256_call_avx512_legal512_prefer256(ptr %arg, ptr readonly %arg1) #1 { define internal fastcc void @callee_avx512_legal256_prefer256_call_avx512_legal512_prefer256(ptr %arg, ptr readonly %arg1) #1 {
; ;
; CHECK: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CHECK: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CHECK-LABEL: define {{[^@]+}}@callee_avx512_legal256_prefer256_call_avx512_legal512_prefer256 ; CHECK-LABEL: define {{[^@]+}}@callee_avx512_legal256_prefer256_call_avx512_legal512_prefer256
; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[ARG:%.*]], ptr noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(64) [[ARG1:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[ARG:%.*]], ptr noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(64) [[ARG1:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: [[TMP:%.*]] = load <8 x i64>, ptr [[ARG1]], align 64 ; CHECK-NEXT: [[TMP:%.*]] = load <8 x i64>, ptr [[ARG1]], align 64
; CHECK-NEXT: store <8 x i64> [[TMP]], ptr [[ARG]], align 64 ; CHECK-NEXT: store <8 x i64> [[TMP]], ptr [[ARG]], align 64
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
bb: bb:
%tmp = load <8 x i64>, ptr %arg1 %tmp = load <8 x i64>, ptr %arg1
store <8 x i64> %tmp, ptr %arg store <8 x i64> %tmp, ptr %arg
ret void ret void
} }
define void @avx512_legal256_prefer256_call_avx512_legal512_prefer256(ptr %arg) #2 { define void @avx512_legal256_prefer256_call_avx512_legal512_prefer256(ptr %arg) #2 {
; ;
; TUNIT: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; TUNIT: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; TUNIT-LABEL: define {{[^@]+}}@avx512_legal256_prefer256_call_avx512_legal512_prefer256 ; TUNIT-LABEL: define {{[^@]+}}@avx512_legal256_prefer256_call_avx512_legal512_prefer256
; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR2:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR2:[0-9]+]] {
; TUNIT-NEXT: bb: ; TUNIT-NEXT: bb:
; TUNIT-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32 ; TUNIT-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32
; TUNIT-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32 ; TUNIT-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32
; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]] ; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]]
; TUNIT-NEXT: call fastcc void @callee_avx512_legal256_prefer256_call_avx512_legal512_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], ptr noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(64) [[TMP]]) #[[ATTR6]] ; TUNIT-NEXT: call fastcc void @callee_avx512_legal256_prefer256_call_avx512_legal512_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], ptr noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(64) [[TMP]]) #[[ATTR6]]
; TUNIT-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64 ; TUNIT-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64
; TUNIT-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2 ; TUNIT-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CGSCC: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CGSCC-LABEL: define {{[^@]+}}@avx512_legal256_prefer256_call_avx512_legal512_prefer256 ; CGSCC-LABEL: define {{[^@]+}}@avx512_legal256_prefer256_call_avx512_legal512_prefer256
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(64) [[ARG:%.*]]) #[[ATTR2:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(64) [[ARG:%.*]]) #[[ATTR2:[0-9]+]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32 ; CGSCC-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32
; CGSCC-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32 ; CGSCC-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32
; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]] ; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]]
; CGSCC-NEXT: call fastcc void @callee_avx512_legal256_prefer256_call_avx512_legal512_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], ptr noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(64) [[TMP]]) #[[ATTR6]] ; CGSCC-NEXT: call fastcc void @callee_avx512_legal256_prefer256_call_avx512_legal512_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], ptr noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(64) [[TMP]]) #[[ATTR6]]
; CGSCC-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64 ; CGSCC-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64
; CGSCC-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2 ; CGSCC-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
bb: bb:
%tmp = alloca <8 x i64>, align 32 %tmp = alloca <8 x i64>, align 32
%tmp2 = alloca <8 x i64>, align 32 %tmp2 = alloca <8 x i64>, align 32
call void @llvm.memset.p0.i64(ptr align 32 %tmp, i8 0, i64 32, i1 false) call void @llvm.memset.p0.i64(ptr align 32 %tmp, i8 0, i64 32, i1 false)
call fastcc void @callee_avx512_legal256_prefer256_call_avx512_legal512_prefer256(ptr %tmp2, ptr %tmp) call fastcc void @callee_avx512_legal256_prefer256_call_avx512_legal512_prefer256(ptr %tmp2, ptr %tmp)
%tmp4 = load <8 x i64>, ptr %tmp2, align 32 %tmp4 = load <8 x i64>, ptr %tmp2, align 32
store <8 x i64> %tmp4, ptr %arg, align 2 store <8 x i64> %tmp4, ptr %arg, align 2
ret void ret void
} }
; This should not promote ; This should not promote
define internal fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal256_prefer256(ptr %arg, ptr readonly %arg1) #2 { define internal fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal256_prefer256(ptr %arg, ptr readonly %arg1) #2 {
; ;
; CHECK: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CHECK: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CHECK-LABEL: define {{[^@]+}}@callee_avx512_legal512_prefer256_call_avx512_legal256_prefer256 ; CHECK-LABEL: define {{[^@]+}}@callee_avx512_legal512_prefer256_call_avx512_legal256_prefer256
; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[ARG:%.*]], ptr noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(64) [[ARG1:%.*]]) #[[ATTR2:[0-9]+]] { ; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[ARG:%.*]], ptr noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(64) [[ARG1:%.*]]) #[[ATTR2:[0-9]+]] {
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: [[TMP:%.*]] = load <8 x i64>, ptr [[ARG1]], align 64 ; CHECK-NEXT: [[TMP:%.*]] = load <8 x i64>, ptr [[ARG1]], align 64
; CHECK-NEXT: store <8 x i64> [[TMP]], ptr [[ARG]], align 64 ; CHECK-NEXT: store <8 x i64> [[TMP]], ptr [[ARG]], align 64
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
bb: bb:
%tmp = load <8 x i64>, ptr %arg1 %tmp = load <8 x i64>, ptr %arg1
store <8 x i64> %tmp, ptr %arg store <8 x i64> %tmp, ptr %arg
ret void ret void
} }
define void @avx512_legal512_prefer256_call_avx512_legal256_prefer256(ptr %arg) #1 { define void @avx512_legal512_prefer256_call_avx512_legal256_prefer256(ptr %arg) #1 {
; ;
; TUNIT: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; TUNIT: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; TUNIT-LABEL: define {{[^@]+}}@avx512_legal512_prefer256_call_avx512_legal256_prefer256 ; TUNIT-LABEL: define {{[^@]+}}@avx512_legal512_prefer256_call_avx512_legal256_prefer256
; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: bb: ; TUNIT-NEXT: bb:
; TUNIT-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32 ; TUNIT-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32
; TUNIT-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32 ; TUNIT-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32
; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]] ; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]]
; TUNIT-NEXT: call fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal256_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], ptr noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(64) [[TMP]]) #[[ATTR6]] ; TUNIT-NEXT: call fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal256_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], ptr noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(64) [[TMP]]) #[[ATTR6]]
; TUNIT-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64 ; TUNIT-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64
; TUNIT-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2 ; TUNIT-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CGSCC: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CGSCC-LABEL: define {{[^@]+}}@avx512_legal512_prefer256_call_avx512_legal256_prefer256 ; CGSCC-LABEL: define {{[^@]+}}@avx512_legal512_prefer256_call_avx512_legal256_prefer256
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(64) [[ARG:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(64) [[ARG:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32 ; CGSCC-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32
; CGSCC-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32 ; CGSCC-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32
; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]] ; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]]
; CGSCC-NEXT: call fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal256_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], ptr noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(64) [[TMP]]) #[[ATTR6]] ; CGSCC-NEXT: call fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal256_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], ptr noalias nocapture nofree noundef nonnull readonly align 64 dereferenceable(64) [[TMP]]) #[[ATTR6]]
; CGSCC-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64 ; CGSCC-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64
; CGSCC-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2 ; CGSCC-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
bb: bb:
%tmp = alloca <8 x i64>, align 32 %tmp = alloca <8 x i64>, align 32
%tmp2 = alloca <8 x i64>, align 32 %tmp2 = alloca <8 x i64>, align 32
call void @llvm.memset.p0.i64(ptr align 32 %tmp, i8 0, i64 32, i1 false) call void @llvm.memset.p0.i64(ptr align 32 %tmp, i8 0, i64 32, i1 false)
call fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal256_prefer256(ptr %tmp2, ptr %tmp) call fastcc void @callee_avx512_legal512_prefer256_call_avx512_legal256_prefer256(ptr %tmp2, ptr %tmp)
%tmp4 = load <8 x i64>, ptr %tmp2, align 32 %tmp4 = load <8 x i64>, ptr %tmp2, align 32
store <8 x i64> %tmp4, ptr %arg, align 2 store <8 x i64> %tmp4, ptr %arg, align 2
ret void ret void
} }
; This should promote ; This should promote
define internal fastcc void @callee_avx2_legal256_prefer256_call_avx2_legal512_prefer256(ptr %arg, ptr readonly %arg1) #3 { define internal fastcc void @callee_avx2_legal256_prefer256_call_avx2_legal512_prefer256(ptr %arg, ptr readonly %arg1) #3 {
; ;
; CHECK: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CHECK: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CHECK-LABEL: define {{[^@]+}}@callee_avx2_legal256_prefer256_call_avx2_legal512_prefer256 ; CHECK-LABEL: define {{[^@]+}}@callee_avx2_legal256_prefer256_call_avx2_legal512_prefer256
; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[ARG:%.*]], <8 x i64> [[TMP0:%.*]]) #[[ATTR3:[0-9]+]] { ; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[ARG:%.*]], <8 x i64> [[TMP0:%.*]]) #[[ATTR3:[0-9]+]] {
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: [[ARG1_PRIV:%.*]] = alloca <8 x i64>, align 64 ; CHECK-NEXT: [[ARG1_PRIV:%.*]] = alloca <8 x i64>, align 64
; CHECK-NEXT: store <8 x i64> [[TMP0]], ptr [[ARG1_PRIV]], align 64 ; CHECK-NEXT: store <8 x i64> [[TMP0]], ptr [[ARG1_PRIV]], align 64
; CHECK-NEXT: [[TMP:%.*]] = load <8 x i64>, ptr [[ARG1_PRIV]], align 64 ; CHECK-NEXT: [[TMP:%.*]] = load <8 x i64>, ptr [[ARG1_PRIV]], align 64
; CHECK-NEXT: store <8 x i64> [[TMP]], ptr [[ARG]], align 64 ; CHECK-NEXT: store <8 x i64> [[TMP]], ptr [[ARG]], align 64
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
bb: bb:
%tmp = load <8 x i64>, ptr %arg1 %tmp = load <8 x i64>, ptr %arg1
store <8 x i64> %tmp, ptr %arg store <8 x i64> %tmp, ptr %arg
ret void ret void
} }
define void @avx2_legal256_prefer256_call_avx2_legal512_prefer256(ptr %arg) #4 { define void @avx2_legal256_prefer256_call_avx2_legal512_prefer256(ptr %arg) #4 {
; ;
; TUNIT: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; TUNIT: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; TUNIT-LABEL: define {{[^@]+}}@avx2_legal256_prefer256_call_avx2_legal512_prefer256 ; TUNIT-LABEL: define {{[^@]+}}@avx2_legal256_prefer256_call_avx2_legal512_prefer256
; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: bb: ; TUNIT-NEXT: bb:
; TUNIT-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32 ; TUNIT-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32
; TUNIT-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32 ; TUNIT-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32
; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]] ; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]]
; TUNIT-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64 ; TUNIT-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64
; TUNIT-NEXT: call fastcc void @callee_avx2_legal256_prefer256_call_avx2_legal512_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]] ; TUNIT-NEXT: call fastcc void @callee_avx2_legal256_prefer256_call_avx2_legal512_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]]
; TUNIT-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64 ; TUNIT-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64
; TUNIT-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2 ; TUNIT-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CGSCC: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CGSCC-LABEL: define {{[^@]+}}@avx2_legal256_prefer256_call_avx2_legal512_prefer256 ; CGSCC-LABEL: define {{[^@]+}}@avx2_legal256_prefer256_call_avx2_legal512_prefer256
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(64) [[ARG:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(64) [[ARG:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32 ; CGSCC-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32
; CGSCC-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32 ; CGSCC-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32
; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]] ; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]]
; CGSCC-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64 ; CGSCC-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64
; CGSCC-NEXT: call fastcc void @callee_avx2_legal256_prefer256_call_avx2_legal512_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]] ; CGSCC-NEXT: call fastcc void @callee_avx2_legal256_prefer256_call_avx2_legal512_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]]
Show All 9 Linesbb:
%tmp4 = load <8 x i64>, ptr %tmp2, align 32 %tmp4 = load <8 x i64>, ptr %tmp2, align 32
store <8 x i64> %tmp4, ptr %arg, align 2 store <8 x i64> %tmp4, ptr %arg, align 2
ret void ret void
} }
; This should promote ; This should promote
define internal fastcc void @callee_avx2_legal512_prefer256_call_avx2_legal256_prefer256(ptr %arg, ptr readonly %arg1) #4 { define internal fastcc void @callee_avx2_legal512_prefer256_call_avx2_legal256_prefer256(ptr %arg, ptr readonly %arg1) #4 {
; ;
; CHECK: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CHECK: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CHECK-LABEL: define {{[^@]+}}@callee_avx2_legal512_prefer256_call_avx2_legal256_prefer256 ; CHECK-LABEL: define {{[^@]+}}@callee_avx2_legal512_prefer256_call_avx2_legal256_prefer256
; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[ARG:%.*]], <8 x i64> [[TMP0:%.*]]) #[[ATTR3]] { ; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[ARG:%.*]], <8 x i64> [[TMP0:%.*]]) #[[ATTR3]] {
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: [[ARG1_PRIV:%.*]] = alloca <8 x i64>, align 64 ; CHECK-NEXT: [[ARG1_PRIV:%.*]] = alloca <8 x i64>, align 64
; CHECK-NEXT: store <8 x i64> [[TMP0]], ptr [[ARG1_PRIV]], align 64 ; CHECK-NEXT: store <8 x i64> [[TMP0]], ptr [[ARG1_PRIV]], align 64
; CHECK-NEXT: [[TMP:%.*]] = load <8 x i64>, ptr [[ARG1_PRIV]], align 64 ; CHECK-NEXT: [[TMP:%.*]] = load <8 x i64>, ptr [[ARG1_PRIV]], align 64
; CHECK-NEXT: store <8 x i64> [[TMP]], ptr [[ARG]], align 64 ; CHECK-NEXT: store <8 x i64> [[TMP]], ptr [[ARG]], align 64
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
bb: bb:
%tmp = load <8 x i64>, ptr %arg1 %tmp = load <8 x i64>, ptr %arg1
store <8 x i64> %tmp, ptr %arg store <8 x i64> %tmp, ptr %arg
ret void ret void
} }
define void @avx2_legal512_prefer256_call_avx2_legal256_prefer256(ptr %arg) #3 { define void @avx2_legal512_prefer256_call_avx2_legal256_prefer256(ptr %arg) #3 {
; ;
; TUNIT: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; TUNIT: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; TUNIT-LABEL: define {{[^@]+}}@avx2_legal512_prefer256_call_avx2_legal256_prefer256 ; TUNIT-LABEL: define {{[^@]+}}@avx2_legal512_prefer256_call_avx2_legal256_prefer256
; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (ptr nocapture nofree writeonly [[ARG:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: bb: ; TUNIT-NEXT: bb:
; TUNIT-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32 ; TUNIT-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32
; TUNIT-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32 ; TUNIT-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32
; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]] ; TUNIT-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 32 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]]
; TUNIT-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64 ; TUNIT-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64
; TUNIT-NEXT: call fastcc void @callee_avx2_legal512_prefer256_call_avx2_legal256_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]] ; TUNIT-NEXT: call fastcc void @callee_avx2_legal512_prefer256_call_avx2_legal256_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]]
; TUNIT-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64 ; TUNIT-NEXT: [[TMP4:%.*]] = load <8 x i64>, ptr [[TMP2]], align 64
; TUNIT-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2 ; TUNIT-NEXT: store <8 x i64> [[TMP4]], ptr [[ARG]], align 2
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CGSCC: Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CGSCC-LABEL: define {{[^@]+}}@avx2_legal512_prefer256_call_avx2_legal256_prefer256 ; CGSCC-LABEL: define {{[^@]+}}@avx2_legal512_prefer256_call_avx2_legal256_prefer256
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(64) [[ARG:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 2 dereferenceable(64) [[ARG:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32 ; CGSCC-NEXT: [[TMP:%.*]] = alloca <8 x i64>, align 32
; CGSCC-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32 ; CGSCC-NEXT: [[TMP2:%.*]] = alloca <8 x i64>, align 32
; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]] ; CGSCC-NEXT: call void @llvm.memset.p0.i64(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP]], i8 noundef 0, i64 noundef 32, i1 noundef false) #[[ATTR5]]
; CGSCC-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64 ; CGSCC-NEXT: [[TMP0:%.*]] = load <8 x i64>, ptr [[TMP]], align 64
; CGSCC-NEXT: call fastcc void @callee_avx2_legal512_prefer256_call_avx2_legal256_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]] ; CGSCC-NEXT: call fastcc void @callee_avx2_legal512_prefer256_call_avx2_legal256_prefer256(ptr noalias nocapture nofree noundef nonnull writeonly align 64 dereferenceable(64) [[TMP2]], <8 x i64> [[TMP0]]) #[[ATTR6]]
Show All 16 Lines
attributes #0 = { inlinehint norecurse nounwind uwtable "target-features"="+avx512vl" "min-legal-vector-width"="512" "prefer-vector-width"="512" } attributes #0 = { inlinehint norecurse nounwind uwtable "target-features"="+avx512vl" "min-legal-vector-width"="512" "prefer-vector-width"="512" }
attributes #1 = { inlinehint norecurse nounwind uwtable "target-features"="+avx512vl" "min-legal-vector-width"="512" "prefer-vector-width"="256" } attributes #1 = { inlinehint norecurse nounwind uwtable "target-features"="+avx512vl" "min-legal-vector-width"="512" "prefer-vector-width"="256" }
attributes #2 = { inlinehint norecurse nounwind uwtable "target-features"="+avx512vl" "min-legal-vector-width"="256" "prefer-vector-width"="256" } attributes #2 = { inlinehint norecurse nounwind uwtable "target-features"="+avx512vl" "min-legal-vector-width"="256" "prefer-vector-width"="256" }
attributes #3 = { inlinehint norecurse nounwind uwtable "target-features"="+avx2" "min-legal-vector-width"="512" "prefer-vector-width"="256" } attributes #3 = { inlinehint norecurse nounwind uwtable "target-features"="+avx2" "min-legal-vector-width"="512" "prefer-vector-width"="256" }
attributes #4 = { inlinehint norecurse nounwind uwtable "target-features"="+avx2" "min-legal-vector-width"="256" "prefer-vector-width"="256" } attributes #4 = { inlinehint norecurse nounwind uwtable "target-features"="+avx2" "min-legal-vector-width"="256" "prefer-vector-width"="256" }
attributes #5 = { argmemonly nounwind } attributes #5 = { argmemonly nounwind }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "min-legal-vector-width"="512" "prefer-vector-width"="512" "target-features"="+avx512vl" } ; TUNIT: attributes #[[ATTR0]] = { inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "min-legal-vector-width"="512" "prefer-vector-width"="512" "target-features"="+avx512vl" }
; TUNIT: attributes #[[ATTR1]] = { inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "min-legal-vector-width"="512" "prefer-vector-width"="256" "target-features"="+avx512vl" } ; TUNIT: attributes #[[ATTR1]] = { inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "min-legal-vector-width"="512" "prefer-vector-width"="256" "target-features"="+avx512vl" }
; TUNIT: attributes #[[ATTR2]] = { inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "min-legal-vector-width"="256" "prefer-vector-width"="256" "target-features"="+avx512vl" } ; TUNIT: attributes #[[ATTR2]] = { inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "min-legal-vector-width"="256" "prefer-vector-width"="256" "target-features"="+avx512vl" }
; TUNIT: attributes #[[ATTR3]] = { inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "min-legal-vector-width"="512" "prefer-vector-width"="256" "target-features"="+avx2" } ; TUNIT: attributes #[[ATTR3]] = { inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "min-legal-vector-width"="512" "prefer-vector-width"="256" "target-features"="+avx2" }
; TUNIT: attributes #[[ATTR4:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR4:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR5]] = { willreturn } ; TUNIT: attributes #[[ATTR5]] = { willreturn }
; TUNIT: attributes #[[ATTR6]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR6]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "min-legal-vector-width"="512" "prefer-vector-width"="512" "target-features"="+avx512vl" } ; CGSCC: attributes #[[ATTR0]] = { inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "min-legal-vector-width"="512" "prefer-vector-width"="512" "target-features"="+avx512vl" }
; CGSCC: attributes #[[ATTR1]] = { inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "min-legal-vector-width"="512" "prefer-vector-width"="256" "target-features"="+avx512vl" } ; CGSCC: attributes #[[ATTR1]] = { inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "min-legal-vector-width"="512" "prefer-vector-width"="256" "target-features"="+avx512vl" }
; CGSCC: attributes #[[ATTR2]] = { inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "min-legal-vector-width"="256" "prefer-vector-width"="256" "target-features"="+avx512vl" } ; CGSCC: attributes #[[ATTR2]] = { inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "min-legal-vector-width"="256" "prefer-vector-width"="256" "target-features"="+avx512vl" }
; CGSCC: attributes #[[ATTR3]] = { inlinehint nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "min-legal-vector-width"="512" "prefer-vector-width"="256" "target-features"="+avx2" } ; CGSCC: attributes #[[ATTR3]] = { inlinehint mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable "min-legal-vector-width"="512" "prefer-vector-width"="256" "target-features"="+avx2" }
; CGSCC: attributes #[[ATTR4:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR4:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR5]] = { willreturn } ; CGSCC: attributes #[[ATTR5]] = { willreturn }
; CGSCC: attributes #[[ATTR6]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR6]] = { nounwind willreturn }
;. ;.

llvm/test/Transforms/Attributor/ArgumentPromotion/aggregate-promote.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
%T = type { i32, i32, i32, i32 } %T = type { i32, i32, i32, i32 }
@G = constant %T { i32 0, i32 0, i32 17, i32 25 } @G = constant %T { i32 0, i32 0, i32 17, i32 25 }
;. ;.
; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = constant [[T:%.*]] { i32 0, i32 0, i32 17, i32 25 } ; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = constant [[T:%.*]] { i32 0, i32 0, i32 17, i32 25 }
;. ;.
define internal i32 @test(ptr %p) { define internal i32 @test(ptr %p) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test ; CGSCC-LABEL: define {{[^@]+}}@test
; CGSCC-SAME: () #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: ret i32 42 ; CGSCC-NEXT: ret i32 42
; ;
entry: entry:
%a.gep = getelementptr %T, ptr %p, i64 0, i32 3 %a.gep = getelementptr %T, ptr %p, i64 0, i32 3
%b.gep = getelementptr %T, ptr %p, i64 0, i32 2 %b.gep = getelementptr %T, ptr %p, i64 0, i32 2
%a = load i32, ptr %a.gep %a = load i32, ptr %a.gep
%b = load i32, ptr %b.gep %b = load i32, ptr %b.gep
%v = add i32 %a, %b %v = add i32 %a, %b
ret i32 %v ret i32 %v
} }
define i32 @caller() { define i32 @caller() {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@caller ; TUNIT-LABEL: define {{[^@]+}}@caller
; TUNIT-SAME: () #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: ret i32 42 ; TUNIT-NEXT: ret i32 42
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@caller ; CGSCC-LABEL: define {{[^@]+}}@caller
; CGSCC-SAME: () #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[V:%.*]] = call noundef i32 @test() #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: [[V:%.*]] = call noundef i32 @test() #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: ret i32 [[V]] ; CGSCC-NEXT: ret i32 [[V]]
; ;
entry: entry:
%v = call i32 @test(ptr @G) %v = call i32 @test(ptr @G)
ret i32 %v ret i32 %v
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { willreturn } ; CGSCC: attributes #[[ATTR2]] = { willreturn }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/ArgumentPromotion/alignment.ll

Show All 34 Lines;
ret void ret void
} }
declare void @z(i32) declare void @z(i32)
; Test2 ; Test2
; Different alignemnt privatizable arguments ; Different alignemnt privatizable arguments
define internal i32 @test(ptr %X, ptr %Y) { define internal i32 @test(ptr %X, ptr %Y) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@test ; CGSCC-LABEL: define {{[^@]+}}@test
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[X:%.*]], i64 [[TMP0:%.*]]) #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[X:%.*]], i64 [[TMP0:%.*]]) #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: [[Y_PRIV:%.*]] = alloca i64, align 8 ; CGSCC-NEXT: [[Y_PRIV:%.*]] = alloca i64, align 8
; CGSCC-NEXT: store i64 [[TMP0]], ptr [[Y_PRIV]], align 4 ; CGSCC-NEXT: store i64 [[TMP0]], ptr [[Y_PRIV]], align 4
; CGSCC-NEXT: [[A:%.*]] = load i32, ptr [[X]], align 4 ; CGSCC-NEXT: [[A:%.*]] = load i32, ptr [[X]], align 4
; CGSCC-NEXT: [[B:%.*]] = load i64, ptr [[Y_PRIV]], align 8 ; CGSCC-NEXT: [[B:%.*]] = load i64, ptr [[Y_PRIV]], align 8
; CGSCC-NEXT: [[C:%.*]] = add i32 [[A]], 1 ; CGSCC-NEXT: [[C:%.*]] = add i32 [[A]], 1
; CGSCC-NEXT: [[D:%.*]] = add i64 [[B]], 1 ; CGSCC-NEXT: [[D:%.*]] = add i64 [[B]], 1
Show All 12 Lines;
br i1 %cond, label %Return1, label %Return2 br i1 %cond, label %Return1, label %Return2
Return1: Return1:
ret i32 %C ret i32 %C
Return2: Return2:
ret i32 %A ret i32 %A
} }
define internal i32 @caller(ptr %A) { define internal i32 @caller(ptr %A) {
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@caller ; CGSCC-LABEL: define {{[^@]+}}@caller
; CGSCC-SAME: (i32 [[TMP0:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (i32 [[TMP0:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: [[A_PRIV:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[A_PRIV:%.*]] = alloca i32, align 4
; CGSCC-NEXT: store i32 [[TMP0]], ptr [[A_PRIV]], align 4 ; CGSCC-NEXT: store i32 [[TMP0]], ptr [[A_PRIV]], align 4
; CGSCC-NEXT: [[C:%.*]] = call i32 @test(ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A_PRIV]], i64 noundef 1) #[[ATTR3:[0-9]+]] ; CGSCC-NEXT: [[C:%.*]] = call i32 @test(ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A_PRIV]], i64 noundef 1) #[[ATTR3:[0-9]+]]
; CGSCC-NEXT: ret i32 [[C]] ; CGSCC-NEXT: ret i32 [[C]]
; ;
%B = alloca i64 %B = alloca i64
store i64 1, ptr %B store i64 1, ptr %B
%C = call i32 @test(ptr %A, ptr %B) %C = call i32 @test(ptr %A, ptr %B)
ret i32 %C ret i32 %C
} }
define i32 @callercaller() { define i32 @callercaller() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@callercaller ; TUNIT-LABEL: define {{[^@]+}}@callercaller
; TUNIT-SAME: () #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: [[B:%.*]] = alloca i32, align 4 ; TUNIT-NEXT: [[B:%.*]] = alloca i32, align 4
; TUNIT-NEXT: ret i32 3 ; TUNIT-NEXT: ret i32 3
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@callercaller ; CGSCC-LABEL: define {{[^@]+}}@callercaller
; CGSCC-SAME: () #[[ATTR2:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR2:[0-9]+]] {
; CGSCC-NEXT: [[X:%.*]] = call i32 @caller(i32 noundef 2) #[[ATTR4:[0-9]+]] ; CGSCC-NEXT: [[X:%.*]] = call i32 @caller(i32 noundef 2) #[[ATTR4:[0-9]+]]
; CGSCC-NEXT: ret i32 [[X]] ; CGSCC-NEXT: ret i32 [[X]]
; ;
%B = alloca i32 %B = alloca i32
store i32 2, ptr %B store i32 2, ptr %B
%X = call i32 @caller(ptr %B) %X = call i32 @caller(ptr %B)
ret i32 %X ret i32 %X
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR3]] = { willreturn memory(read) } ; CGSCC: attributes #[[ATTR3]] = { willreturn memory(read) }
; CGSCC: attributes #[[ATTR4]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR4]] = { nounwind willreturn }
;. ;.

llvm/test/Transforms/Attributor/ArgumentPromotion/attrs.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
%struct.ss = type { i32, i64 } %struct.ss = type { i32, i64 }
; Don't drop 'byval' on %X here. ; Don't drop 'byval' on %X here.
define internal i32 @f(ptr byval(%struct.ss) %b, ptr byval(i32) %X, i32 %i) nounwind { define internal i32 @f(ptr byval(%struct.ss) %b, ptr byval(i32) %X, i32 %i) nounwind {
; ;
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; CHECK-LABEL: define {{[^@]+}}@f ; CHECK-LABEL: define {{[^@]+}}@f
; CHECK-SAME: (i32 [[TMP0:%.*]], i64 [[TMP1:%.*]], i32 [[TMP2:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (i32 [[TMP0:%.*]], i64 [[TMP1:%.*]], i32 [[TMP2:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[X_PRIV:%.*]] = alloca i32, align 4 ; CHECK-NEXT: [[X_PRIV:%.*]] = alloca i32, align 4
; CHECK-NEXT: store i32 [[TMP2]], ptr [[X_PRIV]], align 4 ; CHECK-NEXT: store i32 [[TMP2]], ptr [[X_PRIV]], align 4
; CHECK-NEXT: [[B_PRIV:%.*]] = alloca [[STRUCT_SS:%.*]], align 8 ; CHECK-NEXT: [[B_PRIV:%.*]] = alloca [[STRUCT_SS:%.*]], align 8
; CHECK-NEXT: store i32 [[TMP0]], ptr [[B_PRIV]], align 4 ; CHECK-NEXT: store i32 [[TMP0]], ptr [[B_PRIV]], align 4
; CHECK-NEXT: [[B_PRIV_0_1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[B_PRIV]], i64 0, i32 1 ; CHECK-NEXT: [[B_PRIV_0_1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[B_PRIV]], i64 0, i32 1
Show All 16 Linesentry:
%l = load i32, ptr %X %l = load i32, ptr %X
%a = add i32 %l, %tmp2 %a = add i32 %l, %tmp2
ret i32 %a ret i32 %a
} }
; Also make sure we don't drop the call zeroext attribute. ; Also make sure we don't drop the call zeroext attribute.
define i32 @test(ptr %X) { define i32 @test(ptr %X) {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@test ; TUNIT-LABEL: define {{[^@]+}}@test
; TUNIT-SAME: (ptr nocapture nofree readonly [[X:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr nocapture nofree readonly [[X:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[S:%.*]] = alloca [[STRUCT_SS:%.*]], align 8 ; TUNIT-NEXT: [[S:%.*]] = alloca [[STRUCT_SS:%.*]], align 8
; TUNIT-NEXT: store i32 1, ptr [[S]], align 8 ; TUNIT-NEXT: store i32 1, ptr [[S]], align 8
; TUNIT-NEXT: [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i32 0, i32 1 ; TUNIT-NEXT: [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i32 0, i32 1
; TUNIT-NEXT: [[TMP0:%.*]] = load i32, ptr [[S]], align 8 ; TUNIT-NEXT: [[TMP0:%.*]] = load i32, ptr [[S]], align 8
; TUNIT-NEXT: [[S_0_1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i64 0, i32 1 ; TUNIT-NEXT: [[S_0_1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i64 0, i32 1
; TUNIT-NEXT: [[TMP1:%.*]] = load i64, ptr [[S_0_1]], align 8 ; TUNIT-NEXT: [[TMP1:%.*]] = load i64, ptr [[S_0_1]], align 8
; TUNIT-NEXT: [[TMP2:%.*]] = load i32, ptr [[X]], align 4 ; TUNIT-NEXT: [[TMP2:%.*]] = load i32, ptr [[X]], align 4
; TUNIT-NEXT: [[C:%.*]] = call i32 @f(i32 [[TMP0]], i64 [[TMP1]], i32 [[TMP2]]) #[[ATTR1:[0-9]+]] ; TUNIT-NEXT: [[C:%.*]] = call i32 @f(i32 [[TMP0]], i64 [[TMP1]], i32 [[TMP2]]) #[[ATTR1:[0-9]+]]
; TUNIT-NEXT: ret i32 [[C]] ; TUNIT-NEXT: ret i32 [[C]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@test ; CGSCC-LABEL: define {{[^@]+}}@test
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[X:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[X:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[S:%.*]] = alloca [[STRUCT_SS:%.*]], align 8 ; CGSCC-NEXT: [[S:%.*]] = alloca [[STRUCT_SS:%.*]], align 8
; CGSCC-NEXT: [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i32 0, i32 1 ; CGSCC-NEXT: [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i32 0, i32 1
; CGSCC-NEXT: [[TMP0:%.*]] = load i32, ptr [[X]], align 4 ; CGSCC-NEXT: [[TMP0:%.*]] = load i32, ptr [[X]], align 4
; CGSCC-NEXT: [[C:%.*]] = call i32 @f(i32 noundef 1, i64 noundef 2, i32 [[TMP0]]) #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: [[C:%.*]] = call i32 @f(i32 noundef 1, i64 noundef 2, i32 [[TMP0]]) #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: ret i32 [[C]] ; CGSCC-NEXT: ret i32 [[C]]
; ;
entry: entry:
%S = alloca %struct.ss %S = alloca %struct.ss
store i32 1, ptr %S, align 8 store i32 1, ptr %S, align 8
%tmp4 = getelementptr %struct.ss, ptr %S, i32 0, i32 1 %tmp4 = getelementptr %struct.ss, ptr %S, i32 0, i32 1
store i64 2, ptr %tmp4, align 4 store i64 2, ptr %tmp4, align 4
%c = call i32 @f(ptr byval(%struct.ss) %S, ptr byval(i32) %X, i32 zeroext 0) %c = call i32 @f(ptr byval(%struct.ss) %S, ptr byval(i32) %X, i32 zeroext 0)
ret i32 %c ret i32 %c
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn }
;. ;.

llvm/test/Transforms/Attributor/ArgumentPromotion/basictest.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=5 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=5 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
define internal i32 @test(ptr %X, ptr %Y) { define internal i32 @test(ptr %X, ptr %Y) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@test ; CGSCC-LABEL: define {{[^@]+}}@test
; CGSCC-SAME: (i32 [[TMP0:%.*]], ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[Y:%.*]]) #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: (i32 [[TMP0:%.*]], ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[Y:%.*]]) #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: [[X_PRIV:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[X_PRIV:%.*]] = alloca i32, align 4
; CGSCC-NEXT: store i32 [[TMP0]], ptr [[X_PRIV]], align 4 ; CGSCC-NEXT: store i32 [[TMP0]], ptr [[X_PRIV]], align 4
; CGSCC-NEXT: [[A:%.*]] = load i32, ptr [[X_PRIV]], align 4 ; CGSCC-NEXT: [[A:%.*]] = load i32, ptr [[X_PRIV]], align 4
; CGSCC-NEXT: [[B:%.*]] = load i32, ptr [[Y]], align 4 ; CGSCC-NEXT: [[B:%.*]] = load i32, ptr [[Y]], align 4
; CGSCC-NEXT: [[C:%.*]] = add i32 [[A]], [[B]] ; CGSCC-NEXT: [[C:%.*]] = add i32 [[A]], [[B]]
; CGSCC-NEXT: ret i32 [[C]] ; CGSCC-NEXT: ret i32 [[C]]
; ;
%A = load i32, ptr %X %A = load i32, ptr %X
%B = load i32, ptr %Y %B = load i32, ptr %Y
%C = add i32 %A, %B %C = add i32 %A, %B
ret i32 %C ret i32 %C
} }
define internal i32 @caller(ptr %B) { define internal i32 @caller(ptr %B) {
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@caller ; CGSCC-LABEL: define {{[^@]+}}@caller
; CGSCC-SAME: (i32 [[TMP0:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (i32 [[TMP0:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: [[B_PRIV:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[B_PRIV:%.*]] = alloca i32, align 4
; CGSCC-NEXT: store i32 [[TMP0]], ptr [[B_PRIV]], align 4 ; CGSCC-NEXT: store i32 [[TMP0]], ptr [[B_PRIV]], align 4
; CGSCC-NEXT: [[C:%.*]] = call i32 @test(i32 noundef 1, ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B_PRIV]]) #[[ATTR3:[0-9]+]] ; CGSCC-NEXT: [[C:%.*]] = call i32 @test(i32 noundef 1, ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B_PRIV]]) #[[ATTR3:[0-9]+]]
; CGSCC-NEXT: ret i32 [[C]] ; CGSCC-NEXT: ret i32 [[C]]
; ;
%A = alloca i32 %A = alloca i32
store i32 1, ptr %A store i32 1, ptr %A
%C = call i32 @test(ptr %A, ptr %B) %C = call i32 @test(ptr %A, ptr %B)
ret i32 %C ret i32 %C
} }
define i32 @callercaller() { define i32 @callercaller() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@callercaller ; TUNIT-LABEL: define {{[^@]+}}@callercaller
; TUNIT-SAME: () #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: [[B:%.*]] = alloca i32, align 4 ; TUNIT-NEXT: [[B:%.*]] = alloca i32, align 4
; TUNIT-NEXT: ret i32 3 ; TUNIT-NEXT: ret i32 3
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@callercaller ; CGSCC-LABEL: define {{[^@]+}}@callercaller
; CGSCC-SAME: () #[[ATTR2:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR2:[0-9]+]] {
; CGSCC-NEXT: [[X:%.*]] = call i32 @caller(i32 noundef 2) #[[ATTR4:[0-9]+]] ; CGSCC-NEXT: [[X:%.*]] = call i32 @caller(i32 noundef 2) #[[ATTR4:[0-9]+]]
; CGSCC-NEXT: ret i32 [[X]] ; CGSCC-NEXT: ret i32 [[X]]
; ;
%B = alloca i32 %B = alloca i32
store i32 2, ptr %B store i32 2, ptr %B
%X = call i32 @caller(ptr %B) %X = call i32 @caller(ptr %B)
ret i32 %X ret i32 %X
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR3]] = { willreturn memory(read) } ; CGSCC: attributes #[[ATTR3]] = { willreturn memory(read) }
; CGSCC: attributes #[[ATTR4]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR4]] = { nounwind willreturn }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/ArgumentPromotion/byval-2.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
%struct.ss = type { i32, i64 } %struct.ss = type { i32, i64 }
define internal void @f(ptr byval(%struct.ss) %b, ptr byval(i32) %X) nounwind { define internal void @f(ptr byval(%struct.ss) %b, ptr byval(i32) %X) nounwind {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; CHECK-LABEL: define {{[^@]+}}@f ; CHECK-LABEL: define {{[^@]+}}@f
; CHECK-SAME: (i32 [[TMP0:%.*]], i64 [[TMP1:%.*]], i32 [[TMP2:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (i32 [[TMP0:%.*]], i64 [[TMP1:%.*]], i32 [[TMP2:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[X_PRIV:%.*]] = alloca i32, align 4 ; CHECK-NEXT: [[X_PRIV:%.*]] = alloca i32, align 4
; CHECK-NEXT: store i32 [[TMP2]], ptr [[X_PRIV]], align 4 ; CHECK-NEXT: store i32 [[TMP2]], ptr [[X_PRIV]], align 4
; CHECK-NEXT: [[B_PRIV:%.*]] = alloca [[STRUCT_SS:%.*]], align 8 ; CHECK-NEXT: [[B_PRIV:%.*]] = alloca [[STRUCT_SS:%.*]], align 8
; CHECK-NEXT: store i32 [[TMP0]], ptr [[B_PRIV]], align 4 ; CHECK-NEXT: store i32 [[TMP0]], ptr [[B_PRIV]], align 4
; CHECK-NEXT: [[B_PRIV_0_1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[B_PRIV]], i64 0, i32 1 ; CHECK-NEXT: [[B_PRIV_0_1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[B_PRIV]], i64 0, i32 1
Show All 10 Linesentry:
store i32 %tmp2, ptr %b, align 4 store i32 %tmp2, ptr %b, align 4
store i32 0, ptr %X store i32 0, ptr %X
ret void ret void
} }
define i32 @test(ptr %X) { define i32 @test(ptr %X) {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@test ; TUNIT-LABEL: define {{[^@]+}}@test
; TUNIT-SAME: (ptr nocapture nofree readonly [[X:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr nocapture nofree readonly [[X:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[S:%.*]] = alloca [[STRUCT_SS:%.*]], align 8 ; TUNIT-NEXT: [[S:%.*]] = alloca [[STRUCT_SS:%.*]], align 8
; TUNIT-NEXT: store i32 1, ptr [[S]], align 8 ; TUNIT-NEXT: store i32 1, ptr [[S]], align 8
; TUNIT-NEXT: [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i32 0, i32 1 ; TUNIT-NEXT: [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i32 0, i32 1
; TUNIT-NEXT: [[TMP0:%.*]] = load i32, ptr [[S]], align 8 ; TUNIT-NEXT: [[TMP0:%.*]] = load i32, ptr [[S]], align 8
; TUNIT-NEXT: [[S_0_1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i64 0, i32 1 ; TUNIT-NEXT: [[S_0_1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i64 0, i32 1
; TUNIT-NEXT: [[TMP1:%.*]] = load i64, ptr [[S_0_1]], align 8 ; TUNIT-NEXT: [[TMP1:%.*]] = load i64, ptr [[S_0_1]], align 8
; TUNIT-NEXT: [[TMP2:%.*]] = load i32, ptr [[X]], align 4 ; TUNIT-NEXT: [[TMP2:%.*]] = load i32, ptr [[X]], align 4
; TUNIT-NEXT: call void @f(i32 [[TMP0]], i64 [[TMP1]], i32 [[TMP2]]) #[[ATTR1:[0-9]+]] ; TUNIT-NEXT: call void @f(i32 [[TMP0]], i64 [[TMP1]], i32 [[TMP2]]) #[[ATTR1:[0-9]+]]
; TUNIT-NEXT: ret i32 0 ; TUNIT-NEXT: ret i32 0
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@test ; CGSCC-LABEL: define {{[^@]+}}@test
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[X:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[X:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[S:%.*]] = alloca [[STRUCT_SS:%.*]], align 8 ; CGSCC-NEXT: [[S:%.*]] = alloca [[STRUCT_SS:%.*]], align 8
; CGSCC-NEXT: [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i32 0, i32 1 ; CGSCC-NEXT: [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i32 0, i32 1
; CGSCC-NEXT: [[TMP0:%.*]] = load i32, ptr [[X]], align 4 ; CGSCC-NEXT: [[TMP0:%.*]] = load i32, ptr [[X]], align 4
; CGSCC-NEXT: call void @f(i32 noundef 1, i64 noundef 2, i32 [[TMP0]]) #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: call void @f(i32 noundef 1, i64 noundef 2, i32 [[TMP0]]) #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: ret i32 0 ; CGSCC-NEXT: ret i32 0
; ;
entry: entry:
%S = alloca %struct.ss %S = alloca %struct.ss
store i32 1, ptr %S, align 8 store i32 1, ptr %S, align 8
%tmp4 = getelementptr %struct.ss, ptr %S, i32 0, i32 1 %tmp4 = getelementptr %struct.ss, ptr %S, i32 0, i32 1
store i64 2, ptr %tmp4, align 4 store i64 2, ptr %tmp4, align 4
call void @f(ptr byval(%struct.ss) %S, ptr byval(i32) %X) call void @f(ptr byval(%struct.ss) %S, ptr byval(i32) %X)
ret i32 0 ret i32 0
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn }
;. ;.

llvm/test/Transforms/Attributor/ArgumentPromotion/byval.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
%struct.ss = type { i32, i64 } %struct.ss = type { i32, i64 }
define internal i32 @f(ptr byval(%struct.ss) %b) nounwind { define internal i32 @f(ptr byval(%struct.ss) %b) nounwind {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; CHECK-LABEL: define {{[^@]+}}@f ; CHECK-LABEL: define {{[^@]+}}@f
; CHECK-SAME: (i32 [[TMP0:%.*]], i64 [[TMP1:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (i32 [[TMP0:%.*]], i64 [[TMP1:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[B_PRIV:%.*]] = alloca [[STRUCT_SS:%.*]], align 4 ; CHECK-NEXT: [[B_PRIV:%.*]] = alloca [[STRUCT_SS:%.*]], align 4
; CHECK-NEXT: store i32 [[TMP0]], ptr [[B_PRIV]], align 4 ; CHECK-NEXT: store i32 [[TMP0]], ptr [[B_PRIV]], align 4
; CHECK-NEXT: [[B_PRIV_0_1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[B_PRIV]], i64 0, i32 1 ; CHECK-NEXT: [[B_PRIV_0_1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[B_PRIV]], i64 0, i32 1
; CHECK-NEXT: store i64 [[TMP1]], ptr [[B_PRIV_0_1]], align 4 ; CHECK-NEXT: store i64 [[TMP1]], ptr [[B_PRIV_0_1]], align 4
; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[B_PRIV]], align 8 ; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[B_PRIV]], align 8
; CHECK-NEXT: [[TMP2:%.*]] = add i32 [[TMP1]], 1 ; CHECK-NEXT: [[TMP2:%.*]] = add i32 [[TMP1]], 1
; CHECK-NEXT: store i32 [[TMP2]], ptr [[B_PRIV]], align 8 ; CHECK-NEXT: store i32 [[TMP2]], ptr [[B_PRIV]], align 8
; CHECK-NEXT: ret i32 [[TMP1]] ; CHECK-NEXT: ret i32 [[TMP1]]
; ;
entry: entry:
%tmp1 = load i32, ptr %b, align 4 %tmp1 = load i32, ptr %b, align 4
%tmp2 = add i32 %tmp1, 1 %tmp2 = add i32 %tmp1, 1
store i32 %tmp2, ptr %b, align 4 store i32 %tmp2, ptr %b, align 4
ret i32 %tmp1 ret i32 %tmp1
} }
define internal i32 @g(ptr byval(%struct.ss) align 32 %b) nounwind { define internal i32 @g(ptr byval(%struct.ss) align 32 %b) nounwind {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; CHECK-LABEL: define {{[^@]+}}@g ; CHECK-LABEL: define {{[^@]+}}@g
; CHECK-SAME: (i32 [[TMP0:%.*]], i64 [[TMP1:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32 [[TMP0:%.*]], i64 [[TMP1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[B_PRIV:%.*]] = alloca [[STRUCT_SS:%.*]], align 4 ; CHECK-NEXT: [[B_PRIV:%.*]] = alloca [[STRUCT_SS:%.*]], align 4
; CHECK-NEXT: store i32 [[TMP0]], ptr [[B_PRIV]], align 4 ; CHECK-NEXT: store i32 [[TMP0]], ptr [[B_PRIV]], align 4
; CHECK-NEXT: [[B_PRIV_0_1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[B_PRIV]], i64 0, i32 1 ; CHECK-NEXT: [[B_PRIV_0_1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[B_PRIV]], i64 0, i32 1
; CHECK-NEXT: store i64 [[TMP1]], ptr [[B_PRIV_0_1]], align 4 ; CHECK-NEXT: store i64 [[TMP1]], ptr [[B_PRIV_0_1]], align 4
; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[B_PRIV]], align 32 ; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[B_PRIV]], align 32
; CHECK-NEXT: [[TMP2:%.*]] = add i32 [[TMP1]], 1 ; CHECK-NEXT: [[TMP2:%.*]] = add i32 [[TMP1]], 1
; CHECK-NEXT: store i32 [[TMP2]], ptr [[B_PRIV]], align 32 ; CHECK-NEXT: store i32 [[TMP2]], ptr [[B_PRIV]], align 32
; CHECK-NEXT: ret i32 [[TMP2]] ; CHECK-NEXT: ret i32 [[TMP2]]
; ;
entry: entry:
%tmp1 = load i32, ptr %b, align 4 %tmp1 = load i32, ptr %b, align 4
%tmp2 = add i32 %tmp1, 1 %tmp2 = add i32 %tmp1, 1
store i32 %tmp2, ptr %b, align 4 store i32 %tmp2, ptr %b, align 4
ret i32 %tmp2 ret i32 %tmp2
} }
define i32 @main() nounwind { define i32 @main() nounwind {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@main ; TUNIT-LABEL: define {{[^@]+}}@main
; TUNIT-SAME: () #[[ATTR1:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR1:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[S:%.*]] = alloca [[STRUCT_SS:%.*]], align 4 ; TUNIT-NEXT: [[S:%.*]] = alloca [[STRUCT_SS:%.*]], align 4
; TUNIT-NEXT: store i32 1, ptr [[S]], align 32 ; TUNIT-NEXT: store i32 1, ptr [[S]], align 32
; TUNIT-NEXT: [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i32 0, i32 1 ; TUNIT-NEXT: [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i32 0, i32 1
; TUNIT-NEXT: [[TMP0:%.*]] = load i32, ptr [[S]], align 8 ; TUNIT-NEXT: [[TMP0:%.*]] = load i32, ptr [[S]], align 8
; TUNIT-NEXT: [[S_0_11:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i64 0, i32 1 ; TUNIT-NEXT: [[S_0_11:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i64 0, i32 1
; TUNIT-NEXT: [[TMP1:%.*]] = load i64, ptr [[S_0_11]], align 8 ; TUNIT-NEXT: [[TMP1:%.*]] = load i64, ptr [[S_0_11]], align 8
; TUNIT-NEXT: [[C0:%.*]] = call i32 @f(i32 [[TMP0]], i64 [[TMP1]]) #[[ATTR2:[0-9]+]] ; TUNIT-NEXT: [[C0:%.*]] = call i32 @f(i32 [[TMP0]], i64 [[TMP1]]) #[[ATTR2:[0-9]+]]
; TUNIT-NEXT: [[TMP2:%.*]] = load i32, ptr [[S]], align 32 ; TUNIT-NEXT: [[TMP2:%.*]] = load i32, ptr [[S]], align 32
; TUNIT-NEXT: [[S_0_1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i64 0, i32 1 ; TUNIT-NEXT: [[S_0_1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i64 0, i32 1
; TUNIT-NEXT: [[TMP3:%.*]] = load i64, ptr [[S_0_1]], align 32 ; TUNIT-NEXT: [[TMP3:%.*]] = load i64, ptr [[S_0_1]], align 32
; TUNIT-NEXT: [[C1:%.*]] = call i32 @g(i32 [[TMP2]], i64 [[TMP3]]) #[[ATTR2]] ; TUNIT-NEXT: [[C1:%.*]] = call i32 @g(i32 [[TMP2]], i64 [[TMP3]]) #[[ATTR2]]
; TUNIT-NEXT: [[A:%.*]] = add i32 [[C0]], [[C1]] ; TUNIT-NEXT: [[A:%.*]] = add i32 [[C0]], [[C1]]
; TUNIT-NEXT: ret i32 [[A]] ; TUNIT-NEXT: ret i32 [[A]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@main ; CGSCC-LABEL: define {{[^@]+}}@main
; CGSCC-SAME: () #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[S:%.*]] = alloca [[STRUCT_SS:%.*]], align 4 ; CGSCC-NEXT: [[S:%.*]] = alloca [[STRUCT_SS:%.*]], align 4
; CGSCC-NEXT: [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i32 0, i32 1 ; CGSCC-NEXT: [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i32 0, i32 1
; CGSCC-NEXT: [[C0:%.*]] = call i32 @f(i32 noundef 1, i64 noundef 2) #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: [[C0:%.*]] = call i32 @f(i32 noundef 1, i64 noundef 2) #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: [[C1:%.*]] = call i32 @g(i32 noundef 1, i64 noundef 2) #[[ATTR2]] ; CGSCC-NEXT: [[C1:%.*]] = call i32 @g(i32 noundef 1, i64 noundef 2) #[[ATTR2]]
; CGSCC-NEXT: [[A:%.*]] = add i32 [[C0]], [[C1]] ; CGSCC-NEXT: [[A:%.*]] = add i32 [[C0]], [[C1]]
; CGSCC-NEXT: ret i32 [[A]] ; CGSCC-NEXT: ret i32 [[A]]
; ;
entry: entry:
%S = alloca %struct.ss %S = alloca %struct.ss
store i32 1, ptr %S, align 8 store i32 1, ptr %S, align 8
%tmp4 = getelementptr %struct.ss, ptr %S, i32 0, i32 1 %tmp4 = getelementptr %struct.ss, ptr %S, i32 0, i32 1
store i64 2, ptr %tmp4, align 4 store i64 2, ptr %tmp4, align 4
%c0 = call i32 @f(ptr byval(%struct.ss) %S) nounwind %c0 = call i32 @f(ptr byval(%struct.ss) %S) nounwind
%c1 = call i32 @g(ptr byval(%struct.ss) %S) nounwind %c1 = call i32 @g(ptr byval(%struct.ss) %S) nounwind
%a = add i32 %c0, %c1 %a = add i32 %c0, %c1
ret i32 %a ret i32 %a
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn }
;. ;.

llvm/test/Transforms/Attributor/ArgumentPromotion/chained.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=9 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=9 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
@G1 = constant i32 0 @G1 = constant i32 0
@G2 = constant ptr @G1 @G2 = constant ptr @G1
;. ;.
; CHECK: @[[G1:[a-zA-Z0-9_$"\\.-]+]] = constant i32 0 ; CHECK: @[[G1:[a-zA-Z0-9_$"\\.-]+]] = constant i32 0
; CHECK: @[[G2:[a-zA-Z0-9_$"\\.-]+]] = constant ptr @G1 ; CHECK: @[[G2:[a-zA-Z0-9_$"\\.-]+]] = constant ptr @G1
;. ;.
define internal i32 @test(ptr %x) { define internal i32 @test(ptr %x) {
; ;
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test ; CHECK-LABEL: define {{[^@]+}}@test
; CHECK-SAME: () #[[ATTR0:[0-9]+]] { ; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[Z:%.*]] = load i32, ptr @G1, align 4 ; CHECK-NEXT: [[Z:%.*]] = load i32, ptr @G1, align 4
; CHECK-NEXT: ret i32 [[Z]] ; CHECK-NEXT: ret i32 [[Z]]
; ;
entry: entry:
%y = load ptr, ptr %x %y = load ptr, ptr %x
%z = load i32, ptr %y %z = load i32, ptr %y
ret i32 %z ret i32 %z
} }
define i32 @caller() { define i32 @caller() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@caller ; TUNIT-LABEL: define {{[^@]+}}@caller
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[X:%.*]] = call i32 @test() #[[ATTR1:[0-9]+]] ; TUNIT-NEXT: [[X:%.*]] = call i32 @test() #[[ATTR1:[0-9]+]]
; TUNIT-NEXT: ret i32 [[X]] ; TUNIT-NEXT: ret i32 [[X]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@caller ; CGSCC-LABEL: define {{[^@]+}}@caller
; CGSCC-SAME: () #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[X:%.*]] = call i32 @test() #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: [[X:%.*]] = call i32 @test() #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: ret i32 [[X]] ; CGSCC-NEXT: ret i32 [[X]]
; ;
entry: entry:
%x = call i32 @test(ptr @G2) %x = call i32 @test(ptr @G2)
ret i32 %x ret i32 %x
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { willreturn } ; CGSCC: attributes #[[ATTR2]] = { willreturn }
;. ;.

llvm/test/Transforms/Attributor/ArgumentPromotion/control-flow.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; Don't promote around control flow. ; Don't promote around control flow.
define internal i32 @callee(i1 %C, ptr %P) { define internal i32 @callee(i1 %C, ptr %P) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define {{[^@]+}}@callee ; CHECK-LABEL: define {{[^@]+}}@callee
; CHECK-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree readonly [[P:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree readonly [[P:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; CHECK-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; CHECK: T: ; CHECK: T:
; CHECK-NEXT: ret i32 17 ; CHECK-NEXT: ret i32 17
; CHECK: F: ; CHECK: F:
; CHECK-NEXT: [[X:%.*]] = load i32, ptr [[P]], align 4 ; CHECK-NEXT: [[X:%.*]] = load i32, ptr [[P]], align 4
; CHECK-NEXT: ret i32 [[X]] ; CHECK-NEXT: ret i32 [[X]]
; ;
entry: entry:
br i1 %C, label %T, label %F br i1 %C, label %T, label %F
T: T:
ret i32 17 ret i32 17
F: F:
%X = load i32, ptr %P %X = load i32, ptr %P
ret i32 %X ret i32 %X
} }
define i32 @foo(i1 %C, ptr %P) { define i32 @foo(i1 %C, ptr %P) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; TUNIT-LABEL: define {{[^@]+}}@foo ; TUNIT-LABEL: define {{[^@]+}}@foo
; TUNIT-SAME: (i1 [[C:%.*]], ptr nocapture nofree readonly [[P:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i1 [[C:%.*]], ptr nocapture nofree readonly [[P:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[X:%.*]] = call i32 @callee(i1 [[C]], ptr nocapture nofree readonly [[P]]) #[[ATTR1:[0-9]+]] ; TUNIT-NEXT: [[X:%.*]] = call i32 @callee(i1 [[C]], ptr nocapture nofree readonly [[P]]) #[[ATTR1:[0-9]+]]
; TUNIT-NEXT: ret i32 [[X]] ; TUNIT-NEXT: ret i32 [[X]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@foo ; CGSCC-LABEL: define {{[^@]+}}@foo
; CGSCC-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree readonly [[P:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree readonly [[P:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[X:%.*]] = call i32 @callee(i1 noundef [[C]], ptr nocapture nofree readonly [[P]]) #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: [[X:%.*]] = call i32 @callee(i1 noundef [[C]], ptr nocapture nofree readonly [[P]]) #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: ret i32 [[X]] ; CGSCC-NEXT: ret i32 [[X]]
; ;
entry: entry:
%X = call i32 @callee(i1 %C, ptr %P) %X = call i32 @callee(i1 %C, ptr %P)
ret i32 %X ret i32 %X
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR2]] = { willreturn } ; CGSCC: attributes #[[ATTR2]] = { willreturn }
;. ;.

llvm/test/Transforms/Attributor/ArgumentPromotion/control-flow2.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
define internal i32 @callee(i1 %C, ptr %P) { define internal i32 @callee(i1 %C, ptr %P) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@callee ; CGSCC-LABEL: define {{[^@]+}}@callee
; CGSCC-SAME: (i32 [[TMP0:%.*]]) #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: (i32 [[TMP0:%.*]]) #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: [[P_PRIV:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[P_PRIV:%.*]] = alloca i32, align 4
; CGSCC-NEXT: store i32 [[TMP0]], ptr [[P_PRIV]], align 4 ; CGSCC-NEXT: store i32 [[TMP0]], ptr [[P_PRIV]], align 4
; CGSCC-NEXT: br label [[F:%.*]] ; CGSCC-NEXT: br label [[F:%.*]]
; CGSCC: T: ; CGSCC: T:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: F: ; CGSCC: F:
; CGSCC-NEXT: [[X:%.*]] = load i32, ptr [[P_PRIV]], align 4 ; CGSCC-NEXT: [[X:%.*]] = load i32, ptr [[P_PRIV]], align 4
; CGSCC-NEXT: ret i32 [[X]] ; CGSCC-NEXT: ret i32 [[X]]
; ;
br i1 %C, label %T, label %F br i1 %C, label %T, label %F
T: ; preds = %0 T: ; preds = %0
ret i32 17 ret i32 17
F: ; preds = %0 F: ; preds = %0
%X = load i32, ptr %P ; <i32> [#uses=1] %X = load i32, ptr %P ; <i32> [#uses=1]
ret i32 %X ret i32 %X
} }
define i32 @foo() { define i32 @foo() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@foo ; TUNIT-LABEL: define {{[^@]+}}@foo
; TUNIT-SAME: () #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: [[A:%.*]] = alloca i32, align 4 ; TUNIT-NEXT: [[A:%.*]] = alloca i32, align 4
; TUNIT-NEXT: ret i32 17 ; TUNIT-NEXT: ret i32 17
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@foo ; CGSCC-LABEL: define {{[^@]+}}@foo
; CGSCC-SAME: () #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: [[X:%.*]] = call i32 @callee(i32 noundef 17) #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: [[X:%.*]] = call i32 @callee(i32 noundef 17) #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: ret i32 [[X]] ; CGSCC-NEXT: ret i32 [[X]]
; ;
%A = alloca i32 ; <ptr> [#uses=2] %A = alloca i32 ; <ptr> [#uses=2]
store i32 17, ptr %A store i32 17, ptr %A
%X = call i32 @callee( i1 false, ptr %A ) ; <i32> [#uses=1] %X = call i32 @callee( i1 false, ptr %A ) ; <i32> [#uses=1]
ret i32 %X ret i32 %X
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { willreturn } ; CGSCC: attributes #[[ATTR2]] = { willreturn }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/ArgumentPromotion/crash.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=4 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=4 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
%S = type { ptr } %S = type { ptr }
; Inlining should nuke the invoke (and any inlined calls) here even with ; Inlining should nuke the invoke (and any inlined calls) here even with
; argument promotion running along with it. ; argument promotion running along with it.
define void @zot() personality ptr @wibble { define void @zot() personality ptr @wibble {
; TUNIT: Function Attrs: nofree norecurse noreturn nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@zot ; TUNIT-LABEL: define {{[^@]+}}@zot
; TUNIT-SAME: () #[[ATTR0:[0-9]+]] personality ptr @wibble { ; TUNIT-SAME: () #[[ATTR0:[0-9]+]] personality ptr @wibble {
; TUNIT-NEXT: bb: ; TUNIT-NEXT: bb:
; TUNIT-NEXT: call void @hoge() #[[ATTR2:[0-9]+]] ; TUNIT-NEXT: call void @hoge() #[[ATTR2:[0-9]+]]
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: bb1: ; TUNIT: bb1:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: bb2: ; TUNIT: bb2:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree noreturn nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree noreturn nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@zot ; CGSCC-LABEL: define {{[^@]+}}@zot
; CGSCC-SAME: () #[[ATTR0:[0-9]+]] personality ptr @wibble { ; CGSCC-SAME: () #[[ATTR0:[0-9]+]] personality ptr @wibble {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: call void @hoge() #[[ATTR4:[0-9]+]] ; CGSCC-NEXT: call void @hoge() #[[ATTR4:[0-9]+]]
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: bb1: ; CGSCC: bb1:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: bb2: ; CGSCC: bb2:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
bb: bb:
invoke void @hoge() invoke void @hoge()
to label %bb1 unwind label %bb2 to label %bb1 unwind label %bb2
bb1: bb1:
unreachable unreachable
bb2: bb2:
%tmp = landingpad { ptr, i32 } %tmp = landingpad { ptr, i32 }
cleanup cleanup
unreachable unreachable
} }
define internal void @hoge() { define internal void @hoge() {
; TUNIT: Function Attrs: nofree norecurse noreturn nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@hoge ; TUNIT-LABEL: define {{[^@]+}}@hoge
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: bb: ; TUNIT-NEXT: bb:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree noreturn nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree noreturn nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@hoge ; CGSCC-LABEL: define {{[^@]+}}@hoge
; CGSCC-SAME: () #[[ATTR0]] { ; CGSCC-SAME: () #[[ATTR0]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
bb: bb:
%tmp = call fastcc ptr @spam(ptr @eggs) %tmp = call fastcc ptr @spam(ptr @eggs)
%tmp1 = call fastcc ptr @spam(ptr @barney) %tmp1 = call fastcc ptr @spam(ptr @barney)
unreachable unreachable
} }
define internal fastcc ptr @spam(ptr %arg) { define internal fastcc ptr @spam(ptr %arg) {
; CGSCC: Function Attrs: nofree norecurse noreturn nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@spam ; CGSCC-LABEL: define {{[^@]+}}@spam
; CGSCC-SAME: () #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
bb: bb:
unreachable unreachable
} }
define internal i1 @eggs(ptr %arg) { define internal i1 @eggs(ptr %arg) {
; CGSCC-LABEL: define {{[^@]+}}@eggs ; CGSCC-LABEL: define {{[^@]+}}@eggs
; CGSCC-SAME: (ptr [[ARG:%.*]]) { ; CGSCC-SAME: (ptr [[ARG:%.*]]) {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: [[TMP:%.*]] = call zeroext i1 @barney() ; CGSCC-NEXT: [[TMP:%.*]] = call zeroext i1 @barney()
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
bb: bb:
%tmp = call zeroext i1 @barney(ptr %arg) %tmp = call zeroext i1 @barney(ptr %arg)
unreachable unreachable
} }
define internal i1 @barney(ptr %arg) { define internal i1 @barney(ptr %arg) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@barney ; CGSCC-LABEL: define {{[^@]+}}@barney
; CGSCC-SAME: () #[[ATTR2:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR2:[0-9]+]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: ret i1 undef ; CGSCC-NEXT: ret i1 undef
; ;
bb: bb:
ret i1 undef ret i1 undef
} }
define i32 @test_inf_promote_caller(i32 %arg) { define i32 @test_inf_promote_caller(i32 %arg) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@test_inf_promote_caller ; TUNIT-LABEL: define {{[^@]+}}@test_inf_promote_caller
; TUNIT-SAME: (i32 [[ARG:%.*]]) #[[ATTR1:[0-9]+]] { ; TUNIT-SAME: (i32 [[ARG:%.*]]) #[[ATTR1:[0-9]+]] {
; TUNIT-NEXT: bb: ; TUNIT-NEXT: bb:
; TUNIT-NEXT: ret i32 0 ; TUNIT-NEXT: ret i32 0
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test_inf_promote_caller ; CGSCC-LABEL: define {{[^@]+}}@test_inf_promote_caller
; CGSCC-SAME: (i32 [[ARG:%.*]]) #[[ATTR3:[0-9]+]] { ; CGSCC-SAME: (i32 [[ARG:%.*]]) #[[ATTR3:[0-9]+]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: [[TMP:%.*]] = alloca [[S:%.*]], align 8 ; CGSCC-NEXT: [[TMP:%.*]] = alloca [[S:%.*]], align 8
; CGSCC-NEXT: [[TMP1:%.*]] = alloca [[S]], align 8 ; CGSCC-NEXT: [[TMP1:%.*]] = alloca [[S]], align 8
; CGSCC-NEXT: ret i32 0 ; CGSCC-NEXT: ret i32 0
; ;
bb: bb:
%tmp = alloca %S %tmp = alloca %S
%tmp1 = alloca %S %tmp1 = alloca %S
%tmp2 = call i32 @test_inf_promote_callee(ptr %tmp, ptr %tmp1) %tmp2 = call i32 @test_inf_promote_callee(ptr %tmp, ptr %tmp1)
ret i32 0 ret i32 0
} }
define internal i32 @test_inf_promote_callee(ptr %arg, ptr %arg1) { define internal i32 @test_inf_promote_callee(ptr %arg, ptr %arg1) {
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test_inf_promote_callee ; CGSCC-LABEL: define {{[^@]+}}@test_inf_promote_callee
; CGSCC-SAME: () #[[ATTR3]] { ; CGSCC-SAME: () #[[ATTR3]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: ret i32 undef ; CGSCC-NEXT: ret i32 undef
; ;
bb: bb:
%tmp2 = load ptr, ptr %arg1 %tmp2 = load ptr, ptr %arg1
%tmp4 = load ptr, ptr %arg %tmp4 = load ptr, ptr %arg
%tmp5 = call i32 @test_inf_promote_callee(ptr %tmp4, ptr %tmp2) %tmp5 = call i32 @test_inf_promote_callee(ptr %tmp4, ptr %tmp2)
ret i32 0 ret i32 0
} }
declare i32 @wibble(...) declare i32 @wibble(...)
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse noreturn nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR2]] = { noreturn nounwind } ; TUNIT: attributes #[[ATTR2]] = { noreturn nounwind }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree noreturn nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree noreturn nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse noreturn nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR3]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR4]] = { noreturn nounwind } ; CGSCC: attributes #[[ATTR4]] = { noreturn nounwind }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/ArgumentPromotion/fp80.ll

Show All 13 Lines
@a = internal global %struct.Foo { i32 1, i64 2 }, align 8 @a = internal global %struct.Foo { i32 1, i64 2 }, align 8
;. ;.
; CHECK: @[[B:[a-zA-Z0-9_$"\\.-]+]] = internal global [[STRUCT_S:%.*]] { double 3.140000e+00, i16 9439, i8 25, [5 x i8] undef }, align 16 ; CHECK: @[[B:[a-zA-Z0-9_$"\\.-]+]] = internal global [[STRUCT_S:%.*]] { double 3.140000e+00, i16 9439, i8 25, [5 x i8] undef }, align 16
; CHECK: @[[A:[a-zA-Z0-9_$"\\.-]+]] = internal global [[STRUCT_FOO:%.*]] { i32 1, i64 2 }, align 8 ; CHECK: @[[A:[a-zA-Z0-9_$"\\.-]+]] = internal global [[STRUCT_FOO:%.*]] { i32 1, i64 2 }, align 8
;. ;.
define void @run() { define void @run() {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@run ; TUNIT-LABEL: define {{[^@]+}}@run
; TUNIT-SAME: () #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@run ; CGSCC-LABEL: define {{[^@]+}}@run
; CGSCC-SAME: () #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
entry: entry:
tail call i8 @UseLongDoubleUnsafely(ptr byval(%union.u) align 16 @b) tail call i8 @UseLongDoubleUnsafely(ptr byval(%union.u) align 16 @b)
tail call x86_fp80 @UseLongDoubleSafely(ptr byval(%union.u) align 16 @b) tail call x86_fp80 @UseLongDoubleSafely(ptr byval(%union.u) align 16 @b)
call i64 @AccessPaddingOfStruct(ptr byval(%struct.Foo) @a) call i64 @AccessPaddingOfStruct(ptr byval(%struct.Foo) @a)
call i64 @CaptureAStruct(ptr byval(%struct.Foo) @a) call i64 @CaptureAStruct(ptr byval(%struct.Foo) @a)
ret void ret void
} }
define internal i8 @UseLongDoubleUnsafely(ptr byval(%union.u) align 16 %arg) { define internal i8 @UseLongDoubleUnsafely(ptr byval(%union.u) align 16 %arg) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@UseLongDoubleUnsafely ; CGSCC-LABEL: define {{[^@]+}}@UseLongDoubleUnsafely
; CGSCC-SAME: () #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: ret i8 undef ; CGSCC-NEXT: ret i8 undef
; ;
entry: entry:
%bitcast = bitcast ptr %arg to ptr %bitcast = bitcast ptr %arg to ptr
%gep = getelementptr inbounds %struct.s, ptr %bitcast, i64 0, i32 2 %gep = getelementptr inbounds %struct.s, ptr %bitcast, i64 0, i32 2
%result = load i8, ptr %gep %result = load i8, ptr %gep
ret i8 %result ret i8 %result
} }
define internal x86_fp80 @UseLongDoubleSafely(ptr byval(%union.u) align 16 %arg) { define internal x86_fp80 @UseLongDoubleSafely(ptr byval(%union.u) align 16 %arg) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@UseLongDoubleSafely ; CGSCC-LABEL: define {{[^@]+}}@UseLongDoubleSafely
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: ret x86_fp80 undef ; CGSCC-NEXT: ret x86_fp80 undef
; ;
%gep = getelementptr inbounds %union.u, ptr %arg, i64 0, i32 0 %gep = getelementptr inbounds %union.u, ptr %arg, i64 0, i32 0
%fp80 = load x86_fp80, ptr %gep %fp80 = load x86_fp80, ptr %gep
ret x86_fp80 %fp80 ret x86_fp80 %fp80
} }
define internal i64 @AccessPaddingOfStruct(ptr byval(%struct.Foo) %a) { define internal i64 @AccessPaddingOfStruct(ptr byval(%struct.Foo) %a) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@AccessPaddingOfStruct ; CGSCC-LABEL: define {{[^@]+}}@AccessPaddingOfStruct
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: ret i64 undef ; CGSCC-NEXT: ret i64 undef
; ;
%p = bitcast ptr %a to ptr %p = bitcast ptr %a to ptr
%v = load i64, ptr %p %v = load i64, ptr %p
ret i64 %v ret i64 %v
} }
Show All 21 Lines
loop: loop:
%phi = phi ptr [ null, %entry ], [ %gep, %loop ] %phi = phi ptr [ null, %entry ], [ %gep, %loop ]
%0 = phi ptr [ %a, %entry ], [ %0, %loop ] %0 = phi ptr [ %a, %entry ], [ %0, %loop ]
store ptr %phi, ptr %a_ptr store ptr %phi, ptr %a_ptr
%gep = getelementptr %struct.Foo, ptr %a, i64 0 %gep = getelementptr %struct.Foo, ptr %a, i64 0
br label %loop br label %loop
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { nofree norecurse noreturn nosync nounwind memory(none) } ; CGSCC: attributes #[[ATTR2]] = { nofree norecurse noreturn nosync nounwind memory(none) }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/ArgumentPromotion/inalloca.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
%struct.ss = type { i32, i32 } %struct.ss = type { i32, i32 }
; Argpromote + sroa should change this to passing the two integers by value. ; Argpromote + sroa should change this to passing the two integers by value.
define internal i32 @f(ptr inalloca(%struct.ss) %s) { define internal i32 @f(ptr inalloca(%struct.ss) %s) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define {{[^@]+}}@f ; CHECK-LABEL: define {{[^@]+}}@f
; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull inalloca([[STRUCT_SS:%.*]]) align 4 dereferenceable(8) [[S:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull inalloca([[STRUCT_SS:%.*]]) align 4 dereferenceable(8) [[S:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[F1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i32 0, i32 1 ; CHECK-NEXT: [[F1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i32 0, i32 1
; CHECK-NEXT: [[A:%.*]] = load i32, ptr [[S]], align 4 ; CHECK-NEXT: [[A:%.*]] = load i32, ptr [[S]], align 4
; CHECK-NEXT: [[B:%.*]] = load i32, ptr [[F1]], align 4 ; CHECK-NEXT: [[B:%.*]] = load i32, ptr [[F1]], align 4
; CHECK-NEXT: [[R:%.*]] = add i32 [[A]], [[B]] ; CHECK-NEXT: [[R:%.*]] = add i32 [[A]], [[B]]
; CHECK-NEXT: ret i32 [[R]] ; CHECK-NEXT: ret i32 [[R]]
; ;
entry: entry:
%f1 = getelementptr %struct.ss, ptr %s, i32 0, i32 1 %f1 = getelementptr %struct.ss, ptr %s, i32 0, i32 1
%a = load i32, ptr %s, align 4 %a = load i32, ptr %s, align 4
%b = load i32, ptr %f1, align 4 %b = load i32, ptr %f1, align 4
%r = add i32 %a, %b %r = add i32 %a, %b
ret i32 %r ret i32 %r
} }
define i32 @main() { define i32 @main() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@main ; TUNIT-LABEL: define {{[^@]+}}@main
; TUNIT-SAME: () #[[ATTR1:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR1:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[S:%.*]] = alloca inalloca [[STRUCT_SS:%.*]], align 4 ; TUNIT-NEXT: [[S:%.*]] = alloca inalloca [[STRUCT_SS:%.*]], align 4
; TUNIT-NEXT: [[F1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i32 0, i32 1 ; TUNIT-NEXT: [[F1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i32 0, i32 1
; TUNIT-NEXT: store i32 1, ptr [[S]], align 4 ; TUNIT-NEXT: store i32 1, ptr [[S]], align 4
; TUNIT-NEXT: store i32 2, ptr [[F1]], align 4 ; TUNIT-NEXT: store i32 2, ptr [[F1]], align 4
; TUNIT-NEXT: [[R:%.*]] = call i32 @f(ptr noalias nocapture nofree noundef nonnull inalloca([[STRUCT_SS]]) align 4 dereferenceable(8) [[S]]) #[[ATTR2:[0-9]+]] ; TUNIT-NEXT: [[R:%.*]] = call i32 @f(ptr noalias nocapture nofree noundef nonnull inalloca([[STRUCT_SS]]) align 4 dereferenceable(8) [[S]]) #[[ATTR2:[0-9]+]]
; TUNIT-NEXT: ret i32 [[R]] ; TUNIT-NEXT: ret i32 [[R]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@main ; CGSCC-LABEL: define {{[^@]+}}@main
; CGSCC-SAME: () #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[S:%.*]] = alloca inalloca [[STRUCT_SS:%.*]], align 4 ; CGSCC-NEXT: [[S:%.*]] = alloca inalloca [[STRUCT_SS:%.*]], align 4
; CGSCC-NEXT: [[F1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i32 0, i32 1 ; CGSCC-NEXT: [[F1:%.*]] = getelementptr [[STRUCT_SS]], ptr [[S]], i32 0, i32 1
; CGSCC-NEXT: store i32 1, ptr [[S]], align 4 ; CGSCC-NEXT: store i32 1, ptr [[S]], align 4
; CGSCC-NEXT: store i32 2, ptr [[F1]], align 4 ; CGSCC-NEXT: store i32 2, ptr [[F1]], align 4
; CGSCC-NEXT: [[R:%.*]] = call i32 @f(ptr noalias nocapture nofree noundef nonnull inalloca([[STRUCT_SS]]) align 4 dereferenceable(8) [[S]]) #[[ATTR3:[0-9]+]] ; CGSCC-NEXT: [[R:%.*]] = call i32 @f(ptr noalias nocapture nofree noundef nonnull inalloca([[STRUCT_SS]]) align 4 dereferenceable(8) [[S]]) #[[ATTR3:[0-9]+]]
; CGSCC-NEXT: ret i32 [[R]] ; CGSCC-NEXT: ret i32 [[R]]
; ;
entry: entry:
%S = alloca inalloca %struct.ss %S = alloca inalloca %struct.ss
%f1 = getelementptr %struct.ss, ptr %S, i32 0, i32 1 %f1 = getelementptr %struct.ss, ptr %S, i32 0, i32 1
store i32 1, ptr %S, align 4 store i32 1, ptr %S, align 4
store i32 2, ptr %f1, align 4 store i32 2, ptr %f1, align 4
%r = call i32 @f(ptr inalloca(%struct.ss) %S) %r = call i32 @f(ptr inalloca(%struct.ss) %S)
ret i32 %r ret i32 %r
} }
; Argpromote can't promote %a because of the icmp use. ; Argpromote can't promote %a because of the icmp use.
define internal i1 @g(ptr %a, ptr inalloca(%struct.ss) %b) nounwind { define internal i1 @g(ptr %a, ptr inalloca(%struct.ss) %b) nounwind {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@g ; CGSCC-LABEL: define {{[^@]+}}@g
; CGSCC-SAME: (ptr noalias nocapture nofree nonnull readnone align 4 dereferenceable(8) [[A:%.*]], ptr noalias nocapture nofree nonnull writeonly inalloca([[STRUCT_SS:%.*]]) align 4 dereferenceable(8) [[B:%.*]]) #[[ATTR2:[0-9]+]] { ; CGSCC-SAME: (ptr noalias nocapture nofree nonnull readnone align 4 dereferenceable(8) [[A:%.*]], ptr noalias nocapture nofree nonnull writeonly inalloca([[STRUCT_SS:%.*]]) align 4 dereferenceable(8) [[B:%.*]]) #[[ATTR2:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: ret i1 undef ; CGSCC-NEXT: ret i1 undef
; ;
entry: entry:
%c = icmp eq ptr %a, %b %c = icmp eq ptr %a, %b
ret i1 %c ret i1 %c
} }
define i32 @test() { define i32 @test() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@test ; TUNIT-LABEL: define {{[^@]+}}@test
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: ret i32 0 ; TUNIT-NEXT: ret i32 0
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test ; CGSCC-LABEL: define {{[^@]+}}@test
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: ret i32 0 ; CGSCC-NEXT: ret i32 0
; ;
entry: entry:
%S = alloca inalloca %struct.ss %S = alloca inalloca %struct.ss
%c = call i1 @g(ptr %S, ptr inalloca(%struct.ss) %S) %c = call i1 @g(ptr %S, ptr inalloca(%struct.ss) %S)
ret i32 0 ret i32 0
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR3]] = { willreturn } ; CGSCC: attributes #[[ATTR3]] = { willreturn }
;. ;.

llvm/test/Transforms/Attributor/ArgumentPromotion/invalidation.ll

Show All 15 Lines
;. ;.
define internal i32 @a(ptr %x) { define internal i32 @a(ptr %x) {
entry: entry:
%v = load i32, ptr %x %v = load i32, ptr %x
ret i32 %v ret i32 %v
} }
define i32 @b() { define i32 @b() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@b ; CHECK-LABEL: define {{[^@]+}}@b
; CHECK-SAME: () #[[ATTR0:[0-9]+]] { ; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
entry: entry:
%v = call i32 @a(ptr @G) %v = call i32 @a(ptr @G)
ret i32 %v ret i32 %v
} }
define i32 @c() { define i32 @c() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@c ; CHECK-LABEL: define {{[^@]+}}@c
; CHECK-SAME: () #[[ATTR0]] { ; CHECK-SAME: () #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
entry: entry:
%v1 = call i32 @a(ptr @G) %v1 = call i32 @a(ptr @G)
%v2 = call i32 @b() %v2 = call i32 @b()
%result = add i32 %v1, %v2 %result = add i32 %v1, %v2
ret i32 %result ret i32 %result
} }
;. ;.
; CHECK: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CHECK: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.

llvm/test/Transforms/Attributor/ArgumentPromotion/live_called_from_dead.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
define internal void @dead() { define internal void @dead() {
; CGSCC-LABEL: define {{[^@]+}}@dead() { ; CGSCC-LABEL: define {{[^@]+}}@dead() {
; CGSCC-NEXT: [[TMP1:%.*]] = call i32 @test() ; CGSCC-NEXT: [[TMP1:%.*]] = call i32 @test()
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call i32 @test(ptr null, ptr null) call i32 @test(ptr null, ptr null)
ret void ret void
} }
define internal i32 @test(ptr %X, ptr %Y) { define internal i32 @test(ptr %X, ptr %Y) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test ; CGSCC-LABEL: define {{[^@]+}}@test
; CGSCC-SAME: () #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: br i1 true, label [[LIVE:%.*]], label [[DEAD:%.*]] ; CGSCC-NEXT: br i1 true, label [[LIVE:%.*]], label [[DEAD:%.*]]
; CGSCC: live: ; CGSCC: live:
; CGSCC-NEXT: ret i32 undef ; CGSCC-NEXT: ret i32 undef
; CGSCC: dead: ; CGSCC: dead:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
br i1 true, label %live, label %dead br i1 true, label %live, label %dead
live: live:
store i32 0, ptr %X store i32 0, ptr %X
ret i32 0 ret i32 0
dead: dead:
call i32 @caller(ptr null) call i32 @caller(ptr null)
call void @dead() call void @dead()
ret i32 1 ret i32 1
} }
define internal i32 @caller(ptr %B) { define internal i32 @caller(ptr %B) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@caller ; CGSCC-LABEL: define {{[^@]+}}@caller
; CGSCC-SAME: () #[[ATTR0]] { ; CGSCC-SAME: () #[[ATTR0]] {
; CGSCC-NEXT: [[A:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[A:%.*]] = alloca i32, align 4
; CGSCC-NEXT: ret i32 0 ; CGSCC-NEXT: ret i32 0
; ;
%A = alloca i32 %A = alloca i32
store i32 1, ptr %A store i32 1, ptr %A
%C = call i32 @test(ptr %A, ptr %B) %C = call i32 @test(ptr %A, ptr %B)
ret i32 %C ret i32 %C
} }
define i32 @callercaller() { define i32 @callercaller() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@callercaller ; TUNIT-LABEL: define {{[^@]+}}@callercaller
; TUNIT-SAME: () #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: [[B:%.*]] = alloca i32, align 4 ; TUNIT-NEXT: [[B:%.*]] = alloca i32, align 4
; TUNIT-NEXT: ret i32 0 ; TUNIT-NEXT: ret i32 0
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@callercaller ; CGSCC-LABEL: define {{[^@]+}}@callercaller
; CGSCC-SAME: () #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: [[B:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[B:%.*]] = alloca i32, align 4
; CGSCC-NEXT: [[X:%.*]] = call noundef i32 @caller() #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: [[X:%.*]] = call noundef i32 @caller() #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: ret i32 [[X]] ; CGSCC-NEXT: ret i32 [[X]]
; ;
%B = alloca i32 %B = alloca i32
store i32 2, ptr %B store i32 2, ptr %B
%X = call i32 @caller(ptr %B) %X = call i32 @caller(ptr %B)
ret i32 %X ret i32 %X
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { willreturn } ; CGSCC: attributes #[[ATTR2]] = { willreturn }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/ArgumentPromotion/live_called_from_dead_2.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
define internal void @dead() { define internal void @dead() {
; CGSCC-LABEL: define {{[^@]+}}@dead() { ; CGSCC-LABEL: define {{[^@]+}}@dead() {
; CGSCC-NEXT: [[TMP1:%.*]] = call i32 @test(ptr null) ; CGSCC-NEXT: [[TMP1:%.*]] = call i32 @test(ptr null)
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call i32 @test(ptr null, ptr null) call i32 @test(ptr null, ptr null)
ret void ret void
} }
define internal i32 @test(ptr %X, ptr %Y) { define internal i32 @test(ptr %X, ptr %Y) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@test ; TUNIT-LABEL: define {{[^@]+}}@test
; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[X:%.*]]) #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[X:%.*]]) #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: br i1 true, label [[LIVE:%.*]], label [[DEAD:%.*]] ; TUNIT-NEXT: br i1 true, label [[LIVE:%.*]], label [[DEAD:%.*]]
; TUNIT: live: ; TUNIT: live:
; TUNIT-NEXT: ret i32 undef ; TUNIT-NEXT: ret i32 undef
; TUNIT: dead: ; TUNIT: dead:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@test ; CGSCC-LABEL: define {{[^@]+}}@test
; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[X:%.*]]) #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[X:%.*]]) #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: br i1 true, label [[LIVE:%.*]], label [[DEAD:%.*]] ; CGSCC-NEXT: br i1 true, label [[LIVE:%.*]], label [[DEAD:%.*]]
; CGSCC: live: ; CGSCC: live:
; CGSCC-NEXT: store i32 0, ptr [[X]], align 4 ; CGSCC-NEXT: store i32 0, ptr [[X]], align 4
; CGSCC-NEXT: ret i32 undef ; CGSCC-NEXT: ret i32 undef
; CGSCC: dead: ; CGSCC: dead:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
br i1 true, label %live, label %dead br i1 true, label %live, label %dead
live: live:
store i32 0, ptr %X store i32 0, ptr %X
ret i32 0 ret i32 0
dead: dead:
call i32 @caller(ptr null) call i32 @caller(ptr null)
call void @dead() call void @dead()
ret i32 1 ret i32 1
} }
define internal i32 @caller(ptr %B) { define internal i32 @caller(ptr %B) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@caller ; TUNIT-LABEL: define {{[^@]+}}@caller
; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[A:%.*]] = alloca i32, align 4 ; TUNIT-NEXT: [[A:%.*]] = alloca i32, align 4
; TUNIT-NEXT: [[C:%.*]] = call i32 @test(ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) #[[ATTR2:[0-9]+]] ; TUNIT-NEXT: [[C:%.*]] = call i32 @test(ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) #[[ATTR2:[0-9]+]]
; TUNIT-NEXT: ret i32 undef ; TUNIT-NEXT: ret i32 undef
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@caller ; CGSCC-LABEL: define {{[^@]+}}@caller
; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: [[A:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[A:%.*]] = alloca i32, align 4
; CGSCC-NEXT: [[C:%.*]] = call i32 @test(ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: [[C:%.*]] = call i32 @test(ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: ret i32 0 ; CGSCC-NEXT: ret i32 0
; ;
%A = alloca i32 %A = alloca i32
store i32 1, ptr %A store i32 1, ptr %A
%C = call i32 @test(ptr %B, ptr %A) %C = call i32 @test(ptr %B, ptr %A)
ret i32 %C ret i32 %C
} }
define i32 @callercaller() { define i32 @callercaller() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@callercaller ; TUNIT-LABEL: define {{[^@]+}}@callercaller
; TUNIT-SAME: () #[[ATTR1:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR1:[0-9]+]] {
; TUNIT-NEXT: [[B:%.*]] = alloca i32, align 4 ; TUNIT-NEXT: [[B:%.*]] = alloca i32, align 4
; TUNIT-NEXT: [[X:%.*]] = call i32 @caller(ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) #[[ATTR2]] ; TUNIT-NEXT: [[X:%.*]] = call i32 @caller(ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) #[[ATTR2]]
; TUNIT-NEXT: ret i32 0 ; TUNIT-NEXT: ret i32 0
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@callercaller ; CGSCC-LABEL: define {{[^@]+}}@callercaller
; CGSCC-SAME: () #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: [[B:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[B:%.*]] = alloca i32, align 4
; CGSCC-NEXT: store i32 2, ptr [[B]], align 4 ; CGSCC-NEXT: store i32 2, ptr [[B]], align 4
; CGSCC-NEXT: [[X:%.*]] = call noundef i32 @caller(ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) #[[ATTR3:[0-9]+]] ; CGSCC-NEXT: [[X:%.*]] = call noundef i32 @caller(ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) #[[ATTR3:[0-9]+]]
; CGSCC-NEXT: ret i32 [[X]] ; CGSCC-NEXT: ret i32 [[X]]
; ;
%B = alloca i32 %B = alloca i32
store i32 2, ptr %B store i32 2, ptr %B
%X = call i32 @caller(ptr %B) %X = call i32 @caller(ptr %B)
ret i32 %X ret i32 %X
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR3]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR3]] = { nounwind willreturn }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/ArgumentPromotion/musttail.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=6 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=6 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; PR36543 ; PR36543
; Don't promote arguments of musttail callee ; Don't promote arguments of musttail callee
%T = type { i32, i32, i32, i32 } %T = type { i32, i32, i32, i32 }
define internal i32 @test(ptr %p) { define internal i32 @test(ptr %p) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define {{[^@]+}}@test ; CHECK-LABEL: define {{[^@]+}}@test
; CHECK-SAME: (ptr nocapture nofree readonly [[P:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree readonly [[P:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: [[A_GEP:%.*]] = getelementptr [[T:%.*]], ptr [[P]], i64 0, i32 3 ; CHECK-NEXT: [[A_GEP:%.*]] = getelementptr [[T:%.*]], ptr [[P]], i64 0, i32 3
; CHECK-NEXT: [[B_GEP:%.*]] = getelementptr [[T]], ptr [[P]], i64 0, i32 2 ; CHECK-NEXT: [[B_GEP:%.*]] = getelementptr [[T]], ptr [[P]], i64 0, i32 2
; CHECK-NEXT: [[A:%.*]] = load i32, ptr [[A_GEP]], align 4 ; CHECK-NEXT: [[A:%.*]] = load i32, ptr [[A_GEP]], align 4
; CHECK-NEXT: [[B:%.*]] = load i32, ptr [[B_GEP]], align 4 ; CHECK-NEXT: [[B:%.*]] = load i32, ptr [[B_GEP]], align 4
; CHECK-NEXT: [[V:%.*]] = add i32 [[A]], [[B]] ; CHECK-NEXT: [[V:%.*]] = add i32 [[A]], [[B]]
; CHECK-NEXT: ret i32 [[V]] ; CHECK-NEXT: ret i32 [[V]]
; ;
%a.gep = getelementptr %T, %T* %p, i64 0, i32 3 %a.gep = getelementptr %T, %T* %p, i64 0, i32 3
%b.gep = getelementptr %T, ptr %p, i64 0, i32 2 %b.gep = getelementptr %T, ptr %p, i64 0, i32 2
%a = load i32, ptr %a.gep %a = load i32, ptr %a.gep
%b = load i32, ptr %b.gep %b = load i32, ptr %b.gep
%v = add i32 %a, %b %v = add i32 %a, %b
ret i32 %v ret i32 %v
} }
define i32 @caller(ptr %p) { define i32 @caller(ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; TUNIT-LABEL: define {{[^@]+}}@caller ; TUNIT-LABEL: define {{[^@]+}}@caller
; TUNIT-SAME: (ptr nocapture nofree readonly [[P:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr nocapture nofree readonly [[P:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[V:%.*]] = musttail call i32 @test(ptr nocapture nofree readonly [[P]]) #[[ATTR4:[0-9]+]] ; TUNIT-NEXT: [[V:%.*]] = musttail call i32 @test(ptr nocapture nofree readonly [[P]]) #[[ATTR4:[0-9]+]]
; TUNIT-NEXT: ret i32 [[V]] ; TUNIT-NEXT: ret i32 [[V]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@caller ; CGSCC-LABEL: define {{[^@]+}}@caller
; CGSCC-SAME: (ptr nocapture nofree readonly [[P:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree readonly [[P:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: [[V:%.*]] = musttail call i32 @test(ptr nocapture nofree readonly [[P]]) #[[ATTR5:[0-9]+]] ; CGSCC-NEXT: [[V:%.*]] = musttail call i32 @test(ptr nocapture nofree readonly [[P]]) #[[ATTR5:[0-9]+]]
; CGSCC-NEXT: ret i32 [[V]] ; CGSCC-NEXT: ret i32 [[V]]
; ;
%v = musttail call i32 @test(%T* %p) %v = musttail call i32 @test(%T* %p)
ret i32 %v ret i32 %v
} }
; Don't promote arguments of musttail caller ; Don't promote arguments of musttail caller
define i32 @foo(ptr %p, i32 %v) { define i32 @foo(ptr %p, i32 %v) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@foo ; TUNIT-LABEL: define {{[^@]+}}@foo
; TUNIT-SAME: (ptr nocapture nofree readnone [[P:%.*]], i32 [[V:%.*]]) #[[ATTR1:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree readnone [[P:%.*]], i32 [[V:%.*]]) #[[ATTR1:[0-9]+]] {
; TUNIT-NEXT: ret i32 0 ; TUNIT-NEXT: ret i32 0
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@foo ; CGSCC-LABEL: define {{[^@]+}}@foo
; CGSCC-SAME: (ptr nocapture nofree readnone [[P:%.*]], i32 [[V:%.*]]) #[[ATTR2:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree readnone [[P:%.*]], i32 [[V:%.*]]) #[[ATTR2:[0-9]+]] {
; CGSCC-NEXT: ret i32 0 ; CGSCC-NEXT: ret i32 0
; ;
ret i32 0 ret i32 0
} }
define internal i32 @test2(ptr %p, i32 %p2) { define internal i32 @test2(ptr %p, i32 %p2) {
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@test2 ; CGSCC-LABEL: define {{[^@]+}}@test2
; CGSCC-SAME: (ptr nocapture nofree readonly [[P:%.*]], i32 [[P2:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (ptr nocapture nofree readonly [[P:%.*]], i32 [[P2:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: [[A_GEP:%.*]] = getelementptr [[T:%.*]], ptr [[P]], i64 0, i32 3 ; CGSCC-NEXT: [[A_GEP:%.*]] = getelementptr [[T:%.*]], ptr [[P]], i64 0, i32 3
; CGSCC-NEXT: [[B_GEP:%.*]] = getelementptr [[T]], ptr [[P]], i64 0, i32 2 ; CGSCC-NEXT: [[B_GEP:%.*]] = getelementptr [[T]], ptr [[P]], i64 0, i32 2
; CGSCC-NEXT: [[A:%.*]] = load i32, ptr [[A_GEP]], align 4 ; CGSCC-NEXT: [[A:%.*]] = load i32, ptr [[A_GEP]], align 4
; CGSCC-NEXT: [[B:%.*]] = load i32, ptr [[B_GEP]], align 4 ; CGSCC-NEXT: [[B:%.*]] = load i32, ptr [[B_GEP]], align 4
; CGSCC-NEXT: [[V:%.*]] = add i32 [[A]], [[B]] ; CGSCC-NEXT: [[V:%.*]] = add i32 [[A]], [[B]]
; CGSCC-NEXT: [[CA:%.*]] = musttail call noundef i32 @foo(ptr undef, i32 [[V]]) #[[ATTR5]] ; CGSCC-NEXT: [[CA:%.*]] = musttail call noundef i32 @foo(ptr undef, i32 [[V]]) #[[ATTR5]]
; CGSCC-NEXT: ret i32 [[CA]] ; CGSCC-NEXT: ret i32 [[CA]]
; ;
%a.gep = getelementptr %T, %T* %p, i64 0, i32 3 %a.gep = getelementptr %T, %T* %p, i64 0, i32 3
%b.gep = getelementptr %T, ptr %p, i64 0, i32 2 %b.gep = getelementptr %T, ptr %p, i64 0, i32 2
%a = load i32, ptr %a.gep %a = load i32, ptr %a.gep
%b = load i32, ptr %b.gep %b = load i32, ptr %b.gep
%v = add i32 %a, %b %v = add i32 %a, %b
%ca = musttail call i32 @foo(ptr undef, i32 %v) %ca = musttail call i32 @foo(ptr undef, i32 %v)
ret i32 %ca ret i32 %ca
} }
define i32 @caller2(ptr %g) { define i32 @caller2(ptr %g) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@caller2 ; TUNIT-LABEL: define {{[^@]+}}@caller2
; TUNIT-SAME: (ptr nocapture nofree readnone [[G:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (ptr nocapture nofree readnone [[G:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: ret i32 0 ; TUNIT-NEXT: ret i32 0
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@caller2 ; CGSCC-LABEL: define {{[^@]+}}@caller2
; CGSCC-SAME: (ptr nocapture nofree readonly align 4 [[G:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (ptr nocapture nofree readonly align 4 [[G:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: [[V:%.*]] = call noundef i32 @test2(ptr nocapture nofree readonly [[G]], i32 noundef 0) #[[ATTR5]] ; CGSCC-NEXT: [[V:%.*]] = call noundef i32 @test2(ptr nocapture nofree readonly [[G]], i32 noundef 0) #[[ATTR5]]
; CGSCC-NEXT: ret i32 [[V]] ; CGSCC-NEXT: ret i32 [[V]]
; ;
%v = call i32 @test2(%T* %g, i32 0) %v = call i32 @test2(%T* %g, i32 0)
ret i32 %v ret i32 %v
} }
; In the version above we can remove the call to foo completely. ; In the version above we can remove the call to foo completely.
; In the version below we keep the call and verify the return value ; In the version below we keep the call and verify the return value
; is kept as well. ; is kept as well.
define i32 @bar(ptr %p, i32 %v) { define i32 @bar(ptr %p, i32 %v) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@bar ; TUNIT-LABEL: define {{[^@]+}}@bar
; TUNIT-SAME: (ptr nocapture nofree nonnull writeonly dereferenceable(4) [[P:%.*]], i32 [[V:%.*]]) #[[ATTR2:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree nonnull writeonly dereferenceable(4) [[P:%.*]], i32 [[V:%.*]]) #[[ATTR2:[0-9]+]] {
; TUNIT-NEXT: store i32 [[V]], ptr [[P]], align 4 ; TUNIT-NEXT: store i32 [[V]], ptr [[P]], align 4
; TUNIT-NEXT: ret i32 0 ; TUNIT-NEXT: ret i32 0
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@bar ; CGSCC-LABEL: define {{[^@]+}}@bar
; CGSCC-SAME: (ptr nocapture nofree nonnull writeonly dereferenceable(4) [[P:%.*]], i32 [[V:%.*]]) #[[ATTR3:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree nonnull writeonly dereferenceable(4) [[P:%.*]], i32 [[V:%.*]]) #[[ATTR3:[0-9]+]] {
; CGSCC-NEXT: store i32 [[V]], ptr [[P]], align 4 ; CGSCC-NEXT: store i32 [[V]], ptr [[P]], align 4
; CGSCC-NEXT: ret i32 0 ; CGSCC-NEXT: ret i32 0
; ;
%i32ptr = getelementptr %T, %T* %p, i64 0, i32 0 %i32ptr = getelementptr %T, %T* %p, i64 0, i32 0
store i32 %v, ptr %i32ptr store i32 %v, ptr %i32ptr
ret i32 0 ret i32 0
} }
define internal i32 @test2b(ptr %p, i32 %p2) { define internal i32 @test2b(ptr %p, i32 %p2) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@test2b ; TUNIT-LABEL: define {{[^@]+}}@test2b
; TUNIT-SAME: (ptr nocapture nofree readonly [[P:%.*]], i32 [[P2:%.*]]) #[[ATTR3:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree readonly [[P:%.*]], i32 [[P2:%.*]]) #[[ATTR3:[0-9]+]] {
; TUNIT-NEXT: [[A_GEP:%.*]] = getelementptr [[T:%.*]], ptr [[P]], i64 0, i32 3 ; TUNIT-NEXT: [[A_GEP:%.*]] = getelementptr [[T:%.*]], ptr [[P]], i64 0, i32 3
; TUNIT-NEXT: [[B_GEP:%.*]] = getelementptr [[T]], ptr [[P]], i64 0, i32 2 ; TUNIT-NEXT: [[B_GEP:%.*]] = getelementptr [[T]], ptr [[P]], i64 0, i32 2
; TUNIT-NEXT: [[A:%.*]] = load i32, ptr [[A_GEP]], align 4 ; TUNIT-NEXT: [[A:%.*]] = load i32, ptr [[A_GEP]], align 4
; TUNIT-NEXT: [[B:%.*]] = load i32, ptr [[B_GEP]], align 4 ; TUNIT-NEXT: [[B:%.*]] = load i32, ptr [[B_GEP]], align 4
; TUNIT-NEXT: [[V:%.*]] = add i32 [[A]], [[B]] ; TUNIT-NEXT: [[V:%.*]] = add i32 [[A]], [[B]]
; TUNIT-NEXT: [[CA:%.*]] = musttail call noundef i32 @bar(ptr undef, i32 [[V]]) #[[ATTR4]] ; TUNIT-NEXT: [[CA:%.*]] = musttail call noundef i32 @bar(ptr undef, i32 [[V]]) #[[ATTR4]]
; TUNIT-NEXT: ret i32 [[CA]] ; TUNIT-NEXT: ret i32 [[CA]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@test2b ; CGSCC-LABEL: define {{[^@]+}}@test2b
; CGSCC-SAME: (ptr nocapture nofree readonly [[P:%.*]], i32 [[P2:%.*]]) #[[ATTR4:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree readonly [[P:%.*]], i32 [[P2:%.*]]) #[[ATTR4:[0-9]+]] {
; CGSCC-NEXT: [[A_GEP:%.*]] = getelementptr [[T:%.*]], ptr [[P]], i64 0, i32 3 ; CGSCC-NEXT: [[A_GEP:%.*]] = getelementptr [[T:%.*]], ptr [[P]], i64 0, i32 3
; CGSCC-NEXT: [[B_GEP:%.*]] = getelementptr [[T]], ptr [[P]], i64 0, i32 2 ; CGSCC-NEXT: [[B_GEP:%.*]] = getelementptr [[T]], ptr [[P]], i64 0, i32 2
; CGSCC-NEXT: [[A:%.*]] = load i32, ptr [[A_GEP]], align 4 ; CGSCC-NEXT: [[A:%.*]] = load i32, ptr [[A_GEP]], align 4
; CGSCC-NEXT: [[B:%.*]] = load i32, ptr [[B_GEP]], align 4 ; CGSCC-NEXT: [[B:%.*]] = load i32, ptr [[B_GEP]], align 4
; CGSCC-NEXT: [[V:%.*]] = add i32 [[A]], [[B]] ; CGSCC-NEXT: [[V:%.*]] = add i32 [[A]], [[B]]
; CGSCC-NEXT: [[CA:%.*]] = musttail call noundef i32 @bar(ptr undef, i32 [[V]]) #[[ATTR6:[0-9]+]] ; CGSCC-NEXT: [[CA:%.*]] = musttail call noundef i32 @bar(ptr undef, i32 [[V]]) #[[ATTR6:[0-9]+]]
; CGSCC-NEXT: ret i32 [[CA]] ; CGSCC-NEXT: ret i32 [[CA]]
; ;
%a.gep = getelementptr %T, %T* %p, i64 0, i32 3 %a.gep = getelementptr %T, %T* %p, i64 0, i32 3
%b.gep = getelementptr %T, ptr %p, i64 0, i32 2 %b.gep = getelementptr %T, ptr %p, i64 0, i32 2
%a = load i32, ptr %a.gep %a = load i32, ptr %a.gep
%b = load i32, ptr %b.gep %b = load i32, ptr %b.gep
%v = add i32 %a, %b %v = add i32 %a, %b
%ca = musttail call i32 @bar(ptr undef, i32 %v) %ca = musttail call i32 @bar(ptr undef, i32 %v)
ret i32 %ca ret i32 %ca
} }
define i32 @caller2b(ptr %g) { define i32 @caller2b(ptr %g) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@caller2b ; TUNIT-LABEL: define {{[^@]+}}@caller2b
; TUNIT-SAME: (ptr nocapture nofree readonly [[G:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (ptr nocapture nofree readonly [[G:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: [[V:%.*]] = call noundef i32 @test2b(ptr nocapture nofree readonly [[G]], i32 undef) #[[ATTR4]] ; TUNIT-NEXT: [[V:%.*]] = call noundef i32 @test2b(ptr nocapture nofree readonly [[G]], i32 undef) #[[ATTR4]]
; TUNIT-NEXT: ret i32 [[V]] ; TUNIT-NEXT: ret i32 [[V]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@caller2b ; CGSCC-LABEL: define {{[^@]+}}@caller2b
; CGSCC-SAME: (ptr nocapture nofree readonly align 4 [[G:%.*]]) #[[ATTR4]] { ; CGSCC-SAME: (ptr nocapture nofree readonly align 4 [[G:%.*]]) #[[ATTR4]] {
; CGSCC-NEXT: [[V:%.*]] = call noundef i32 @test2b(ptr nocapture nofree readonly [[G]], i32 noundef 0) #[[ATTR7:[0-9]+]] ; CGSCC-NEXT: [[V:%.*]] = call noundef i32 @test2b(ptr nocapture nofree readonly [[G]], i32 noundef 0) #[[ATTR7:[0-9]+]]
; CGSCC-NEXT: ret i32 [[V]] ; CGSCC-NEXT: ret i32 [[V]]
; ;
%v = call i32 @test2b(%T* %g, i32 0) %v = call i32 @test2b(%T* %g, i32 0)
ret i32 %v ret i32 %v
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR3]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR4]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR4]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR3]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR4]] = { nofree nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR4]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR5]] = { willreturn } ; CGSCC: attributes #[[ATTR5]] = { willreturn }
; CGSCC: attributes #[[ATTR6]] = { nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR6]] = { nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR7]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR7]] = { nounwind willreturn }
;. ;.

llvm/test/Transforms/Attributor/ArgumentPromotion/pr32917.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; PR 32917 ; PR 32917
@b = common local_unnamed_addr global i32 0, align 4 @b = common local_unnamed_addr global i32 0, align 4
@a = common local_unnamed_addr global i32 0, align 4 @a = common local_unnamed_addr global i32 0, align 4
;. ;.
; CHECK: @[[B:[a-zA-Z0-9_$"\\.-]+]] = common local_unnamed_addr global i32 0, align 4 ; CHECK: @[[B:[a-zA-Z0-9_$"\\.-]+]] = common local_unnamed_addr global i32 0, align 4
; CHECK: @[[A:[a-zA-Z0-9_$"\\.-]+]] = common local_unnamed_addr global i32 0, align 4 ; CHECK: @[[A:[a-zA-Z0-9_$"\\.-]+]] = common local_unnamed_addr global i32 0, align 4
;. ;.
define i32 @fn2() local_unnamed_addr { define i32 @fn2() local_unnamed_addr {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@fn2 ; TUNIT-LABEL: define {{[^@]+}}@fn2
; TUNIT-SAME: () local_unnamed_addr #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: () local_unnamed_addr #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: [[TMP1:%.*]] = load i32, ptr @b, align 4 ; TUNIT-NEXT: [[TMP1:%.*]] = load i32, ptr @b, align 4
; TUNIT-NEXT: [[TMP2:%.*]] = sext i32 [[TMP1]] to i64 ; TUNIT-NEXT: [[TMP2:%.*]] = sext i32 [[TMP1]] to i64
; TUNIT-NEXT: [[TMP3:%.*]] = inttoptr i64 [[TMP2]] to ptr ; TUNIT-NEXT: [[TMP3:%.*]] = inttoptr i64 [[TMP2]] to ptr
; TUNIT-NEXT: call fastcc void @fn1(ptr nocapture nofree readonly align 4 [[TMP3]]) #[[ATTR1:[0-9]+]] ; TUNIT-NEXT: call fastcc void @fn1(ptr nocapture nofree readonly align 4 [[TMP3]]) #[[ATTR1:[0-9]+]]
; TUNIT-NEXT: ret i32 undef ; TUNIT-NEXT: ret i32 undef
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@fn2 ; CGSCC-LABEL: define {{[^@]+}}@fn2
; CGSCC-SAME: () local_unnamed_addr #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: () local_unnamed_addr #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: [[TMP1:%.*]] = load i32, ptr @b, align 4 ; CGSCC-NEXT: [[TMP1:%.*]] = load i32, ptr @b, align 4
; CGSCC-NEXT: [[TMP2:%.*]] = sext i32 [[TMP1]] to i64 ; CGSCC-NEXT: [[TMP2:%.*]] = sext i32 [[TMP1]] to i64
; CGSCC-NEXT: [[TMP3:%.*]] = inttoptr i64 [[TMP2]] to ptr ; CGSCC-NEXT: [[TMP3:%.*]] = inttoptr i64 [[TMP2]] to ptr
; CGSCC-NEXT: call fastcc void @fn1(ptr nocapture nofree nonnull readonly align 4 [[TMP3]]) #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: call fastcc void @fn1(ptr nocapture nofree nonnull readonly align 4 [[TMP3]]) #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: ret i32 undef ; CGSCC-NEXT: ret i32 undef
; ;
%1 = load i32, ptr @b, align 4 %1 = load i32, ptr @b, align 4
%2 = sext i32 %1 to i64 %2 = sext i32 %1 to i64
%3 = inttoptr i64 %2 to ptr %3 = inttoptr i64 %2 to ptr
call fastcc void @fn1(ptr %3) call fastcc void @fn1(ptr %3)
ret i32 undef ret i32 undef
} }
define internal fastcc void @fn1(ptr nocapture readonly) unnamed_addr { define internal fastcc void @fn1(ptr nocapture readonly) unnamed_addr {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@fn1 ; TUNIT-LABEL: define {{[^@]+}}@fn1
; TUNIT-SAME: (ptr nocapture nofree nonnull readonly align 4 [[TMP0:%.*]]) unnamed_addr #[[ATTR0]] { ; TUNIT-SAME: (ptr nocapture nofree nonnull readonly align 4 [[TMP0:%.*]]) unnamed_addr #[[ATTR0]] {
; TUNIT-NEXT: [[TMP2:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 -1 ; TUNIT-NEXT: [[TMP2:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 -1
; TUNIT-NEXT: [[TMP3:%.*]] = load i32, ptr [[TMP2]], align 4 ; TUNIT-NEXT: [[TMP3:%.*]] = load i32, ptr [[TMP2]], align 4
; TUNIT-NEXT: store i32 [[TMP3]], ptr @a, align 4 ; TUNIT-NEXT: store i32 [[TMP3]], ptr @a, align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@fn1 ; CGSCC-LABEL: define {{[^@]+}}@fn1
; CGSCC-SAME: (ptr nocapture nofree nonnull readonly align 4 [[TMP0:%.*]]) unnamed_addr #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree nonnull readonly align 4 [[TMP0:%.*]]) unnamed_addr #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: [[TMP2:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 -1 ; CGSCC-NEXT: [[TMP2:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 -1
; CGSCC-NEXT: [[TMP3:%.*]] = load i32, ptr [[TMP2]], align 4 ; CGSCC-NEXT: [[TMP3:%.*]] = load i32, ptr [[TMP2]], align 4
; CGSCC-NEXT: store i32 [[TMP3]], ptr @a, align 4 ; CGSCC-NEXT: store i32 [[TMP3]], ptr @a, align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%2 = getelementptr inbounds i32, ptr %0, i64 -1 %2 = getelementptr inbounds i32, ptr %0, i64 -1
%3 = load i32, ptr %2, align 4 %3 = load i32, ptr %2, align 4
store i32 %3, ptr @a, align 4 store i32 %3, ptr @a, align 4
ret void ret void
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree nosync nounwind willreturn } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree nosync nounwind willreturn }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn }
; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/ArgumentPromotion/pr33641_remove_arg_dbgvalue.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; Fix for PR33641. ArgumentPromotion removed the argument to bar but left the call to ; Fix for PR33641. ArgumentPromotion removed the argument to bar but left the call to
; dbg.value which still used the removed argument. ; dbg.value which still used the removed argument.
; The %p argument should be removed, and the use of it in dbg.value should be ; The %p argument should be removed, and the use of it in dbg.value should be
; changed to undef. ; changed to undef.
%p_t = type ptr %p_t = type ptr
%fun_t = type ptr %fun_t = type ptr
define void @foo() { define void @foo() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@foo ; CHECK-LABEL: define {{[^@]+}}@foo
; CHECK-SAME: () #[[ATTR0:[0-9]+]] { ; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: [[TMP:%.*]] = alloca ptr, align 8 ; CHECK-NEXT: [[TMP:%.*]] = alloca ptr, align 8
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%tmp = alloca %fun_t %tmp = alloca %fun_t
store %fun_t @bar, ptr %tmp store %fun_t @bar, ptr %tmp
ret void ret void
} }
define internal void @bar(%p_t %p) { define internal void @bar(%p_t %p) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@bar ; CGSCC-LABEL: define {{[^@]+}}@bar
; CGSCC-SAME: (ptr nocapture nofree readnone [[P:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (ptr nocapture nofree readnone [[P:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: call void @llvm.dbg.value(metadata ptr [[P]], metadata [[META3:![0-9]+]], metadata !DIExpression()) #[[ATTR2:[0-9]+]], !dbg [[DBG5:![0-9]+]] ; CGSCC-NEXT: call void @llvm.dbg.value(metadata ptr [[P]], metadata [[META3:![0-9]+]], metadata !DIExpression()) #[[ATTR2:[0-9]+]], !dbg [[DBG5:![0-9]+]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @llvm.dbg.value(metadata %p_t %p, metadata !4, metadata !5), !dbg !6 call void @llvm.dbg.value(metadata %p_t %p, metadata !4, metadata !5), !dbg !6
ret void ret void
} }
declare void @llvm.dbg.value(metadata, metadata, metadata) declare void @llvm.dbg.value(metadata, metadata, metadata)
!llvm.dbg.cu = !{!0} !llvm.dbg.cu = !{!0}
!llvm.module.flags = !{!2} !llvm.module.flags = !{!2}
!0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1) !0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1)
!1 = !DIFile(filename: "test.c", directory: "") !1 = !DIFile(filename: "test.c", directory: "")
!2 = !{i32 2, !"Debug Info Version", i32 3} !2 = !{i32 2, !"Debug Info Version", i32 3}
!3 = distinct !DISubprogram(name: "bar", unit: !0) !3 = distinct !DISubprogram(name: "bar", unit: !0)
!4 = !DILocalVariable(name: "p", scope: !3) !4 = !DILocalVariable(name: "p", scope: !3)
!5 = !DIExpression() !5 = !DIExpression()
!6 = !DILocation(line: 1, column: 1, scope: !3) !6 = !DILocation(line: 1, column: 1, scope: !3)
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } ; TUNIT: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } ; CGSCC: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { willreturn } ; CGSCC: attributes #[[ATTR2]] = { willreturn }
;. ;.
; TUNIT: [[META0:![0-9]+]] = distinct !DICompileUnit(language: DW_LANG_C, file: !1, isOptimized: false, runtimeVersion: 0, emissionKind: NoDebug) ; TUNIT: [[META0:![0-9]+]] = distinct !DICompileUnit(language: DW_LANG_C, file: !1, isOptimized: false, runtimeVersion: 0, emissionKind: NoDebug)
; TUNIT: [[META1:![0-9]+]] = !DIFile(filename: "test.c", directory: "") ; TUNIT: [[META1:![0-9]+]] = !DIFile(filename: "test.c", directory: "")
; TUNIT: [[META2:![0-9]+]] = !{i32 2, !"Debug Info Version", i32 3} ; TUNIT: [[META2:![0-9]+]] = !{i32 2, !"Debug Info Version", i32 3}
;. ;.
; CGSCC: [[META0:![0-9]+]] = distinct !DICompileUnit(language: DW_LANG_C, file: !1, isOptimized: false, runtimeVersion: 0, emissionKind: NoDebug) ; CGSCC: [[META0:![0-9]+]] = distinct !DICompileUnit(language: DW_LANG_C, file: !1, isOptimized: false, runtimeVersion: 0, emissionKind: NoDebug)
; CGSCC: [[META1:![0-9]+]] = !DIFile(filename: "test.c", directory: "") ; CGSCC: [[META1:![0-9]+]] = !DIFile(filename: "test.c", directory: "")
; CGSCC: [[META2:![0-9]+]] = !{i32 2, !"Debug Info Version", i32 3} ; CGSCC: [[META2:![0-9]+]] = !{i32 2, !"Debug Info Version", i32 3}
; CGSCC: [[META3]] = !DILocalVariable(name: "p", scope: !4) ; CGSCC: [[META3]] = !DILocalVariable(name: "p", scope: !4)
; CGSCC: [[META4:![0-9]+]] = distinct !DISubprogram(name: "bar", scope: null, spFlags: DISPFlagDefinition, unit: !0) ; CGSCC: [[META4:![0-9]+]] = distinct !DISubprogram(name: "bar", scope: null, spFlags: DISPFlagDefinition, unit: !0)
; CGSCC: [[DBG5]] = !DILocation(line: 1, column: 1, scope: !4) ; CGSCC: [[DBG5]] = !DILocation(line: 1, column: 1, scope: !4)
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; TUNIT: {{.*}} ; TUNIT: {{.*}}

llvm/test/Transforms/Attributor/ArgumentPromotion/reserve-tbaa.ll

Show All 16 Lines
;. ;.
; CHECK: @[[A:[a-zA-Z0-9_$"\\.-]+]] = global ptr null, align 8 ; CHECK: @[[A:[a-zA-Z0-9_$"\\.-]+]] = global ptr null, align 8
; CHECK: @[[E:[a-zA-Z0-9_$"\\.-]+]] = global ptr @a, align 8 ; CHECK: @[[E:[a-zA-Z0-9_$"\\.-]+]] = global ptr @a, align 8
; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = global i32 0, align 4 ; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = global i32 0, align 4
; CHECK: @[[C:[a-zA-Z0-9_$"\\.-]+]] = global i64 0, align 8 ; CHECK: @[[C:[a-zA-Z0-9_$"\\.-]+]] = global i64 0, align 8
; CHECK: @[[D:[a-zA-Z0-9_$"\\.-]+]] = global i8 0, align 1 ; CHECK: @[[D:[a-zA-Z0-9_$"\\.-]+]] = global i8 0, align 1
;. ;.
define internal fastcc void @fn(ptr nocapture readonly %p1, ptr nocapture readonly %p2) { define internal fastcc void @fn(ptr nocapture readonly %p1, ptr nocapture readonly %p2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CHECK-LABEL: define {{[^@]+}}@fn ; CHECK-LABEL: define {{[^@]+}}@fn
; CHECK-SAME: () #[[ATTR0:[0-9]+]] { ; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr @g, align 4, !tbaa [[TBAA0:![0-9]+]] ; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr @g, align 4, !tbaa [[TBAA0:![0-9]+]]
; CHECK-NEXT: [[CONV1:%.*]] = trunc i32 [[TMP0]] to i8 ; CHECK-NEXT: [[CONV1:%.*]] = trunc i32 [[TMP0]] to i8
; CHECK-NEXT: store i8 [[CONV1]], ptr @d, align 1, !tbaa [[TBAA4:![0-9]+]] ; CHECK-NEXT: store i8 [[CONV1]], ptr @d, align 1, !tbaa [[TBAA4:![0-9]+]]
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
%0 = load i64, ptr %p2, align 8, !tbaa !1 %0 = load i64, ptr %p2, align 8, !tbaa !1
%conv = trunc i64 %0 to i32 %conv = trunc i64 %0 to i32
%1 = load i32, ptr %p1, align 4, !tbaa !5 %1 = load i32, ptr %p1, align 4, !tbaa !5
%conv1 = trunc i32 %1 to i8 %conv1 = trunc i32 %1 to i8
store i8 %conv1, ptr @d, align 1, !tbaa !7 store i8 %conv1, ptr @d, align 1, !tbaa !7
ret void ret void
} }
define i32 @main() { define i32 @main() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@main ; TUNIT-LABEL: define {{[^@]+}}@main
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[TMP0:%.*]] = load ptr, ptr @e, align 8, !tbaa [[TBAA5:![0-9]+]] ; TUNIT-NEXT: [[TMP0:%.*]] = load ptr, ptr @e, align 8, !tbaa [[TBAA5:![0-9]+]]
; TUNIT-NEXT: store ptr @g, ptr [[TMP0]], align 8, !tbaa [[TBAA5]] ; TUNIT-NEXT: store ptr @g, ptr [[TMP0]], align 8, !tbaa [[TBAA5]]
; TUNIT-NEXT: [[TMP1:%.*]] = load ptr, ptr @a, align 8, !tbaa [[TBAA5]] ; TUNIT-NEXT: [[TMP1:%.*]] = load ptr, ptr @a, align 8, !tbaa [[TBAA5]]
; TUNIT-NEXT: store i32 1, ptr [[TMP1]], align 4, !tbaa [[TBAA0]] ; TUNIT-NEXT: store i32 1, ptr [[TMP1]], align 4, !tbaa [[TBAA0]]
; TUNIT-NEXT: call fastcc void @fn() #[[ATTR1:[0-9]+]] ; TUNIT-NEXT: call fastcc void @fn() #[[ATTR1:[0-9]+]]
; TUNIT-NEXT: ret i32 0 ; TUNIT-NEXT: ret i32 0
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@main ; CGSCC-LABEL: define {{[^@]+}}@main
; CGSCC-SAME: () #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[TMP0:%.*]] = load ptr, ptr @e, align 8, !tbaa [[TBAA5:![0-9]+]] ; CGSCC-NEXT: [[TMP0:%.*]] = load ptr, ptr @e, align 8, !tbaa [[TBAA5:![0-9]+]]
; CGSCC-NEXT: store ptr @g, ptr [[TMP0]], align 8, !tbaa [[TBAA5]] ; CGSCC-NEXT: store ptr @g, ptr [[TMP0]], align 8, !tbaa [[TBAA5]]
; CGSCC-NEXT: [[TMP1:%.*]] = load ptr, ptr @a, align 8, !tbaa [[TBAA5]] ; CGSCC-NEXT: [[TMP1:%.*]] = load ptr, ptr @a, align 8, !tbaa [[TBAA5]]
; CGSCC-NEXT: store i32 1, ptr [[TMP1]], align 4, !tbaa [[TBAA0]] ; CGSCC-NEXT: store i32 1, ptr [[TMP1]], align 4, !tbaa [[TBAA0]]
; CGSCC-NEXT: call fastcc void @fn() #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: call fastcc void @fn() #[[ATTR2:[0-9]+]]
Show All 15 Lines
!4 = !{!"Simple C/C++ TBAA"} !4 = !{!"Simple C/C++ TBAA"}
!5 = !{!6, !6, i64 0} !5 = !{!6, !6, i64 0}
!6 = !{!"int", !3, i64 0} !6 = !{!"int", !3, i64 0}
!7 = !{!3, !3, i64 0} !7 = !{!3, !3, i64 0}
!8 = !{!9, !9, i64 0} !8 = !{!9, !9, i64 0}
!9 = !{!"any pointer", !3, i64 0} !9 = !{!"any pointer", !3, i64 0}
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn }
; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn }
;. ;.
; CHECK: [[TBAA0]] = !{!1, !1, i64 0} ; CHECK: [[TBAA0]] = !{!1, !1, i64 0}
; CHECK: [[META1:![0-9]+]] = !{!"int", !2, i64 0} ; CHECK: [[META1:![0-9]+]] = !{!"int", !2, i64 0}
; CHECK: [[META2:![0-9]+]] = !{!"omnipotent char", !3, i64 0} ; CHECK: [[META2:![0-9]+]] = !{!"omnipotent char", !3, i64 0}
; CHECK: [[META3:![0-9]+]] = !{!"Simple C/C++ TBAA"} ; CHECK: [[META3:![0-9]+]] = !{!"Simple C/C++ TBAA"}
; CHECK: [[TBAA4]] = !{!2, !2, i64 0} ; CHECK: [[TBAA4]] = !{!2, !2, i64 0}
; CHECK: [[META5:![0-9]+]] = !{!6, !6, i64 0} ; CHECK: [[META5:![0-9]+]] = !{!6, !6, i64 0}
; CHECK: [[META6:![0-9]+]] = !{!"any pointer", !2, i64 0} ; CHECK: [[META6:![0-9]+]] = !{!"any pointer", !2, i64 0}
;. ;.

llvm/test/Transforms/Attributor/ArgumentPromotion/sret.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
define internal void @add(ptr %this, ptr sret(i32) %r) { define internal void @add(ptr %this, ptr sret(i32) %r) {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@add ; TUNIT-LABEL: define {{[^@]+}}@add
; TUNIT-SAME: (ptr noalias nocapture nofree nonnull readnone align 8 dereferenceable(8) [[THIS:%.*]], ptr noalias nocapture nofree noundef nonnull writeonly sret(i32) align 4 dereferenceable(4) [[R:%.*]]) #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: (ptr noalias nocapture nofree nonnull readnone align 8 dereferenceable(8) [[THIS:%.*]], ptr noalias nocapture nofree noundef nonnull writeonly sret(i32) align 4 dereferenceable(4) [[R:%.*]]) #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: store i32 undef, ptr [[R]], align 4 ; TUNIT-NEXT: store i32 undef, ptr [[R]], align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@add ; CGSCC-LABEL: define {{[^@]+}}@add
; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull readonly align 8 dereferenceable(8) [[THIS:%.*]], ptr noalias nocapture nofree noundef nonnull writeonly sret(i32) align 4 dereferenceable(4) [[R:%.*]]) #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull readonly align 8 dereferenceable(8) [[THIS:%.*]], ptr noalias nocapture nofree noundef nonnull writeonly sret(i32) align 4 dereferenceable(4) [[R:%.*]]) #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: [[BP:%.*]] = getelementptr { i32, i32 }, ptr [[THIS]], i32 0, i32 1 ; CGSCC-NEXT: [[BP:%.*]] = getelementptr { i32, i32 }, ptr [[THIS]], i32 0, i32 1
; CGSCC-NEXT: [[A:%.*]] = load i32, ptr [[THIS]], align 8 ; CGSCC-NEXT: [[A:%.*]] = load i32, ptr [[THIS]], align 8
; CGSCC-NEXT: [[B:%.*]] = load i32, ptr [[BP]], align 4 ; CGSCC-NEXT: [[B:%.*]] = load i32, ptr [[BP]], align 4
; CGSCC-NEXT: [[AB:%.*]] = add i32 [[A]], [[B]] ; CGSCC-NEXT: [[AB:%.*]] = add i32 [[A]], [[B]]
; CGSCC-NEXT: store i32 [[AB]], ptr [[R]], align 4 ; CGSCC-NEXT: store i32 [[AB]], ptr [[R]], align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%ap = getelementptr {i32, i32}, ptr %this, i32 0, i32 0 %ap = getelementptr {i32, i32}, ptr %this, i32 0, i32 0
%bp = getelementptr {i32, i32}, ptr %this, i32 0, i32 1 %bp = getelementptr {i32, i32}, ptr %this, i32 0, i32 1
%a = load i32, ptr %ap %a = load i32, ptr %ap
%b = load i32, ptr %bp %b = load i32, ptr %bp
%ab = add i32 %a, %b %ab = add i32 %a, %b
store i32 %ab, ptr %r store i32 %ab, ptr %r
ret void ret void
} }
define void @f() { define void @f() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@f ; TUNIT-LABEL: define {{[^@]+}}@f
; TUNIT-SAME: () #[[ATTR1:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR1:[0-9]+]] {
; TUNIT-NEXT: [[R:%.*]] = alloca i32, align 4 ; TUNIT-NEXT: [[R:%.*]] = alloca i32, align 4
; TUNIT-NEXT: call void @add(ptr noalias nocapture nofree nonnull readnone align 8 dereferenceable(8) undef, ptr noalias nocapture nofree noundef nonnull writeonly sret(i32) align 4 dereferenceable(4) [[R]]) #[[ATTR2:[0-9]+]] ; TUNIT-NEXT: call void @add(ptr noalias nocapture nofree nonnull readnone align 8 dereferenceable(8) undef, ptr noalias nocapture nofree noundef nonnull writeonly sret(i32) align 4 dereferenceable(4) [[R]]) #[[ATTR2:[0-9]+]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@f ; CGSCC-LABEL: define {{[^@]+}}@f
; CGSCC-SAME: () #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: [[R:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[R:%.*]] = alloca i32, align 4
; CGSCC-NEXT: [[PAIR:%.*]] = alloca { i32, i32 }, align 8 ; CGSCC-NEXT: [[PAIR:%.*]] = alloca { i32, i32 }, align 8
; CGSCC-NEXT: call void @add(ptr noalias nocapture nofree noundef nonnull readonly align 8 dereferenceable(8) [[PAIR]], ptr noalias nocapture nofree noundef nonnull writeonly sret(i32) align 4 dereferenceable(4) [[R]]) #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: call void @add(ptr noalias nocapture nofree noundef nonnull readonly align 8 dereferenceable(8) [[PAIR]], ptr noalias nocapture nofree noundef nonnull writeonly sret(i32) align 4 dereferenceable(4) [[R]]) #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%r = alloca i32 %r = alloca i32
%pair = alloca {i32, i32} %pair = alloca {i32, i32}
call void @add(ptr %pair, ptr sret(i32) %r) call void @add(ptr %pair, ptr sret(i32) %r)
ret void ret void
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/IPConstantProp/2009-09-24-byval-ptr.ll

Show All 37 Linesentry:
call void @use(i8 %l) call void @use(i8 %l)
br label %return br label %return
return: ; preds = %entry return: ; preds = %entry
ret void ret void
} }
define internal i32 @vfu2(ptr byval(%struct.MYstr) align 4 %u) nounwind readonly { define internal i32 @vfu2(ptr byval(%struct.MYstr) align 4 %u) nounwind readonly {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define {{[^@]+}}@vfu2 ; CHECK-LABEL: define {{[^@]+}}@vfu2
; CHECK-SAME: (i8 [[TMP0:%.*]], i32 [[TMP1:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (i8 [[TMP0:%.*]], i32 [[TMP1:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[U_PRIV:%.*]] = alloca [[STRUCT_MYSTR:%.*]], align 8 ; CHECK-NEXT: [[U_PRIV:%.*]] = alloca [[STRUCT_MYSTR:%.*]], align 8
; CHECK-NEXT: store i8 [[TMP0]], ptr [[U_PRIV]], align 1 ; CHECK-NEXT: store i8 [[TMP0]], ptr [[U_PRIV]], align 1
; CHECK-NEXT: [[U_PRIV_0_1:%.*]] = getelementptr [[STRUCT_MYSTR]], ptr [[U_PRIV]], i64 0, i32 1 ; CHECK-NEXT: [[U_PRIV_0_1:%.*]] = getelementptr [[STRUCT_MYSTR]], ptr [[U_PRIV]], i64 0, i32 1
; CHECK-NEXT: store i32 [[TMP1]], ptr [[U_PRIV_0_1]], align 4 ; CHECK-NEXT: store i32 [[TMP1]], ptr [[U_PRIV_0_1]], align 4
; CHECK-NEXT: [[TMP2:%.*]] = getelementptr [[STRUCT_MYSTR]], ptr [[U_PRIV]], i32 0, i32 1 ; CHECK-NEXT: [[TMP2:%.*]] = getelementptr [[STRUCT_MYSTR]], ptr [[U_PRIV]], i32 0, i32 1
Show All 30 Lines
; ;
entry: entry:
call void @vfu1(ptr byval(%struct.MYstr) align 4 @mystr) nounwind call void @vfu1(ptr byval(%struct.MYstr) align 4 @mystr) nounwind
%result = call i32 @vfu2(ptr byval(%struct.MYstr) align 4 @mystr) nounwind %result = call i32 @vfu2(ptr byval(%struct.MYstr) align 4 @mystr) nounwind
ret i32 %result ret i32 %result
} }
define internal i32 @vfu2_v2(ptr byval(%struct.MYstr) align 4 %u) nounwind readonly { define internal i32 @vfu2_v2(ptr byval(%struct.MYstr) align 4 %u) nounwind readonly {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define {{[^@]+}}@vfu2_v2 ; CHECK-LABEL: define {{[^@]+}}@vfu2_v2
; CHECK-SAME: (i8 [[TMP0:%.*]], i32 [[TMP1:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (i8 [[TMP0:%.*]], i32 [[TMP1:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[U_PRIV:%.*]] = alloca [[STRUCT_MYSTR:%.*]], align 8 ; CHECK-NEXT: [[U_PRIV:%.*]] = alloca [[STRUCT_MYSTR:%.*]], align 8
; CHECK-NEXT: store i8 [[TMP0]], ptr [[U_PRIV]], align 1 ; CHECK-NEXT: store i8 [[TMP0]], ptr [[U_PRIV]], align 1
; CHECK-NEXT: [[U_PRIV_0_1:%.*]] = getelementptr [[STRUCT_MYSTR]], ptr [[U_PRIV]], i64 0, i32 1 ; CHECK-NEXT: [[U_PRIV_0_1:%.*]] = getelementptr [[STRUCT_MYSTR]], ptr [[U_PRIV]], i64 0, i32 1
; CHECK-NEXT: store i32 [[TMP1]], ptr [[U_PRIV_0_1]], align 4 ; CHECK-NEXT: store i32 [[TMP1]], ptr [[U_PRIV_0_1]], align 4
; CHECK-NEXT: [[Z:%.*]] = getelementptr [[STRUCT_MYSTR]], ptr [[U_PRIV]], i32 0, i32 1 ; CHECK-NEXT: [[Z:%.*]] = getelementptr [[STRUCT_MYSTR]], ptr [[U_PRIV]], i32 0, i32 1
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
; ;
entry: entry:
call void @vfu1(ptr byval(%struct.MYstr) align 4 @mystr) nounwind call void @vfu1(ptr byval(%struct.MYstr) align 4 @mystr) nounwind
%result = call i32 @vfu2_v2(ptr byval(%struct.MYstr) align 4 @mystr) nounwind %result = call i32 @vfu2_v2(ptr byval(%struct.MYstr) align 4 @mystr) nounwind
ret i32 %result ret i32 %result
} }
;. ;.
; CHECK: attributes #[[ATTR0]] = { nounwind } ; CHECK: attributes #[[ATTR0]] = { nounwind }
; CHECK: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; CHECK: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
;. ;.

llvm/test/Transforms/Attributor/IPConstantProp/PR16052.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define i64 @fn2() { define i64 @fn2() {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@fn2 ; TUNIT-LABEL: define {{[^@]+}}@fn2
; TUNIT-SAME: () #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: ret i64 undef ; TUNIT-NEXT: ret i64 undef
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@fn2 ; CGSCC-LABEL: define {{[^@]+}}@fn2
; CGSCC-SAME: () #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CONV:%.*]] = sext i32 undef to i64 ; CGSCC-NEXT: [[CONV:%.*]] = sext i32 undef to i64
; CGSCC-NEXT: [[DIV:%.*]] = sdiv i64 8, [[CONV]] ; CGSCC-NEXT: [[DIV:%.*]] = sdiv i64 8, [[CONV]]
; CGSCC-NEXT: [[CALL2:%.*]] = call i64 @fn1(i64 [[DIV]]) #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: [[CALL2:%.*]] = call i64 @fn1(i64 [[DIV]]) #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: ret i64 [[CALL2]] ; CGSCC-NEXT: ret i64 [[CALL2]]
; ;
entry: entry:
%conv = sext i32 undef to i64 %conv = sext i32 undef to i64
%div = sdiv i64 8, %conv %div = sdiv i64 8, %conv
%call2 = call i64 @fn1(i64 %div) %call2 = call i64 @fn1(i64 %div)
ret i64 %call2 ret i64 %call2
} }
define i64 @fn2b(i32 %arg) { define i64 @fn2b(i32 %arg) {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@fn2b ; TUNIT-LABEL: define {{[^@]+}}@fn2b
; TUNIT-SAME: (i32 [[ARG:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i32 [[ARG:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[CONV:%.*]] = sext i32 [[ARG]] to i64 ; TUNIT-NEXT: [[CONV:%.*]] = sext i32 [[ARG]] to i64
; TUNIT-NEXT: [[DIV:%.*]] = sdiv i64 8, [[CONV]] ; TUNIT-NEXT: [[DIV:%.*]] = sdiv i64 8, [[CONV]]
; TUNIT-NEXT: ret i64 [[DIV]] ; TUNIT-NEXT: ret i64 [[DIV]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@fn2b ; CGSCC-LABEL: define {{[^@]+}}@fn2b
; CGSCC-SAME: (i32 [[ARG:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (i32 [[ARG:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CONV:%.*]] = sext i32 [[ARG]] to i64 ; CGSCC-NEXT: [[CONV:%.*]] = sext i32 [[ARG]] to i64
; CGSCC-NEXT: [[DIV:%.*]] = sdiv i64 8, [[CONV]] ; CGSCC-NEXT: [[DIV:%.*]] = sdiv i64 8, [[CONV]]
; CGSCC-NEXT: [[CALL2:%.*]] = call i64 @fn1(i64 [[DIV]]) #[[ATTR2]] ; CGSCC-NEXT: [[CALL2:%.*]] = call i64 @fn1(i64 [[DIV]]) #[[ATTR2]]
; CGSCC-NEXT: ret i64 [[CALL2]] ; CGSCC-NEXT: ret i64 [[CALL2]]
; ;
entry: entry:
%conv = sext i32 %arg to i64 %conv = sext i32 %arg to i64
%div = sdiv i64 8, %conv %div = sdiv i64 8, %conv
%call2 = call i64 @fn1(i64 %div) %call2 = call i64 @fn1(i64 %div)
ret i64 %call2 ret i64 %call2
} }
define i64 @fn2c() { define i64 @fn2c() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@fn2c ; TUNIT-LABEL: define {{[^@]+}}@fn2c
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: ret i64 42 ; TUNIT-NEXT: ret i64 42
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@fn2c ; CGSCC-LABEL: define {{[^@]+}}@fn2c
; CGSCC-SAME: () #[[ATTR0]] { ; CGSCC-SAME: () #[[ATTR0]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CONV:%.*]] = sext i32 undef to i64 ; CGSCC-NEXT: [[CONV:%.*]] = sext i32 undef to i64
; CGSCC-NEXT: [[ADD:%.*]] = add i64 42, [[CONV]] ; CGSCC-NEXT: [[ADD:%.*]] = add i64 42, [[CONV]]
; CGSCC-NEXT: [[CALL2:%.*]] = call i64 @fn1(i64 [[ADD]]) #[[ATTR2]] ; CGSCC-NEXT: [[CALL2:%.*]] = call i64 @fn1(i64 [[ADD]]) #[[ATTR2]]
; CGSCC-NEXT: ret i64 [[CALL2]] ; CGSCC-NEXT: ret i64 [[CALL2]]
; ;
entry: entry:
%conv = sext i32 undef to i64 %conv = sext i32 undef to i64
%add = add i64 42, %conv %add = add i64 42, %conv
%call2 = call i64 @fn1(i64 %add) %call2 = call i64 @fn1(i64 %add)
ret i64 %call2 ret i64 %call2
} }
define internal i64 @fn1(i64 %p1) { define internal i64 @fn1(i64 %p1) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@fn1 ; CGSCC-LABEL: define {{[^@]+}}@fn1
; CGSCC-SAME: (i64 returned [[P1:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (i64 returned [[P1:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: ret i64 [[P1]] ; CGSCC-NEXT: ret i64 [[P1]]
; ;
entry: entry:
%tobool = icmp ne i64 %p1, 0 %tobool = icmp ne i64 %p1, 0
%cond = select i1 %tobool, i64 %p1, i64 %p1 %cond = select i1 %tobool, i64 %p1, i64 %p1
ret i64 %cond ret i64 %cond
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { willreturn } ; CGSCC: attributes #[[ATTR2]] = { willreturn }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/IPConstantProp/PR26044.ll

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Linesif.end: ; preds = %entry, %for.cond1
%call = call i32 @fn1(i32 %0) %call = call i32 @fn1(i32 %0)
store i32 %call, ptr %P store i32 %call, ptr %P
br label %for.cond1 br label %for.cond1
exit: exit:
ret void ret void
} }
define internal i32 @fn1(i32 %p1) { define internal i32 @fn1(i32 %p1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@fn1 ; CHECK-LABEL: define {{[^@]+}}@fn1
; CHECK-SAME: (i32 returned [[P1:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (i32 returned [[P1:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret i32 [[P1]] ; CHECK-NEXT: ret i32 [[P1]]
; ;
entry: entry:
%tobool = icmp ne i32 %p1, 0 %tobool = icmp ne i32 %p1, 0
%cond = select i1 %tobool, i32 %p1, i32 %p1 %cond = select i1 %tobool, i32 %p1, i32 %p1
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Linesif.end: ; preds = %entry, %for.cond1
%call = call i32 @fn0(i32 %0) %call = call i32 @fn0(i32 %0)
store i32 %call, ptr %P store i32 %call, ptr %P
br label %for.cond1 br label %for.cond1
exit: exit:
ret void ret void
} }
define internal i32 @fn0(i32 %p1) { define internal i32 @fn0(i32 %p1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@fn0 ; CHECK-LABEL: define {{[^@]+}}@fn0
; CHECK-SAME: (i32 returned [[P1:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (i32 returned [[P1:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret i32 [[P1]] ; CHECK-NEXT: ret i32 [[P1]]
; ;
entry: entry:
%tobool = icmp ne i32 %p1, 0 %tobool = icmp ne i32 %p1, 0
%cond = select i1 %tobool, i32 %p1, i32 %p1 %cond = select i1 %tobool, i32 %p1, i32 %p1
ret i32 %cond ret i32 %cond
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind null_pointer_is_valid } ; TUNIT: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind null_pointer_is_valid }
; TUNIT: attributes #[[ATTR3]] = { nofree nosync nounwind } ; TUNIT: attributes #[[ATTR3]] = { nofree nosync nounwind }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree nosync nounwind memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR0]] = { nofree nosync nounwind memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind null_pointer_is_valid } ; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind null_pointer_is_valid }
;. ;.

llvm/test/Transforms/Attributor/IPConstantProp/PR43857.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
%struct.wobble = type { i32 } %struct.wobble = type { i32 }
%struct.zot = type { %struct.wobble, %struct.wobble, %struct.wobble } %struct.zot = type { %struct.wobble, %struct.wobble, %struct.wobble }
declare dso_local fastcc float @bar(ptr noalias, <8 x i32>) unnamed_addr declare dso_local fastcc float @bar(ptr noalias, <8 x i32>) unnamed_addr
define %struct.zot @widget(<8 x i32> %arg) local_unnamed_addr { define %struct.zot @widget(<8 x i32> %arg) local_unnamed_addr {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@widget ; CHECK-LABEL: define {{[^@]+}}@widget
; CHECK-SAME: (<8 x i32> [[ARG:%.*]]) local_unnamed_addr #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (<8 x i32> [[ARG:%.*]]) local_unnamed_addr #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: ret [[STRUCT_ZOT:%.*]] undef ; CHECK-NEXT: ret [[STRUCT_ZOT:%.*]] undef
; ;
bb: bb:
ret %struct.zot undef ret %struct.zot undef
} }
define void @baz(<8 x i32> %arg) local_unnamed_addr { define void @baz(<8 x i32> %arg) local_unnamed_addr {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@baz ; TUNIT-LABEL: define {{[^@]+}}@baz
; TUNIT-SAME: (<8 x i32> [[ARG:%.*]]) local_unnamed_addr #[[ATTR0]] { ; TUNIT-SAME: (<8 x i32> [[ARG:%.*]]) local_unnamed_addr #[[ATTR0]] {
; TUNIT-NEXT: bb: ; TUNIT-NEXT: bb:
; TUNIT-NEXT: [[TMP1:%.*]] = extractvalue [[STRUCT_ZOT:%.*]] undef, 0, 0 ; TUNIT-NEXT: [[TMP1:%.*]] = extractvalue [[STRUCT_ZOT:%.*]] undef, 0, 0
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@baz ; CGSCC-LABEL: define {{[^@]+}}@baz
; CGSCC-SAME: (<8 x i32> [[ARG:%.*]]) local_unnamed_addr #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (<8 x i32> [[ARG:%.*]]) local_unnamed_addr #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
bb: bb:
%tmp = call %struct.zot @widget(<8 x i32> %arg) %tmp = call %struct.zot @widget(<8 x i32> %arg)
%tmp1 = extractvalue %struct.zot %tmp, 0, 0 %tmp1 = extractvalue %struct.zot %tmp, 0, 0
ret void ret void
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
;. ;.

llvm/test/Transforms/Attributor/IPConstantProp/arg-count-mismatch.ll

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
; CGSCC-NEXT: [[CALL:%.*]] = call i16 bitcast (i16 (i16, i16)* @bar to i16 (i16)*)(i16 [[A]]) ; CGSCC-NEXT: [[CALL:%.*]] = call i16 bitcast (i16 (i16, i16)* @bar to i16 (i16)*)(i16 [[A]])
; CGSCC-NEXT: ret i16 [[CALL]] ; CGSCC-NEXT: ret i16 [[CALL]]
; ;
%call = call i16 bitcast (i16 (i16, i16) * @bar to i16 (i16) *)(i16 %a) %call = call i16 bitcast (i16 (i16, i16) * @bar to i16 (i16) *)(i16 %a)
ret i16 %call ret i16 %call
} }
define internal i16 @bar(i16 %p1, i16 %p2) { define internal i16 @bar(i16 %p1, i16 %p2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@bar ; CHECK-LABEL: define {{[^@]+}}@bar
; CHECK-SAME: (i16 [[P1:%.*]], i16 [[P2:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (i16 [[P1:%.*]], i16 [[P2:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: ret i16 0 ; CHECK-NEXT: ret i16 0
; ;
ret i16 0 ret i16 0
} }
define dso_local i16 @foo2(i16 %a) { define dso_local i16 @foo2(i16 %a) {
Show All 9 Lines
; CGSCC-NEXT: [[CALL:%.*]] = call i16 bitcast (i16 (i16, i16)* @bar2 to i16 (i16)*)(i16 [[A]]) ; CGSCC-NEXT: [[CALL:%.*]] = call i16 bitcast (i16 (i16, i16)* @bar2 to i16 (i16)*)(i16 [[A]])
; CGSCC-NEXT: ret i16 [[CALL]] ; CGSCC-NEXT: ret i16 [[CALL]]
; ;
%call = call i16 bitcast (i16 (i16, i16) * @bar2 to i16 (i16) *)(i16 %a) %call = call i16 bitcast (i16 (i16, i16) * @bar2 to i16 (i16) *)(i16 %a)
ret i16 %call ret i16 %call
} }
define internal i16 @bar2(i16 %p1, i16 %p2) { define internal i16 @bar2(i16 %p1, i16 %p2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@bar2 ; CHECK-LABEL: define {{[^@]+}}@bar2
; CHECK-SAME: (i16 [[P1:%.*]], i16 [[P2:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (i16 [[P1:%.*]], i16 [[P2:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[A:%.*]] = add i16 [[P1]], [[P2]] ; CHECK-NEXT: [[A:%.*]] = add i16 [[P1]], [[P2]]
; CHECK-NEXT: ret i16 [[A]] ; CHECK-NEXT: ret i16 [[A]]
; ;
%a = add i16 %p1, %p2 %a = add i16 %p1, %p2
ret i16 %a ret i16 %a
} }
Show All 22 Lines
; ;
%call1 = call i16 (i16, ...) @vararg_prop(i16 7, i16 8, i16 %a) %call1 = call i16 (i16, ...) @vararg_prop(i16 7, i16 8, i16 %a)
%call2 = call i16 bitcast (i16 (i16, i16, ...) * @vararg_no_prop to i16 (i16) *) (i16 7) %call2 = call i16 bitcast (i16 (i16, i16, ...) * @vararg_no_prop to i16 (i16) *) (i16 7)
%add = add i16 %call1, %call2 %add = add i16 %call1, %call2
ret i16 %add ret i16 %add
} }
define internal i16 @vararg_prop(i16 %p1, ...) { define internal i16 @vararg_prop(i16 %p1, ...) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@vararg_prop ; CGSCC-LABEL: define {{[^@]+}}@vararg_prop
; CGSCC-SAME: (i16 [[P1:%.*]], ...) #[[ATTR1]] { ; CGSCC-SAME: (i16 [[P1:%.*]], ...) #[[ATTR1]] {
; CGSCC-NEXT: ret i16 7 ; CGSCC-NEXT: ret i16 7
; ;
ret i16 %p1 ret i16 %p1
} }
define internal i16 @vararg_no_prop(i16 %p1, i16 %p2, ...) { define internal i16 @vararg_no_prop(i16 %p1, i16 %p2, ...) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@vararg_no_prop ; CHECK-LABEL: define {{[^@]+}}@vararg_no_prop
; CHECK-SAME: (i16 [[P1:%.*]], i16 [[P2:%.*]], ...) #[[ATTR1]] { ; CHECK-SAME: (i16 [[P1:%.*]], i16 [[P2:%.*]], ...) #[[ATTR1]] {
; CHECK-NEXT: ret i16 7 ; CHECK-NEXT: ret i16 7
; ;
ret i16 %p1 ret i16 %p1
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { norecurse } ; TUNIT: attributes #[[ATTR0]] = { norecurse }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree nosync nounwind } ; CGSCC: attributes #[[ATTR0]] = { nofree nosync nounwind }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { willreturn } ; CGSCC: attributes #[[ATTR2]] = { willreturn }
;. ;.

llvm/test/Transforms/Attributor/IPConstantProp/arg-type-mismatch.ll

Show All 21 Lines;
ret i16 %call ret i16 %call
} }
define internal i16 @bar(i16 %p1, i16 %p2) { define internal i16 @bar(i16 %p1, i16 %p2) {
; TUNIT-LABEL: define {{[^@]+}}@bar ; TUNIT-LABEL: define {{[^@]+}}@bar
; TUNIT-SAME: (i16 [[P1:%.*]], i16 [[P2:%.*]]) { ; TUNIT-SAME: (i16 [[P1:%.*]], i16 [[P2:%.*]]) {
; TUNIT-NEXT: ret i16 [[P2]] ; TUNIT-NEXT: ret i16 [[P2]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@bar ; CGSCC-LABEL: define {{[^@]+}}@bar
; CGSCC-SAME: (i16 [[P1:%.*]], i16 returned [[P2:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (i16 [[P1:%.*]], i16 returned [[P2:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: ret i16 [[P2]] ; CGSCC-NEXT: ret i16 [[P2]]
; ;
ret i16 %p2 ret i16 %p2
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { norecurse } ; TUNIT: attributes #[[ATTR0]] = { norecurse }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree nosync nounwind memory(none) } ; CGSCC: attributes #[[ATTR0]] = { nofree nosync nounwind memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/IPConstantProp/comdat-ipo.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; See PR26774 ; See PR26774
define i32 @baz() { define i32 @baz() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@baz ; CHECK-LABEL: define {{[^@]+}}@baz
; CHECK-SAME: () #[[ATTR0:[0-9]+]] { ; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: ret i32 10 ; CHECK-NEXT: ret i32 10
; ;
ret i32 10 ret i32 10
} }
; We can const-prop @baz's return value *into* @foo, but cannot ; We can const-prop @baz's return value *into* @foo, but cannot
Show All 23 Lines
; CGSCC-NEXT: [[VAL:%.*]] = call i32 @foo() ; CGSCC-NEXT: [[VAL:%.*]] = call i32 @foo()
; CGSCC-NEXT: ret i32 [[VAL]] ; CGSCC-NEXT: ret i32 [[VAL]]
; ;
%val = call i32 @foo() %val = call i32 @foo()
ret i32 %val ret i32 %val
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1]] = { norecurse } ; TUNIT: attributes #[[ATTR1]] = { norecurse }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.

llvm/test/Transforms/Attributor/IPConstantProp/dangling-block-address.ll

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Linesindirectgoto: ; preds = %lab0, %entry
%pc.addr.0 = getelementptr i32, ptr %pc, i32 %indvar ; <ptr> [#uses=1] %pc.addr.0 = getelementptr i32, ptr %pc, i32 %indvar ; <ptr> [#uses=1]
%tmp1.pn = load i32, ptr %pc.addr.0 ; <i32> [#uses=1] %tmp1.pn = load i32, ptr %pc.addr.0 ; <i32> [#uses=1]
%indirect.goto.dest.in = getelementptr inbounds [2 x ptr], ptr @bar.l, i32 0, i32 %tmp1.pn ; <ptr> [#uses=1] %indirect.goto.dest.in = getelementptr inbounds [2 x ptr], ptr @bar.l, i32 0, i32 %tmp1.pn ; <ptr> [#uses=1]
%indirect.goto.dest = load ptr, ptr %indirect.goto.dest.in ; <ptr> [#uses=1] %indirect.goto.dest = load ptr, ptr %indirect.goto.dest.in ; <ptr> [#uses=1]
indirectbr ptr %indirect.goto.dest, [label %lab0, label %end] indirectbr ptr %indirect.goto.dest, [label %lab0, label %end]
} }
define i32 @main() nounwind readnone { define i32 @main() nounwind readnone {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@main ; TUNIT-LABEL: define {{[^@]+}}@main
; TUNIT-SAME: () #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: ret i32 0 ; TUNIT-NEXT: ret i32 0
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@main ; CGSCC-LABEL: define {{[^@]+}}@main
; CGSCC-SAME: () #[[ATTR2:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR2:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: ret i32 0 ; CGSCC-NEXT: ret i32 0
; ;
entry: entry:
ret i32 0 ret i32 0
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nounwind memory(none) } ; CGSCC: attributes #[[ATTR0]] = { nounwind memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nounwind memory(read) } ; CGSCC: attributes #[[ATTR1]] = { nounwind memory(read) }
; CGSCC: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/IPConstantProp/deadarg.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
define internal void @foo(i32 %X) { define internal void @foo(i32 %X) {
; CGSCC-LABEL: define {{[^@]+}}@foo ; CGSCC-LABEL: define {{[^@]+}}@foo
; CGSCC-SAME: (i32 [[X:%.*]]) { ; CGSCC-SAME: (i32 [[X:%.*]]) {
; CGSCC-NEXT: call void @foo(i32 [[X]]) ; CGSCC-NEXT: call void @foo(i32 [[X]])
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @foo( i32 %X ) call void @foo( i32 %X )
ret void ret void
} }
define void @bar() { define void @bar() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@bar ; CHECK-LABEL: define {{[^@]+}}@bar
; CHECK-SAME: () #[[ATTR0:[0-9]+]] { ; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
ret void ret void
} }
;. ;.
; CHECK: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CHECK: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; TUNIT: {{.*}} ; TUNIT: {{.*}}

llvm/test/Transforms/Attributor/IPConstantProp/global.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
@_ZL6test1g = internal global i32 42, align 4 @_ZL6test1g = internal global i32 42, align 4
;. ;.
; CHECK: @[[_ZL6TEST1G:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 42, align 4 ; CHECK: @[[_ZL6TEST1G:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 42, align 4
;. ;.
define void @_Z7test1f1v() nounwind { define void @_Z7test1f1v() nounwind {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@_Z7test1f1v ; CHECK-LABEL: define {{[^@]+}}@_Z7test1f1v
; CHECK-SAME: () #[[ATTR0:[0-9]+]] { ; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[IF_END:%.*]] ; CHECK-NEXT: br label [[IF_END:%.*]]
; CHECK: if.then: ; CHECK: if.then:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; CHECK: if.end: ; CHECK: if.end:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
%tmp = load i32, ptr @_ZL6test1g, align 4 %tmp = load i32, ptr @_ZL6test1g, align 4
%cmp = icmp eq i32 %tmp, 0 %cmp = icmp eq i32 %tmp, 0
br i1 %cmp, label %if.then, label %if.end br i1 %cmp, label %if.then, label %if.end
if.then: ; preds = %entry if.then: ; preds = %entry
store i32 0, ptr @_ZL6test1g, align 4 store i32 0, ptr @_ZL6test1g, align 4
br label %if.end br label %if.end
if.end: ; preds = %if.then, %entry if.end: ; preds = %if.then, %entry
ret void ret void
} }
define i32 @_Z7test1f2v() nounwind { define i32 @_Z7test1f2v() nounwind {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@_Z7test1f2v ; CHECK-LABEL: define {{[^@]+}}@_Z7test1f2v
; CHECK-SAME: () #[[ATTR0]] { ; CHECK-SAME: () #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret i32 42 ; CHECK-NEXT: ret i32 42
; ;
entry: entry:
%tmp = load i32, ptr @_ZL6test1g, align 4 %tmp = load i32, ptr @_ZL6test1g, align 4
ret i32 %tmp ret i32 %tmp
} }
;. ;.
; CHECK: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CHECK: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CGSCC: {{.*}} ; CGSCC: {{.*}}
; TUNIT: {{.*}} ; TUNIT: {{.*}}

llvm/test/Transforms/Attributor/IPConstantProp/multiple_callbacks.ll

Show All 32 Lines
; broker(cb1, cb2, cb2, 0, 1); ; broker(cb1, cb2, cb2, 0, 1);
; broker(cb3, cb2, cb3, 0, 1); ; broker(cb3, cb2, cb3, 0, 1);
; broker(cb4, cb4, cb4, 0, 1); ; broker(cb4, cb4, cb4, 0, 1);
; } ; }
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define internal i32 @cb0(i32 %zero) { define internal i32 @cb0(i32 %zero) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@cb0 ; CHECK-LABEL: define {{[^@]+}}@cb0
; CHECK-SAME: (i32 [[ZERO:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (i32 [[ZERO:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
entry: entry:
ret i32 %zero ret i32 %zero
} }
define internal i32 @cb1(i32 %unknown) { define internal i32 @cb1(i32 %unknown) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@cb1 ; CHECK-LABEL: define {{[^@]+}}@cb1
; CHECK-SAME: (i32 noundef [[UNKNOWN:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32 noundef [[UNKNOWN:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret i32 [[UNKNOWN]] ; CHECK-NEXT: ret i32 [[UNKNOWN]]
; ;
entry: entry:
ret i32 %unknown ret i32 %unknown
} }
define internal i32 @cb2(i32 %unknown) { define internal i32 @cb2(i32 %unknown) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@cb2 ; TUNIT-LABEL: define {{[^@]+}}@cb2
; TUNIT-SAME: (i32 noundef [[UNKNOWN:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i32 noundef [[UNKNOWN:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: ret i32 [[UNKNOWN]] ; TUNIT-NEXT: ret i32 [[UNKNOWN]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@cb2 ; CGSCC-LABEL: define {{[^@]+}}@cb2
; CGSCC-SAME: (i32 noundef [[UNKNOWN:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (i32 noundef [[UNKNOWN:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: ret i32 [[UNKNOWN]] ; CGSCC-NEXT: ret i32 [[UNKNOWN]]
; ;
entry: entry:
%call = call i32 @cb0(i32 0) %call = call i32 @cb0(i32 0)
ret i32 %unknown ret i32 %unknown
} }
define internal i32 @cb3(i32 %unknown) { define internal i32 @cb3(i32 %unknown) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@cb3 ; CHECK-LABEL: define {{[^@]+}}@cb3
; CHECK-SAME: (i32 noundef [[UNKNOWN:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32 noundef [[UNKNOWN:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret i32 [[UNKNOWN]] ; CHECK-NEXT: ret i32 [[UNKNOWN]]
; ;
entry: entry:
ret i32 %unknown ret i32 %unknown
} }
define internal i32 @cb4(i32 %unknown) { define internal i32 @cb4(i32 %unknown) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@cb4 ; CHECK-LABEL: define {{[^@]+}}@cb4
; CHECK-SAME: (i32 noundef [[UNKNOWN:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32 noundef [[UNKNOWN:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret i32 [[UNKNOWN]] ; CHECK-NEXT: ret i32 [[UNKNOWN]]
; ;
entry: entry:
ret i32 %unknown ret i32 %unknown
} }
Show All 19 Lines
declare !callback !3 void @broker(ptr, ptr, ptr, i32, i32) declare !callback !3 void @broker(ptr, ptr, ptr, i32, i32)
!0 = !{i64 0, i64 3, i1 false} !0 = !{i64 0, i64 3, i1 false}
!1 = !{i64 1, i64 4, i1 false} !1 = !{i64 1, i64 4, i1 false}
!2 = !{i64 2, i64 3, i1 false} !2 = !{i64 2, i64 3, i1 false}
!3 = !{!0, !2, !1} !3 = !{!0, !2, !1}
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
;. ;.
; CHECK: [[META0:![0-9]+]] = !{!1, !2, !3} ; CHECK: [[META0:![0-9]+]] = !{!1, !2, !3}
; CHECK: [[META1:![0-9]+]] = !{i64 0, i64 3, i1 false} ; CHECK: [[META1:![0-9]+]] = !{i64 0, i64 3, i1 false}
; CHECK: [[META2:![0-9]+]] = !{i64 2, i64 3, i1 false} ; CHECK: [[META2:![0-9]+]] = !{i64 2, i64 3, i1 false}
; CHECK: [[META3:![0-9]+]] = !{i64 1, i64 4, i1 false} ; CHECK: [[META3:![0-9]+]] = !{i64 1, i64 4, i1 false}
;. ;.

llvm/test/Transforms/Attributor/IPConstantProp/musttail-call.ll

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Lines;
%ca = musttail call ptr @start(i8 %v) %ca = musttail call ptr @start(i8 %v)
; Thus the result must be returned anyway ; Thus the result must be returned anyway
ret ptr %ca ret ptr %ca
} }
define internal ptr @no_side_effects(i8 %v) readonly nounwind { define internal ptr @no_side_effects(i8 %v) readonly nounwind {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@no_side_effects ; CGSCC-LABEL: define {{[^@]+}}@no_side_effects
; CGSCC-SAME: (i8 [[V:%.*]]) #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: (i8 [[V:%.*]]) #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: ret ptr null ; CGSCC-NEXT: ret ptr null
; ;
ret ptr null ret ptr null
} }
define internal ptr @dont_zap_me(i8 %v) { define internal ptr @dont_zap_me(i8 %v) {
; CHECK-LABEL: define {{[^@]+}}@dont_zap_me ; CHECK-LABEL: define {{[^@]+}}@dont_zap_me
; CHECK-SAME: (i8 [[V:%.*]]) { ; CHECK-SAME: (i8 [[V:%.*]]) {
; CHECK-NEXT: [[I1:%.*]] = call i32 @external() ; CHECK-NEXT: [[I1:%.*]] = call i32 @external()
; CHECK-NEXT: ret ptr null ; CHECK-NEXT: ret ptr null
; ;
%i1 = call i32 @external() %i1 = call i32 @external()
ret ptr null ret ptr null
} }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.

llvm/test/Transforms/Attributor/IPConstantProp/pthreads.ll

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Linesentry:
%call2 = call i32 @pthread_create(ptr nonnull %thread, ptr null, ptr nonnull @baz, ptr nocapture %alloc1) %call2 = call i32 @pthread_create(ptr nonnull %thread, ptr null, ptr nonnull @baz, ptr nocapture %alloc1)
%call3 = call i32 @pthread_create(ptr nonnull %thread, ptr null, ptr nonnull @buz, ptr %alloc2) %call3 = call i32 @pthread_create(ptr nonnull %thread, ptr null, ptr nonnull @buz, ptr %alloc2)
ret i32 0 ret i32 0
} }
declare !callback !0 dso_local i32 @pthread_create(ptr, ptr, ptr, ptr) declare !callback !0 dso_local i32 @pthread_create(ptr, ptr, ptr, ptr)
define internal ptr @foo(ptr %arg) { define internal ptr @foo(ptr %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@foo ; CHECK-LABEL: define {{[^@]+}}@foo
; CHECK-SAME: (ptr noalias nocapture nofree readnone align 4294967296 [[ARG:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr noalias nocapture nofree readnone align 4294967296 [[ARG:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret ptr null ; CHECK-NEXT: ret ptr null
; ;
entry: entry:
ret ptr %arg ret ptr %arg
} }
define internal ptr @bar(ptr %arg) { define internal ptr @bar(ptr %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@bar ; CHECK-LABEL: define {{[^@]+}}@bar
; CHECK-SAME: (ptr noalias nocapture nofree nonnull readnone align 8 dereferenceable(8) [[ARG:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr noalias nocapture nofree nonnull readnone align 8 dereferenceable(8) [[ARG:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret ptr @GlobalVPtr ; CHECK-NEXT: ret ptr @GlobalVPtr
; ;
entry: entry:
ret ptr %arg ret ptr %arg
} }
define internal ptr @baz(ptr %arg) { define internal ptr @baz(ptr %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@baz ; CHECK-LABEL: define {{[^@]+}}@baz
; CHECK-SAME: (ptr noalias nofree noundef nonnull readnone returned align 8 dereferenceable(1) "no-capture-maybe-returned" [[ARG:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr noalias nofree noundef nonnull readnone returned align 8 dereferenceable(1) "no-capture-maybe-returned" [[ARG:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret ptr [[ARG]] ; CHECK-NEXT: ret ptr [[ARG]]
; ;
entry: entry:
ret ptr %arg ret ptr %arg
} }
define internal ptr @buz(ptr %arg) { define internal ptr @buz(ptr %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@buz ; CHECK-LABEL: define {{[^@]+}}@buz
; CHECK-SAME: (ptr noalias nofree noundef nonnull readnone returned align 8 dereferenceable(1) "no-capture-maybe-returned" [[ARG:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr noalias nofree noundef nonnull readnone returned align 8 dereferenceable(1) "no-capture-maybe-returned" [[ARG:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret ptr [[ARG]] ; CHECK-NEXT: ret ptr [[ARG]]
; ;
entry: entry:
ret ptr %arg ret ptr %arg
} }
!1 = !{i64 2, i64 3, i1 false} !1 = !{i64 2, i64 3, i1 false}
!0 = !{!1} !0 = !{!1}
;. ;.
; CHECK: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CHECK: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
; CHECK: [[META0:![0-9]+]] = !{!1} ; CHECK: [[META0:![0-9]+]] = !{!1}
; CHECK: [[META1:![0-9]+]] = !{i64 2, i64 3, i1 false} ; CHECK: [[META1:![0-9]+]] = !{i64 2, i64 3, i1 false}
;. ;.

llvm/test/Transforms/Attributor/IPConstantProp/recursion.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; CHECK-NOT: %X ; CHECK-NOT: %X
define internal i32 @foo(i32 %X) { define internal i32 @foo(i32 %X) {
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@foo ; CGSCC-LABEL: define {{[^@]+}}@foo
; CGSCC-SAME: () #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: ret i32 undef ; CGSCC-NEXT: ret i32 undef
; ;
%Y = call i32 @foo( i32 %X ) ; <i32> [#uses=1] %Y = call i32 @foo( i32 %X ) ; <i32> [#uses=1]
%Z = add i32 %Y, 1 ; <i32> [#uses=1] %Z = add i32 %Y, 1 ; <i32> [#uses=1]
ret i32 %Z ret i32 %Z
} }
define void @bar() { define void @bar() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@bar ; TUNIT-LABEL: define {{[^@]+}}@bar
; TUNIT-SAME: () #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@bar ; CGSCC-LABEL: define {{[^@]+}}@bar
; CGSCC-SAME: () #[[ATTR0]] { ; CGSCC-SAME: () #[[ATTR0]] {
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call i32 @foo( i32 17 ) ; <i32>:1 [#uses=0] call i32 @foo( i32 17 ) ; <i32>:1 [#uses=0]
ret void ret void
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/IPConstantProp/remove-call-inst.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; PR5596 ; PR5596
; IPSCCP should propagate the 0 argument, eliminate the switch, and propagate ; IPSCCP should propagate the 0 argument, eliminate the switch, and propagate
; the result. ; the result.
; FIXME: Remove obsolete calls/instructions ; FIXME: Remove obsolete calls/instructions
define i32 @main() noreturn nounwind { define i32 @main() noreturn nounwind {
; TUNIT: Function Attrs: nofree norecurse noreturn nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@main ; TUNIT-LABEL: define {{[^@]+}}@main
; TUNIT-SAME: () #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: ret i32 123 ; TUNIT-NEXT: ret i32 123
; ;
; CGSCC: Function Attrs: nofree noreturn nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree noreturn nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@main ; CGSCC-LABEL: define {{[^@]+}}@main
; CGSCC-SAME: () #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CALL2:%.*]] = tail call noundef i32 @wwrite() #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: [[CALL2:%.*]] = tail call noundef i32 @wwrite() #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: ret i32 [[CALL2]] ; CGSCC-NEXT: ret i32 [[CALL2]]
; ;
entry: entry:
%call2 = tail call i32 @wwrite(i64 0) nounwind %call2 = tail call i32 @wwrite(i64 0) nounwind
ret i32 %call2 ret i32 %call2
} }
define internal i32 @wwrite(i64 %i) nounwind readnone { define internal i32 @wwrite(i64 %i) nounwind readnone {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@wwrite ; CGSCC-LABEL: define {{[^@]+}}@wwrite
; CGSCC-SAME: () #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: switch i64 0, label [[SW_DEFAULT:%.*]] [ ; CGSCC-NEXT: switch i64 0, label [[SW_DEFAULT:%.*]] [
; CGSCC-NEXT: i64 3, label [[RETURN:%.*]] ; CGSCC-NEXT: i64 3, label [[RETURN:%.*]]
; CGSCC-NEXT: i64 10, label [[RETURN]] ; CGSCC-NEXT: i64 10, label [[RETURN]]
; CGSCC-NEXT: ] ; CGSCC-NEXT: ]
; CGSCC: sw.default: ; CGSCC: sw.default:
Show All 9 Lines
sw.default: sw.default:
ret i32 123 ret i32 123
return: return:
ret i32 0 ret i32 0
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse noreturn nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree noreturn nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree noreturn nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/IPConstantProp/return-argument.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=5 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=5 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
;; This function returns its second argument on all return statements ;; This function returns its second argument on all return statements
define internal ptr @incdec(i1 %C, ptr %V) { define internal ptr @incdec(i1 %C, ptr %V) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@incdec ; TUNIT-LABEL: define {{[^@]+}}@incdec
; TUNIT-SAME: (i1 noundef [[C:%.*]], ptr noalias nofree noundef nonnull returned writeonly align 4 dereferenceable(4) "no-capture-maybe-returned" [[V:%.*]]) #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: (i1 noundef [[C:%.*]], ptr noalias nofree noundef nonnull returned writeonly align 4 dereferenceable(4) "no-capture-maybe-returned" [[V:%.*]]) #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: T: ; TUNIT: T:
; TUNIT-NEXT: ret ptr [[V]] ; TUNIT-NEXT: ret ptr [[V]]
; TUNIT: F: ; TUNIT: F:
; TUNIT-NEXT: ret ptr [[V]] ; TUNIT-NEXT: ret ptr [[V]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@incdec ; CGSCC-LABEL: define {{[^@]+}}@incdec
; CGSCC-SAME: (i1 noundef [[C:%.*]], ptr nofree noundef nonnull returned align 4 dereferenceable(4) "no-capture-maybe-returned" [[V:%.*]]) #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]], ptr nofree noundef nonnull returned align 4 dereferenceable(4) "no-capture-maybe-returned" [[V:%.*]]) #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: [[X:%.*]] = load i32, ptr [[V]], align 4 ; CGSCC-NEXT: [[X:%.*]] = load i32, ptr [[V]], align 4
; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: T: ; CGSCC: T:
; CGSCC-NEXT: [[X1:%.*]] = add i32 [[X]], 1 ; CGSCC-NEXT: [[X1:%.*]] = add i32 [[X]], 1
; CGSCC-NEXT: store i32 [[X1]], ptr [[V]], align 4 ; CGSCC-NEXT: store i32 [[X1]], ptr [[V]], align 4
; CGSCC-NEXT: ret ptr [[V]] ; CGSCC-NEXT: ret ptr [[V]]
Show All 14 LinesF: ; preds = %0
%X2 = sub i32 %X, 1 %X2 = sub i32 %X, 1
store i32 %X2, ptr %V store i32 %X2, ptr %V
ret ptr %V ret ptr %V
} }
;; This function returns its first argument as a part of a multiple return ;; This function returns its first argument as a part of a multiple return
;; value ;; value
define internal { i32, i32 } @foo(i32 %A, i32 %B) { define internal { i32, i32 } @foo(i32 %A, i32 %B) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@foo ; CGSCC-LABEL: define {{[^@]+}}@foo
; CGSCC-SAME: (i32 noundef [[A:%.*]], i32 noundef [[B:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (i32 noundef [[A:%.*]], i32 noundef [[B:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: [[X:%.*]] = add i32 [[A]], [[B]] ; CGSCC-NEXT: [[X:%.*]] = add i32 [[A]], [[B]]
; CGSCC-NEXT: [[Y:%.*]] = insertvalue { i32, i32 } undef, i32 [[A]], 0 ; CGSCC-NEXT: [[Y:%.*]] = insertvalue { i32, i32 } undef, i32 [[A]], 0
; CGSCC-NEXT: [[Z:%.*]] = insertvalue { i32, i32 } [[Y]], i32 [[X]], 1 ; CGSCC-NEXT: [[Z:%.*]] = insertvalue { i32, i32 } [[Y]], i32 [[X]], 1
; CGSCC-NEXT: ret { i32, i32 } [[Z]] ; CGSCC-NEXT: ret { i32, i32 } [[Z]]
; ;
%X = add i32 %A, %B %X = add i32 %A, %B
%Y = insertvalue { i32, i32 } undef, i32 %A, 0 %Y = insertvalue { i32, i32 } undef, i32 %A, 0
%Z = insertvalue { i32, i32 } %Y, i32 %X, 1 %Z = insertvalue { i32, i32 } %Y, i32 %X, 1
ret { i32, i32 } %Z ret { i32, i32 } %Z
} }
define void @caller(i1 %C) personality ptr @__gxx_personality_v0 { define void @caller(i1 %C) personality ptr @__gxx_personality_v0 {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@caller ; TUNIT-LABEL: define {{[^@]+}}@caller
; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR1:[0-9]+]] personality ptr @__gxx_personality_v0 { ; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR1:[0-9]+]] personality ptr @__gxx_personality_v0 {
; TUNIT-NEXT: [[Q:%.*]] = alloca i32, align 4 ; TUNIT-NEXT: [[Q:%.*]] = alloca i32, align 4
; TUNIT-NEXT: [[W:%.*]] = call align 4 ptr @incdec(i1 [[C]], ptr noalias nofree noundef nonnull writeonly align 4 dereferenceable(4) "no-capture-maybe-returned" [[Q]]) #[[ATTR2:[0-9]+]] ; TUNIT-NEXT: [[W:%.*]] = call align 4 ptr @incdec(i1 [[C]], ptr noalias nofree noundef nonnull writeonly align 4 dereferenceable(4) "no-capture-maybe-returned" [[Q]]) #[[ATTR2:[0-9]+]]
; TUNIT-NEXT: br label [[OK:%.*]] ; TUNIT-NEXT: br label [[OK:%.*]]
; TUNIT: OK: ; TUNIT: OK:
; TUNIT-NEXT: br label [[RET:%.*]] ; TUNIT-NEXT: br label [[RET:%.*]]
; TUNIT: LPAD: ; TUNIT: LPAD:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: RET: ; TUNIT: RET:
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@caller ; CGSCC-LABEL: define {{[^@]+}}@caller
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2:[0-9]+]] personality ptr @__gxx_personality_v0 { ; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2:[0-9]+]] personality ptr @__gxx_personality_v0 {
; CGSCC-NEXT: [[Q:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[Q:%.*]] = alloca i32, align 4
; CGSCC-NEXT: [[W:%.*]] = call align 4 ptr @incdec(i1 noundef [[C]], ptr nofree noundef nonnull align 4 dereferenceable(4) [[Q]]) #[[ATTR3:[0-9]+]] ; CGSCC-NEXT: [[W:%.*]] = call align 4 ptr @incdec(i1 noundef [[C]], ptr nofree noundef nonnull align 4 dereferenceable(4) [[Q]]) #[[ATTR3:[0-9]+]]
; CGSCC-NEXT: [[S1:%.*]] = call { i32, i32 } @foo(i32 noundef 1, i32 noundef 2) #[[ATTR4:[0-9]+]] ; CGSCC-NEXT: [[S1:%.*]] = call { i32, i32 } @foo(i32 noundef 1, i32 noundef 2) #[[ATTR4:[0-9]+]]
; CGSCC-NEXT: [[X1:%.*]] = extractvalue { i32, i32 } [[S1]], 0 ; CGSCC-NEXT: [[X1:%.*]] = extractvalue { i32, i32 } [[S1]], 0
; CGSCC-NEXT: [[S2:%.*]] = call { i32, i32 } @foo(i32 noundef 3, i32 noundef 4) #[[ATTR3]] ; CGSCC-NEXT: [[S2:%.*]] = call { i32, i32 } @foo(i32 noundef 3, i32 noundef 4) #[[ATTR3]]
; CGSCC-NEXT: br label [[OK:%.*]] ; CGSCC-NEXT: br label [[OK:%.*]]
Show All 29 LinesLPAD:
br label %RET br label %RET
RET: RET:
ret void ret void
} }
declare i32 @__gxx_personality_v0(...) declare i32 @__gxx_personality_v0(...)
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn } ; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree nosync nounwind willreturn }
; CGSCC: attributes #[[ATTR3]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR3]] = { nounwind willreturn }
; CGSCC: attributes #[[ATTR4]] = { willreturn } ; CGSCC: attributes #[[ATTR4]] = { willreturn }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/IPConstantProp/return-constant.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=5 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=5 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; FIXME: icmp folding is missing ; FIXME: icmp folding is missing
define i1 @invokecaller(i1 %C) personality ptr @__gxx_personality_v0 { define i1 @invokecaller(i1 %C) personality ptr @__gxx_personality_v0 {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@invokecaller ; TUNIT-LABEL: define {{[^@]+}}@invokecaller
; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0:[0-9]+]] personality ptr @__gxx_personality_v0 { ; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0:[0-9]+]] personality ptr @__gxx_personality_v0 {
; TUNIT-NEXT: [[X:%.*]] = call i32 @foo(i1 [[C]]) #[[ATTR1:[0-9]+]] ; TUNIT-NEXT: [[X:%.*]] = call i32 @foo(i1 [[C]]) #[[ATTR1:[0-9]+]]
; TUNIT-NEXT: br label [[OK:%.*]] ; TUNIT-NEXT: br label [[OK:%.*]]
; TUNIT: OK: ; TUNIT: OK:
; TUNIT-NEXT: ret i1 true ; TUNIT-NEXT: ret i1 true
; TUNIT: FAIL: ; TUNIT: FAIL:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@invokecaller ; CGSCC-LABEL: define {{[^@]+}}@invokecaller
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0:[0-9]+]] personality ptr @__gxx_personality_v0 { ; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0:[0-9]+]] personality ptr @__gxx_personality_v0 {
; CGSCC-NEXT: [[X:%.*]] = call i32 @foo(i1 noundef [[C]]) #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: [[X:%.*]] = call i32 @foo(i1 noundef [[C]]) #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: br label [[OK:%.*]] ; CGSCC-NEXT: br label [[OK:%.*]]
; CGSCC: OK: ; CGSCC: OK:
; CGSCC-NEXT: [[Y:%.*]] = icmp ne i32 [[X]], 0 ; CGSCC-NEXT: [[Y:%.*]] = icmp ne i32 [[X]], 0
; CGSCC-NEXT: ret i1 [[Y]] ; CGSCC-NEXT: ret i1 [[Y]]
; CGSCC: FAIL: ; CGSCC: FAIL:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
%X = invoke i32 @foo( i1 %C ) to label %OK unwind label %FAIL ; <i32> [#uses=1] %X = invoke i32 @foo( i1 %C ) to label %OK unwind label %FAIL ; <i32> [#uses=1]
OK: OK:
%Y = icmp ne i32 %X, 0 ; <i1> [#uses=1] %Y = icmp ne i32 %X, 0 ; <i1> [#uses=1]
ret i1 %Y ret i1 %Y
FAIL: FAIL:
%exn = landingpad {ptr, i32} %exn = landingpad {ptr, i32}
cleanup cleanup
ret i1 false ret i1 false
} }
define internal i32 @foo(i1 %C) { define internal i32 @foo(i1 %C) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@foo ; TUNIT-LABEL: define {{[^@]+}}@foo
; TUNIT-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: T: ; TUNIT: T:
; TUNIT-NEXT: ret i32 undef ; TUNIT-NEXT: ret i32 undef
; TUNIT: F: ; TUNIT: F:
; TUNIT-NEXT: ret i32 undef ; TUNIT-NEXT: ret i32 undef
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@foo ; CGSCC-LABEL: define {{[^@]+}}@foo
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: T: ; CGSCC: T:
; CGSCC-NEXT: ret i32 52 ; CGSCC-NEXT: ret i32 52
; CGSCC: F: ; CGSCC: F:
; CGSCC-NEXT: ret i32 52 ; CGSCC-NEXT: ret i32 52
; ;
br i1 %C, label %T, label %F br i1 %C, label %T, label %F
T: ; preds = %0 T: ; preds = %0
ret i32 52 ret i32 52
F: ; preds = %0 F: ; preds = %0
ret i32 52 ret i32 52
} }
define i1 @caller(i1 %C) { define i1 @caller(i1 %C) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@caller ; TUNIT-LABEL: define {{[^@]+}}@caller
; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: ret i1 true ; TUNIT-NEXT: ret i1 true
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@caller ; CGSCC-LABEL: define {{[^@]+}}@caller
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: [[X:%.*]] = call i32 @foo(i1 noundef [[C]]) #[[ATTR3:[0-9]+]] ; CGSCC-NEXT: [[X:%.*]] = call i32 @foo(i1 noundef [[C]]) #[[ATTR3:[0-9]+]]
; CGSCC-NEXT: [[Y:%.*]] = icmp ne i32 [[X]], 0 ; CGSCC-NEXT: [[Y:%.*]] = icmp ne i32 [[X]], 0
; CGSCC-NEXT: ret i1 [[Y]] ; CGSCC-NEXT: ret i1 [[Y]]
; ;
%X = call i32 @foo( i1 %C ) ; <i32> [#uses=1] %X = call i32 @foo( i1 %C ) ; <i32> [#uses=1]
%Y = icmp ne i32 %X, 0 ; <i1> [#uses=1] %Y = icmp ne i32 %X, 0 ; <i1> [#uses=1]
ret i1 %Y ret i1 %Y
} }
declare i32 @__gxx_personality_v0(...) declare i32 @__gxx_personality_v0(...)
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1]] = { nounwind } ; TUNIT: attributes #[[ATTR1]] = { nounwind }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn }
; CGSCC: attributes #[[ATTR3]] = { willreturn } ; CGSCC: attributes #[[ATTR3]] = { willreturn }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/IPConstantProp/return-constants.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=8 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=8 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
;; FIXME: support for extractvalue and insertvalue missing. ;; FIXME: support for extractvalue and insertvalue missing.
%0 = type { i32, i32 } %0 = type { i32, i32 }
define internal %0 @foo(i1 %Q) { define internal %0 @foo(i1 %Q) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@foo ; CHECK-LABEL: define {{[^@]+}}@foo
; CHECK-SAME: (i1 noundef [[Q:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (i1 noundef [[Q:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: br i1 [[Q]], label [[T:%.*]], label [[F:%.*]] ; CHECK-NEXT: br i1 [[Q]], label [[T:%.*]], label [[F:%.*]]
; CHECK: T: ; CHECK: T:
; CHECK-NEXT: [[MRV:%.*]] = insertvalue [[TMP0:%.*]] undef, i32 21, 0 ; CHECK-NEXT: [[MRV:%.*]] = insertvalue [[TMP0:%.*]] undef, i32 21, 0
; CHECK-NEXT: [[MRV1:%.*]] = insertvalue [[TMP0]] [[MRV]], i32 22, 1 ; CHECK-NEXT: [[MRV1:%.*]] = insertvalue [[TMP0]] [[MRV]], i32 22, 1
; CHECK-NEXT: ret [[TMP0]] [[MRV1]] ; CHECK-NEXT: ret [[TMP0]] [[MRV1]]
; CHECK: F: ; CHECK: F:
Show All 10 Lines
F: ; preds = %0 F: ; preds = %0
%mrv2 = insertvalue %0 undef, i32 21, 0 %mrv2 = insertvalue %0 undef, i32 21, 0
%mrv3 = insertvalue %0 %mrv2, i32 23, 1 %mrv3 = insertvalue %0 %mrv2, i32 23, 1
ret %0 %mrv3 ret %0 %mrv3
} }
define internal %0 @bar(i1 %Q) { define internal %0 @bar(i1 %Q) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@bar ; CHECK-LABEL: define {{[^@]+}}@bar
; CHECK-SAME: (i1 noundef [[Q:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i1 noundef [[Q:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[A:%.*]] = insertvalue [[TMP0:%.*]] undef, i32 21, 0 ; CHECK-NEXT: [[A:%.*]] = insertvalue [[TMP0:%.*]] undef, i32 21, 0
; CHECK-NEXT: br i1 [[Q]], label [[T:%.*]], label [[F:%.*]] ; CHECK-NEXT: br i1 [[Q]], label [[T:%.*]], label [[F:%.*]]
; CHECK: T: ; CHECK: T:
; CHECK-NEXT: [[B:%.*]] = insertvalue [[TMP0]] [[A]], i32 22, 1 ; CHECK-NEXT: [[B:%.*]] = insertvalue [[TMP0]] [[A]], i32 22, 1
; CHECK-NEXT: ret [[TMP0]] [[B]] ; CHECK-NEXT: ret [[TMP0]] [[B]]
; CHECK: F: ; CHECK: F:
; CHECK-NEXT: [[C:%.*]] = insertvalue [[TMP0]] [[A]], i32 23, 1 ; CHECK-NEXT: [[C:%.*]] = insertvalue [[TMP0]] [[A]], i32 23, 1
; CHECK-NEXT: ret [[TMP0]] [[C]] ; CHECK-NEXT: ret [[TMP0]] [[C]]
; ;
%A = insertvalue %0 undef, i32 21, 0 %A = insertvalue %0 undef, i32 21, 0
br i1 %Q, label %T, label %F br i1 %Q, label %T, label %F
T: ; preds = %0 T: ; preds = %0
%B = insertvalue %0 %A, i32 22, 1 %B = insertvalue %0 %A, i32 22, 1
ret %0 %B ret %0 %B
F: ; preds = %0 F: ; preds = %0
%C = insertvalue %0 %A, i32 23, 1 %C = insertvalue %0 %A, i32 23, 1
ret %0 %C ret %0 %C
} }
define %0 @caller(i1 %Q) { define %0 @caller(i1 %Q) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@caller ; TUNIT-LABEL: define {{[^@]+}}@caller
; TUNIT-SAME: (i1 [[Q:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i1 [[Q:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[X:%.*]] = call [[TMP0:%.*]] @foo(i1 [[Q]]) #[[ATTR1:[0-9]+]] ; TUNIT-NEXT: [[X:%.*]] = call [[TMP0:%.*]] @foo(i1 [[Q]]) #[[ATTR1:[0-9]+]]
; TUNIT-NEXT: ret [[TMP0]] [[X]] ; TUNIT-NEXT: ret [[TMP0]] [[X]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@caller ; CGSCC-LABEL: define {{[^@]+}}@caller
; CGSCC-SAME: (i1 noundef [[Q:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (i1 noundef [[Q:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: [[X:%.*]] = call [[TMP0:%.*]] @foo(i1 noundef [[Q]]) #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: [[X:%.*]] = call [[TMP0:%.*]] @foo(i1 noundef [[Q]]) #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: ret [[TMP0]] [[X]] ; CGSCC-NEXT: ret [[TMP0]] [[X]]
; ;
%X = call %0 @foo(i1 %Q) %X = call %0 @foo(i1 %Q)
%A = extractvalue %0 %X, 0 %A = extractvalue %0 %X, 0
%B = extractvalue %0 %X, 1 %B = extractvalue %0 %X, 1
%Y = call %0 @bar(i1 %Q) %Y = call %0 @bar(i1 %Q)
%C = extractvalue %0 %Y, 0 %C = extractvalue %0 %Y, 0
%D = extractvalue %0 %Y, 1 %D = extractvalue %0 %Y, 1
%M = add i32 %A, %C %M = add i32 %A, %C
%N = add i32 %B, %D %N = add i32 %B, %D
ret %0 %X ret %0 %X
} }
; Similar to @caller but the result of both calls are actually used. ; Similar to @caller but the result of both calls are actually used.
define i32 @caller2(i1 %Q) { define i32 @caller2(i1 %Q) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@caller2 ; TUNIT-LABEL: define {{[^@]+}}@caller2
; TUNIT-SAME: (i1 [[Q:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i1 [[Q:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[X:%.*]] = call [[TMP0:%.*]] @foo(i1 [[Q]]) #[[ATTR1]] ; TUNIT-NEXT: [[X:%.*]] = call [[TMP0:%.*]] @foo(i1 [[Q]]) #[[ATTR1]]
; TUNIT-NEXT: [[A:%.*]] = extractvalue [[TMP0]] [[X]], 0 ; TUNIT-NEXT: [[A:%.*]] = extractvalue [[TMP0]] [[X]], 0
; TUNIT-NEXT: [[B:%.*]] = extractvalue [[TMP0]] [[X]], 1 ; TUNIT-NEXT: [[B:%.*]] = extractvalue [[TMP0]] [[X]], 1
; TUNIT-NEXT: [[Y:%.*]] = call [[TMP0]] @bar(i1 [[Q]]) #[[ATTR1]] ; TUNIT-NEXT: [[Y:%.*]] = call [[TMP0]] @bar(i1 [[Q]]) #[[ATTR1]]
; TUNIT-NEXT: [[C:%.*]] = extractvalue [[TMP0]] [[Y]], 0 ; TUNIT-NEXT: [[C:%.*]] = extractvalue [[TMP0]] [[Y]], 0
; TUNIT-NEXT: [[D:%.*]] = extractvalue [[TMP0]] [[Y]], 1 ; TUNIT-NEXT: [[D:%.*]] = extractvalue [[TMP0]] [[Y]], 1
; TUNIT-NEXT: [[M:%.*]] = add i32 [[A]], [[C]] ; TUNIT-NEXT: [[M:%.*]] = add i32 [[A]], [[C]]
; TUNIT-NEXT: [[N:%.*]] = add i32 [[B]], [[D]] ; TUNIT-NEXT: [[N:%.*]] = add i32 [[B]], [[D]]
; TUNIT-NEXT: [[R:%.*]] = add i32 [[N]], [[M]] ; TUNIT-NEXT: [[R:%.*]] = add i32 [[N]], [[M]]
; TUNIT-NEXT: ret i32 [[R]] ; TUNIT-NEXT: ret i32 [[R]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@caller2 ; CGSCC-LABEL: define {{[^@]+}}@caller2
; CGSCC-SAME: (i1 noundef [[Q:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (i1 noundef [[Q:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: [[X:%.*]] = call [[TMP0:%.*]] @foo(i1 noundef [[Q]]) #[[ATTR2]] ; CGSCC-NEXT: [[X:%.*]] = call [[TMP0:%.*]] @foo(i1 noundef [[Q]]) #[[ATTR2]]
; CGSCC-NEXT: [[A:%.*]] = extractvalue [[TMP0]] [[X]], 0 ; CGSCC-NEXT: [[A:%.*]] = extractvalue [[TMP0]] [[X]], 0
; CGSCC-NEXT: [[B:%.*]] = extractvalue [[TMP0]] [[X]], 1 ; CGSCC-NEXT: [[B:%.*]] = extractvalue [[TMP0]] [[X]], 1
; CGSCC-NEXT: [[Y:%.*]] = call [[TMP0]] @bar(i1 noundef [[Q]]) #[[ATTR2]] ; CGSCC-NEXT: [[Y:%.*]] = call [[TMP0]] @bar(i1 noundef [[Q]]) #[[ATTR2]]
; CGSCC-NEXT: [[C:%.*]] = extractvalue [[TMP0]] [[Y]], 0 ; CGSCC-NEXT: [[C:%.*]] = extractvalue [[TMP0]] [[Y]], 0
; CGSCC-NEXT: [[D:%.*]] = extractvalue [[TMP0]] [[Y]], 1 ; CGSCC-NEXT: [[D:%.*]] = extractvalue [[TMP0]] [[Y]], 1
Show All 10 Lines;
%D = extractvalue %0 %Y, 1 %D = extractvalue %0 %Y, 1
%M = add i32 %A, %C %M = add i32 %A, %C
;; Check that the second return values didn't get propagated ;; Check that the second return values didn't get propagated
%N = add i32 %B, %D %N = add i32 %B, %D
%R = add i32 %N, %M %R = add i32 %N, %M
ret i32 %R ret i32 %R
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { willreturn } ; CGSCC: attributes #[[ATTR2]] = { willreturn }
;. ;.

llvm/test/Transforms/Attributor/IPConstantProp/solve-after-each-resolving-undefs-for-function.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
define internal i32 @testf(i1 %c) { define internal i32 @testf(i1 %c) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@testf ; CGSCC-LABEL: define {{[^@]+}}@testf
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: br i1 [[C]], label [[IF_COND:%.*]], label [[IF_END:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[IF_COND:%.*]], label [[IF_END:%.*]]
; CGSCC: if.cond: ; CGSCC: if.cond:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: if.then: ; CGSCC: if.then:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
Show All 9 Lines
if.then: ; preds = %entry, %if.then if.then: ; preds = %entry, %if.then
ret i32 11 ret i32 11
if.end: ; preds = %if.then1, %entry if.end: ; preds = %if.then1, %entry
ret i32 10 ret i32 10
} }
define internal i32 @test1(i1 %c) { define internal i32 @test1(i1 %c) {
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test1 ; CGSCC-LABEL: define {{[^@]+}}@test1
; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: br label [[IF_THEN:%.*]] ; CGSCC-NEXT: br label [[IF_THEN:%.*]]
; CGSCC: if.then: ; CGSCC: if.then:
; CGSCC-NEXT: [[CALL:%.*]] = call i32 @testf(i1 noundef [[C]]) #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: [[CALL:%.*]] = call i32 @testf(i1 noundef [[C]]) #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: [[RES:%.*]] = icmp eq i32 [[CALL]], 10 ; CGSCC-NEXT: [[RES:%.*]] = icmp eq i32 [[CALL]], 10
; CGSCC-NEXT: br i1 [[RES]], label [[RET1:%.*]], label [[RET2:%.*]] ; CGSCC-NEXT: br i1 [[RES]], label [[RET1:%.*]], label [[RET2:%.*]]
Show All 13 Lines
ret1: ; preds = %if.then, %entry ret1: ; preds = %if.then, %entry
ret i32 99 ret i32 99
ret2: ; preds = %if.then, %entry ret2: ; preds = %if.then, %entry
ret i32 0 ret i32 0
} }
define i32 @main(i1 %c) { define i32 @main(i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@main ; TUNIT-LABEL: define {{[^@]+}}@main
; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: ret i32 99 ; TUNIT-NEXT: ret i32 99
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@main ; CGSCC-LABEL: define {{[^@]+}}@main
; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: [[RES:%.*]] = call noundef i32 @test1(i1 [[C]]) #[[ATTR2]] ; CGSCC-NEXT: [[RES:%.*]] = call noundef i32 @test1(i1 [[C]]) #[[ATTR2]]
; CGSCC-NEXT: ret i32 [[RES]] ; CGSCC-NEXT: ret i32 [[RES]]
; ;
%res = call i32 @test1(i1 %c) %res = call i32 @test1(i1 %c)
ret i32 %res ret i32 %res
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { willreturn } ; CGSCC: attributes #[[ATTR2]] = { willreturn }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/IPConstantProp/thread_local_acs.ll

Show All 20 Lines
@gtl = dso_local thread_local global i32 0, align 4 @gtl = dso_local thread_local global i32 0, align 4
@gsh = dso_local global i32 0, align 4 @gsh = dso_local global i32 0, align 4
;. ;.
; CHECK: @[[GTL:[a-zA-Z0-9_$"\\.-]+]] = dso_local thread_local global i32 0, align 4 ; CHECK: @[[GTL:[a-zA-Z0-9_$"\\.-]+]] = dso_local thread_local global i32 0, align 4
; CHECK: @[[GSH:[a-zA-Z0-9_$"\\.-]+]] = dso_local global i32 0, align 4 ; CHECK: @[[GSH:[a-zA-Z0-9_$"\\.-]+]] = dso_local global i32 0, align 4
;. ;.
define internal i32 @callee(ptr %thread_local_ptr, ptr %shared_ptr) { define internal i32 @callee(ptr %thread_local_ptr, ptr %shared_ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
; CHECK-LABEL: define {{[^@]+}}@callee ; CHECK-LABEL: define {{[^@]+}}@callee
; CHECK-SAME: (ptr nocapture nofree nonnull readonly align 4 dereferenceable(4) [[THREAD_LOCAL_PTR:%.*]], ptr nocapture nofree nonnull readonly align 4 dereferenceable(4) [[SHARED_PTR:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readonly align 4 dereferenceable(4) [[THREAD_LOCAL_PTR:%.*]], ptr nocapture nofree nonnull readonly align 4 dereferenceable(4) [[SHARED_PTR:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP:%.*]] = load i32, ptr @gtl, align 4 ; CHECK-NEXT: [[TMP:%.*]] = load i32, ptr @gtl, align 4
; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr @gsh, align 4 ; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr @gsh, align 4
; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP]], [[TMP1]] ; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP]], [[TMP1]]
; CHECK-NEXT: ret i32 [[ADD]] ; CHECK-NEXT: ret i32 [[ADD]]
; ;
Show All 20 Linesentry:
ret void ret void
} }
declare !callback !0 dso_local void @broker(ptr, ptr, ptr) declare !callback !0 dso_local void @broker(ptr, ptr, ptr)
!1 = !{i64 1, i64 0, i64 2, i1 false} !1 = !{i64 1, i64 0, i64 2, i1 false}
!0 = !{!1} !0 = !{!1}
;. ;.
; CHECK: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(read) } ; CHECK: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(read) }
;. ;.
; CHECK: [[META0:![0-9]+]] = !{!1} ; CHECK: [[META0:![0-9]+]] = !{!1}
; CHECK: [[META1:![0-9]+]] = !{i64 1, i64 0, i64 2, i1 false} ; CHECK: [[META1:![0-9]+]] = !{i64 1, i64 0, i64 2, i1 false}
;. ;.

llvm/test/Transforms/Attributor/align.ll

Show All 11 Lines
;; ;;
;. ;.
; CHECK: @[[A1:[a-zA-Z0-9_$"\\.-]+]] = common global i8 0, align 8 ; CHECK: @[[A1:[a-zA-Z0-9_$"\\.-]+]] = common global i8 0, align 8
; CHECK: @[[A2:[a-zA-Z0-9_$"\\.-]+]] = common global i8 0, align 16 ; CHECK: @[[A2:[a-zA-Z0-9_$"\\.-]+]] = common global i8 0, align 16
; CHECK: @[[CND:[a-zA-Z0-9_$"\\.-]+]] = external global i1 ; CHECK: @[[CND:[a-zA-Z0-9_$"\\.-]+]] = external global i1
; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = global i8 0, align 32 ; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = global i8 0, align 32
;. ;.
define ptr @test1(ptr align 8 %0) #0 { define ptr @test1(ptr align 8 %0) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@test1 ; CHECK-LABEL: define {{[^@]+}}@test1
; CHECK-SAME: (ptr nofree readnone returned align 8 "no-capture-maybe-returned" [[TMP0:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr nofree readnone returned align 8 "no-capture-maybe-returned" [[TMP0:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: ret ptr [[TMP0]] ; CHECK-NEXT: ret ptr [[TMP0]]
; ;
ret i32* %0 ret i32* %0
} }
; TEST 2 ; TEST 2
define ptr @test2(ptr %0) #0 { define ptr @test2(ptr %0) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@test2 ; CHECK-LABEL: define {{[^@]+}}@test2
; CHECK-SAME: (ptr nofree readnone returned "no-capture-maybe-returned" [[TMP0:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nofree readnone returned "no-capture-maybe-returned" [[TMP0:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: ret ptr [[TMP0]] ; CHECK-NEXT: ret ptr [[TMP0]]
; ;
ret i32* %0 ret i32* %0
} }
; TEST 3 ; TEST 3
define ptr @test3(ptr align 8 %0, ptr align 4 %1, i1 %2) #0 { define ptr @test3(ptr align 8 %0, ptr align 4 %1, i1 %2) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@test3 ; CHECK-LABEL: define {{[^@]+}}@test3
; CHECK-SAME: (ptr nofree readnone align 8 "no-capture-maybe-returned" [[TMP0:%.*]], ptr nofree readnone align 4 "no-capture-maybe-returned" [[TMP1:%.*]], i1 [[TMP2:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nofree readnone align 8 "no-capture-maybe-returned" [[TMP0:%.*]], ptr nofree readnone align 4 "no-capture-maybe-returned" [[TMP1:%.*]], i1 [[TMP2:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[RET:%.*]] = select i1 [[TMP2]], ptr [[TMP0]], ptr [[TMP1]] ; CHECK-NEXT: [[RET:%.*]] = select i1 [[TMP2]], ptr [[TMP0]], ptr [[TMP1]]
; CHECK-NEXT: ret ptr [[RET]] ; CHECK-NEXT: ret ptr [[RET]]
; ;
%ret = select i1 %2, i32* %0, i32* %1 %ret = select i1 %2, i32* %0, i32* %1
ret ptr %ret ret ptr %ret
} }
; TEST 4 ; TEST 4
define ptr @test4(ptr align 32 %0, ptr align 32 %1, i1 %2) #0 { define ptr @test4(ptr align 32 %0, ptr align 32 %1, i1 %2) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@test4 ; CHECK-LABEL: define {{[^@]+}}@test4
; CHECK-SAME: (ptr nofree readnone align 32 "no-capture-maybe-returned" [[TMP0:%.*]], ptr nofree readnone align 32 "no-capture-maybe-returned" [[TMP1:%.*]], i1 [[TMP2:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nofree readnone align 32 "no-capture-maybe-returned" [[TMP0:%.*]], ptr nofree readnone align 32 "no-capture-maybe-returned" [[TMP1:%.*]], i1 [[TMP2:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[RET:%.*]] = select i1 [[TMP2]], ptr [[TMP0]], ptr [[TMP1]] ; CHECK-NEXT: [[RET:%.*]] = select i1 [[TMP2]], ptr [[TMP0]], ptr [[TMP1]]
; CHECK-NEXT: ret ptr [[RET]] ; CHECK-NEXT: ret ptr [[RET]]
; ;
%ret = select i1 %2, i32* %0, i32* %1 %ret = select i1 %2, i32* %0, i32* %1
ret ptr %ret ret ptr %ret
} }
Show All 19 Lines
; ;
%ret = tail call i32* @align8() %ret = tail call i32* @align8()
ret ptr %ret ret ptr %ret
} }
; TEST 6 ; TEST 6
; SCC ; SCC
define ptr @test6_1() #0 { define ptr @test6_1() #0 {
; TUNIT: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
; TUNIT-LABEL: define {{[^@]+}}@test6_1 ; TUNIT-LABEL: define {{[^@]+}}@test6_1
; TUNIT-SAME: () #[[ATTR1:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR1:[0-9]+]] {
; TUNIT-NEXT: ret ptr undef ; TUNIT-NEXT: ret ptr undef
; ;
; CGSCC: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@test6_1 ; CGSCC-LABEL: define {{[^@]+}}@test6_1
; CGSCC-SAME: () #[[ATTR0]] { ; CGSCC-SAME: () #[[ATTR0]] {
; CGSCC-NEXT: ret ptr undef ; CGSCC-NEXT: ret ptr undef
; ;
%ret = tail call i32* @test6_2() %ret = tail call i32* @test6_2()
ret ptr %ret ret ptr %ret
} }
define ptr @test6_2() #0 { define ptr @test6_2() #0 {
; TUNIT: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
; TUNIT-LABEL: define {{[^@]+}}@test6_2 ; TUNIT-LABEL: define {{[^@]+}}@test6_2
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret ptr undef ; TUNIT-NEXT: ret ptr undef
; ;
; CGSCC: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@test6_2 ; CGSCC-LABEL: define {{[^@]+}}@test6_2
; CGSCC-SAME: () #[[ATTR0]] { ; CGSCC-SAME: () #[[ATTR0]] {
; CGSCC-NEXT: ret ptr undef ; CGSCC-NEXT: ret ptr undef
; ;
%ret = tail call i32* @test6_1() %ret = tail call i32* @test6_1()
ret ptr %ret ret ptr %ret
} }
Show All 12 Lines
; return a?&a1: f1(&a2); ; return a?&a1: f1(&a2);
; } ; }
@a1 = common global i8 0, align 8 @a1 = common global i8 0, align 8
@a2 = common global i8 0, align 16 @a2 = common global i8 0, align 16
; Function Attrs: nounwind readnone ssp uwtable ; Function Attrs: nounwind readnone ssp uwtable
define internal ptr @f1(ptr readnone %0) local_unnamed_addr #0 { define internal ptr @f1(ptr readnone %0) local_unnamed_addr #0 {
; CGSCC: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@f1 ; CGSCC-LABEL: define {{[^@]+}}@f1
; CGSCC-SAME: () local_unnamed_addr #[[ATTR0]] { ; CGSCC-SAME: () local_unnamed_addr #[[ATTR0]] {
; CGSCC-NEXT: br label [[TMP2:%.*]] ; CGSCC-NEXT: br label [[TMP2:%.*]]
; CGSCC: 1: ; CGSCC: 1:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: 2: ; CGSCC: 2:
; CGSCC-NEXT: ret ptr @a1 ; CGSCC-NEXT: ret ptr @a1
; ;
%2 = icmp eq i8* %0, null %2 = icmp eq i8* %0, null
br i1 %2, label %3, label %5 br i1 %2, label %3, label %5
; <label>:3: ; preds = %1 ; <label>:3: ; preds = %1
%4 = tail call ptr @f2(ptr nonnull @a1) %4 = tail call ptr @f2(ptr nonnull @a1)
%l = load i8, ptr %4 %l = load i8, ptr %4
br label %5 br label %5
; <label>:5: ; preds = %1, %3 ; <label>:5: ; preds = %1, %3
%6 = phi ptr [ %4, %3 ], [ %0, %1 ] %6 = phi ptr [ %4, %3 ], [ %0, %1 ]
ret ptr %6 ret ptr %6
} }
; Function Attrs: nounwind readnone ssp uwtable ; Function Attrs: nounwind readnone ssp uwtable
define ptr @f2(ptr readnone %0) local_unnamed_addr #0 { define ptr @f2(ptr readnone %0) local_unnamed_addr #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@f2 ; CHECK-LABEL: define {{[^@]+}}@f2
; CHECK-SAME: (ptr nofree readnone [[TMP0:%.*]]) local_unnamed_addr #[[ATTR0]] { ; CHECK-SAME: (ptr nofree readnone [[TMP0:%.*]]) local_unnamed_addr #[[ATTR0]] {
; CHECK-NEXT: [[TMP2:%.*]] = icmp eq ptr [[TMP0]], null ; CHECK-NEXT: [[TMP2:%.*]] = icmp eq ptr [[TMP0]], null
; CHECK-NEXT: br i1 [[TMP2]], label [[TMP4:%.*]], label [[TMP3:%.*]] ; CHECK-NEXT: br i1 [[TMP2]], label [[TMP4:%.*]], label [[TMP3:%.*]]
; CHECK: 3: ; CHECK: 3:
; CHECK-NEXT: br label [[TMP5:%.*]] ; CHECK-NEXT: br label [[TMP5:%.*]]
; CHECK: 4: ; CHECK: 4:
; CHECK-NEXT: br label [[TMP5]] ; CHECK-NEXT: br label [[TMP5]]
Show All 15 Lines
; <label>:7: ; preds = %5, %3 ; <label>:7: ; preds = %5, %3
%8 = phi ptr [ %4, %3 ], [ %6, %5 ] %8 = phi ptr [ %4, %3 ], [ %6, %5 ]
ret ptr %8 ret ptr %8
} }
; Function Attrs: nounwind readnone ssp uwtable ; Function Attrs: nounwind readnone ssp uwtable
define internal ptr @f3(ptr readnone %0) local_unnamed_addr #0 { define internal ptr @f3(ptr readnone %0) local_unnamed_addr #0 {
; CGSCC: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@f3 ; CGSCC-LABEL: define {{[^@]+}}@f3
; CGSCC-SAME: () local_unnamed_addr #[[ATTR0]] { ; CGSCC-SAME: () local_unnamed_addr #[[ATTR0]] {
; CGSCC-NEXT: br label [[TMP2:%.*]] ; CGSCC-NEXT: br label [[TMP2:%.*]]
; CGSCC: 1: ; CGSCC: 1:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: 2: ; CGSCC: 2:
; CGSCC-NEXT: ret ptr undef ; CGSCC-NEXT: ret ptr undef
; ;
%2 = icmp eq i8* %0, null %2 = icmp eq i8* %0, null
br i1 %2, label %3, label %5 br i1 %2, label %3, label %5
; <label>:3: ; preds = %1 ; <label>:3: ; preds = %1
%4 = tail call ptr @f1(ptr nonnull @a2) %4 = tail call ptr @f1(ptr nonnull @a2)
br label %5 br label %5
; <label>:5: ; preds = %1, %3 ; <label>:5: ; preds = %1, %3
%6 = phi ptr [ %4, %3 ], [ @a1, %1 ] %6 = phi ptr [ %4, %3 ], [ @a1, %1 ]
ret ptr %6 ret ptr %6
} }
; TEST 7 ; TEST 7
; Better than IR information ; Better than IR information
define align 4 ptr @test7() #0 { define align 4 ptr @test7() #0 {
; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; TUNIT-LABEL: define {{[^@]+}}@test7 ; TUNIT-LABEL: define {{[^@]+}}@test7
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: ret ptr @a1 ; TUNIT-NEXT: ret ptr @a1
; ;
; CGSCC: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@test7 ; CGSCC-LABEL: define {{[^@]+}}@test7
; CGSCC-SAME: () #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: [[C:%.*]] = tail call noundef nonnull align 8 dereferenceable(1) ptr @f1() #[[ATTR13:[0-9]+]] ; CGSCC-NEXT: [[C:%.*]] = tail call noundef nonnull align 8 dereferenceable(1) ptr @f1() #[[ATTR14:[0-9]+]]
; CGSCC-NEXT: ret ptr [[C]] ; CGSCC-NEXT: ret ptr [[C]]
; ;
%c = tail call i8* @f1(i8* align 8 dereferenceable(1) @a1) %c = tail call i8* @f1(i8* align 8 dereferenceable(1) @a1)
ret ptr %c ret ptr %c
} }
; TEST 7b ; TEST 7b
; Function Attrs: nounwind readnone ssp uwtable ; Function Attrs: nounwind readnone ssp uwtable
define internal ptr @f1b(ptr readnone %0) local_unnamed_addr #0 { define internal ptr @f1b(ptr readnone %0) local_unnamed_addr #0 {
; CGSCC: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@f1b ; CGSCC-LABEL: define {{[^@]+}}@f1b
; CGSCC-SAME: () local_unnamed_addr #[[ATTR0]] { ; CGSCC-SAME: () local_unnamed_addr #[[ATTR0]] {
; CGSCC-NEXT: br label [[TMP2:%.*]] ; CGSCC-NEXT: br label [[TMP2:%.*]]
; CGSCC: 1: ; CGSCC: 1:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: 2: ; CGSCC: 2:
; CGSCC-NEXT: ret ptr undef ; CGSCC-NEXT: ret ptr undef
; ;
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
; <label>:7: ; preds = %5, %3 ; <label>:7: ; preds = %5, %3
%8 = phi ptr [ %4, %3 ], [ %6, %5 ] %8 = phi ptr [ %4, %3 ], [ %6, %5 ]
ret ptr %8 ret ptr %8
} }
; Function Attrs: nounwind readnone ssp uwtable ; Function Attrs: nounwind readnone ssp uwtable
define internal ptr @f3b(ptr readnone %0) local_unnamed_addr #0 { define internal ptr @f3b(ptr readnone %0) local_unnamed_addr #0 {
; ;
; CGSCC: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@f3b ; CGSCC-LABEL: define {{[^@]+}}@f3b
; CGSCC-SAME: () local_unnamed_addr #[[ATTR0]] { ; CGSCC-SAME: () local_unnamed_addr #[[ATTR0]] {
; CGSCC-NEXT: br label [[TMP2:%.*]] ; CGSCC-NEXT: br label [[TMP2:%.*]]
; CGSCC: 1: ; CGSCC: 1:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: 2: ; CGSCC: 2:
; CGSCC-NEXT: ret ptr @a1 ; CGSCC-NEXT: ret ptr @a1
; ;
%2 = icmp eq i8* %0, null %2 = icmp eq i8* %0, null
br i1 %2, label %3, label %5 br i1 %2, label %3, label %5
; <label>:3: ; preds = %1 ; <label>:3: ; preds = %1
%4 = tail call ptr @f1b(ptr nonnull @a2) %4 = tail call ptr @f1b(ptr nonnull @a2)
br label %5 br label %5
; <label>:5: ; preds = %1, %3 ; <label>:5: ; preds = %1, %3
%6 = phi ptr [ %4, %3 ], [ @a1, %1 ] %6 = phi ptr [ %4, %3 ], [ @a1, %1 ]
ret ptr %6 ret ptr %6
} }
define align 4 ptr @test7b(ptr align 32 %p) #0 { define align 4 ptr @test7b(ptr align 32 %p) #0 {
; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; TUNIT-LABEL: define {{[^@]+}}@test7b ; TUNIT-LABEL: define {{[^@]+}}@test7b
; TUNIT-SAME: (ptr nofree readnone returned align 32 "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr nofree readnone returned align 32 "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: ret ptr [[P]] ; TUNIT-NEXT: ret ptr [[P]]
; ;
; CGSCC: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@test7b ; CGSCC-LABEL: define {{[^@]+}}@test7b
; CGSCC-SAME: (ptr nofree readnone returned align 32 "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (ptr nofree readnone returned align 32 "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: ret ptr [[P]] ; CGSCC-NEXT: ret ptr [[P]]
; ;
tail call i8* @f1b(i8* align 8 dereferenceable(1) @a1) tail call i8* @f1b(i8* align 8 dereferenceable(1) @a1)
ret ptr %p ret ptr %p
} }
▲ Show 20 Lines • Show All 185 Lines • ▼ Show 20 Linesf:
br label %e br label %e
e: e:
%phi = phi ptr [%g0, %t], [%g1, %f] %phi = phi ptr [%g0, %t], [%g1, %f]
ret ptr %phi ret ptr %phi
} }
define i64 @test11(ptr %p) { define i64 @test11(ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; TUNIT-LABEL: define {{[^@]+}}@test11 ; TUNIT-LABEL: define {{[^@]+}}@test11
; TUNIT-SAME: (ptr nocapture nofree nonnull readonly align 8 dereferenceable(8) [[P:%.*]]) #[[ATTR4:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree nonnull readonly align 8 dereferenceable(8) [[P:%.*]]) #[[ATTR4:[0-9]+]] {
; TUNIT-NEXT: [[RET:%.*]] = load i64, ptr [[P]], align 8 ; TUNIT-NEXT: [[RET:%.*]] = load i64, ptr [[P]], align 8
; TUNIT-NEXT: ret i64 [[RET]] ; TUNIT-NEXT: ret i64 [[RET]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@test11 ; CGSCC-LABEL: define {{[^@]+}}@test11
; CGSCC-SAME: (ptr nocapture nofree nonnull readonly align 8 dereferenceable(8) [[P:%.*]]) #[[ATTR5:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree nonnull readonly align 8 dereferenceable(8) [[P:%.*]]) #[[ATTR5:[0-9]+]] {
; CGSCC-NEXT: [[RET:%.*]] = load i64, ptr [[P]], align 8 ; CGSCC-NEXT: [[RET:%.*]] = load i64, ptr [[P]], align 8
; CGSCC-NEXT: ret i64 [[RET]] ; CGSCC-NEXT: ret i64 [[RET]]
; ;
%p-cast = bitcast i32* %p to i64* %p-cast = bitcast i32* %p to i64*
%ret = load i64, ptr %p-cast, align 8 %ret = load i64, ptr %p-cast, align 8
ret i64 %ret ret i64 %ret
} }
; TEST 12 ; TEST 12
; Test for deduction using must-be-executed-context and GEP instruction ; Test for deduction using must-be-executed-context and GEP instruction
; FXIME: %p should have nonnull ; FXIME: %p should have nonnull
define i64 @test12-1(ptr align 4 %p) { define i64 @test12-1(ptr align 4 %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; TUNIT-LABEL: define {{[^@]+}}@test12-1 ; TUNIT-LABEL: define {{[^@]+}}@test12-1
; TUNIT-SAME: (ptr nocapture nofree readonly align 16 [[P:%.*]]) #[[ATTR4]] { ; TUNIT-SAME: (ptr nocapture nofree readonly align 16 [[P:%.*]]) #[[ATTR4]] {
; TUNIT-NEXT: [[ARRAYIDX0:%.*]] = getelementptr i64, ptr [[P]], i64 1 ; TUNIT-NEXT: [[ARRAYIDX0:%.*]] = getelementptr i64, ptr [[P]], i64 1
; TUNIT-NEXT: [[ARRAYIDX1:%.*]] = getelementptr i64, ptr [[ARRAYIDX0]], i64 3 ; TUNIT-NEXT: [[ARRAYIDX1:%.*]] = getelementptr i64, ptr [[ARRAYIDX0]], i64 3
; TUNIT-NEXT: [[RET:%.*]] = load i64, ptr [[ARRAYIDX1]], align 16 ; TUNIT-NEXT: [[RET:%.*]] = load i64, ptr [[ARRAYIDX1]], align 16
; TUNIT-NEXT: ret i64 [[RET]] ; TUNIT-NEXT: ret i64 [[RET]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@test12-1 ; CGSCC-LABEL: define {{[^@]+}}@test12-1
; CGSCC-SAME: (ptr nocapture nofree readonly align 16 [[P:%.*]]) #[[ATTR5]] { ; CGSCC-SAME: (ptr nocapture nofree readonly align 16 [[P:%.*]]) #[[ATTR5]] {
; CGSCC-NEXT: [[ARRAYIDX0:%.*]] = getelementptr i64, ptr [[P]], i64 1 ; CGSCC-NEXT: [[ARRAYIDX0:%.*]] = getelementptr i64, ptr [[P]], i64 1
; CGSCC-NEXT: [[ARRAYIDX1:%.*]] = getelementptr i64, ptr [[ARRAYIDX0]], i64 3 ; CGSCC-NEXT: [[ARRAYIDX1:%.*]] = getelementptr i64, ptr [[ARRAYIDX0]], i64 3
; CGSCC-NEXT: [[RET:%.*]] = load i64, ptr [[ARRAYIDX1]], align 16 ; CGSCC-NEXT: [[RET:%.*]] = load i64, ptr [[ARRAYIDX1]], align 16
; CGSCC-NEXT: ret i64 [[RET]] ; CGSCC-NEXT: ret i64 [[RET]]
; ;
%p-cast = bitcast i32* %p to i64* %p-cast = bitcast i32* %p to i64*
%arrayidx0 = getelementptr i64, ptr %p-cast, i64 1 %arrayidx0 = getelementptr i64, ptr %p-cast, i64 1
%arrayidx1 = getelementptr i64, ptr %arrayidx0, i64 3 %arrayidx1 = getelementptr i64, ptr %arrayidx0, i64 3
%ret = load i64, ptr %arrayidx1, align 16 %ret = load i64, ptr %arrayidx1, align 16
ret i64 %ret ret i64 %ret
} }
define i64 @test12-2(ptr align 4 %p) { define i64 @test12-2(ptr align 4 %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; TUNIT-LABEL: define {{[^@]+}}@test12-2 ; TUNIT-LABEL: define {{[^@]+}}@test12-2
; TUNIT-SAME: (ptr nocapture nofree nonnull readonly align 16 dereferenceable(8) [[P:%.*]]) #[[ATTR4]] { ; TUNIT-SAME: (ptr nocapture nofree nonnull readonly align 16 dereferenceable(8) [[P:%.*]]) #[[ATTR4]] {
; TUNIT-NEXT: [[RET:%.*]] = load i64, ptr [[P]], align 16 ; TUNIT-NEXT: [[RET:%.*]] = load i64, ptr [[P]], align 16
; TUNIT-NEXT: ret i64 [[RET]] ; TUNIT-NEXT: ret i64 [[RET]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@test12-2 ; CGSCC-LABEL: define {{[^@]+}}@test12-2
; CGSCC-SAME: (ptr nocapture nofree nonnull readonly align 16 dereferenceable(8) [[P:%.*]]) #[[ATTR5]] { ; CGSCC-SAME: (ptr nocapture nofree nonnull readonly align 16 dereferenceable(8) [[P:%.*]]) #[[ATTR5]] {
; CGSCC-NEXT: [[RET:%.*]] = load i64, ptr [[P]], align 16 ; CGSCC-NEXT: [[RET:%.*]] = load i64, ptr [[P]], align 16
; CGSCC-NEXT: ret i64 [[RET]] ; CGSCC-NEXT: ret i64 [[RET]]
; ;
%p-cast = bitcast i32* %p to i64* %p-cast = bitcast i32* %p to i64*
%ret = load i64, ptr %p-cast, align 16 %ret = load i64, ptr %p-cast, align 16
ret i64 %ret ret i64 %ret
} }
; FXIME: %p should have nonnull ; FXIME: %p should have nonnull
define void @test12-3(ptr align 4 %p) { define void @test12-3(ptr align 4 %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@test12-3 ; TUNIT-LABEL: define {{[^@]+}}@test12-3
; TUNIT-SAME: (ptr nocapture nofree writeonly align 16 [[P:%.*]]) #[[ATTR5:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree writeonly align 16 [[P:%.*]]) #[[ATTR5:[0-9]+]] {
; TUNIT-NEXT: [[ARRAYIDX0:%.*]] = getelementptr i64, ptr [[P]], i64 1 ; TUNIT-NEXT: [[ARRAYIDX0:%.*]] = getelementptr i64, ptr [[P]], i64 1
; TUNIT-NEXT: [[ARRAYIDX1:%.*]] = getelementptr i64, ptr [[ARRAYIDX0]], i64 3 ; TUNIT-NEXT: [[ARRAYIDX1:%.*]] = getelementptr i64, ptr [[ARRAYIDX0]], i64 3
; TUNIT-NEXT: store i64 0, ptr [[ARRAYIDX1]], align 16 ; TUNIT-NEXT: store i64 0, ptr [[ARRAYIDX1]], align 16
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@test12-3 ; CGSCC-LABEL: define {{[^@]+}}@test12-3
; CGSCC-SAME: (ptr nocapture nofree writeonly align 16 [[P:%.*]]) #[[ATTR6:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree writeonly align 16 [[P:%.*]]) #[[ATTR6:[0-9]+]] {
; CGSCC-NEXT: [[ARRAYIDX0:%.*]] = getelementptr i64, ptr [[P]], i64 1 ; CGSCC-NEXT: [[ARRAYIDX0:%.*]] = getelementptr i64, ptr [[P]], i64 1
; CGSCC-NEXT: [[ARRAYIDX1:%.*]] = getelementptr i64, ptr [[ARRAYIDX0]], i64 3 ; CGSCC-NEXT: [[ARRAYIDX1:%.*]] = getelementptr i64, ptr [[ARRAYIDX0]], i64 3
; CGSCC-NEXT: store i64 0, ptr [[ARRAYIDX1]], align 16 ; CGSCC-NEXT: store i64 0, ptr [[ARRAYIDX1]], align 16
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%p-cast = bitcast i32* %p to i64* %p-cast = bitcast i32* %p to i64*
%arrayidx0 = getelementptr i64, ptr %p-cast, i64 1 %arrayidx0 = getelementptr i64, ptr %p-cast, i64 1
%arrayidx1 = getelementptr i64, ptr %arrayidx0, i64 3 %arrayidx1 = getelementptr i64, ptr %arrayidx0, i64 3
store i64 0, ptr %arrayidx1, align 16 store i64 0, ptr %arrayidx1, align 16
ret void ret void
} }
define void @test12-4(ptr align 4 %p) { define void @test12-4(ptr align 4 %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@test12-4 ; TUNIT-LABEL: define {{[^@]+}}@test12-4
; TUNIT-SAME: (ptr nocapture nofree nonnull writeonly align 16 dereferenceable(8) [[P:%.*]]) #[[ATTR5]] { ; TUNIT-SAME: (ptr nocapture nofree nonnull writeonly align 16 dereferenceable(8) [[P:%.*]]) #[[ATTR5]] {
; TUNIT-NEXT: store i64 0, ptr [[P]], align 16 ; TUNIT-NEXT: store i64 0, ptr [[P]], align 16
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@test12-4 ; CGSCC-LABEL: define {{[^@]+}}@test12-4
; CGSCC-SAME: (ptr nocapture nofree nonnull writeonly align 16 dereferenceable(8) [[P:%.*]]) #[[ATTR6]] { ; CGSCC-SAME: (ptr nocapture nofree nonnull writeonly align 16 dereferenceable(8) [[P:%.*]]) #[[ATTR6]] {
; CGSCC-NEXT: store i64 0, ptr [[P]], align 16 ; CGSCC-NEXT: store i64 0, ptr [[P]], align 16
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%p-cast = bitcast i32* %p to i64* %p-cast = bitcast i32* %p to i64*
store i64 0, ptr %p-cast, align 16 store i64 0, ptr %p-cast, align 16
ret void ret void
} }
declare void @use(ptr) willreturn nounwind declare void @use(ptr) willreturn nounwind
define void @test12-5(ptr align 4 %p) { define void @test12-5(ptr align 4 %p) {
; TUNIT: Function Attrs: nounwind willreturn ; TUNIT: Function Attrs: mustprogress nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@test12-5 ; TUNIT-LABEL: define {{[^@]+}}@test12-5
; TUNIT-SAME: (ptr align 16 [[P:%.*]]) #[[ATTR6:[0-9]+]] { ; TUNIT-SAME: (ptr align 16 [[P:%.*]]) #[[ATTR7:[0-9]+]] {
; TUNIT-NEXT: [[ARRAYIDX0:%.*]] = getelementptr i64, ptr [[P]], i64 1 ; TUNIT-NEXT: [[ARRAYIDX0:%.*]] = getelementptr i64, ptr [[P]], i64 1
; TUNIT-NEXT: [[ARRAYIDX1:%.*]] = getelementptr i64, ptr [[ARRAYIDX0]], i64 3 ; TUNIT-NEXT: [[ARRAYIDX1:%.*]] = getelementptr i64, ptr [[ARRAYIDX0]], i64 3
; TUNIT-NEXT: tail call void @use(ptr align 16 [[ARRAYIDX1]]) #[[ATTR6]] ; TUNIT-NEXT: tail call void @use(ptr align 16 [[ARRAYIDX1]]) #[[ATTR6:[0-9]+]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nounwind willreturn ; CGSCC: Function Attrs: mustprogress nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@test12-5 ; CGSCC-LABEL: define {{[^@]+}}@test12-5
; CGSCC-SAME: (ptr align 16 [[P:%.*]]) #[[ATTR7:[0-9]+]] { ; CGSCC-SAME: (ptr align 16 [[P:%.*]]) #[[ATTR8:[0-9]+]] {
; CGSCC-NEXT: [[ARRAYIDX0:%.*]] = getelementptr i64, ptr [[P]], i64 1 ; CGSCC-NEXT: [[ARRAYIDX0:%.*]] = getelementptr i64, ptr [[P]], i64 1
; CGSCC-NEXT: [[ARRAYIDX1:%.*]] = getelementptr i64, ptr [[ARRAYIDX0]], i64 3 ; CGSCC-NEXT: [[ARRAYIDX1:%.*]] = getelementptr i64, ptr [[ARRAYIDX0]], i64 3
; CGSCC-NEXT: tail call void @use(ptr align 16 [[ARRAYIDX1]]) #[[ATTR7]] ; CGSCC-NEXT: tail call void @use(ptr align 16 [[ARRAYIDX1]]) #[[ATTR7:[0-9]+]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%p-cast = bitcast i32* %p to i64* %p-cast = bitcast i32* %p to i64*
%arrayidx0 = getelementptr i64, ptr %p-cast, i64 1 %arrayidx0 = getelementptr i64, ptr %p-cast, i64 1
%arrayidx1 = getelementptr i64, ptr %arrayidx0, i64 3 %arrayidx1 = getelementptr i64, ptr %arrayidx0, i64 3
tail call void @use(ptr align 16 %arrayidx1) tail call void @use(ptr align 16 %arrayidx1)
ret void ret void
} }
define void @test12-6(ptr align 4 %p) { define void @test12-6(ptr align 4 %p) {
; TUNIT: Function Attrs: nounwind willreturn ; TUNIT: Function Attrs: mustprogress nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@test12-6 ; TUNIT-LABEL: define {{[^@]+}}@test12-6
; TUNIT-SAME: (ptr align 16 [[P:%.*]]) #[[ATTR6]] { ; TUNIT-SAME: (ptr align 16 [[P:%.*]]) #[[ATTR7]] {
; TUNIT-NEXT: tail call void @use(ptr align 16 [[P]]) #[[ATTR6]] ; TUNIT-NEXT: tail call void @use(ptr align 16 [[P]]) #[[ATTR6]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nounwind willreturn ; CGSCC: Function Attrs: mustprogress nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@test12-6 ; CGSCC-LABEL: define {{[^@]+}}@test12-6
; CGSCC-SAME: (ptr align 16 [[P:%.*]]) #[[ATTR7]] { ; CGSCC-SAME: (ptr align 16 [[P:%.*]]) #[[ATTR8]] {
; CGSCC-NEXT: tail call void @use(ptr align 16 [[P]]) #[[ATTR7]] ; CGSCC-NEXT: tail call void @use(ptr align 16 [[P]]) #[[ATTR7]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%p-cast = bitcast i32* %p to i64* %p-cast = bitcast i32* %p to i64*
tail call void @use(ptr align 16 %p-cast) tail call void @use(ptr align 16 %p-cast)
ret void ret void
} }
define void @test13(i1 %c, ptr align 32 %dst) #0 { define void @test13(i1 %c, ptr align 32 %dst) #0 {
; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable
; TUNIT-LABEL: define {{[^@]+}}@test13 ; TUNIT-LABEL: define {{[^@]+}}@test13
; TUNIT-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR7:[0-9]+]] { ; TUNIT-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR8:[0-9]+]] {
; TUNIT-NEXT: br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]] ; TUNIT-NEXT: br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
; TUNIT: truebb: ; TUNIT: truebb:
; TUNIT-NEXT: br label [[END:%.*]] ; TUNIT-NEXT: br label [[END:%.*]]
; TUNIT: falsebb: ; TUNIT: falsebb:
; TUNIT-NEXT: br label [[END]] ; TUNIT-NEXT: br label [[END]]
; TUNIT: end: ; TUNIT: end:
; TUNIT-NEXT: [[PTR:%.*]] = phi ptr [ [[DST]], [[TRUEBB]] ], [ null, [[FALSEBB]] ] ; TUNIT-NEXT: [[PTR:%.*]] = phi ptr [ [[DST]], [[TRUEBB]] ], [ null, [[FALSEBB]] ]
; TUNIT-NEXT: store i32 0, ptr [[PTR]], align 32 ; TUNIT-NEXT: store i32 0, ptr [[PTR]], align 32
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable
; CGSCC-LABEL: define {{[^@]+}}@test13 ; CGSCC-LABEL: define {{[^@]+}}@test13
; CGSCC-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR8:[0-9]+]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR9:[0-9]+]] {
; CGSCC-NEXT: br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
; CGSCC: truebb: ; CGSCC: truebb:
; CGSCC-NEXT: br label [[END:%.*]] ; CGSCC-NEXT: br label [[END:%.*]]
; CGSCC: falsebb: ; CGSCC: falsebb:
; CGSCC-NEXT: br label [[END]] ; CGSCC-NEXT: br label [[END]]
; CGSCC: end: ; CGSCC: end:
; CGSCC-NEXT: [[PTR:%.*]] = phi ptr [ [[DST]], [[TRUEBB]] ], [ null, [[FALSEBB]] ] ; CGSCC-NEXT: [[PTR:%.*]] = phi ptr [ [[DST]], [[TRUEBB]] ], [ null, [[FALSEBB]] ]
; CGSCC-NEXT: store i32 0, ptr [[PTR]], align 32 ; CGSCC-NEXT: store i32 0, ptr [[PTR]], align 32
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
br i1 %c, label %truebb, label %falsebb br i1 %c, label %truebb, label %falsebb
truebb: truebb:
br label %end br label %end
falsebb: falsebb:
br label %end br label %end
end: end:
%ptr = phi ptr [ %dst, %truebb ], [ null, %falsebb ] %ptr = phi ptr [ %dst, %truebb ], [ null, %falsebb ]
store i32 0, ptr %ptr store i32 0, ptr %ptr
ret void ret void
} }
define void @test13-1(i1 %c, ptr align 32 %dst) { define void @test13-1(i1 %c, ptr align 32 %dst) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@test13-1 ; TUNIT-LABEL: define {{[^@]+}}@test13-1
; TUNIT-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR8:[0-9]+]] { ; TUNIT-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR9:[0-9]+]] {
; TUNIT-NEXT: br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]] ; TUNIT-NEXT: br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
; TUNIT: truebb: ; TUNIT: truebb:
; TUNIT-NEXT: br label [[END:%.*]] ; TUNIT-NEXT: br label [[END:%.*]]
; TUNIT: falsebb: ; TUNIT: falsebb:
; TUNIT-NEXT: br label [[END]] ; TUNIT-NEXT: br label [[END]]
; TUNIT: end: ; TUNIT: end:
; TUNIT-NEXT: [[PTR:%.*]] = phi ptr [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 48 to ptr), [[FALSEBB]] ] ; TUNIT-NEXT: [[PTR:%.*]] = phi ptr [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 48 to ptr), [[FALSEBB]] ]
; TUNIT-NEXT: store i32 0, ptr [[PTR]], align 16 ; TUNIT-NEXT: store i32 0, ptr [[PTR]], align 16
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@test13-1 ; CGSCC-LABEL: define {{[^@]+}}@test13-1
; CGSCC-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR9:[0-9]+]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR10:[0-9]+]] {
; CGSCC-NEXT: br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
; CGSCC: truebb: ; CGSCC: truebb:
; CGSCC-NEXT: br label [[END:%.*]] ; CGSCC-NEXT: br label [[END:%.*]]
; CGSCC: falsebb: ; CGSCC: falsebb:
; CGSCC-NEXT: br label [[END]] ; CGSCC-NEXT: br label [[END]]
; CGSCC: end: ; CGSCC: end:
; CGSCC-NEXT: [[PTR:%.*]] = phi ptr [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 48 to ptr), [[FALSEBB]] ] ; CGSCC-NEXT: [[PTR:%.*]] = phi ptr [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 48 to ptr), [[FALSEBB]] ]
; CGSCC-NEXT: store i32 0, ptr [[PTR]], align 16 ; CGSCC-NEXT: store i32 0, ptr [[PTR]], align 16
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
br i1 %c, label %truebb, label %falsebb br i1 %c, label %truebb, label %falsebb
truebb: truebb:
br label %end br label %end
falsebb: falsebb:
br label %end br label %end
end: end:
%ptr = phi ptr [ %dst, %truebb ], [ inttoptr (i64 48 to ptr), %falsebb ] %ptr = phi ptr [ %dst, %truebb ], [ inttoptr (i64 48 to ptr), %falsebb ]
store i32 0, ptr %ptr store i32 0, ptr %ptr
ret void ret void
} }
define void @test13-2(i1 %c, ptr align 32 %dst) { define void @test13-2(i1 %c, ptr align 32 %dst) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@test13-2 ; TUNIT-LABEL: define {{[^@]+}}@test13-2
; TUNIT-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR8]] { ; TUNIT-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR9]] {
; TUNIT-NEXT: br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]] ; TUNIT-NEXT: br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
; TUNIT: truebb: ; TUNIT: truebb:
; TUNIT-NEXT: br label [[END:%.*]] ; TUNIT-NEXT: br label [[END:%.*]]
; TUNIT: falsebb: ; TUNIT: falsebb:
; TUNIT-NEXT: br label [[END]] ; TUNIT-NEXT: br label [[END]]
; TUNIT: end: ; TUNIT: end:
; TUNIT-NEXT: [[PTR:%.*]] = phi ptr [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 160 to ptr), [[FALSEBB]] ] ; TUNIT-NEXT: [[PTR:%.*]] = phi ptr [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 160 to ptr), [[FALSEBB]] ]
; TUNIT-NEXT: store i32 0, ptr [[PTR]], align 32 ; TUNIT-NEXT: store i32 0, ptr [[PTR]], align 32
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@test13-2 ; CGSCC-LABEL: define {{[^@]+}}@test13-2
; CGSCC-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR9]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR10]] {
; CGSCC-NEXT: br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
; CGSCC: truebb: ; CGSCC: truebb:
; CGSCC-NEXT: br label [[END:%.*]] ; CGSCC-NEXT: br label [[END:%.*]]
; CGSCC: falsebb: ; CGSCC: falsebb:
; CGSCC-NEXT: br label [[END]] ; CGSCC-NEXT: br label [[END]]
; CGSCC: end: ; CGSCC: end:
; CGSCC-NEXT: [[PTR:%.*]] = phi ptr [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 160 to ptr), [[FALSEBB]] ] ; CGSCC-NEXT: [[PTR:%.*]] = phi ptr [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 160 to ptr), [[FALSEBB]] ]
; CGSCC-NEXT: store i32 0, ptr [[PTR]], align 32 ; CGSCC-NEXT: store i32 0, ptr [[PTR]], align 32
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
br i1 %c, label %truebb, label %falsebb br i1 %c, label %truebb, label %falsebb
truebb: truebb:
br label %end br label %end
falsebb: falsebb:
br label %end br label %end
end: end:
%ptr = phi ptr [ %dst, %truebb ], [ inttoptr (i64 160 to ptr), %falsebb ] %ptr = phi ptr [ %dst, %truebb ], [ inttoptr (i64 160 to ptr), %falsebb ]
store i32 0, ptr %ptr store i32 0, ptr %ptr
ret void ret void
} }
define void @test13-3(i1 %c, ptr align 32 %dst) { define void @test13-3(i1 %c, ptr align 32 %dst) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@test13-3 ; TUNIT-LABEL: define {{[^@]+}}@test13-3
; TUNIT-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR8]] { ; TUNIT-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR9]] {
; TUNIT-NEXT: br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]] ; TUNIT-NEXT: br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
; TUNIT: truebb: ; TUNIT: truebb:
; TUNIT-NEXT: br label [[END:%.*]] ; TUNIT-NEXT: br label [[END:%.*]]
; TUNIT: falsebb: ; TUNIT: falsebb:
; TUNIT-NEXT: br label [[END]] ; TUNIT-NEXT: br label [[END]]
; TUNIT: end: ; TUNIT: end:
; TUNIT-NEXT: [[PTR:%.*]] = phi ptr [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 128 to ptr), [[FALSEBB]] ] ; TUNIT-NEXT: [[PTR:%.*]] = phi ptr [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 128 to ptr), [[FALSEBB]] ]
; TUNIT-NEXT: store i32 0, ptr [[PTR]], align 32 ; TUNIT-NEXT: store i32 0, ptr [[PTR]], align 32
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@test13-3 ; CGSCC-LABEL: define {{[^@]+}}@test13-3
; CGSCC-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR9]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]], ptr nocapture nofree writeonly align 32 [[DST:%.*]]) #[[ATTR10]] {
; CGSCC-NEXT: br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[TRUEBB:%.*]], label [[FALSEBB:%.*]]
; CGSCC: truebb: ; CGSCC: truebb:
; CGSCC-NEXT: br label [[END:%.*]] ; CGSCC-NEXT: br label [[END:%.*]]
; CGSCC: falsebb: ; CGSCC: falsebb:
; CGSCC-NEXT: br label [[END]] ; CGSCC-NEXT: br label [[END]]
; CGSCC: end: ; CGSCC: end:
; CGSCC-NEXT: [[PTR:%.*]] = phi ptr [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 128 to ptr), [[FALSEBB]] ] ; CGSCC-NEXT: [[PTR:%.*]] = phi ptr [ [[DST]], [[TRUEBB]] ], [ inttoptr (i64 128 to ptr), [[FALSEBB]] ]
; CGSCC-NEXT: store i32 0, ptr [[PTR]], align 32 ; CGSCC-NEXT: store i32 0, ptr [[PTR]], align 32
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
br i1 %c, label %truebb, label %falsebb br i1 %c, label %truebb, label %falsebb
truebb: truebb:
br label %end br label %end
falsebb: falsebb:
br label %end br label %end
end: end:
%ptr = phi ptr [ %dst, %truebb ], [ inttoptr (i64 128 to ptr), %falsebb ] %ptr = phi ptr [ %dst, %truebb ], [ inttoptr (i64 128 to ptr), %falsebb ]
store i32 0, ptr %ptr store i32 0, ptr %ptr
ret void ret void
} }
; Don't crash on ptr2int/int2ptr uses. ; Don't crash on ptr2int/int2ptr uses.
define i64 @ptr2int(ptr %p) { define i64 @ptr2int(ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@ptr2int ; TUNIT-LABEL: define {{[^@]+}}@ptr2int
; TUNIT-SAME: (ptr nofree readnone [[P:%.*]]) #[[ATTR9:[0-9]+]] { ; TUNIT-SAME: (ptr nofree readnone [[P:%.*]]) #[[ATTR10:[0-9]+]] {
; TUNIT-NEXT: [[P2I:%.*]] = ptrtoint ptr [[P]] to i64 ; TUNIT-NEXT: [[P2I:%.*]] = ptrtoint ptr [[P]] to i64
; TUNIT-NEXT: ret i64 [[P2I]] ; TUNIT-NEXT: ret i64 [[P2I]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@ptr2int ; CGSCC-LABEL: define {{[^@]+}}@ptr2int
; CGSCC-SAME: (ptr nofree readnone [[P:%.*]]) #[[ATTR10:[0-9]+]] { ; CGSCC-SAME: (ptr nofree readnone [[P:%.*]]) #[[ATTR11:[0-9]+]] {
; CGSCC-NEXT: [[P2I:%.*]] = ptrtoint ptr [[P]] to i64 ; CGSCC-NEXT: [[P2I:%.*]] = ptrtoint ptr [[P]] to i64
; CGSCC-NEXT: ret i64 [[P2I]] ; CGSCC-NEXT: ret i64 [[P2I]]
; ;
%p2i = ptrtoint i32* %p to i64 %p2i = ptrtoint i32* %p to i64
ret i64 %p2i ret i64 %p2i
} }
define ptr @int2ptr(i64 %i) { define ptr @int2ptr(i64 %i) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@int2ptr ; TUNIT-LABEL: define {{[^@]+}}@int2ptr
; TUNIT-SAME: (i64 [[I:%.*]]) #[[ATTR9]] { ; TUNIT-SAME: (i64 [[I:%.*]]) #[[ATTR10]] {
; TUNIT-NEXT: [[I2P:%.*]] = inttoptr i64 [[I]] to ptr ; TUNIT-NEXT: [[I2P:%.*]] = inttoptr i64 [[I]] to ptr
; TUNIT-NEXT: ret ptr [[I2P]] ; TUNIT-NEXT: ret ptr [[I2P]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@int2ptr ; CGSCC-LABEL: define {{[^@]+}}@int2ptr
; CGSCC-SAME: (i64 [[I:%.*]]) #[[ATTR10]] { ; CGSCC-SAME: (i64 [[I:%.*]]) #[[ATTR11]] {
; CGSCC-NEXT: [[I2P:%.*]] = inttoptr i64 [[I]] to ptr ; CGSCC-NEXT: [[I2P:%.*]] = inttoptr i64 [[I]] to ptr
; CGSCC-NEXT: ret ptr [[I2P]] ; CGSCC-NEXT: ret ptr [[I2P]]
; ;
%i2p = inttoptr i64 %i to i64* %i2p = inttoptr i64 %i to i64*
ret ptr %i2p ret ptr %i2p
} }
; Use the store alignment only for the pointer operand. ; Use the store alignment only for the pointer operand.
define void @aligned_store(ptr %Value, ptr %Ptr) { define void @aligned_store(ptr %Value, ptr %Ptr) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@aligned_store ; TUNIT-LABEL: define {{[^@]+}}@aligned_store
; TUNIT-SAME: (ptr nofree writeonly [[VALUE:%.*]], ptr nocapture nofree noundef nonnull writeonly align 32 dereferenceable(8) [[PTR:%.*]]) #[[ATTR5]] { ; TUNIT-SAME: (ptr nofree writeonly [[VALUE:%.*]], ptr nocapture nofree noundef nonnull writeonly align 32 dereferenceable(8) [[PTR:%.*]]) #[[ATTR5]] {
; TUNIT-NEXT: store ptr [[VALUE]], ptr [[PTR]], align 32 ; TUNIT-NEXT: store ptr [[VALUE]], ptr [[PTR]], align 32
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@aligned_store ; CGSCC-LABEL: define {{[^@]+}}@aligned_store
; CGSCC-SAME: (ptr nofree writeonly [[VALUE:%.*]], ptr nocapture nofree noundef nonnull writeonly align 32 dereferenceable(8) [[PTR:%.*]]) #[[ATTR6]] { ; CGSCC-SAME: (ptr nofree writeonly [[VALUE:%.*]], ptr nocapture nofree noundef nonnull writeonly align 32 dereferenceable(8) [[PTR:%.*]]) #[[ATTR6]] {
; CGSCC-NEXT: store ptr [[VALUE]], ptr [[PTR]], align 32 ; CGSCC-NEXT: store ptr [[VALUE]], ptr [[PTR]], align 32
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
store i8* %Value, i8** %Ptr, align 32 store i8* %Value, i8** %Ptr, align 32
ret void ret void
} }
declare ptr @some_func(ptr) declare ptr @some_func(ptr)
define void @align_call_op_not_store(ptr align 2048 %arg) { define void @align_call_op_not_store(ptr align 2048 %arg) {
; CHECK-LABEL: define {{[^@]+}}@align_call_op_not_store ; CHECK-LABEL: define {{[^@]+}}@align_call_op_not_store
; CHECK-SAME: (ptr align 2048 [[ARG:%.*]]) { ; CHECK-SAME: (ptr align 2048 [[ARG:%.*]]) {
; CHECK-NEXT: [[UNKNOWN:%.*]] = call ptr @some_func(ptr align 2048 [[ARG]]) ; CHECK-NEXT: [[UNKNOWN:%.*]] = call ptr @some_func(ptr align 2048 [[ARG]])
; CHECK-NEXT: store i8 0, ptr [[UNKNOWN]], align 1 ; CHECK-NEXT: store i8 0, ptr [[UNKNOWN]], align 1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%unknown = call i8* @some_func(i8* %arg) %unknown = call i8* @some_func(i8* %arg)
store i8 0, ptr %unknown store i8 0, ptr %unknown
ret void ret void
} }
define void @align_store_after_bc(ptr align 2048 %arg) { define void @align_store_after_bc(ptr align 2048 %arg) {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@align_store_after_bc ; TUNIT-LABEL: define {{[^@]+}}@align_store_after_bc
; TUNIT-SAME: (ptr nocapture nofree nonnull writeonly align 2048 dereferenceable(1) [[ARG:%.*]]) #[[ATTR5]] { ; TUNIT-SAME: (ptr nocapture nofree nonnull writeonly align 2048 dereferenceable(1) [[ARG:%.*]]) #[[ATTR5]] {
; TUNIT-NEXT: store i8 0, ptr [[ARG]], align 2048 ; TUNIT-NEXT: store i8 0, ptr [[ARG]], align 2048
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@align_store_after_bc ; CGSCC-LABEL: define {{[^@]+}}@align_store_after_bc
; CGSCC-SAME: (ptr nocapture nofree nonnull writeonly align 2048 dereferenceable(1) [[ARG:%.*]]) #[[ATTR6]] { ; CGSCC-SAME: (ptr nocapture nofree nonnull writeonly align 2048 dereferenceable(1) [[ARG:%.*]]) #[[ATTR6]] {
; CGSCC-NEXT: store i8 0, ptr [[ARG]], align 2048 ; CGSCC-NEXT: store i8 0, ptr [[ARG]], align 2048
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%bc = bitcast i32* %arg to i8* %bc = bitcast i32* %arg to i8*
store i8 0, ptr %bc store i8 0, ptr %bc
ret void ret void
} }
; Make sure we do not annotate the callee of a must-tail call with an alignment ; Make sure we do not annotate the callee of a must-tail call with an alignment
; we cannot also put on the caller. ; we cannot also put on the caller.
@cnd = external global i1 @cnd = external global i1
define i32 @musttail_callee_1(ptr %p) { define i32 @musttail_callee_1(ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; TUNIT-LABEL: define {{[^@]+}}@musttail_callee_1 ; TUNIT-LABEL: define {{[^@]+}}@musttail_callee_1
; TUNIT-SAME: (ptr nocapture nofree noundef nonnull readonly dereferenceable(4) [[P:%.*]]) #[[ATTR4]] { ; TUNIT-SAME: (ptr nocapture nofree noundef nonnull readonly dereferenceable(4) [[P:%.*]]) #[[ATTR4]] {
; TUNIT-NEXT: [[V:%.*]] = load i32, ptr [[P]], align 32 ; TUNIT-NEXT: [[V:%.*]] = load i32, ptr [[P]], align 32
; TUNIT-NEXT: ret i32 [[V]] ; TUNIT-NEXT: ret i32 [[V]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@musttail_callee_1 ; CGSCC-LABEL: define {{[^@]+}}@musttail_callee_1
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly dereferenceable(4) [[P:%.*]]) #[[ATTR5]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly dereferenceable(4) [[P:%.*]]) #[[ATTR5]] {
; CGSCC-NEXT: [[V:%.*]] = load i32, ptr [[P]], align 32 ; CGSCC-NEXT: [[V:%.*]] = load i32, ptr [[P]], align 32
; CGSCC-NEXT: ret i32 [[V]] ; CGSCC-NEXT: ret i32 [[V]]
; ;
%v = load i32, i32* %p, align 32 %v = load i32, i32* %p, align 32
ret i32 %v ret i32 %v
} }
define i32 @musttail_caller_1(ptr %p) { define i32 @musttail_caller_1(ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
; TUNIT-LABEL: define {{[^@]+}}@musttail_caller_1 ; TUNIT-LABEL: define {{[^@]+}}@musttail_caller_1
; TUNIT-SAME: (ptr nocapture nofree readonly [[P:%.*]]) #[[ATTR10:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree readonly [[P:%.*]]) #[[ATTR11:[0-9]+]] {
; TUNIT-NEXT: [[C:%.*]] = load i1, ptr @cnd, align 1 ; TUNIT-NEXT: [[C:%.*]] = load i1, ptr @cnd, align 1
; TUNIT-NEXT: br i1 [[C]], label [[MT:%.*]], label [[EXIT:%.*]] ; TUNIT-NEXT: br i1 [[C]], label [[MT:%.*]], label [[EXIT:%.*]]
; TUNIT: mt: ; TUNIT: mt:
; TUNIT-NEXT: [[V:%.*]] = musttail call i32 @musttail_callee_1(ptr nocapture nofree readonly [[P]]) #[[ATTR11:[0-9]+]] ; TUNIT-NEXT: [[V:%.*]] = musttail call i32 @musttail_callee_1(ptr nocapture nofree readonly [[P]]) #[[ATTR12:[0-9]+]]
; TUNIT-NEXT: ret i32 [[V]] ; TUNIT-NEXT: ret i32 [[V]]
; TUNIT: exit: ; TUNIT: exit:
; TUNIT-NEXT: ret i32 0 ; TUNIT-NEXT: ret i32 0
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(read) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(read)
; CGSCC-LABEL: define {{[^@]+}}@musttail_caller_1 ; CGSCC-LABEL: define {{[^@]+}}@musttail_caller_1
; CGSCC-SAME: (ptr nocapture nofree readonly [[P:%.*]]) #[[ATTR11:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree readonly [[P:%.*]]) #[[ATTR12:[0-9]+]] {
; CGSCC-NEXT: [[C:%.*]] = load i1, ptr @cnd, align 1 ; CGSCC-NEXT: [[C:%.*]] = load i1, ptr @cnd, align 1
; CGSCC-NEXT: br i1 [[C]], label [[MT:%.*]], label [[EXIT:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[MT:%.*]], label [[EXIT:%.*]]
; CGSCC: mt: ; CGSCC: mt:
; CGSCC-NEXT: [[V:%.*]] = musttail call i32 @musttail_callee_1(ptr nocapture nofree noundef nonnull readonly dereferenceable(4) [[P]]) #[[ATTR13]] ; CGSCC-NEXT: [[V:%.*]] = musttail call i32 @musttail_callee_1(ptr nocapture nofree noundef nonnull readonly dereferenceable(4) [[P]]) #[[ATTR14]]
; CGSCC-NEXT: ret i32 [[V]] ; CGSCC-NEXT: ret i32 [[V]]
; CGSCC: exit: ; CGSCC: exit:
; CGSCC-NEXT: ret i32 0 ; CGSCC-NEXT: ret i32 0
; ;
%c = load i1, i1* @cnd %c = load i1, i1* @cnd
br i1 %c, label %mt, label %exit br i1 %c, label %mt, label %exit
mt: mt:
%v = musttail call i32 @musttail_callee_1(ptr %p) %v = musttail call i32 @musttail_callee_1(ptr %p)
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines;
ret void ret void
} }
declare void @align4_callee(ptr align(4) %p) declare void @align4_callee(ptr align(4) %p)
@G = global i8 0, align 32 @G = global i8 0, align 32
define internal ptr @aligned_8_return(ptr %a, i1 %c1, i1 %c2) norecurse { define internal ptr @aligned_8_return(ptr %a, i1 %c1, i1 %c2) norecurse {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@aligned_8_return ; TUNIT-LABEL: define {{[^@]+}}@aligned_8_return
; TUNIT-SAME: (ptr noalias nofree readnone align 16 "no-capture-maybe-returned" [[A:%.*]], i1 noundef [[C1:%.*]], i1 [[C2:%.*]]) #[[ATTR9]] { ; TUNIT-SAME: (ptr noalias nofree readnone align 16 "no-capture-maybe-returned" [[A:%.*]], i1 noundef [[C1:%.*]], i1 [[C2:%.*]]) #[[ATTR10]] {
; TUNIT-NEXT: [[STACK:%.*]] = alloca ptr, align 8 ; TUNIT-NEXT: [[STACK:%.*]] = alloca ptr, align 8
; TUNIT-NEXT: br i1 [[C1]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[C1]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: [[GEP:%.*]] = getelementptr i8, ptr @G, i32 8 ; TUNIT-NEXT: [[GEP:%.*]] = getelementptr i8, ptr @G, i32 8
; TUNIT-NEXT: [[SEL:%.*]] = select i1 [[C2]], ptr [[A]], ptr [[GEP]] ; TUNIT-NEXT: [[SEL:%.*]] = select i1 [[C2]], ptr [[A]], ptr [[GEP]]
; TUNIT-NEXT: store ptr [[SEL]], ptr [[STACK]], align 8 ; TUNIT-NEXT: store ptr [[SEL]], ptr [[STACK]], align 8
; TUNIT-NEXT: br label [[END:%.*]] ; TUNIT-NEXT: br label [[END:%.*]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: store ptr @G, ptr [[STACK]], align 8 ; TUNIT-NEXT: store ptr @G, ptr [[STACK]], align 8
; TUNIT-NEXT: br label [[END]] ; TUNIT-NEXT: br label [[END]]
; TUNIT: end: ; TUNIT: end:
; TUNIT-NEXT: [[L:%.*]] = load ptr, ptr [[STACK]], align 8 ; TUNIT-NEXT: [[L:%.*]] = load ptr, ptr [[STACK]], align 8
; TUNIT-NEXT: ret ptr [[L]] ; TUNIT-NEXT: ret ptr [[L]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@aligned_8_return ; CGSCC-LABEL: define {{[^@]+}}@aligned_8_return
; CGSCC-SAME: (ptr noalias nofree readnone align 16 "no-capture-maybe-returned" [[A:%.*]], i1 noundef [[C1:%.*]], i1 [[C2:%.*]]) #[[ATTR10]] { ; CGSCC-SAME: (ptr noalias nofree readnone align 16 "no-capture-maybe-returned" [[A:%.*]], i1 noundef [[C1:%.*]], i1 [[C2:%.*]]) #[[ATTR11]] {
; CGSCC-NEXT: [[STACK:%.*]] = alloca ptr, align 8 ; CGSCC-NEXT: [[STACK:%.*]] = alloca ptr, align 8
; CGSCC-NEXT: br i1 [[C1]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[C1]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: [[GEP:%.*]] = getelementptr i8, ptr @G, i32 8 ; CGSCC-NEXT: [[GEP:%.*]] = getelementptr i8, ptr @G, i32 8
; CGSCC-NEXT: [[SEL:%.*]] = select i1 [[C2]], ptr [[A]], ptr [[GEP]] ; CGSCC-NEXT: [[SEL:%.*]] = select i1 [[C2]], ptr [[A]], ptr [[GEP]]
; CGSCC-NEXT: store ptr [[SEL]], ptr [[STACK]], align 8 ; CGSCC-NEXT: store ptr [[SEL]], ptr [[STACK]], align 8
; CGSCC-NEXT: br label [[END:%.*]] ; CGSCC-NEXT: br label [[END:%.*]]
; CGSCC: f: ; CGSCC: f:
Show All 14 Linesf:
store ptr @G, ptr %stack store ptr @G, ptr %stack
br label %end br label %end
end: end:
%l = load ptr, ptr %stack %l = load ptr, ptr %stack
ret ptr %l ret ptr %l
} }
define ptr @aligned_8_return_caller(ptr align(16) %a, i1 %c1, i1 %c2) { define ptr @aligned_8_return_caller(ptr align(16) %a, i1 %c1, i1 %c2) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@aligned_8_return_caller ; TUNIT-LABEL: define {{[^@]+}}@aligned_8_return_caller
; TUNIT-SAME: (ptr nofree readnone align 16 "no-capture-maybe-returned" [[A:%.*]], i1 [[C1:%.*]], i1 [[C2:%.*]]) #[[ATTR9]] { ; TUNIT-SAME: (ptr nofree readnone align 16 "no-capture-maybe-returned" [[A:%.*]], i1 [[C1:%.*]], i1 [[C2:%.*]]) #[[ATTR10]] {
; TUNIT-NEXT: [[R:%.*]] = call align 8 ptr @aligned_8_return(ptr noalias nofree readnone align 16 "no-capture-maybe-returned" [[A]], i1 [[C1]], i1 [[C2]]) #[[ATTR11]] ; TUNIT-NEXT: [[R:%.*]] = call align 8 ptr @aligned_8_return(ptr noalias nofree readnone align 16 "no-capture-maybe-returned" [[A]], i1 [[C1]], i1 [[C2]]) #[[ATTR12]]
; TUNIT-NEXT: ret ptr [[R]] ; TUNIT-NEXT: ret ptr [[R]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@aligned_8_return_caller ; CGSCC-LABEL: define {{[^@]+}}@aligned_8_return_caller
; CGSCC-SAME: (ptr nofree readnone align 16 [[A:%.*]], i1 noundef [[C1:%.*]], i1 [[C2:%.*]]) #[[ATTR12:[0-9]+]] { ; CGSCC-SAME: (ptr nofree readnone align 16 [[A:%.*]], i1 noundef [[C1:%.*]], i1 [[C2:%.*]]) #[[ATTR13:[0-9]+]] {
; CGSCC-NEXT: [[R:%.*]] = call align 8 ptr @aligned_8_return(ptr noalias nofree readnone align 16 [[A]], i1 noundef [[C1]], i1 [[C2]]) #[[ATTR13]] ; CGSCC-NEXT: [[R:%.*]] = call align 8 ptr @aligned_8_return(ptr noalias nofree readnone align 16 [[A]], i1 noundef [[C1]], i1 [[C2]]) #[[ATTR14]]
; CGSCC-NEXT: ret ptr [[R]] ; CGSCC-NEXT: ret ptr [[R]]
; ;
%r = call i8* @aligned_8_return(i8* %a, i1 %c1, i1 %c2) %r = call i8* @aligned_8_return(i8* %a, i1 %c1, i1 %c2)
ret ptr %r ret ptr %r
} }
attributes #0 = { nounwind uwtable noinline } attributes #0 = { nounwind uwtable noinline }
attributes #1 = { uwtable noinline } attributes #1 = { uwtable noinline }
attributes #2 = { null_pointer_is_valid } attributes #2 = { null_pointer_is_valid }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable }
; TUNIT: attributes #[[ATTR1]] = { nofree noinline nosync nounwind willreturn memory(none) uwtable } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable }
; TUNIT: attributes #[[ATTR2]] = { nounwind } ; TUNIT: attributes #[[ATTR2]] = { nounwind }
; TUNIT: attributes #[[ATTR3]] = { nofree nosync nounwind } ; TUNIT: attributes #[[ATTR3]] = { nofree nosync nounwind }
; TUNIT: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; TUNIT: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; TUNIT: attributes #[[ATTR5]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR5]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR6]] = { nounwind willreturn } ; TUNIT: attributes #[[ATTR6]] = { nounwind willreturn }
; TUNIT: attributes #[[ATTR7]] = { nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable } ; TUNIT: attributes #[[ATTR7]] = { mustprogress nounwind willreturn }
; TUNIT: attributes #[[ATTR8]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; TUNIT: attributes #[[ATTR8]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable }
; TUNIT: attributes #[[ATTR9]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR9]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; TUNIT: attributes #[[ATTR10]] = { nofree norecurse nosync nounwind willreturn memory(read) } ; TUNIT: attributes #[[ATTR10]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR11]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR11]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(read) }
; TUNIT: attributes #[[ATTR12]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable }
; CGSCC: attributes #[[ATTR1]] = { nofree noinline nosync nounwind willreturn memory(none) uwtable } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable }
; CGSCC: attributes #[[ATTR2]] = { noinline nounwind uwtable } ; CGSCC: attributes #[[ATTR2]] = { noinline nounwind uwtable }
; CGSCC: attributes #[[ATTR3]] = { nounwind } ; CGSCC: attributes #[[ATTR3]] = { nounwind }
; CGSCC: attributes #[[ATTR4]] = { nofree nosync nounwind } ; CGSCC: attributes #[[ATTR4]] = { nofree nosync nounwind }
; CGSCC: attributes #[[ATTR5]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR5]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR6]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR6]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR7]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR7]] = { nounwind willreturn }
; CGSCC: attributes #[[ATTR8]] = { nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable } ; CGSCC: attributes #[[ATTR8]] = { mustprogress nounwind willreturn }
; CGSCC: attributes #[[ATTR9]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR9]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable }
; CGSCC: attributes #[[ATTR10]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR10]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR11]] = { nofree nosync nounwind willreturn memory(read) } ; CGSCC: attributes #[[ATTR11]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR12]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR12]] = { mustprogress nofree nosync nounwind willreturn memory(read) }
; CGSCC: attributes #[[ATTR13]] = { willreturn } ; CGSCC: attributes #[[ATTR13]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR14]] = { willreturn }
;. ;.

llvm/test/Transforms/Attributor/alwaysinline.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; ;
; When a function is marked `alwaysinline` and is able to be inlined, ; When a function is marked `alwaysinline` and is able to be inlined,
; we can IPO its boundaries ; we can IPO its boundaries
; the function is not exactly defined, and marked alwaysinline and can be inlined, ; the function is not exactly defined, and marked alwaysinline and can be inlined,
; so the function can be analyzed ; so the function can be analyzed
define linkonce void @inner1() alwaysinline { define linkonce void @inner1() alwaysinline {
; CHECK: Function Attrs: alwaysinline nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: alwaysinline mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@inner1 ; CHECK-LABEL: define {{[^@]+}}@inner1
; CHECK-SAME: () #[[ATTR0:[0-9]+]] { ; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
ret void ret void
} }
define void @outer1() { define void @outer1() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@outer1 ; TUNIT-LABEL: define {{[^@]+}}@outer1
; TUNIT-SAME: () #[[ATTR1:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR1:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@outer1 ; CGSCC-LABEL: define {{[^@]+}}@outer1
; CGSCC-SAME: () #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
entry: entry:
call void @inner1() call void @inner1()
ret void ret void
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines
; CGSCC-NEXT: ret i32 [[CALL]] ; CGSCC-NEXT: ret i32 [[CALL]]
; ;
%cmp = icmp slt i32 %x, 42 %cmp = icmp slt i32 %x, 42
%addr = select i1 %cmp, ptr blockaddress(@inner3, %one), ptr blockaddress(@inner3, %two) %addr = select i1 %cmp, ptr blockaddress(@inner3, %one), ptr blockaddress(@inner3, %two)
%call = call i32 @inner3(ptr %addr) %call = call i32 @inner3(ptr %addr)
ret i32 %call ret i32 %call
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { alwaysinline nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { alwaysinline mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR2]] = { norecurse } ; TUNIT: attributes #[[ATTR2]] = { norecurse }
; TUNIT: attributes #[[ATTR3]] = { alwaysinline } ; TUNIT: attributes #[[ATTR3]] = { alwaysinline }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { alwaysinline nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { alwaysinline mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { alwaysinline } ; CGSCC: attributes #[[ATTR2]] = { alwaysinline }
;. ;.

llvm/test/Transforms/Attributor/call-simplify-pointer-info.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=7 -S < %s | FileCheck %s --check-prefixes=TUNIT ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=7 -S < %s | FileCheck %s --check-prefixes=TUNIT
; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CGSCC ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CGSCC
; ;
define internal i8 @read_arg(i8* %p) { define internal i8 @read_arg(i8* %p) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@read_arg ; CGSCC-LABEL: define {{[^@]+}}@read_arg
; CGSCC-SAME: (i8* nocapture nofree noundef nonnull readonly dereferenceable(1022) [[P:%.*]]) #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: (i8* nocapture nofree noundef nonnull readonly dereferenceable(1022) [[P:%.*]]) #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[L:%.*]] = load i8, i8* [[P]], align 1 ; CGSCC-NEXT: [[L:%.*]] = load i8, i8* [[P]], align 1
; CGSCC-NEXT: ret i8 [[L]] ; CGSCC-NEXT: ret i8 [[L]]
; ;
entry: entry:
%l = load i8, i8* %p, align 1 %l = load i8, i8* %p, align 1
ret i8 %l ret i8 %l
} }
define internal i8 @read_arg_index(i8* %p, i64 %index) { define internal i8 @read_arg_index(i8* %p, i64 %index) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@read_arg_index ; CGSCC-LABEL: define {{[^@]+}}@read_arg_index
; CGSCC-SAME: (i8* nocapture nofree noundef nonnull readonly align 16 dereferenceable(1024) [[P:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (i8* nocapture nofree noundef nonnull readonly align 16 dereferenceable(1024) [[P:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[G:%.*]] = getelementptr inbounds i8, i8* [[P]], i64 2 ; CGSCC-NEXT: [[G:%.*]] = getelementptr inbounds i8, i8* [[P]], i64 2
; CGSCC-NEXT: [[L:%.*]] = load i8, i8* [[G]], align 1 ; CGSCC-NEXT: [[L:%.*]] = load i8, i8* [[G]], align 1
; CGSCC-NEXT: ret i8 [[L]] ; CGSCC-NEXT: ret i8 [[L]]
; ;
entry: entry:
%g = getelementptr inbounds i8, i8* %p, i64 %index %g = getelementptr inbounds i8, i8* %p, i64 %index
%l = load i8, i8* %g, align 1 %l = load i8, i8* %g, align 1
ret i8 %l ret i8 %l
} }
define i8 @call_simplifiable_1() { define i8 @call_simplifiable_1() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@call_simplifiable_1 ; TUNIT-LABEL: define {{[^@]+}}@call_simplifiable_1
; TUNIT-SAME: () #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; TUNIT-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; TUNIT-NEXT: [[I0:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 2 ; TUNIT-NEXT: [[I0:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 2
; TUNIT-NEXT: ret i8 2 ; TUNIT-NEXT: ret i8 2
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@call_simplifiable_1 ; CGSCC-LABEL: define {{[^@]+}}@call_simplifiable_1
; CGSCC-SAME: () #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; CGSCC-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; CGSCC-NEXT: [[I0:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 2 ; CGSCC-NEXT: [[I0:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 2
; CGSCC-NEXT: store i8 2, i8* [[I0]], align 2 ; CGSCC-NEXT: store i8 2, i8* [[I0]], align 2
; CGSCC-NEXT: [[R:%.*]] = call i8 @read_arg(i8* nocapture nofree noundef nonnull readonly align 2 dereferenceable(1022) [[I0]]) #[[ATTR4:[0-9]+]] ; CGSCC-NEXT: [[R:%.*]] = call i8 @read_arg(i8* nocapture nofree noundef nonnull readonly align 2 dereferenceable(1022) [[I0]]) #[[ATTR4:[0-9]+]]
; CGSCC-NEXT: ret i8 [[R]] ; CGSCC-NEXT: ret i8 [[R]]
; ;
entry: entry:
%Bytes = alloca [1024 x i8], align 16 %Bytes = alloca [1024 x i8], align 16
%i0 = getelementptr inbounds [1024 x i8], [1024 x i8]* %Bytes, i64 0, i64 2 %i0 = getelementptr inbounds [1024 x i8], [1024 x i8]* %Bytes, i64 0, i64 2
store i8 2, i8* %i0, align 1 store i8 2, i8* %i0, align 1
%r = call i8 @read_arg(i8* %i0) %r = call i8 @read_arg(i8* %i0)
ret i8 %r ret i8 %r
} }
;;; Same as read_arg, but we need a copy to form distinct leaves in the callgraph. ;;; Same as read_arg, but we need a copy to form distinct leaves in the callgraph.
define internal i8 @read_arg_1(i8* %p) { define internal i8 @read_arg_1(i8* %p) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@read_arg_1 ; CGSCC-LABEL: define {{[^@]+}}@read_arg_1
; CGSCC-SAME: (i8* nocapture nofree noundef nonnull readonly dereferenceable(1) [[P:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (i8* nocapture nofree noundef nonnull readonly dereferenceable(1) [[P:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[L:%.*]] = load i8, i8* [[P]], align 1 ; CGSCC-NEXT: [[L:%.*]] = load i8, i8* [[P]], align 1
; CGSCC-NEXT: ret i8 [[L]] ; CGSCC-NEXT: ret i8 [[L]]
; ;
entry: entry:
%l = load i8, i8* %p, align 1 %l = load i8, i8* %p, align 1
ret i8 %l ret i8 %l
} }
define internal i8 @sum_two_same_loads(i8* %p) { define internal i8 @sum_two_same_loads(i8* %p) {
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@sum_two_same_loads ; CGSCC-LABEL: define {{[^@]+}}@sum_two_same_loads
; CGSCC-SAME: (i8* nocapture nofree noundef nonnull readonly dereferenceable(1022) [[P:%.*]]) #[[ATTR2:[0-9]+]] { ; CGSCC-SAME: (i8* nocapture nofree noundef nonnull readonly dereferenceable(1022) [[P:%.*]]) #[[ATTR2:[0-9]+]] {
; CGSCC-NEXT: [[X:%.*]] = call i8 @read_arg_1(i8* nocapture nofree noundef nonnull readonly dereferenceable(1022) [[P]]) #[[ATTR5:[0-9]+]] ; CGSCC-NEXT: [[X:%.*]] = call i8 @read_arg_1(i8* nocapture nofree noundef nonnull readonly dereferenceable(1022) [[P]]) #[[ATTR5:[0-9]+]]
; CGSCC-NEXT: [[Y:%.*]] = call i8 @read_arg_1(i8* nocapture nofree noundef nonnull readonly dereferenceable(1022) [[P]]) #[[ATTR5]] ; CGSCC-NEXT: [[Y:%.*]] = call i8 @read_arg_1(i8* nocapture nofree noundef nonnull readonly dereferenceable(1022) [[P]]) #[[ATTR5]]
; CGSCC-NEXT: [[Z:%.*]] = add nsw i8 [[X]], [[Y]] ; CGSCC-NEXT: [[Z:%.*]] = add nsw i8 [[X]], [[Y]]
; CGSCC-NEXT: ret i8 [[Z]] ; CGSCC-NEXT: ret i8 [[Z]]
; ;
%x = call i8 @read_arg_1(i8* %p) %x = call i8 @read_arg_1(i8* %p)
%y = call i8 @read_arg_1(i8* %p) %y = call i8 @read_arg_1(i8* %p)
%z = add nsw i8 %x, %y %z = add nsw i8 %x, %y
ret i8 %z ret i8 %z
} }
define i8 @call_simplifiable_2() { define i8 @call_simplifiable_2() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@call_simplifiable_2 ; TUNIT-LABEL: define {{[^@]+}}@call_simplifiable_2
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; TUNIT-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; TUNIT-NEXT: [[I0:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 2 ; TUNIT-NEXT: [[I0:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 2
; TUNIT-NEXT: [[I1:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 3 ; TUNIT-NEXT: [[I1:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 3
; TUNIT-NEXT: ret i8 4 ; TUNIT-NEXT: ret i8 4
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@call_simplifiable_2 ; CGSCC-LABEL: define {{[^@]+}}@call_simplifiable_2
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; CGSCC-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; CGSCC-NEXT: [[I0:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 2 ; CGSCC-NEXT: [[I0:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 2
; CGSCC-NEXT: store i8 2, i8* [[I0]], align 2 ; CGSCC-NEXT: store i8 2, i8* [[I0]], align 2
; CGSCC-NEXT: [[I1:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 3 ; CGSCC-NEXT: [[I1:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 3
; CGSCC-NEXT: store i8 3, i8* [[I1]], align 1 ; CGSCC-NEXT: store i8 3, i8* [[I1]], align 1
; CGSCC-NEXT: [[R:%.*]] = call i8 @sum_two_same_loads(i8* nocapture nofree noundef nonnull readonly align 2 dereferenceable(1022) [[I0]]) #[[ATTR4]] ; CGSCC-NEXT: [[R:%.*]] = call i8 @sum_two_same_loads(i8* nocapture nofree noundef nonnull readonly align 2 dereferenceable(1022) [[I0]]) #[[ATTR4]]
; CGSCC-NEXT: ret i8 [[R]] ; CGSCC-NEXT: ret i8 [[R]]
; ;
entry: entry:
%Bytes = alloca [1024 x i8], align 16 %Bytes = alloca [1024 x i8], align 16
%i0 = getelementptr inbounds [1024 x i8], [1024 x i8]* %Bytes, i64 0, i64 2 %i0 = getelementptr inbounds [1024 x i8], [1024 x i8]* %Bytes, i64 0, i64 2
store i8 2, i8* %i0 store i8 2, i8* %i0
%i1 = getelementptr inbounds [1024 x i8], [1024 x i8]* %Bytes, i64 0, i64 3 %i1 = getelementptr inbounds [1024 x i8], [1024 x i8]* %Bytes, i64 0, i64 3
store i8 3, i8* %i1 store i8 3, i8* %i1
%r = call i8 @sum_two_same_loads(i8* %i0) %r = call i8 @sum_two_same_loads(i8* %i0)
ret i8 %r ret i8 %r
} }
define i8 @call_simplifiable_3() { define i8 @call_simplifiable_3() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@call_simplifiable_3 ; TUNIT-LABEL: define {{[^@]+}}@call_simplifiable_3
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; TUNIT-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; TUNIT-NEXT: [[I2:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 2 ; TUNIT-NEXT: [[I2:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 2
; TUNIT-NEXT: ret i8 2 ; TUNIT-NEXT: ret i8 2
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@call_simplifiable_3 ; CGSCC-LABEL: define {{[^@]+}}@call_simplifiable_3
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; CGSCC-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; CGSCC-NEXT: [[I0:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 0 ; CGSCC-NEXT: [[I0:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 0
; CGSCC-NEXT: [[I2:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 2 ; CGSCC-NEXT: [[I2:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 2
; CGSCC-NEXT: store i8 2, i8* [[I2]], align 2 ; CGSCC-NEXT: store i8 2, i8* [[I2]], align 2
; CGSCC-NEXT: [[R:%.*]] = call i8 @read_arg_index(i8* nocapture nofree noundef nonnull readonly align 16 dereferenceable(1024) [[I0]]) #[[ATTR4]] ; CGSCC-NEXT: [[R:%.*]] = call i8 @read_arg_index(i8* nocapture nofree noundef nonnull readonly align 16 dereferenceable(1024) [[I0]]) #[[ATTR4]]
; CGSCC-NEXT: ret i8 [[R]] ; CGSCC-NEXT: ret i8 [[R]]
; ;
entry: entry:
%Bytes = alloca [1024 x i8], align 16 %Bytes = alloca [1024 x i8], align 16
%i0 = getelementptr inbounds [1024 x i8], [1024 x i8]* %Bytes, i64 0, i64 0 %i0 = getelementptr inbounds [1024 x i8], [1024 x i8]* %Bytes, i64 0, i64 0
%i2 = getelementptr inbounds [1024 x i8], [1024 x i8]* %Bytes, i64 0, i64 2 %i2 = getelementptr inbounds [1024 x i8], [1024 x i8]* %Bytes, i64 0, i64 2
store i8 2, i8* %i2, align 1 store i8 2, i8* %i2, align 1
%r = call i8 @read_arg_index(i8* %i0, i64 2) %r = call i8 @read_arg_index(i8* %i0, i64 2)
ret i8 %r ret i8 %r
} }
;;; Same as read_arg, but we need a copy to form distinct leaves in the callgraph. ;;; Same as read_arg, but we need a copy to form distinct leaves in the callgraph.
define internal i8 @read_arg_2(i8* %p) { define internal i8 @read_arg_2(i8* %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; TUNIT-LABEL: define {{[^@]+}}@read_arg_2 ; TUNIT-LABEL: define {{[^@]+}}@read_arg_2
; TUNIT-SAME: (i8* nocapture nofree noundef nonnull readonly dereferenceable(971) [[P:%.*]]) #[[ATTR1:[0-9]+]] { ; TUNIT-SAME: (i8* nocapture nofree noundef nonnull readonly dereferenceable(971) [[P:%.*]]) #[[ATTR1:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[L:%.*]] = load i8, i8* [[P]], align 1 ; TUNIT-NEXT: [[L:%.*]] = load i8, i8* [[P]], align 1
; TUNIT-NEXT: ret i8 [[L]] ; TUNIT-NEXT: ret i8 [[L]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@read_arg_2 ; CGSCC-LABEL: define {{[^@]+}}@read_arg_2
; CGSCC-SAME: (i8* nocapture nofree noundef nonnull readonly dereferenceable(1) [[P:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (i8* nocapture nofree noundef nonnull readonly dereferenceable(1) [[P:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[L:%.*]] = load i8, i8* [[P]], align 1 ; CGSCC-NEXT: [[L:%.*]] = load i8, i8* [[P]], align 1
; CGSCC-NEXT: ret i8 [[L]] ; CGSCC-NEXT: ret i8 [[L]]
; ;
entry: entry:
%l = load i8, i8* %p, align 1 %l = load i8, i8* %p, align 1
ret i8 %l ret i8 %l
} }
define internal i8 @sum_two_different_loads(i8* %p, i8* %q) { define internal i8 @sum_two_different_loads(i8* %p, i8* %q) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; TUNIT-LABEL: define {{[^@]+}}@sum_two_different_loads ; TUNIT-LABEL: define {{[^@]+}}@sum_two_different_loads
; TUNIT-SAME: (i8* nocapture nofree nonnull readonly dereferenceable(972) [[P:%.*]], i8* nocapture nofree noundef nonnull readonly dereferenceable(971) [[Q:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i8* nocapture nofree nonnull readonly dereferenceable(972) [[P:%.*]], i8* nocapture nofree noundef nonnull readonly dereferenceable(971) [[Q:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: [[X:%.*]] = call i8 @read_arg_2(i8* nocapture nofree nonnull readonly dereferenceable(972) [[P]]) #[[ATTR3:[0-9]+]] ; TUNIT-NEXT: [[X:%.*]] = call i8 @read_arg_2(i8* nocapture nofree nonnull readonly dereferenceable(972) [[P]]) #[[ATTR3:[0-9]+]]
; TUNIT-NEXT: [[Y:%.*]] = call i8 @read_arg_2(i8* nocapture nofree noundef nonnull readonly dereferenceable(971) [[Q]]) #[[ATTR3]] ; TUNIT-NEXT: [[Y:%.*]] = call i8 @read_arg_2(i8* nocapture nofree noundef nonnull readonly dereferenceable(971) [[Q]]) #[[ATTR3]]
; TUNIT-NEXT: [[Z:%.*]] = add nsw i8 [[X]], [[Y]] ; TUNIT-NEXT: [[Z:%.*]] = add nsw i8 [[X]], [[Y]]
; TUNIT-NEXT: ret i8 [[Z]] ; TUNIT-NEXT: ret i8 [[Z]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@sum_two_different_loads ; CGSCC-LABEL: define {{[^@]+}}@sum_two_different_loads
; CGSCC-SAME: (i8* nocapture nofree noundef nonnull readonly dereferenceable(972) [[P:%.*]], i8* nocapture nofree noundef nonnull readonly dereferenceable(971) [[Q:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i8* nocapture nofree noundef nonnull readonly dereferenceable(972) [[P:%.*]], i8* nocapture nofree noundef nonnull readonly dereferenceable(971) [[Q:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[X:%.*]] = call i8 @read_arg_2(i8* nocapture nofree noundef nonnull readonly dereferenceable(972) [[P]]) #[[ATTR5]] ; CGSCC-NEXT: [[X:%.*]] = call i8 @read_arg_2(i8* nocapture nofree noundef nonnull readonly dereferenceable(972) [[P]]) #[[ATTR5]]
; CGSCC-NEXT: [[Y:%.*]] = call i8 @read_arg_2(i8* nocapture nofree noundef nonnull readonly dereferenceable(971) [[Q]]) #[[ATTR5]] ; CGSCC-NEXT: [[Y:%.*]] = call i8 @read_arg_2(i8* nocapture nofree noundef nonnull readonly dereferenceable(971) [[Q]]) #[[ATTR5]]
; CGSCC-NEXT: [[Z:%.*]] = add nsw i8 [[X]], [[Y]] ; CGSCC-NEXT: [[Z:%.*]] = add nsw i8 [[X]], [[Y]]
; CGSCC-NEXT: ret i8 [[Z]] ; CGSCC-NEXT: ret i8 [[Z]]
; ;
%x = call i8 @read_arg_2(i8* %p) %x = call i8 @read_arg_2(i8* %p)
%y = call i8 @read_arg_2(i8* %q) %y = call i8 @read_arg_2(i8* %q)
%z = add nsw i8 %x, %y %z = add nsw i8 %x, %y
ret i8 %z ret i8 %z
} }
define i8 @call_partially_simplifiable_1() { define i8 @call_partially_simplifiable_1() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@call_partially_simplifiable_1 ; TUNIT-LABEL: define {{[^@]+}}@call_partially_simplifiable_1
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; TUNIT-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; TUNIT-NEXT: [[I2:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 2 ; TUNIT-NEXT: [[I2:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 2
; TUNIT-NEXT: store i8 2, i8* [[I2]], align 2 ; TUNIT-NEXT: store i8 2, i8* [[I2]], align 2
; TUNIT-NEXT: [[I3:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 3 ; TUNIT-NEXT: [[I3:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 3
; TUNIT-NEXT: store i8 3, i8* [[I3]], align 1 ; TUNIT-NEXT: store i8 3, i8* [[I3]], align 1
; TUNIT-NEXT: [[I4:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 4 ; TUNIT-NEXT: [[I4:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 4
; TUNIT-NEXT: [[R:%.*]] = call i8 @sum_two_different_loads(i8* nocapture nofree noundef nonnull readonly align 2 dereferenceable(1022) [[I2]], i8* nocapture nofree noundef nonnull readonly dereferenceable(1021) [[I3]]) #[[ATTR3]] ; TUNIT-NEXT: [[R:%.*]] = call i8 @sum_two_different_loads(i8* nocapture nofree noundef nonnull readonly align 2 dereferenceable(1022) [[I2]], i8* nocapture nofree noundef nonnull readonly dereferenceable(1021) [[I3]]) #[[ATTR3]]
; TUNIT-NEXT: ret i8 [[R]] ; TUNIT-NEXT: ret i8 [[R]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@call_partially_simplifiable_1 ; CGSCC-LABEL: define {{[^@]+}}@call_partially_simplifiable_1
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; CGSCC-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; CGSCC-NEXT: [[I2:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 2 ; CGSCC-NEXT: [[I2:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 2
; CGSCC-NEXT: store i8 2, i8* [[I2]], align 2 ; CGSCC-NEXT: store i8 2, i8* [[I2]], align 2
; CGSCC-NEXT: [[I3:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 3 ; CGSCC-NEXT: [[I3:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 3
; CGSCC-NEXT: store i8 3, i8* [[I3]], align 1 ; CGSCC-NEXT: store i8 3, i8* [[I3]], align 1
Show All 11 Linesentry:
%i4 = getelementptr inbounds [1024 x i8], [1024 x i8]* %Bytes, i64 0, i64 4 %i4 = getelementptr inbounds [1024 x i8], [1024 x i8]* %Bytes, i64 0, i64 4
;;; This store is redundant, hence removed. ;;; This store is redundant, hence removed.
store i8 4, i8* %i4 store i8 4, i8* %i4
%r = call i8 @sum_two_different_loads(i8* %i2, i8* %i3) %r = call i8 @sum_two_different_loads(i8* %i2, i8* %i3)
ret i8 %r ret i8 %r
} }
define i8 @call_partially_simplifiable_2(i1 %cond) { define i8 @call_partially_simplifiable_2(i1 %cond) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@call_partially_simplifiable_2 ; TUNIT-LABEL: define {{[^@]+}}@call_partially_simplifiable_2
; TUNIT-SAME: (i1 [[COND:%.*]]) #[[ATTR2:[0-9]+]] { ; TUNIT-SAME: (i1 [[COND:%.*]]) #[[ATTR2:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; TUNIT-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; TUNIT-NEXT: [[I51:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 51 ; TUNIT-NEXT: [[I51:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 51
; TUNIT-NEXT: [[I52:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 52 ; TUNIT-NEXT: [[I52:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 52
; TUNIT-NEXT: store i8 2, i8* [[I52]], align 4 ; TUNIT-NEXT: store i8 2, i8* [[I52]], align 4
; TUNIT-NEXT: [[I53:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 53 ; TUNIT-NEXT: [[I53:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 53
; TUNIT-NEXT: store i8 3, i8* [[I53]], align 1 ; TUNIT-NEXT: store i8 3, i8* [[I53]], align 1
; TUNIT-NEXT: [[I54:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 54 ; TUNIT-NEXT: [[I54:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 54
; TUNIT-NEXT: [[SEL:%.*]] = select i1 [[COND]], i8* [[I51]], i8* [[I52]] ; TUNIT-NEXT: [[SEL:%.*]] = select i1 [[COND]], i8* [[I51]], i8* [[I52]]
; TUNIT-NEXT: [[R:%.*]] = call i8 @sum_two_different_loads(i8* nocapture nofree nonnull readonly dereferenceable(972) [[SEL]], i8* nocapture nofree noundef nonnull readonly dereferenceable(971) [[I53]]) #[[ATTR3]] ; TUNIT-NEXT: [[R:%.*]] = call i8 @sum_two_different_loads(i8* nocapture nofree nonnull readonly dereferenceable(972) [[SEL]], i8* nocapture nofree noundef nonnull readonly dereferenceable(971) [[I53]]) #[[ATTR3]]
; TUNIT-NEXT: ret i8 [[R]] ; TUNIT-NEXT: ret i8 [[R]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@call_partially_simplifiable_2 ; CGSCC-LABEL: define {{[^@]+}}@call_partially_simplifiable_2
; CGSCC-SAME: (i1 [[COND:%.*]]) #[[ATTR3:[0-9]+]] { ; CGSCC-SAME: (i1 [[COND:%.*]]) #[[ATTR3:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; CGSCC-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; CGSCC-NEXT: [[I51:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 51 ; CGSCC-NEXT: [[I51:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 51
; CGSCC-NEXT: [[I52:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 52 ; CGSCC-NEXT: [[I52:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 52
; CGSCC-NEXT: store i8 2, i8* [[I52]], align 4 ; CGSCC-NEXT: store i8 2, i8* [[I52]], align 4
; CGSCC-NEXT: [[I53:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 53 ; CGSCC-NEXT: [[I53:%.*]] = getelementptr inbounds [1024 x i8], [1024 x i8]* [[BYTES]], i64 0, i64 53
Show All 15 Linesentry:
;;; This store is redundant, hence removed. Not affected by the select. ;;; This store is redundant, hence removed. Not affected by the select.
store i8 4, i8* %i54 store i8 4, i8* %i54
%sel = select i1 %cond, i8* %i51, i8 *%i52 %sel = select i1 %cond, i8* %i51, i8 *%i52
%r = call i8 @sum_two_different_loads(i8* %sel, i8* %i53) %r = call i8 @sum_two_different_loads(i8* %sel, i8* %i53)
ret i8 %r ret i8 %r
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; TUNIT: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR3]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR3]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR3]] = { nofree nosync nounwind willreturn } ; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree nosync nounwind willreturn }
; CGSCC: attributes #[[ATTR4]] = { willreturn } ; CGSCC: attributes #[[ATTR4]] = { willreturn }
; CGSCC: attributes #[[ATTR5]] = { willreturn memory(read) } ; CGSCC: attributes #[[ATTR5]] = { willreturn memory(read) }
;. ;.

llvm/test/Transforms/Attributor/cb_liveness_disabled.ll

Show First 20 Lines • Show All 186 Lines • ▼ Show 20 Lines;
ret i32 %4 ret i32 %4
} }
attributes #0 = { noinline nounwind sspstrong uwtable} attributes #0 = { noinline nounwind sspstrong uwtable}
; TUNIT_: !0 = !{i32 0, i32 101} ; TUNIT_: !0 = !{i32 0, i32 101}
; TUNIT_: !1 = !{i32 100, i32 201} ; TUNIT_: !1 = !{i32 100, i32 201}
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree noinline norecurse nosync nounwind sspstrong willreturn memory(none) uwtable } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind sspstrong willreturn memory(none) uwtable }
; TUNIT: attributes #[[ATTR1:[0-9]+]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR1:[0-9]+]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree noinline norecurse nosync nounwind sspstrong willreturn memory(none) uwtable } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind sspstrong willreturn memory(none) uwtable }
; CGSCC: attributes #[[ATTR1]] = { nofree noinline nosync nounwind sspstrong willreturn memory(none) uwtable } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree noinline nosync nounwind sspstrong willreturn memory(none) uwtable }
; CGSCC: attributes #[[ATTR2:[0-9]+]] = { willreturn } ; CGSCC: attributes #[[ATTR2:[0-9]+]] = { willreturn }
;. ;.

llvm/test/Transforms/Attributor/cb_liveness_enabled.ll

Show First 20 Lines • Show All 189 Lines • ▼ Show 20 Lines;
ret i32 %4 ret i32 %4
} }
attributes #0 = { noinline nounwind sspstrong uwtable} attributes #0 = { noinline nounwind sspstrong uwtable}
; TUNIT_: !0 = !{i32 0, i32 101} ; TUNIT_: !0 = !{i32 0, i32 101}
; TUNIT_: !1 = !{i32 100, i32 201} ; TUNIT_: !1 = !{i32 100, i32 201}
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree noinline norecurse nosync nounwind sspstrong willreturn memory(none) uwtable } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind sspstrong willreturn memory(none) uwtable }
; TUNIT: attributes #[[ATTR1:[0-9]+]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR1:[0-9]+]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree noinline norecurse nosync nounwind sspstrong willreturn memory(none) uwtable } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind sspstrong willreturn memory(none) uwtable }
; CGSCC: attributes #[[ATTR1]] = { nofree noinline nosync nounwind sspstrong willreturn memory(none) uwtable } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree noinline nosync nounwind sspstrong willreturn memory(none) uwtable }
; CGSCC: attributes #[[ATTR2:[0-9]+]] = { willreturn } ; CGSCC: attributes #[[ATTR2:[0-9]+]] = { willreturn }
;. ;.

llvm/test/Transforms/Attributor/cb_range_disabled.ll

Show First 20 Lines • Show All 135 Lines • ▼ Show 20 Lines
; CGSCC-NEXT: ret i32 [[TMP3]] ; CGSCC-NEXT: ret i32 [[TMP3]]
; ;
%1 = call i32 @test2(i32 %unknown, i32 20) %1 = call i32 @test2(i32 %unknown, i32 20)
%2 = icmp sge i32 %1, 30 %2 = icmp sge i32 %1, 30
%3 = zext i1 %2 to i32 %3 = zext i1 %2 to i32
ret i32 %3 ret i32 %3
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1:[0-9]+]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR1:[0-9]+]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2:[0-9]+]] = { willreturn } ; CGSCC: attributes #[[ATTR2:[0-9]+]] = { willreturn }
;. ;.

llvm/test/Transforms/Attributor/cb_range_enabled.ll

Show First 20 Lines • Show All 139 Lines • ▼ Show 20 Lines
; CGSCC-NEXT: ret i32 [[TMP3]] ; CGSCC-NEXT: ret i32 [[TMP3]]
; ;
%1 = call i32 @test2(i32 %unknown, i32 20) %1 = call i32 @test2(i32 %unknown, i32 20)
%2 = icmp sge i32 %1, 30 %2 = icmp sge i32 %1, 30
%3 = zext i1 %2 to i32 %3 = zext i1 %2 to i32
ret i32 %3 ret i32 %3
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1:[0-9]+]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR1:[0-9]+]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2:[0-9]+]] = { willreturn } ; CGSCC: attributes #[[ATTR2:[0-9]+]] = { willreturn }
;. ;.

llvm/test/Transforms/Attributor/convergent.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
define i32 @defined() convergent { define i32 @defined() convergent {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@defined ; CHECK-LABEL: define {{[^@]+}}@defined
; CHECK-SAME: () #[[ATTR0:[0-9]+]] { ; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: ret i32 1 ; CHECK-NEXT: ret i32 1
; ;
ret i32 1 ret i32 1
} }
define i32 @calls_defined() convergent { define i32 @calls_defined() convergent {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@calls_defined ; TUNIT-LABEL: define {{[^@]+}}@calls_defined
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: ret i32 1 ; TUNIT-NEXT: ret i32 1
; ;
; CGSCC: Function Attrs: convergent nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: convergent mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@calls_defined ; CGSCC-LABEL: define {{[^@]+}}@calls_defined
; CGSCC-SAME: () #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: [[A:%.*]] = call noundef i32 @defined() #[[ATTR5:[0-9]+]] ; CGSCC-NEXT: [[A:%.*]] = call noundef i32 @defined() #[[ATTR5:[0-9]+]]
; CGSCC-NEXT: ret i32 [[A]] ; CGSCC-NEXT: ret i32 [[A]]
; ;
%a = call i32 @defined() %a = call i32 @defined()
ret i32 %a ret i32 %a
} }
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
; ;
%c = call i32 @defined_with_asm(i32 %a, i32 %b) %c = call i32 @defined_with_asm(i32 %a, i32 %b)
ret i32 %c ret i32 %c
} }
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 %size, i1 %isVolatile) convergent declare void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 %size, i1 %isVolatile) convergent
define void @calls_intrinsic(i8* %dest, i8* %src, i64 %size) convergent { define void @calls_intrinsic(i8* %dest, i8* %src, i64 %size) convergent {
; TUNIT: Function Attrs: convergent nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: convergent mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@calls_intrinsic ; TUNIT-LABEL: define {{[^@]+}}@calls_intrinsic
; TUNIT-SAME: (ptr nocapture nofree writeonly [[DEST:%.*]], ptr nocapture nofree readonly [[SRC:%.*]], i64 [[SIZE:%.*]]) #[[ATTR2:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree writeonly [[DEST:%.*]], ptr nocapture nofree readonly [[SRC:%.*]], i64 [[SIZE:%.*]]) #[[ATTR2:[0-9]+]] {
; TUNIT-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture nofree writeonly [[DEST]], ptr noalias nocapture nofree readonly [[SRC]], i64 [[SIZE]], i1 noundef false) #[[ATTR4:[0-9]+]] ; TUNIT-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture nofree writeonly [[DEST]], ptr noalias nocapture nofree readonly [[SRC]], i64 [[SIZE]], i1 noundef false) #[[ATTR4:[0-9]+]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: convergent nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: convergent mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@calls_intrinsic ; CGSCC-LABEL: define {{[^@]+}}@calls_intrinsic
; CGSCC-SAME: (ptr nocapture nofree writeonly [[DEST:%.*]], ptr nocapture nofree readonly [[SRC:%.*]], i64 [[SIZE:%.*]]) #[[ATTR3:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree writeonly [[DEST:%.*]], ptr nocapture nofree readonly [[SRC:%.*]], i64 [[SIZE:%.*]]) #[[ATTR3:[0-9]+]] {
; CGSCC-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture nofree writeonly [[DEST]], ptr noalias nocapture nofree readonly [[SRC]], i64 [[SIZE]], i1 noundef false) #[[ATTR5]] ; CGSCC-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture nofree writeonly [[DEST]], ptr noalias nocapture nofree readonly [[SRC]], i64 [[SIZE]], i1 noundef false) #[[ATTR5]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 %size, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 %size, i1 false)
ret void ret void
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1]] = { convergent } ; TUNIT: attributes #[[ATTR1]] = { convergent }
; TUNIT: attributes #[[ATTR2]] = { convergent nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR2]] = { convergent mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR3:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR3:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR4]] = { willreturn } ; TUNIT: attributes #[[ATTR4]] = { willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { convergent nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { convergent mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { convergent } ; CGSCC: attributes #[[ATTR2]] = { convergent }
; CGSCC: attributes #[[ATTR3]] = { convergent nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR3]] = { convergent mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR4:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR4:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR5]] = { willreturn } ; CGSCC: attributes #[[ATTR5]] = { willreturn }
;. ;.

llvm/test/Transforms/Attributor/depgraph.ll

Show First 20 Lines • Show All 133 Lines • ▼ Show 20 Lines
; GRAPH-NEXT: [AACallEdges] for CtxI ' %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs: [@-1]} with state CallEdges[0,1] ; GRAPH-NEXT: [AACallEdges] for CtxI ' %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs: [@-1]} with state CallEdges[0,1]
; GRAPH-EMPTY: ; GRAPH-EMPTY:
; GRAPH-NEXT: [AAIsDead] for CtxI ' br label %8' at position {flt: [@-1]} with state assumed-live ; GRAPH-NEXT: [AAIsDead] for CtxI ' br label %8' at position {flt: [@-1]} with state assumed-live
; GRAPH-EMPTY: ; GRAPH-EMPTY:
; GRAPH-NEXT: [AAWillReturn] for CtxI ' %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs: [@-1]} with state may-noreturn ; GRAPH-NEXT: [AAWillReturn] for CtxI ' %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs: [@-1]} with state may-noreturn
; GRAPH-EMPTY: ; GRAPH-EMPTY:
; GRAPH-NEXT: [AANoRecurse] for CtxI ' %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs: [@-1]} with state may-recurse ; GRAPH-NEXT: [AANoRecurse] for CtxI ' %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs: [@-1]} with state may-recurse
; GRAPH-EMPTY: ; GRAPH-EMPTY:
; GRAPH-NEXT: [AAMustProgress] for CtxI ' %2 = load i32, ptr %0, align 4' at position {fn:checkAndAdvance [checkAndAdvance@-1]} with state may-not-progress
; GRAPH-EMPTY:
; GRAPH-NEXT: [AAUndefinedBehavior] for CtxI ' %2 = load i32, ptr %0, align 4' at position {fn:checkAndAdvance [checkAndAdvance@-1]} with state undefined-behavior ; GRAPH-NEXT: [AAUndefinedBehavior] for CtxI ' %2 = load i32, ptr %0, align 4' at position {fn:checkAndAdvance [checkAndAdvance@-1]} with state undefined-behavior
; GRAPH-EMPTY: ; GRAPH-EMPTY:
; GRAPH-NEXT: [AANoUndef] for CtxI ' %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs_arg: [@0]} with state may-undef-or-poison ; GRAPH-NEXT: [AANoUndef] for CtxI ' %6 = call ptr @checkAndAdvance(ptr %5)' at position {cs_arg: [@0]} with state may-undef-or-poison
; GRAPH-EMPTY: ; GRAPH-EMPTY:
; GRAPH-NEXT: [AANoUndef] for CtxI ' %5 = getelementptr inbounds i32, ptr %0, i64 4' at position {flt: [@-1]} with state may-undef-or-poison ; GRAPH-NEXT: [AANoUndef] for CtxI ' %5 = getelementptr inbounds i32, ptr %0, i64 4' at position {flt: [@-1]} with state may-undef-or-poison
; GRAPH-EMPTY: ; GRAPH-EMPTY:
; GRAPH-NEXT: [AAIsDead] for CtxI ' %2 = load i32, ptr %0, align 4' at position {fn_ret:checkAndAdvance [checkAndAdvance@-1]} with state assumed-live ; GRAPH-NEXT: [AAIsDead] for CtxI ' %2 = load i32, ptr %0, align 4' at position {fn_ret:checkAndAdvance [checkAndAdvance@-1]} with state assumed-live
; GRAPH-EMPTY: ; GRAPH-EMPTY:
▲ Show 20 Lines • Show All 209 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/dereferenceable-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=6 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=6 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; FIXME: Figure out why we need 16 iterations here. ; FIXME: Figure out why we need 16 iterations here.
declare void @deref_phi_user(ptr %a); declare void @deref_phi_user(ptr %a);
; TEST 1 ; TEST 1
; take mininimum of return values ; take mininimum of return values
; ;
;. ;.
; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = global i64 0 ; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = global i64 0
;. ;.
define ptr @test1(ptr dereferenceable(4) %0, ptr dereferenceable(8) %1, i1 zeroext %2) local_unnamed_addr { define ptr @test1(ptr dereferenceable(4) %0, ptr dereferenceable(8) %1, i1 zeroext %2) local_unnamed_addr {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test1 ; CHECK-LABEL: define {{[^@]+}}@test1
; CHECK-SAME: (ptr nofree noundef nonnull readnone dereferenceable(4) "no-capture-maybe-returned" [[TMP0:%.*]], ptr nofree noundef nonnull readnone dereferenceable(8) "no-capture-maybe-returned" [[TMP1:%.*]], i1 zeroext [[TMP2:%.*]]) local_unnamed_addr #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr nofree noundef nonnull readnone dereferenceable(4) "no-capture-maybe-returned" [[TMP0:%.*]], ptr nofree noundef nonnull readnone dereferenceable(8) "no-capture-maybe-returned" [[TMP1:%.*]], i1 zeroext [[TMP2:%.*]]) local_unnamed_addr #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: [[TMP4:%.*]] = select i1 [[TMP2]], ptr [[TMP0]], ptr [[TMP1]] ; CHECK-NEXT: [[TMP4:%.*]] = select i1 [[TMP2]], ptr [[TMP0]], ptr [[TMP1]]
; CHECK-NEXT: ret ptr [[TMP4]] ; CHECK-NEXT: ret ptr [[TMP4]]
; ;
%4 = select i1 %2, ptr %0, ptr %1 %4 = select i1 %2, ptr %0, ptr %1
ret ptr %4 ret ptr %4
} }
; TEST 2 ; TEST 2
define ptr @test2(ptr dereferenceable_or_null(4) %0, ptr dereferenceable(8) %1, i1 zeroext %2) local_unnamed_addr { define ptr @test2(ptr dereferenceable_or_null(4) %0, ptr dereferenceable(8) %1, i1 zeroext %2) local_unnamed_addr {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test2 ; CHECK-LABEL: define {{[^@]+}}@test2
; CHECK-SAME: (ptr nofree noundef readnone dereferenceable_or_null(4) "no-capture-maybe-returned" [[TMP0:%.*]], ptr nofree noundef nonnull readnone dereferenceable(8) "no-capture-maybe-returned" [[TMP1:%.*]], i1 zeroext [[TMP2:%.*]]) local_unnamed_addr #[[ATTR0]] { ; CHECK-SAME: (ptr nofree noundef readnone dereferenceable_or_null(4) "no-capture-maybe-returned" [[TMP0:%.*]], ptr nofree noundef nonnull readnone dereferenceable(8) "no-capture-maybe-returned" [[TMP1:%.*]], i1 zeroext [[TMP2:%.*]]) local_unnamed_addr #[[ATTR0]] {
; CHECK-NEXT: [[TMP4:%.*]] = select i1 [[TMP2]], ptr [[TMP0]], ptr [[TMP1]] ; CHECK-NEXT: [[TMP4:%.*]] = select i1 [[TMP2]], ptr [[TMP0]], ptr [[TMP1]]
; CHECK-NEXT: ret ptr [[TMP4]] ; CHECK-NEXT: ret ptr [[TMP4]]
; ;
%4 = select i1 %2, ptr %0, ptr %1 %4 = select i1 %2, ptr %0, ptr %1
ret ptr %4 ret ptr %4
} }
; TEST 3 ; TEST 3
; GEP inbounds ; GEP inbounds
define ptr @test3_1(ptr dereferenceable(8) %0) local_unnamed_addr { define ptr @test3_1(ptr dereferenceable(8) %0) local_unnamed_addr {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test3_1 ; CHECK-LABEL: define {{[^@]+}}@test3_1
; CHECK-SAME: (ptr nofree noundef nonnull readnone dereferenceable(8) "no-capture-maybe-returned" [[TMP0:%.*]]) local_unnamed_addr #[[ATTR0]] { ; CHECK-SAME: (ptr nofree noundef nonnull readnone dereferenceable(8) "no-capture-maybe-returned" [[TMP0:%.*]]) local_unnamed_addr #[[ATTR0]] {
; CHECK-NEXT: [[RET:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 1 ; CHECK-NEXT: [[RET:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 1
; CHECK-NEXT: ret ptr [[RET]] ; CHECK-NEXT: ret ptr [[RET]]
; ;
%ret = getelementptr inbounds i32, ptr %0, i64 1 %ret = getelementptr inbounds i32, ptr %0, i64 1
ret ptr %ret ret ptr %ret
} }
define ptr @test3_2(ptr dereferenceable_or_null(32) %0) local_unnamed_addr { define ptr @test3_2(ptr dereferenceable_or_null(32) %0) local_unnamed_addr {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test3_2 ; CHECK-LABEL: define {{[^@]+}}@test3_2
; CHECK-SAME: (ptr nofree noundef readnone dereferenceable_or_null(32) "no-capture-maybe-returned" [[TMP0:%.*]]) local_unnamed_addr #[[ATTR0]] { ; CHECK-SAME: (ptr nofree noundef readnone dereferenceable_or_null(32) "no-capture-maybe-returned" [[TMP0:%.*]]) local_unnamed_addr #[[ATTR0]] {
; CHECK-NEXT: [[RET:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 4 ; CHECK-NEXT: [[RET:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 4
; CHECK-NEXT: ret ptr [[RET]] ; CHECK-NEXT: ret ptr [[RET]]
; ;
%ret = getelementptr inbounds i32, ptr %0, i64 4 %ret = getelementptr inbounds i32, ptr %0, i64 4
ret ptr %ret ret ptr %ret
} }
define ptr @test3_3(ptr dereferenceable(8) %0, ptr dereferenceable(16) %1, i1 %2) local_unnamed_addr { define ptr @test3_3(ptr dereferenceable(8) %0, ptr dereferenceable(16) %1, i1 %2) local_unnamed_addr {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test3_3 ; CHECK-LABEL: define {{[^@]+}}@test3_3
; CHECK-SAME: (ptr nofree noundef nonnull readnone dereferenceable(8) "no-capture-maybe-returned" [[TMP0:%.*]], ptr nofree noundef nonnull readnone dereferenceable(16) "no-capture-maybe-returned" [[TMP1:%.*]], i1 [[TMP2:%.*]]) local_unnamed_addr #[[ATTR0]] { ; CHECK-SAME: (ptr nofree noundef nonnull readnone dereferenceable(8) "no-capture-maybe-returned" [[TMP0:%.*]], ptr nofree noundef nonnull readnone dereferenceable(16) "no-capture-maybe-returned" [[TMP1:%.*]], i1 [[TMP2:%.*]]) local_unnamed_addr #[[ATTR0]] {
; CHECK-NEXT: [[RET1:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 1 ; CHECK-NEXT: [[RET1:%.*]] = getelementptr inbounds i32, ptr [[TMP0]], i64 1
; CHECK-NEXT: [[RET2:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 2 ; CHECK-NEXT: [[RET2:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 2
; CHECK-NEXT: [[RET:%.*]] = select i1 [[TMP2]], ptr [[RET1]], ptr [[RET2]] ; CHECK-NEXT: [[RET:%.*]] = select i1 [[TMP2]], ptr [[RET1]], ptr [[RET2]]
; CHECK-NEXT: ret ptr [[RET]] ; CHECK-NEXT: ret ptr [[RET]]
; ;
%ret1 = getelementptr inbounds i32, ptr %0, i64 1 %ret1 = getelementptr inbounds i32, ptr %0, i64 1
%ret2 = getelementptr inbounds i32, ptr %1, i64 2 %ret2 = getelementptr inbounds i32, ptr %1, i64 2
%ret = select i1 %2, ptr %ret1, ptr %ret2 %ret = select i1 %2, ptr %ret1, ptr %ret2
ret ptr %ret ret ptr %ret
} }
; TEST 4 ; TEST 4
; Better than known in IR. ; Better than known in IR.
define dereferenceable(4) ptr @test4(ptr dereferenceable(8) %0) local_unnamed_addr { define dereferenceable(4) ptr @test4(ptr dereferenceable(8) %0) local_unnamed_addr {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test4 ; CHECK-LABEL: define {{[^@]+}}@test4
; CHECK-SAME: (ptr nofree noundef nonnull readnone returned dereferenceable(8) "no-capture-maybe-returned" [[TMP0:%.*]]) local_unnamed_addr #[[ATTR0]] { ; CHECK-SAME: (ptr nofree noundef nonnull readnone returned dereferenceable(8) "no-capture-maybe-returned" [[TMP0:%.*]]) local_unnamed_addr #[[ATTR0]] {
; CHECK-NEXT: ret ptr [[TMP0]] ; CHECK-NEXT: ret ptr [[TMP0]]
; ;
ret ptr %0 ret ptr %0
} }
; TEST 5 ; TEST 5
▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 Linesfor.end: ; preds = %for.cond.cleanup
ret void ret void
} }
; TEST 7 ; TEST 7
; share known infomation in must-be-executed-context ; share known infomation in must-be-executed-context
declare ptr @unkown_ptr() willreturn nounwind declare ptr @unkown_ptr() willreturn nounwind
declare i32 @unkown_f(ptr) willreturn nounwind declare i32 @unkown_f(ptr) willreturn nounwind
define ptr @f7_0(ptr %ptr) { define ptr @f7_0(ptr %ptr) {
; CHECK: Function Attrs: nounwind willreturn ; CHECK: Function Attrs: mustprogress nounwind willreturn
; CHECK-LABEL: define {{[^@]+}}@f7_0 ; CHECK-LABEL: define {{[^@]+}}@f7_0
; CHECK-SAME: (ptr noundef nonnull returned dereferenceable(8) [[PTR:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (ptr noundef nonnull returned dereferenceable(8) [[PTR:%.*]]) #[[ATTR2:[0-9]+]] {
; CHECK-NEXT: [[T:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull dereferenceable(8) [[PTR]]) #[[ATTR1]] ; CHECK-NEXT: [[T:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull dereferenceable(8) [[PTR]]) #[[ATTR1:[0-9]+]]
; CHECK-NEXT: ret ptr [[PTR]] ; CHECK-NEXT: ret ptr [[PTR]]
; ;
%T = tail call i32 @unkown_f(ptr dereferenceable(8) %ptr) %T = tail call i32 @unkown_f(ptr dereferenceable(8) %ptr)
ret ptr %ptr ret ptr %ptr
} }
define void @f7_1(ptr %ptr, i1 %c) { define void @f7_1(ptr %ptr, i1 %c) {
; CHECK: Function Attrs: nounwind willreturn ; CHECK: Function Attrs: mustprogress nounwind willreturn
; CHECK-LABEL: define {{[^@]+}}@f7_1 ; CHECK-LABEL: define {{[^@]+}}@f7_1
; CHECK-SAME: (ptr noundef nonnull align 4 dereferenceable(4) [[PTR:%.*]], i1 noundef [[C:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ptr noundef nonnull align 4 dereferenceable(4) [[PTR:%.*]], i1 noundef [[C:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[A:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull align 4 dereferenceable(4) [[PTR]]) #[[ATTR1]] ; CHECK-NEXT: [[A:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull align 4 dereferenceable(4) [[PTR]]) #[[ATTR1]]
; CHECK-NEXT: [[PTR_0:%.*]] = load i32, ptr [[PTR]], align 4 ; CHECK-NEXT: [[PTR_0:%.*]] = load i32, ptr [[PTR]], align 4
; CHECK-NEXT: [[B:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull align 4 dereferenceable(4) [[PTR]]) #[[ATTR1]] ; CHECK-NEXT: [[B:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull align 4 dereferenceable(4) [[PTR]]) #[[ATTR1]]
; CHECK-NEXT: br i1 [[C]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]] ; CHECK-NEXT: br i1 [[C]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]]
; CHECK: if.true: ; CHECK: if.true:
; CHECK-NEXT: [[C:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull align 4 dereferenceable(8) [[PTR]]) #[[ATTR1]] ; CHECK-NEXT: [[C:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull align 4 dereferenceable(8) [[PTR]]) #[[ATTR1]]
; CHECK-NEXT: [[D:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull align 4 dereferenceable(8) [[PTR]]) #[[ATTR1]] ; CHECK-NEXT: [[D:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull align 4 dereferenceable(8) [[PTR]]) #[[ATTR1]]
; CHECK-NEXT: [[E:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull align 4 dereferenceable(8) [[PTR]]) #[[ATTR1]] ; CHECK-NEXT: [[E:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull align 4 dereferenceable(8) [[PTR]]) #[[ATTR1]]
Show All 12 Linesif.true:
%D = tail call i32 @unkown_f(ptr dereferenceable(8) %ptr) %D = tail call i32 @unkown_f(ptr dereferenceable(8) %ptr)
%E = tail call i32 @unkown_f(ptr %ptr) %E = tail call i32 @unkown_f(ptr %ptr)
ret void ret void
if.false: if.false:
ret void ret void
} }
define void @f7_2(i1 %c) { define void @f7_2(i1 %c) {
; CHECK: Function Attrs: nounwind willreturn ; CHECK: Function Attrs: mustprogress nounwind willreturn
; CHECK-LABEL: define {{[^@]+}}@f7_2 ; CHECK-LABEL: define {{[^@]+}}@f7_2
; CHECK-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[PTR:%.*]] = tail call nonnull align 4 dereferenceable(4) ptr @unkown_ptr() #[[ATTR1]] ; CHECK-NEXT: [[PTR:%.*]] = tail call nonnull align 4 dereferenceable(4) ptr @unkown_ptr() #[[ATTR1]]
; CHECK-NEXT: [[A:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull align 4 dereferenceable(4) [[PTR]]) #[[ATTR1]] ; CHECK-NEXT: [[A:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull align 4 dereferenceable(4) [[PTR]]) #[[ATTR1]]
; CHECK-NEXT: [[ARG_A_0:%.*]] = load i32, ptr [[PTR]], align 4 ; CHECK-NEXT: [[ARG_A_0:%.*]] = load i32, ptr [[PTR]], align 4
; CHECK-NEXT: [[B:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull align 4 dereferenceable(4) [[PTR]]) #[[ATTR1]] ; CHECK-NEXT: [[B:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull align 4 dereferenceable(4) [[PTR]]) #[[ATTR1]]
; CHECK-NEXT: br i1 [[C]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]] ; CHECK-NEXT: br i1 [[C]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]]
; CHECK: if.true: ; CHECK: if.true:
; CHECK-NEXT: [[C:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull align 4 dereferenceable(8) [[PTR]]) #[[ATTR1]] ; CHECK-NEXT: [[C:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull align 4 dereferenceable(8) [[PTR]]) #[[ATTR1]]
; CHECK-NEXT: [[D:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull align 4 dereferenceable(8) [[PTR]]) #[[ATTR1]] ; CHECK-NEXT: [[D:%.*]] = tail call i32 @unkown_f(ptr noundef nonnull align 4 dereferenceable(8) [[PTR]]) #[[ATTR1]]
Show All 13 Linesif.true:
%D = tail call i32 @unkown_f(ptr dereferenceable(8) %ptr) %D = tail call i32 @unkown_f(ptr dereferenceable(8) %ptr)
%E = tail call i32 @unkown_f(ptr %ptr) %E = tail call i32 @unkown_f(ptr %ptr)
ret void ret void
if.false: if.false:
ret void ret void
} }
define ptr @f7_3() { define ptr @f7_3() {
; CHECK: Function Attrs: nounwind willreturn ; CHECK: Function Attrs: mustprogress nounwind willreturn
; CHECK-LABEL: define {{[^@]+}}@f7_3 ; CHECK-LABEL: define {{[^@]+}}@f7_3
; CHECK-SAME: () #[[ATTR1]] { ; CHECK-SAME: () #[[ATTR2]] {
; CHECK-NEXT: [[PTR:%.*]] = tail call noundef nonnull align 16 dereferenceable(4) ptr @unkown_ptr() #[[ATTR1]] ; CHECK-NEXT: [[PTR:%.*]] = tail call noundef nonnull align 16 dereferenceable(4) ptr @unkown_ptr() #[[ATTR1]]
; CHECK-NEXT: store i32 10, ptr [[PTR]], align 16 ; CHECK-NEXT: store i32 10, ptr [[PTR]], align 16
; CHECK-NEXT: ret ptr [[PTR]] ; CHECK-NEXT: ret ptr [[PTR]]
; ;
%ptr = tail call ptr @unkown_ptr() %ptr = tail call ptr @unkown_ptr()
store i32 10, ptr %ptr, align 16 store i32 10, ptr %ptr, align 16
ret ptr %ptr ret ptr %ptr
} }
; FIXME: This should have a return dereferenceable(8) but we need to make sure it will work in loops as well. ; FIXME: This should have a return dereferenceable(8) but we need to make sure it will work in loops as well.
define ptr @test_for_minus_index(ptr %p) { define ptr @test_for_minus_index(ptr %p) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@test_for_minus_index ; CHECK-LABEL: define {{[^@]+}}@test_for_minus_index
; CHECK-SAME: (ptr nofree nonnull writeonly align 4 "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR2:[0-9]+]] { ; CHECK-SAME: (ptr nofree nonnull writeonly align 4 "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR3:[0-9]+]] {
; CHECK-NEXT: [[Q:%.*]] = getelementptr inbounds i32, ptr [[P]], i32 -2 ; CHECK-NEXT: [[Q:%.*]] = getelementptr inbounds i32, ptr [[P]], i32 -2
; CHECK-NEXT: store i32 1, ptr [[Q]], align 4 ; CHECK-NEXT: store i32 1, ptr [[Q]], align 4
; CHECK-NEXT: ret ptr [[Q]] ; CHECK-NEXT: ret ptr [[Q]]
; ;
%q = getelementptr inbounds i32, ptr %p, i32 -2 %q = getelementptr inbounds i32, ptr %p, i32 -2
store i32 1, ptr %q store i32 1, ptr %q
ret ptr %q ret ptr %q
} }
define void @deref_or_null_and_nonnull(ptr dereferenceable_or_null(100) %0) { define void @deref_or_null_and_nonnull(ptr dereferenceable_or_null(100) %0) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@deref_or_null_and_nonnull ; CHECK-LABEL: define {{[^@]+}}@deref_or_null_and_nonnull
; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(100) [[TMP0:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(100) [[TMP0:%.*]]) #[[ATTR3]] {
; CHECK-NEXT: store i32 1, ptr [[TMP0]], align 4 ; CHECK-NEXT: store i32 1, ptr [[TMP0]], align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store i32 1, ptr %0 store i32 1, ptr %0
ret void ret void
} }
; TEST 8 ; TEST 8
; Use Constant range in deereferenceable ; Use Constant range in deereferenceable
; void g(int *p, long long int *range){ ; void g(int *p, long long int *range){
; int r = *range ; // [10, 99] ; int r = *range ; // [10, 99]
; fill_range(p, *range); ; fill_range(p, *range);
; } ; }
; FIXME: %ptr should be dereferenceable(31) ; FIXME: %ptr should be dereferenceable(31)
define void @test8(ptr %ptr) #0 { define void @test8(ptr %ptr) #0 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@test8 ; CHECK-LABEL: define {{[^@]+}}@test8
; CHECK-SAME: (ptr nocapture nofree nonnull writeonly dereferenceable(21) [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull writeonly dereferenceable(21) [[PTR:%.*]]) #[[ATTR3]] {
; CHECK-NEXT: br label [[TMP1:%.*]] ; CHECK-NEXT: br label [[TMP1:%.*]]
; CHECK: 1: ; CHECK: 1:
; CHECK-NEXT: [[I_0:%.*]] = phi i32 [ 20, [[TMP0:%.*]] ], [ [[TMP4:%.*]], [[TMP5:%.*]] ] ; CHECK-NEXT: [[I_0:%.*]] = phi i32 [ 20, [[TMP0:%.*]] ], [ [[TMP4:%.*]], [[TMP5:%.*]] ]
; CHECK-NEXT: [[TMP2:%.*]] = sext i32 [[I_0]] to i64 ; CHECK-NEXT: [[TMP2:%.*]] = sext i32 [[I_0]] to i64
; CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 [[TMP2]] ; CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 [[TMP2]]
; CHECK-NEXT: store i8 32, ptr [[TMP3]], align 1 ; CHECK-NEXT: store i8 32, ptr [[TMP3]], align 1
; CHECK-NEXT: [[TMP4]] = add nsw i32 [[I_0]], 1 ; CHECK-NEXT: [[TMP4]] = add nsw i32 [[I_0]], 1
; CHECK-NEXT: br label [[TMP5]] ; CHECK-NEXT: br label [[TMP5]]
Show All 16 Lines5: ; preds = %1
br i1 %6, label %1, label %7 br i1 %6, label %1, label %7
7: ; preds = %5 7: ; preds = %5
ret void ret void
} }
; 8.2 (negative case) ; 8.2 (negative case)
define void @test8_neg(i32 %i, ptr %ptr) #0 { define void @test8_neg(i32 %i, ptr %ptr) #0 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@test8_neg ; CHECK-LABEL: define {{[^@]+}}@test8_neg
; CHECK-SAME: (i32 [[I:%.*]], ptr nocapture nofree nonnull writeonly [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (i32 [[I:%.*]], ptr nocapture nofree nonnull writeonly [[PTR:%.*]]) #[[ATTR3]] {
; CHECK-NEXT: [[TMP1:%.*]] = sext i32 [[I]] to i64 ; CHECK-NEXT: [[TMP1:%.*]] = sext i32 [[I]] to i64
; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 [[TMP1]] ; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, ptr [[PTR]], i64 [[TMP1]]
; CHECK-NEXT: store i8 65, ptr [[TMP2]], align 1 ; CHECK-NEXT: store i8 65, ptr [[TMP2]], align 1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%1 = sext i32 %i to i64 %1 = sext i32 %i to i64
%2 = getelementptr inbounds i8, ptr %ptr, i64 %1 %2 = getelementptr inbounds i8, ptr %ptr, i64 %1
store i8 65, ptr %2, align 1 store i8 65, ptr %2, align 1
ret void ret void
} }
; void fill_range(int* p, long long int start){ ; void fill_range(int* p, long long int start){
; for(long long int i = start;i<start+10;i++){ ; for(long long int i = start;i<start+10;i++){
; // If p[i] is inbounds, p is dereferenceable(40) at least. ; // If p[i] is inbounds, p is dereferenceable(40) at least.
; p[i] = i; ; p[i] = i;
; } ; }
; } ; }
; NOTE: %p should not be dereferenceable ; NOTE: %p should not be dereferenceable
define internal void @fill_range_not_inbounds(ptr %p, i64 %start){ define internal void @fill_range_not_inbounds(ptr %p, i64 %start){
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@fill_range_not_inbounds ; CHECK-LABEL: define {{[^@]+}}@fill_range_not_inbounds
; CHECK-SAME: (ptr nocapture nofree writeonly [[P:%.*]], i64 [[START:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree writeonly [[P:%.*]], i64 [[START:%.*]]) #[[ATTR3]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = add nsw i64 [[START]], 9 ; CHECK-NEXT: [[TMP0:%.*]] = add nsw i64 [[START]], 9
; CHECK-NEXT: br label [[FOR_BODY:%.*]] ; CHECK-NEXT: br label [[FOR_BODY:%.*]]
; CHECK: for.cond.cleanup: ; CHECK: for.cond.cleanup:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK: for.body: ; CHECK: for.body:
; CHECK-NEXT: [[I_06:%.*]] = phi i64 [ [[START]], [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FOR_BODY]] ] ; CHECK-NEXT: [[I_06:%.*]] = phi i64 [ [[START]], [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[CONV:%.*]] = trunc i64 [[I_06]] to i32 ; CHECK-NEXT: [[CONV:%.*]] = trunc i64 [[I_06]] to i32
Show All 17 Linesfor.body: ; preds = %entry, %for.body
store i32 %conv, ptr %arrayidx, align 4 store i32 %conv, ptr %arrayidx, align 4
%inc = add nsw i64 %i.06, 1 %inc = add nsw i64 %i.06, 1
%cmp = icmp slt i64 %i.06, %0 %cmp = icmp slt i64 %i.06, %0
br i1 %cmp, label %for.body, label %for.cond.cleanup br i1 %cmp, label %for.body, label %for.cond.cleanup
} }
; FIXME: %p should be dereferenceable(40) ; FIXME: %p should be dereferenceable(40)
define internal void @fill_range_inbounds(ptr %p, i64 %start){ define internal void @fill_range_inbounds(ptr %p, i64 %start){
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@fill_range_inbounds ; CHECK-LABEL: define {{[^@]+}}@fill_range_inbounds
; CHECK-SAME: (ptr nocapture nofree writeonly [[P:%.*]], i64 [[START:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree writeonly [[P:%.*]], i64 [[START:%.*]]) #[[ATTR3]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = add nsw i64 [[START]], 9 ; CHECK-NEXT: [[TMP0:%.*]] = add nsw i64 [[START]], 9
; CHECK-NEXT: br label [[FOR_BODY:%.*]] ; CHECK-NEXT: br label [[FOR_BODY:%.*]]
; CHECK: for.cond.cleanup: ; CHECK: for.cond.cleanup:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK: for.body: ; CHECK: for.body:
; CHECK-NEXT: [[I_06:%.*]] = phi i64 [ [[START]], [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FOR_BODY]] ] ; CHECK-NEXT: [[I_06:%.*]] = phi i64 [ [[START]], [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FOR_BODY]] ]
; CHECK-NEXT: [[CONV:%.*]] = trunc i64 [[I_06]] to i32 ; CHECK-NEXT: [[CONV:%.*]] = trunc i64 [[I_06]] to i32
Show All 16 Linesfor.body: ; preds = %entry, %for.body
%arrayidx = getelementptr inbounds i32, ptr %p, i64 %i.06 %arrayidx = getelementptr inbounds i32, ptr %p, i64 %i.06
store i32 %conv, ptr %arrayidx, align 4 store i32 %conv, ptr %arrayidx, align 4
%inc = add nsw i64 %i.06, 1 %inc = add nsw i64 %i.06, 1
%cmp = icmp slt i64 %i.06, %0 %cmp = icmp slt i64 %i.06, %0
br i1 %cmp, label %for.body, label %for.cond.cleanup br i1 %cmp, label %for.body, label %for.cond.cleanup
} }
define void @call_fill_range(ptr nocapture %p, ptr nocapture readonly %range) { define void @call_fill_range(ptr nocapture %p, ptr nocapture readonly %range) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@call_fill_range ; TUNIT-LABEL: define {{[^@]+}}@call_fill_range
; TUNIT-SAME: (ptr nocapture nofree writeonly [[P:%.*]], ptr nocapture nofree noundef nonnull readonly align 8 dereferenceable(8) [[RANGE:%.*]]) #[[ATTR3:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree writeonly [[P:%.*]], ptr nocapture nofree noundef nonnull readonly align 8 dereferenceable(8) [[RANGE:%.*]]) #[[ATTR4:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[TMP0:%.*]] = load i64, ptr [[RANGE]], align 8, !range [[RNG0:![0-9]+]] ; TUNIT-NEXT: [[TMP0:%.*]] = load i64, ptr [[RANGE]], align 8, !range [[RNG0:![0-9]+]]
; TUNIT-NEXT: tail call void @fill_range_inbounds(ptr nocapture nofree writeonly [[P]], i64 [[TMP0]]) #[[ATTR6:[0-9]+]] ; TUNIT-NEXT: tail call void @fill_range_inbounds(ptr nocapture nofree writeonly [[P]], i64 [[TMP0]]) #[[ATTR7:[0-9]+]]
; TUNIT-NEXT: tail call void @fill_range_not_inbounds(ptr nocapture nofree writeonly [[P]], i64 [[TMP0]]) #[[ATTR6]] ; TUNIT-NEXT: tail call void @fill_range_not_inbounds(ptr nocapture nofree writeonly [[P]], i64 [[TMP0]]) #[[ATTR7]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@call_fill_range ; CGSCC-LABEL: define {{[^@]+}}@call_fill_range
; CGSCC-SAME: (ptr nocapture nofree writeonly [[P:%.*]], ptr nocapture nofree noundef nonnull readonly align 8 dereferenceable(8) [[RANGE:%.*]]) #[[ATTR3:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree writeonly [[P:%.*]], ptr nocapture nofree noundef nonnull readonly align 8 dereferenceable(8) [[RANGE:%.*]]) #[[ATTR4:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[TMP0:%.*]] = load i64, ptr [[RANGE]], align 8, !range [[RNG0:![0-9]+]] ; CGSCC-NEXT: [[TMP0:%.*]] = load i64, ptr [[RANGE]], align 8, !range [[RNG0:![0-9]+]]
; CGSCC-NEXT: tail call void @fill_range_inbounds(ptr nocapture nofree writeonly [[P]], i64 [[TMP0]]) #[[ATTR1]] ; CGSCC-NEXT: tail call void @fill_range_inbounds(ptr nocapture nofree writeonly [[P]], i64 [[TMP0]]) #[[ATTR1]]
; CGSCC-NEXT: tail call void @fill_range_not_inbounds(ptr nocapture nofree writeonly [[P]], i64 [[TMP0]]) #[[ATTR1]] ; CGSCC-NEXT: tail call void @fill_range_not_inbounds(ptr nocapture nofree writeonly [[P]], i64 [[TMP0]]) #[[ATTR1]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
entry: entry:
%0 = load i64, ptr %range, align 8, !range !0 %0 = load i64, ptr %range, align 8, !range !0
Show All 9 Lines
; simple path test ; simple path test
; if(..) ; if(..)
; fun2(dereferenceable(8) %a, dereferenceable(8) %b) ; fun2(dereferenceable(8) %a, dereferenceable(8) %b)
; else ; else
; fun2(dereferenceable(4) %a, %b) ; fun2(dereferenceable(4) %a, %b)
; We can say that %a is dereferenceable(4) but %b is not. ; We can say that %a is dereferenceable(4) but %b is not.
define void @simple-path(ptr %a, ptr %b, i8 %c) { define void @simple-path(ptr %a, ptr %b, i8 %c) {
; CHECK: Function Attrs: nounwind willreturn ; CHECK: Function Attrs: mustprogress nounwind willreturn
; CHECK-LABEL: define {{[^@]+}}@simple-path ; CHECK-LABEL: define {{[^@]+}}@simple-path
; CHECK-SAME: (ptr nonnull dereferenceable(4) [[A:%.*]], ptr [[B:%.*]], i8 [[C:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ptr nonnull dereferenceable(4) [[A:%.*]], ptr [[B:%.*]], i8 [[C:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i8 [[C]], 0 ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i8 [[C]], 0
; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; CHECK: if.then: ; CHECK: if.then:
; CHECK-NEXT: tail call void @use2(ptr nonnull dereferenceable(8) [[A]], ptr nonnull dereferenceable(8) [[B]]) #[[ATTR1]] ; CHECK-NEXT: tail call void @use2(ptr nonnull dereferenceable(8) [[A]], ptr nonnull dereferenceable(8) [[B]]) #[[ATTR1]]
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK: if.else: ; CHECK: if.else:
; CHECK-NEXT: tail call void @use2(ptr nonnull dereferenceable(4) [[A]], ptr [[B]]) #[[ATTR1]] ; CHECK-NEXT: tail call void @use2(ptr nonnull dereferenceable(4) [[A]], ptr [[B]]) #[[ATTR1]]
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
Show All 16 Lines
; fun1(dereferenceable(12) %a) ; fun1(dereferenceable(12) %a)
; else ; else
; ... (willreturn & nounwind) ; ... (willreturn & nounwind)
; fun1(dereferenceable(16) %a) ; fun1(dereferenceable(16) %a)
; fun1(dereferenceable(8) %a) ; fun1(dereferenceable(8) %a)
; } ; }
; %a is dereferenceable(12) ; %a is dereferenceable(12)
define void @complex-path(ptr %a, ptr %b, i8 %c) { define void @complex-path(ptr %a, ptr %b, i8 %c) {
; CHECK: Function Attrs: nounwind willreturn ; CHECK: Function Attrs: mustprogress nounwind willreturn
; CHECK-LABEL: define {{[^@]+}}@complex-path ; CHECK-LABEL: define {{[^@]+}}@complex-path
; CHECK-SAME: (ptr noundef nonnull dereferenceable(12) [[A:%.*]], ptr nocapture nofree readnone [[B:%.*]], i8 [[C:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ptr noundef nonnull dereferenceable(12) [[A:%.*]], ptr nocapture nofree readnone [[B:%.*]], i8 [[C:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i8 [[C]], 0 ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i8 [[C]], 0
; CHECK-NEXT: tail call void @use1(ptr noundef nonnull dereferenceable(12) [[A]]) #[[ATTR1]] ; CHECK-NEXT: tail call void @use1(ptr noundef nonnull dereferenceable(12) [[A]]) #[[ATTR1]]
; CHECK-NEXT: br i1 [[CMP]], label [[CONT_THEN:%.*]], label [[CONT_ELSE:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[CONT_THEN:%.*]], label [[CONT_ELSE:%.*]]
; CHECK: cont.then: ; CHECK: cont.then:
; CHECK-NEXT: tail call void @use1(ptr noundef nonnull dereferenceable(12) [[A]]) #[[ATTR1]] ; CHECK-NEXT: tail call void @use1(ptr noundef nonnull dereferenceable(12) [[A]]) #[[ATTR1]]
; CHECK-NEXT: br label [[CONT2:%.*]] ; CHECK-NEXT: br label [[CONT2:%.*]]
; CHECK: cont.else: ; CHECK: cont.else:
; CHECK-NEXT: tail call void @use1(ptr noundef nonnull dereferenceable(16) [[A]]) #[[ATTR1]] ; CHECK-NEXT: tail call void @use1(ptr noundef nonnull dereferenceable(16) [[A]]) #[[ATTR1]]
Show All 27 Lines
; *ptr = 3; ; *ptr = 3;
; else ; else
; *ptr = 4; ; *ptr = 4;
; } ; }
; } ; }
; ;
; FIXME: %ptr should be dereferenceable(4) ; FIXME: %ptr should be dereferenceable(4)
define dso_local void @rec-branch-1(i32 %a, i32 %b, i32 %c, ptr %ptr) { define dso_local void @rec-branch-1(i32 %a, i32 %b, i32 %c, ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@rec-branch-1 ; CHECK-LABEL: define {{[^@]+}}@rec-branch-1
; CHECK-SAME: (i32 [[A:%.*]], i32 [[B:%.*]], i32 [[C:%.*]], ptr nocapture nofree writeonly [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (i32 [[A:%.*]], i32 [[B:%.*]], i32 [[C:%.*]], ptr nocapture nofree writeonly [[PTR:%.*]]) #[[ATTR3]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[A]], 0 ; CHECK-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[A]], 0
; CHECK-NEXT: br i1 [[TOBOOL]], label [[IF_ELSE3:%.*]], label [[IF_THEN:%.*]] ; CHECK-NEXT: br i1 [[TOBOOL]], label [[IF_ELSE3:%.*]], label [[IF_THEN:%.*]]
; CHECK: if.then: ; CHECK: if.then:
; CHECK-NEXT: [[TOBOOL1:%.*]] = icmp eq i32 [[B]], 0 ; CHECK-NEXT: [[TOBOOL1:%.*]] = icmp eq i32 [[B]], 0
; CHECK-NEXT: br i1 [[TOBOOL1]], label [[IF_ELSE:%.*]], label [[IF_THEN2:%.*]] ; CHECK-NEXT: br i1 [[TOBOOL1]], label [[IF_ELSE:%.*]], label [[IF_THEN2:%.*]]
; CHECK: if.then2: ; CHECK: if.then2:
; CHECK-NEXT: store i32 1, ptr [[PTR]], align 4 ; CHECK-NEXT: store i32 1, ptr [[PTR]], align 4
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
; else ; else
; rec-branch-2(1, 1, 1, ptr); ; rec-branch-2(1, 1, 1, ptr);
; } ; }
; } ; }
; FIXME: %ptr should be dereferenceable(4) ; FIXME: %ptr should be dereferenceable(4)
define dso_local void @rec-branch-2(i32 %a, i32 %b, i32 %c, ptr %ptr) { define dso_local void @rec-branch-2(i32 %a, i32 %b, i32 %c, ptr %ptr) {
; TUNIT: Function Attrs: nofree nosync nounwind memory(argmem: write) ; TUNIT: Function Attrs: nofree nosync nounwind memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@rec-branch-2 ; TUNIT-LABEL: define {{[^@]+}}@rec-branch-2
; TUNIT-SAME: (i32 [[A:%.*]], i32 [[B:%.*]], i32 [[C:%.*]], ptr nocapture nofree writeonly [[PTR:%.*]]) #[[ATTR4:[0-9]+]] { ; TUNIT-SAME: (i32 [[A:%.*]], i32 [[B:%.*]], i32 [[C:%.*]], ptr nocapture nofree writeonly [[PTR:%.*]]) #[[ATTR5:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[A]], 0 ; TUNIT-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[A]], 0
; TUNIT-NEXT: br i1 [[TOBOOL]], label [[IF_ELSE3:%.*]], label [[IF_THEN:%.*]] ; TUNIT-NEXT: br i1 [[TOBOOL]], label [[IF_ELSE3:%.*]], label [[IF_THEN:%.*]]
; TUNIT: if.then: ; TUNIT: if.then:
; TUNIT-NEXT: [[TOBOOL1:%.*]] = icmp eq i32 [[B]], 0 ; TUNIT-NEXT: [[TOBOOL1:%.*]] = icmp eq i32 [[B]], 0
; TUNIT-NEXT: br i1 [[TOBOOL1]], label [[IF_ELSE:%.*]], label [[IF_THEN2:%.*]] ; TUNIT-NEXT: br i1 [[TOBOOL1]], label [[IF_ELSE:%.*]], label [[IF_THEN2:%.*]]
; TUNIT: if.then2: ; TUNIT: if.then2:
; TUNIT-NEXT: store i32 1, ptr [[PTR]], align 4 ; TUNIT-NEXT: store i32 1, ptr [[PTR]], align 4
; TUNIT-NEXT: br label [[IF_END8:%.*]] ; TUNIT-NEXT: br label [[IF_END8:%.*]]
; TUNIT: if.else: ; TUNIT: if.else:
; TUNIT-NEXT: store i32 2, ptr [[PTR]], align 4 ; TUNIT-NEXT: store i32 2, ptr [[PTR]], align 4
; TUNIT-NEXT: br label [[IF_END8]] ; TUNIT-NEXT: br label [[IF_END8]]
; TUNIT: if.else3: ; TUNIT: if.else3:
; TUNIT-NEXT: [[TOBOOL4:%.*]] = icmp eq i32 [[C]], 0 ; TUNIT-NEXT: [[TOBOOL4:%.*]] = icmp eq i32 [[C]], 0
; TUNIT-NEXT: br i1 [[TOBOOL4]], label [[IF_ELSE6:%.*]], label [[IF_THEN5:%.*]] ; TUNIT-NEXT: br i1 [[TOBOOL4]], label [[IF_ELSE6:%.*]], label [[IF_THEN5:%.*]]
; TUNIT: if.then5: ; TUNIT: if.then5:
; TUNIT-NEXT: store i32 3, ptr [[PTR]], align 4 ; TUNIT-NEXT: store i32 3, ptr [[PTR]], align 4
; TUNIT-NEXT: br label [[IF_END8]] ; TUNIT-NEXT: br label [[IF_END8]]
; TUNIT: if.else6: ; TUNIT: if.else6:
; TUNIT-NEXT: tail call void @rec-branch-2(i32 noundef 1, i32 noundef 1, i32 noundef 1, ptr nocapture nofree writeonly [[PTR]]) #[[ATTR7:[0-9]+]] ; TUNIT-NEXT: tail call void @rec-branch-2(i32 noundef 1, i32 noundef 1, i32 noundef 1, ptr nocapture nofree writeonly [[PTR]]) #[[ATTR8:[0-9]+]]
; TUNIT-NEXT: br label [[IF_END8]] ; TUNIT-NEXT: br label [[IF_END8]]
; TUNIT: if.end8: ; TUNIT: if.end8:
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind memory(argmem: write) ; CGSCC: Function Attrs: nofree nosync nounwind memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@rec-branch-2 ; CGSCC-LABEL: define {{[^@]+}}@rec-branch-2
; CGSCC-SAME: (i32 [[A:%.*]], i32 [[B:%.*]], i32 [[C:%.*]], ptr nocapture nofree writeonly [[PTR:%.*]]) #[[ATTR4:[0-9]+]] { ; CGSCC-SAME: (i32 [[A:%.*]], i32 [[B:%.*]], i32 [[C:%.*]], ptr nocapture nofree writeonly [[PTR:%.*]]) #[[ATTR5:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[A]], 0 ; CGSCC-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[A]], 0
; CGSCC-NEXT: br i1 [[TOBOOL]], label [[IF_ELSE3:%.*]], label [[IF_THEN:%.*]] ; CGSCC-NEXT: br i1 [[TOBOOL]], label [[IF_ELSE3:%.*]], label [[IF_THEN:%.*]]
; CGSCC: if.then: ; CGSCC: if.then:
; CGSCC-NEXT: [[TOBOOL1:%.*]] = icmp eq i32 [[B]], 0 ; CGSCC-NEXT: [[TOBOOL1:%.*]] = icmp eq i32 [[B]], 0
; CGSCC-NEXT: br i1 [[TOBOOL1]], label [[IF_ELSE:%.*]], label [[IF_THEN2:%.*]] ; CGSCC-NEXT: br i1 [[TOBOOL1]], label [[IF_ELSE:%.*]], label [[IF_THEN2:%.*]]
; CGSCC: if.then2: ; CGSCC: if.then2:
; CGSCC-NEXT: store i32 1, ptr [[PTR]], align 4 ; CGSCC-NEXT: store i32 1, ptr [[PTR]], align 4
; CGSCC-NEXT: br label [[IF_END8:%.*]] ; CGSCC-NEXT: br label [[IF_END8:%.*]]
; CGSCC: if.else: ; CGSCC: if.else:
; CGSCC-NEXT: store i32 2, ptr [[PTR]], align 4 ; CGSCC-NEXT: store i32 2, ptr [[PTR]], align 4
; CGSCC-NEXT: br label [[IF_END8]] ; CGSCC-NEXT: br label [[IF_END8]]
; CGSCC: if.else3: ; CGSCC: if.else3:
; CGSCC-NEXT: [[TOBOOL4:%.*]] = icmp eq i32 [[C]], 0 ; CGSCC-NEXT: [[TOBOOL4:%.*]] = icmp eq i32 [[C]], 0
; CGSCC-NEXT: br i1 [[TOBOOL4]], label [[IF_ELSE6:%.*]], label [[IF_THEN5:%.*]] ; CGSCC-NEXT: br i1 [[TOBOOL4]], label [[IF_ELSE6:%.*]], label [[IF_THEN5:%.*]]
; CGSCC: if.then5: ; CGSCC: if.then5:
; CGSCC-NEXT: store i32 3, ptr [[PTR]], align 4 ; CGSCC-NEXT: store i32 3, ptr [[PTR]], align 4
; CGSCC-NEXT: br label [[IF_END8]] ; CGSCC-NEXT: br label [[IF_END8]]
; CGSCC: if.else6: ; CGSCC: if.else6:
; CGSCC-NEXT: tail call void @rec-branch-2(i32 noundef 1, i32 noundef 1, i32 noundef 1, ptr nocapture nofree writeonly [[PTR]]) #[[ATTR6:[0-9]+]] ; CGSCC-NEXT: tail call void @rec-branch-2(i32 noundef 1, i32 noundef 1, i32 noundef 1, ptr nocapture nofree writeonly [[PTR]]) #[[ATTR7:[0-9]+]]
; CGSCC-NEXT: br label [[IF_END8]] ; CGSCC-NEXT: br label [[IF_END8]]
; CGSCC: if.end8: ; CGSCC: if.end8:
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
entry: entry:
%tobool = icmp eq i32 %a, 0 %tobool = icmp eq i32 %a, 0
br i1 %tobool, label %if.else3, label %if.then br i1 %tobool, label %if.else3, label %if.then
Show All 30 Lines
; ATTRIBUTOR-LABEL: define {{[^@]+}}@nonnull_assume_pos ; ATTRIBUTOR-LABEL: define {{[^@]+}}@nonnull_assume_pos
; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(101) [[ARG1:%.*]], ptr nocapture nofree readnone dereferenceable_or_null(31) [[ARG2:%.*]], ptr nocapture nofree nonnull readnone [[ARG3:%.*]], ptr nocapture nofree readnone dereferenceable_or_null(42) [[ARG4:%.*]]) ; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(101) [[ARG1:%.*]], ptr nocapture nofree readnone dereferenceable_or_null(31) [[ARG2:%.*]], ptr nocapture nofree nonnull readnone [[ARG3:%.*]], ptr nocapture nofree readnone dereferenceable_or_null(42) [[ARG4:%.*]])
; ATTRIBUTOR-NEXT: call void @llvm.assume(i1 true) #6 [ "nonnull"(ptr undef), "dereferenceable"(ptr undef, i64 1), "dereferenceable"(ptr undef, i64 2), "dereferenceable"(ptr undef, i64 101), "dereferenceable_or_null"(ptr undef, i64 31), "dereferenceable_or_null"(ptr undef, i64 42) ] ; ATTRIBUTOR-NEXT: call void @llvm.assume(i1 true) #6 [ "nonnull"(ptr undef), "dereferenceable"(ptr undef, i64 1), "dereferenceable"(ptr undef, i64 2), "dereferenceable"(ptr undef, i64 101), "dereferenceable_or_null"(ptr undef, i64 31), "dereferenceable_or_null"(ptr undef, i64 42) ]
; ATTRIBUTOR-NEXT: call void @unknown() ; ATTRIBUTOR-NEXT: call void @unknown()
; ATTRIBUTOR-NEXT: ret void ; ATTRIBUTOR-NEXT: ret void
; ;
; TUNIT-LABEL: define {{[^@]+}}@nonnull_assume_pos ; TUNIT-LABEL: define {{[^@]+}}@nonnull_assume_pos
; TUNIT-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(101) [[ARG1:%.*]], ptr nocapture nofree readnone dereferenceable_or_null(31) [[ARG2:%.*]], ptr nocapture nofree nonnull readnone [[ARG3:%.*]], ptr nocapture nofree readnone dereferenceable_or_null(42) [[ARG4:%.*]]) { ; TUNIT-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(101) [[ARG1:%.*]], ptr nocapture nofree readnone dereferenceable_or_null(31) [[ARG2:%.*]], ptr nocapture nofree nonnull readnone [[ARG3:%.*]], ptr nocapture nofree readnone dereferenceable_or_null(42) [[ARG4:%.*]]) {
; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR8:[0-9]+]] [ "nonnull"(ptr [[ARG3]]), "dereferenceable"(ptr [[ARG1]], i64 1), "dereferenceable"(ptr [[ARG1]], i64 2), "dereferenceable"(ptr [[ARG1]], i64 101), "dereferenceable_or_null"(ptr [[ARG2]], i64 31), "dereferenceable_or_null"(ptr [[ARG4]], i64 42) ] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR9:[0-9]+]] [ "nonnull"(ptr [[ARG3]]), "dereferenceable"(ptr [[ARG1]], i64 1), "dereferenceable"(ptr [[ARG1]], i64 2), "dereferenceable"(ptr [[ARG1]], i64 101), "dereferenceable_or_null"(ptr [[ARG2]], i64 31), "dereferenceable_or_null"(ptr [[ARG4]], i64 42) ]
; TUNIT-NEXT: call void @unknown() ; TUNIT-NEXT: call void @unknown()
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC-LABEL: define {{[^@]+}}@nonnull_assume_pos ; CGSCC-LABEL: define {{[^@]+}}@nonnull_assume_pos
; CGSCC-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(101) [[ARG1:%.*]], ptr nocapture nofree readnone dereferenceable_or_null(31) [[ARG2:%.*]], ptr nocapture nofree nonnull readnone [[ARG3:%.*]], ptr nocapture nofree readnone dereferenceable_or_null(42) [[ARG4:%.*]]) { ; CGSCC-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(101) [[ARG1:%.*]], ptr nocapture nofree readnone dereferenceable_or_null(31) [[ARG2:%.*]], ptr nocapture nofree nonnull readnone [[ARG3:%.*]], ptr nocapture nofree readnone dereferenceable_or_null(42) [[ARG4:%.*]]) {
; CGSCC-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR7:[0-9]+]] [ "nonnull"(ptr [[ARG3]]), "dereferenceable"(ptr [[ARG1]], i64 1), "dereferenceable"(ptr [[ARG1]], i64 2), "dereferenceable"(ptr [[ARG1]], i64 101), "dereferenceable_or_null"(ptr [[ARG2]], i64 31), "dereferenceable_or_null"(ptr [[ARG4]], i64 42) ] ; CGSCC-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR8:[0-9]+]] [ "nonnull"(ptr [[ARG3]]), "dereferenceable"(ptr [[ARG1]], i64 1), "dereferenceable"(ptr [[ARG1]], i64 2), "dereferenceable"(ptr [[ARG1]], i64 101), "dereferenceable_or_null"(ptr [[ARG2]], i64 31), "dereferenceable_or_null"(ptr [[ARG4]], i64 42) ]
; CGSCC-NEXT: call void @unknown() ; CGSCC-NEXT: call void @unknown()
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @llvm.assume(i1 true) [ "nonnull"(ptr %arg3), "dereferenceable"(ptr %arg1, i64 1), "dereferenceable"(ptr %arg1, i64 2), "dereferenceable"(ptr %arg1, i64 101), "dereferenceable_or_null"(ptr %arg2, i64 31), "dereferenceable_or_null"(ptr %arg4, i64 42)] call void @llvm.assume(i1 true) [ "nonnull"(ptr %arg3), "dereferenceable"(ptr %arg1, i64 1), "dereferenceable"(ptr %arg1, i64 2), "dereferenceable"(ptr %arg1, i64 101), "dereferenceable_or_null"(ptr %arg2, i64 31), "dereferenceable_or_null"(ptr %arg4, i64 42)]
call void @unknown() call void @unknown()
ret void ret void
} }
define void @nonnull_assume_neg(ptr %arg1, ptr %arg2, ptr %arg3) { define void @nonnull_assume_neg(ptr %arg1, ptr %arg2, ptr %arg3) {
Show All 30 Lines
; ATTRIBUTOR-NEXT: call void @unknown_use8(ptr nonnull dereferenceable(42) [[ARG4]]) ; ATTRIBUTOR-NEXT: call void @unknown_use8(ptr nonnull dereferenceable(42) [[ARG4]])
; ATTRIBUTOR-NEXT: call void @unknown_use32(ptr nonnull dereferenceable(101) [[P]]) ; ATTRIBUTOR-NEXT: call void @unknown_use32(ptr nonnull dereferenceable(101) [[P]])
; ATTRIBUTOR-NEXT: call void @unknown() ; ATTRIBUTOR-NEXT: call void @unknown()
; ATTRIBUTOR-NEXT: ret void ; ATTRIBUTOR-NEXT: ret void
; ;
; TUNIT-LABEL: define {{[^@]+}}@nonnull_assume_call ; TUNIT-LABEL: define {{[^@]+}}@nonnull_assume_call
; TUNIT-SAME: (ptr [[ARG1:%.*]], ptr [[ARG2:%.*]], ptr [[ARG3:%.*]], ptr [[ARG4:%.*]]) { ; TUNIT-SAME: (ptr [[ARG1:%.*]], ptr [[ARG2:%.*]], ptr [[ARG3:%.*]], ptr [[ARG4:%.*]]) {
; TUNIT-NEXT: call void @unknown() ; TUNIT-NEXT: call void @unknown()
; TUNIT-NEXT: [[P:%.*]] = call nonnull dereferenceable(101) ptr @unkown_ptr() #[[ATTR9:[0-9]+]] ; TUNIT-NEXT: [[P:%.*]] = call nonnull dereferenceable(101) ptr @unkown_ptr() #[[ATTR10:[0-9]+]]
; TUNIT-NEXT: call void @unknown_use32(ptr nonnull dereferenceable(101) [[P]]) #[[ATTR9]] ; TUNIT-NEXT: call void @unknown_use32(ptr nonnull dereferenceable(101) [[P]]) #[[ATTR10]]
; TUNIT-NEXT: call void @unknown_use8(ptr dereferenceable_or_null(42) [[ARG4]]) #[[ATTR9]] ; TUNIT-NEXT: call void @unknown_use8(ptr dereferenceable_or_null(42) [[ARG4]]) #[[ATTR10]]
; TUNIT-NEXT: call void @unknown_use8(ptr nonnull [[ARG3]]) #[[ATTR9]] ; TUNIT-NEXT: call void @unknown_use8(ptr nonnull [[ARG3]]) #[[ATTR10]]
; TUNIT-NEXT: call void @unknown_use8(ptr dereferenceable_or_null(31) [[ARG2]]) #[[ATTR9]] ; TUNIT-NEXT: call void @unknown_use8(ptr dereferenceable_or_null(31) [[ARG2]]) #[[ATTR10]]
; TUNIT-NEXT: call void @unknown_use8(ptr nonnull dereferenceable(2) [[ARG1]]) #[[ATTR9]] ; TUNIT-NEXT: call void @unknown_use8(ptr nonnull dereferenceable(2) [[ARG1]]) #[[ATTR10]]
; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) [ "nonnull"(ptr [[ARG3]]), "dereferenceable"(ptr [[ARG1]], i64 1), "dereferenceable"(ptr [[ARG1]], i64 2), "dereferenceable"(ptr [[P]], i64 101), "dereferenceable_or_null"(ptr [[ARG2]], i64 31), "dereferenceable_or_null"(ptr [[ARG4]], i64 42) ] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) [ "nonnull"(ptr [[ARG3]]), "dereferenceable"(ptr [[ARG1]], i64 1), "dereferenceable"(ptr [[ARG1]], i64 2), "dereferenceable"(ptr [[P]], i64 101), "dereferenceable_or_null"(ptr [[ARG2]], i64 31), "dereferenceable_or_null"(ptr [[ARG4]], i64 42) ]
; TUNIT-NEXT: call void @unknown_use8(ptr nonnull dereferenceable(2) [[ARG1]]) #[[ATTR9]] ; TUNIT-NEXT: call void @unknown_use8(ptr nonnull dereferenceable(2) [[ARG1]]) #[[ATTR10]]
; TUNIT-NEXT: call void @unknown_use8(ptr dereferenceable_or_null(31) [[ARG2]]) #[[ATTR9]] ; TUNIT-NEXT: call void @unknown_use8(ptr dereferenceable_or_null(31) [[ARG2]]) #[[ATTR10]]
; TUNIT-NEXT: call void @unknown_use8(ptr nonnull [[ARG3]]) #[[ATTR9]] ; TUNIT-NEXT: call void @unknown_use8(ptr nonnull [[ARG3]]) #[[ATTR10]]
; TUNIT-NEXT: call void @unknown_use8(ptr dereferenceable_or_null(42) [[ARG4]]) #[[ATTR9]] ; TUNIT-NEXT: call void @unknown_use8(ptr dereferenceable_or_null(42) [[ARG4]]) #[[ATTR10]]
; TUNIT-NEXT: call void @unknown_use32(ptr nonnull dereferenceable(101) [[P]]) #[[ATTR9]] ; TUNIT-NEXT: call void @unknown_use32(ptr nonnull dereferenceable(101) [[P]]) #[[ATTR10]]
; TUNIT-NEXT: call void @unknown() ; TUNIT-NEXT: call void @unknown()
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC-LABEL: define {{[^@]+}}@nonnull_assume_call ; CGSCC-LABEL: define {{[^@]+}}@nonnull_assume_call
; CGSCC-SAME: (ptr [[ARG1:%.*]], ptr [[ARG2:%.*]], ptr [[ARG3:%.*]], ptr [[ARG4:%.*]]) { ; CGSCC-SAME: (ptr [[ARG1:%.*]], ptr [[ARG2:%.*]], ptr [[ARG3:%.*]], ptr [[ARG4:%.*]]) {
; CGSCC-NEXT: call void @unknown() ; CGSCC-NEXT: call void @unknown()
; CGSCC-NEXT: [[P:%.*]] = call nonnull dereferenceable(101) ptr @unkown_ptr() #[[ATTR8:[0-9]+]] ; CGSCC-NEXT: [[P:%.*]] = call nonnull dereferenceable(101) ptr @unkown_ptr() #[[ATTR9:[0-9]+]]
; CGSCC-NEXT: call void @unknown_use32(ptr nonnull dereferenceable(101) [[P]]) #[[ATTR8]] ; CGSCC-NEXT: call void @unknown_use32(ptr nonnull dereferenceable(101) [[P]]) #[[ATTR9]]
; CGSCC-NEXT: call void @unknown_use8(ptr dereferenceable_or_null(42) [[ARG4]]) #[[ATTR8]] ; CGSCC-NEXT: call void @unknown_use8(ptr dereferenceable_or_null(42) [[ARG4]]) #[[ATTR9]]
; CGSCC-NEXT: call void @unknown_use8(ptr nonnull [[ARG3]]) #[[ATTR8]] ; CGSCC-NEXT: call void @unknown_use8(ptr nonnull [[ARG3]]) #[[ATTR9]]
; CGSCC-NEXT: call void @unknown_use8(ptr dereferenceable_or_null(31) [[ARG2]]) #[[ATTR8]] ; CGSCC-NEXT: call void @unknown_use8(ptr dereferenceable_or_null(31) [[ARG2]]) #[[ATTR9]]
; CGSCC-NEXT: call void @unknown_use8(ptr nonnull dereferenceable(2) [[ARG1]]) #[[ATTR8]] ; CGSCC-NEXT: call void @unknown_use8(ptr nonnull dereferenceable(2) [[ARG1]]) #[[ATTR9]]
; CGSCC-NEXT: call void @llvm.assume(i1 noundef true) [ "nonnull"(ptr [[ARG3]]), "dereferenceable"(ptr [[ARG1]], i64 1), "dereferenceable"(ptr [[ARG1]], i64 2), "dereferenceable"(ptr [[P]], i64 101), "dereferenceable_or_null"(ptr [[ARG2]], i64 31), "dereferenceable_or_null"(ptr [[ARG4]], i64 42) ] ; CGSCC-NEXT: call void @llvm.assume(i1 noundef true) [ "nonnull"(ptr [[ARG3]]), "dereferenceable"(ptr [[ARG1]], i64 1), "dereferenceable"(ptr [[ARG1]], i64 2), "dereferenceable"(ptr [[P]], i64 101), "dereferenceable_or_null"(ptr [[ARG2]], i64 31), "dereferenceable_or_null"(ptr [[ARG4]], i64 42) ]
; CGSCC-NEXT: call void @unknown_use8(ptr nonnull dereferenceable(2) [[ARG1]]) #[[ATTR8]] ; CGSCC-NEXT: call void @unknown_use8(ptr nonnull dereferenceable(2) [[ARG1]]) #[[ATTR9]]
; CGSCC-NEXT: call void @unknown_use8(ptr dereferenceable_or_null(31) [[ARG2]]) #[[ATTR8]] ; CGSCC-NEXT: call void @unknown_use8(ptr dereferenceable_or_null(31) [[ARG2]]) #[[ATTR9]]
; CGSCC-NEXT: call void @unknown_use8(ptr nonnull [[ARG3]]) #[[ATTR8]] ; CGSCC-NEXT: call void @unknown_use8(ptr nonnull [[ARG3]]) #[[ATTR9]]
; CGSCC-NEXT: call void @unknown_use8(ptr dereferenceable_or_null(42) [[ARG4]]) #[[ATTR8]] ; CGSCC-NEXT: call void @unknown_use8(ptr dereferenceable_or_null(42) [[ARG4]]) #[[ATTR9]]
; CGSCC-NEXT: call void @unknown_use32(ptr nonnull dereferenceable(101) [[P]]) #[[ATTR8]] ; CGSCC-NEXT: call void @unknown_use32(ptr nonnull dereferenceable(101) [[P]]) #[[ATTR9]]
; CGSCC-NEXT: call void @unknown() ; CGSCC-NEXT: call void @unknown()
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @unknown() call void @unknown()
%p = call ptr @unkown_ptr() %p = call ptr @unkown_ptr()
call void @unknown_use32(ptr %p) call void @unknown_use32(ptr %p)
call void @unknown_use8(ptr %arg4) call void @unknown_use8(ptr %arg4)
call void @unknown_use8(ptr %arg3) call void @unknown_use8(ptr %arg3)
Show All 9 Lines;
ret void ret void
} }
declare void @unknown_use8(ptr) willreturn nounwind declare void @unknown_use8(ptr) willreturn nounwind
declare void @unknown_use32(ptr) willreturn nounwind declare void @unknown_use32(ptr) willreturn nounwind
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
@g = global i64 0 @g = global i64 0
define void @max_offset(i1 %c) { define void @max_offset(i1 %c) {
; CHECK: Function Attrs: nounwind willreturn ; CHECK: Function Attrs: mustprogress nounwind willreturn
; CHECK-LABEL: define {{[^@]+}}@max_offset ; CHECK-LABEL: define {{[^@]+}}@max_offset
; CHECK-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; CHECK-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; CHECK: t: ; CHECK: t:
; CHECK-NEXT: [[GEP:%.*]] = getelementptr i8, ptr @g, i64 2 ; CHECK-NEXT: [[GEP:%.*]] = getelementptr i8, ptr @g, i64 2
; CHECK-NEXT: br label [[F]] ; CHECK-NEXT: br label [[F]]
; CHECK: f: ; CHECK: f:
; CHECK-NEXT: [[PHI:%.*]] = phi ptr [ [[GEP]], [[T]] ], [ @g, [[ENTRY:%.*]] ] ; CHECK-NEXT: [[PHI:%.*]] = phi ptr [ [[GEP]], [[T]] ], [ @g, [[ENTRY:%.*]] ]
; CHECK-NEXT: call void @unknown_use8(ptr noundef align 2 dereferenceable_or_null(6) [[PHI]]) #[[ATTR1]] ; CHECK-NEXT: call void @unknown_use8(ptr noundef align 2 dereferenceable_or_null(6) [[PHI]]) #[[ATTR1]]
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
br i1 %c, label %t, label %f br i1 %c, label %t, label %f
t: t:
%gep = getelementptr i8, ptr @g, i64 2 %gep = getelementptr i8, ptr @g, i64 2
br label %f br label %f
f: f:
%phi = phi ptr [%gep, %t], [@g, %entry] %phi = phi ptr [%gep, %t], [@g, %entry]
call void @unknown_use8(ptr %phi) call void @unknown_use8(ptr %phi)
ret void ret void
} }
!0 = !{i64 10, i64 100} !0 = !{i64 10, i64 100}
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1]] = { nounwind willreturn } ; TUNIT: attributes #[[ATTR1]] = { nounwind willreturn }
; TUNIT: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR2]] = { mustprogress nounwind willreturn }
; TUNIT: attributes #[[ATTR3]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR4]] = { nofree nosync nounwind memory(argmem: write) } ; TUNIT: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR5:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; TUNIT: attributes #[[ATTR5]] = { nofree nosync nounwind memory(argmem: write) }
; TUNIT: attributes #[[ATTR6]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR6:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
; TUNIT: attributes #[[ATTR7]] = { nofree nosync nounwind } ; TUNIT: attributes #[[ATTR7]] = { nofree nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR8]] = { willreturn } ; TUNIT: attributes #[[ATTR8]] = { nofree nosync nounwind }
; TUNIT: attributes #[[ATTR9]] = { nounwind } ; TUNIT: attributes #[[ATTR9]] = { willreturn }
; TUNIT: attributes #[[ATTR10]] = { nounwind }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR1]] = { nounwind willreturn }
; CGSCC: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR2]] = { mustprogress nounwind willreturn }
; CGSCC: attributes #[[ATTR3]] = { nofree nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR4]] = { nofree nosync nounwind memory(argmem: write) } ; CGSCC: attributes #[[ATTR4]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR5:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; CGSCC: attributes #[[ATTR5]] = { nofree nosync nounwind memory(argmem: write) }
; CGSCC: attributes #[[ATTR6]] = { nofree nosync nounwind } ; CGSCC: attributes #[[ATTR6:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
; CGSCC: attributes #[[ATTR7]] = { willreturn } ; CGSCC: attributes #[[ATTR7]] = { nofree nosync nounwind }
; CGSCC: attributes #[[ATTR8]] = { nounwind } ; CGSCC: attributes #[[ATTR8]] = { willreturn }
; CGSCC: attributes #[[ATTR9]] = { nounwind }
;. ;.
; CHECK: [[META0:![0-9]+]] = !{i64 10, i64 100} ; CHECK: [[META0:![0-9]+]] = !{i64 10, i64 100}
;. ;.

llvm/test/Transforms/Attributor/dereferenceable-2-inseltpoison.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; Determine dereference-ability before unused loads get deleted: ; Determine dereference-ability before unused loads get deleted:
; https://bugs.llvm.org/show_bug.cgi?id=21780 ; https://bugs.llvm.org/show_bug.cgi?id=21780
define <4 x double> @PR21780(ptr %ptr) { define <4 x double> @PR21780(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define {{[^@]+}}@PR21780 ; CHECK-LABEL: define {{[^@]+}}@PR21780
; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 8 dereferenceable(32) [[PTR:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 8 dereferenceable(32) [[PTR:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds double, ptr [[PTR]], i64 1 ; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds double, ptr [[PTR]], i64 1
; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds double, ptr [[PTR]], i64 2 ; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds double, ptr [[PTR]], i64 2
; CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr inbounds double, ptr [[PTR]], i64 3 ; CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr inbounds double, ptr [[PTR]], i64 3
; CHECK-NEXT: [[T0:%.*]] = load double, ptr [[PTR]], align 8 ; CHECK-NEXT: [[T0:%.*]] = load double, ptr [[PTR]], align 8
; CHECK-NEXT: [[T1:%.*]] = load double, ptr [[ARRAYIDX1]], align 8 ; CHECK-NEXT: [[T1:%.*]] = load double, ptr [[ARRAYIDX1]], align 8
; CHECK-NEXT: [[T2:%.*]] = load double, ptr [[ARRAYIDX2]], align 8 ; CHECK-NEXT: [[T2:%.*]] = load double, ptr [[ARRAYIDX2]], align 8
Show All 21 Lines;
%vecinit2 = insertelement <4 x double> %vecinit1, double %t2, i32 2 %vecinit2 = insertelement <4 x double> %vecinit1, double %t2, i32 2
%vecinit3 = insertelement <4 x double> %vecinit2, double %t3, i32 3 %vecinit3 = insertelement <4 x double> %vecinit2, double %t3, i32 3
%shuffle = shufflevector <4 x double> %vecinit3, <4 x double> %vecinit3, <4 x i32> <i32 0, i32 0, i32 2, i32 2> %shuffle = shufflevector <4 x double> %vecinit3, <4 x double> %vecinit3, <4 x i32> <i32 0, i32 0, i32 2, i32 2>
ret <4 x double> %shuffle ret <4 x double> %shuffle
} }
define double @PR21780_only_access3_with_inbounds(ptr %ptr) { define double @PR21780_only_access3_with_inbounds(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define {{[^@]+}}@PR21780_only_access3_with_inbounds ; CHECK-LABEL: define {{[^@]+}}@PR21780_only_access3_with_inbounds
; CHECK-SAME: (ptr nocapture nofree nonnull readonly align 8 dereferenceable(32) [[PTR:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readonly align 8 dereferenceable(32) [[PTR:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr inbounds double, ptr [[PTR]], i64 3 ; CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr inbounds double, ptr [[PTR]], i64 3
; CHECK-NEXT: [[T3:%.*]] = load double, ptr [[ARRAYIDX3]], align 8 ; CHECK-NEXT: [[T3:%.*]] = load double, ptr [[ARRAYIDX3]], align 8
; CHECK-NEXT: ret double [[T3]] ; CHECK-NEXT: ret double [[T3]]
; ;
%arrayidx3 = getelementptr inbounds double, double* %ptr, i64 3 %arrayidx3 = getelementptr inbounds double, double* %ptr, i64 3
%t3 = load double, ptr %arrayidx3, align 8 %t3 = load double, ptr %arrayidx3, align 8
ret double %t3 ret double %t3
} }
define double @PR21780_only_access3_without_inbounds(ptr %ptr) { define double @PR21780_only_access3_without_inbounds(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define {{[^@]+}}@PR21780_only_access3_without_inbounds ; CHECK-LABEL: define {{[^@]+}}@PR21780_only_access3_without_inbounds
; CHECK-SAME: (ptr nocapture nofree readonly align 8 [[PTR:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nocapture nofree readonly align 8 [[PTR:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr double, ptr [[PTR]], i64 3 ; CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr double, ptr [[PTR]], i64 3
; CHECK-NEXT: [[T3:%.*]] = load double, ptr [[ARRAYIDX3]], align 8 ; CHECK-NEXT: [[T3:%.*]] = load double, ptr [[ARRAYIDX3]], align 8
; CHECK-NEXT: ret double [[T3]] ; CHECK-NEXT: ret double [[T3]]
; ;
%arrayidx3 = getelementptr double, double* %ptr, i64 3 %arrayidx3 = getelementptr double, double* %ptr, i64 3
%t3 = load double, ptr %arrayidx3, align 8 %t3 = load double, ptr %arrayidx3, align 8
ret double %t3 ret double %t3
} }
define double @PR21780_without_inbounds(ptr %ptr) { define double @PR21780_without_inbounds(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define {{[^@]+}}@PR21780_without_inbounds ; CHECK-LABEL: define {{[^@]+}}@PR21780_without_inbounds
; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 8 dereferenceable(32) [[PTR:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 8 dereferenceable(32) [[PTR:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr double, ptr [[PTR]], i64 3 ; CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr double, ptr [[PTR]], i64 3
; CHECK-NEXT: [[T3:%.*]] = load double, ptr [[ARRAYIDX3]], align 8 ; CHECK-NEXT: [[T3:%.*]] = load double, ptr [[ARRAYIDX3]], align 8
; CHECK-NEXT: ret double [[T3]] ; CHECK-NEXT: ret double [[T3]]
; ;
%arrayidx1 = getelementptr double, double* %ptr, i64 1 %arrayidx1 = getelementptr double, double* %ptr, i64 1
%arrayidx2 = getelementptr double, ptr %ptr, i64 2 %arrayidx2 = getelementptr double, ptr %ptr, i64 2
%arrayidx3 = getelementptr double, ptr %ptr, i64 3 %arrayidx3 = getelementptr double, ptr %ptr, i64 3
%t0 = load double, ptr %ptr, align 8 %t0 = load double, ptr %ptr, align 8
%t1 = load double, ptr %arrayidx1, align 8 %t1 = load double, ptr %arrayidx1, align 8
%t2 = load double, ptr %arrayidx2, align 8 %t2 = load double, ptr %arrayidx2, align 8
%t3 = load double, ptr %arrayidx3, align 8 %t3 = load double, ptr %arrayidx3, align 8
ret double %t3 ret double %t3
} }
; Unsimplified, but still valid. Also, throw in some bogus arguments. ; Unsimplified, but still valid. Also, throw in some bogus arguments.
define void @gep0(ptr %unused, ptr %other, ptr %ptr) { define void @gep0(ptr %unused, ptr %other, ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; CHECK-LABEL: define {{[^@]+}}@gep0 ; CHECK-LABEL: define {{[^@]+}}@gep0
; CHECK-SAME: (ptr nocapture nofree readnone [[UNUSED:%.*]], ptr nocapture nofree noundef nonnull writeonly dereferenceable(1) [[OTHER:%.*]], ptr nocapture nofree nonnull readonly dereferenceable(3) [[PTR:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree readnone [[UNUSED:%.*]], ptr nocapture nofree noundef nonnull writeonly dereferenceable(1) [[OTHER:%.*]], ptr nocapture nofree nonnull readonly dereferenceable(3) [[PTR:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr i8, ptr [[PTR]], i64 2 ; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr i8, ptr [[PTR]], i64 2
; CHECK-NEXT: [[T2:%.*]] = load i8, ptr [[ARRAYIDX2]], align 1 ; CHECK-NEXT: [[T2:%.*]] = load i8, ptr [[ARRAYIDX2]], align 1
; CHECK-NEXT: store i8 [[T2]], ptr [[OTHER]], align 1 ; CHECK-NEXT: store i8 [[T2]], ptr [[OTHER]], align 1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx0 = getelementptr i8, i8* %ptr, i64 0 %arrayidx0 = getelementptr i8, i8* %ptr, i64 0
%arrayidx1 = getelementptr i8, ptr %ptr, i64 1 %arrayidx1 = getelementptr i8, ptr %ptr, i64 1
%arrayidx2 = getelementptr i8, ptr %ptr, i64 2 %arrayidx2 = getelementptr i8, ptr %ptr, i64 2
%t0 = load i8, ptr %arrayidx0 %t0 = load i8, ptr %arrayidx0
%t1 = load i8, ptr %arrayidx1 %t1 = load i8, ptr %arrayidx1
%t2 = load i8, ptr %arrayidx2 %t2 = load i8, ptr %arrayidx2
store i8 %t2, ptr %other store i8 %t2, ptr %other
ret void ret void
} }
; Order of accesses does not change computation. ; Order of accesses does not change computation.
; Multiple arguments may be dereferenceable. ; Multiple arguments may be dereferenceable.
define void @ordering(ptr %ptr1, ptr %ptr2) { define void @ordering(ptr %ptr1, ptr %ptr2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@ordering ; CHECK-LABEL: define {{[^@]+}}@ordering
; CHECK-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(3) [[PTR1:%.*]], ptr nocapture nofree nonnull readnone align 4 dereferenceable(8) [[PTR2:%.*]]) #[[ATTR2:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(3) [[PTR1:%.*]], ptr nocapture nofree nonnull readnone align 4 dereferenceable(8) [[PTR2:%.*]]) #[[ATTR2:[0-9]+]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%a20 = getelementptr i32, i32* %ptr2, i64 0 %a20 = getelementptr i32, i32* %ptr2, i64 0
%a12 = getelementptr i8, ptr %ptr1, i64 2 %a12 = getelementptr i8, ptr %ptr1, i64 2
%t12 = load i8, ptr %a12 %t12 = load i8, ptr %a12
%a11 = getelementptr i8, ptr %ptr1, i64 1 %a11 = getelementptr i8, ptr %ptr1, i64 1
%t20 = load i32, ptr %a20 %t20 = load i32, ptr %a20
%t10 = load i8, ptr %ptr1 %t10 = load i8, ptr %ptr1
%t11 = load i8, ptr %a11 %t11 = load i8, ptr %a11
%a21 = getelementptr i32, ptr %ptr2, i64 1 %a21 = getelementptr i32, ptr %ptr2, i64 1
%t21 = load i32, ptr %a21 %t21 = load i32, ptr %a21
ret void ret void
} }
; Not in entry block. ; Not in entry block.
define void @not_entry_but_guaranteed_to_execute(ptr %ptr) { define void @not_entry_but_guaranteed_to_execute(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@not_entry_but_guaranteed_to_execute ; CHECK-LABEL: define {{[^@]+}}@not_entry_but_guaranteed_to_execute
; CHECK-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(3) [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(3) [[PTR:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[EXIT:%.*]] ; CHECK-NEXT: br label [[EXIT:%.*]]
; CHECK: exit: ; CHECK: exit:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
br label %exit br label %exit
exit: exit:
%arrayidx1 = getelementptr i8, ptr %ptr, i64 1 %arrayidx1 = getelementptr i8, ptr %ptr, i64 1
%arrayidx2 = getelementptr i8, ptr %ptr, i64 2 %arrayidx2 = getelementptr i8, ptr %ptr, i64 2
%t0 = load i8, ptr %ptr %t0 = load i8, ptr %ptr
%t1 = load i8, ptr %arrayidx1 %t1 = load i8, ptr %arrayidx1
%t2 = load i8, ptr %arrayidx2 %t2 = load i8, ptr %arrayidx2
ret void ret void
} }
; Not in entry block and not guaranteed to execute. ; Not in entry block and not guaranteed to execute.
define void @not_entry_not_guaranteed_to_execute(ptr %ptr, i1 %cond) { define void @not_entry_not_guaranteed_to_execute(ptr %ptr, i1 %cond) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@not_entry_not_guaranteed_to_execute ; CHECK-LABEL: define {{[^@]+}}@not_entry_not_guaranteed_to_execute
; CHECK-SAME: (ptr nocapture nofree readnone [[PTR:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree readnone [[PTR:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[COND]], label [[LOADS:%.*]], label [[EXIT:%.*]] ; CHECK-NEXT: br i1 [[COND]], label [[LOADS:%.*]], label [[EXIT:%.*]]
; CHECK: loads: ; CHECK: loads:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK: exit: ; CHECK: exit:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
Show All 9 Linesloads:
ret void ret void
exit: exit:
ret void ret void
} }
; The last load may not execute, so derefenceable bytes only covers the 1st two loads. ; The last load may not execute, so derefenceable bytes only covers the 1st two loads.
define void @partial_in_entry(ptr %ptr, i1 %cond) { define void @partial_in_entry(ptr %ptr, i1 %cond) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@partial_in_entry ; CHECK-LABEL: define {{[^@]+}}@partial_in_entry
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 2 dereferenceable(4) [[PTR:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 2 dereferenceable(4) [[PTR:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[COND]], label [[LOADS:%.*]], label [[EXIT:%.*]] ; CHECK-NEXT: br i1 [[COND]], label [[LOADS:%.*]], label [[EXIT:%.*]]
; CHECK: loads: ; CHECK: loads:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK: exit: ; CHECK: exit:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
Show All 10 Lines
exit: exit:
ret void ret void
} }
; The volatile load can't be used to prove a non-volatile access is allowed. ; The volatile load can't be used to prove a non-volatile access is allowed.
; The 2nd and 3rd loads may never execute. ; The 2nd and 3rd loads may never execute.
define void @volatile_is_not_dereferenceable(ptr %ptr) { define void @volatile_is_not_dereferenceable(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
; CHECK-LABEL: define {{[^@]+}}@volatile_is_not_dereferenceable ; CHECK-LABEL: define {{[^@]+}}@volatile_is_not_dereferenceable
; CHECK-SAME: (ptr nofree align 2 [[PTR:%.*]]) #[[ATTR3:[0-9]+]] { ; CHECK-SAME: (ptr nofree align 2 [[PTR:%.*]]) #[[ATTR3:[0-9]+]] {
; CHECK-NEXT: [[T0:%.*]] = load volatile i16, ptr [[PTR]], align 2 ; CHECK-NEXT: [[T0:%.*]] = load volatile i16, ptr [[PTR]], align 2
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx0 = getelementptr i16, i16* %ptr, i64 0 %arrayidx0 = getelementptr i16, i16* %ptr, i64 0
%arrayidx1 = getelementptr i16, ptr %ptr, i64 1 %arrayidx1 = getelementptr i16, ptr %ptr, i64 1
%arrayidx2 = getelementptr i16, ptr %ptr, i64 2 %arrayidx2 = getelementptr i16, ptr %ptr, i64 2
%t0 = load volatile i16, ptr %arrayidx0 %t0 = load volatile i16, ptr %arrayidx0
%t1 = load i16, ptr %arrayidx1 %t1 = load i16, ptr %arrayidx1
%t2 = load i16, ptr %arrayidx2 %t2 = load i16, ptr %arrayidx2
ret void ret void
} }
; TODO: We should allow inference for atomic (but not volatile) ops. ; TODO: We should allow inference for atomic (but not volatile) ops.
define void @atomic_is_alright(ptr %ptr) { define void @atomic_is_alright(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@atomic_is_alright ; CHECK-LABEL: define {{[^@]+}}@atomic_is_alright
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 2 dereferenceable(6) [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 2 dereferenceable(6) [[PTR:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx0 = getelementptr i16, i16* %ptr, i64 0 %arrayidx0 = getelementptr i16, i16* %ptr, i64 0
%arrayidx1 = getelementptr i16, ptr %ptr, i64 1 %arrayidx1 = getelementptr i16, ptr %ptr, i64 1
%arrayidx2 = getelementptr i16, ptr %ptr, i64 2 %arrayidx2 = getelementptr i16, ptr %ptr, i64 2
%t0 = load atomic i16, ptr %arrayidx0 unordered, align 2 %t0 = load atomic i16, ptr %arrayidx0 unordered, align 2
Show All 18 Lines;
%t1 = load i16, ptr %arrayidx1 %t1 = load i16, ptr %arrayidx1
%t2 = load i16, ptr %arrayidx2 %t2 = load i16, ptr %arrayidx2
ret void ret void
} }
; We must have consecutive accesses. ; We must have consecutive accesses.
define void @variable_gep_index(ptr %unused, ptr %ptr, i64 %variable_index) { define void @variable_gep_index(ptr %unused, ptr %ptr, i64 %variable_index) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@variable_gep_index ; CHECK-LABEL: define {{[^@]+}}@variable_gep_index
; CHECK-SAME: (ptr nocapture nofree readnone [[UNUSED:%.*]], ptr nocapture nofree nonnull readnone dereferenceable(1) [[PTR:%.*]], i64 [[VARIABLE_INDEX:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree readnone [[UNUSED:%.*]], ptr nocapture nofree nonnull readnone dereferenceable(1) [[PTR:%.*]], i64 [[VARIABLE_INDEX:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx1 = getelementptr i8, i8* %ptr, i64 %variable_index %arrayidx1 = getelementptr i8, i8* %ptr, i64 %variable_index
%arrayidx2 = getelementptr i8, ptr %ptr, i64 2 %arrayidx2 = getelementptr i8, ptr %ptr, i64 2
%t0 = load i8, ptr %ptr %t0 = load i8, ptr %ptr
%t1 = load i8, ptr %arrayidx1 %t1 = load i8, ptr %arrayidx1
%t2 = load i8, ptr %arrayidx2 %t2 = load i8, ptr %arrayidx2
ret void ret void
} }
; Deal with >1 GEP index. ; Deal with >1 GEP index.
define void @multi_index_gep(ptr %ptr) { define void @multi_index_gep(ptr %ptr) {
; FIXME: %ptr should be dereferenceable(4) ; FIXME: %ptr should be dereferenceable(4)
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@multi_index_gep ; CHECK-LABEL: define {{[^@]+}}@multi_index_gep
; CHECK-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(1) [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(1) [[PTR:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx00 = getelementptr <4 x i8>, <4 x i8>* %ptr, i64 0, i64 0 %arrayidx00 = getelementptr <4 x i8>, <4 x i8>* %ptr, i64 0, i64 0
%t0 = load i8, ptr %arrayidx00 %t0 = load i8, ptr %arrayidx00
ret void ret void
} }
; Could round weird bitwidths down? ; Could round weird bitwidths down?
define void @not_byte_multiple(ptr %ptr) { define void @not_byte_multiple(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@not_byte_multiple ; CHECK-LABEL: define {{[^@]+}}@not_byte_multiple
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 2 dereferenceable(2) [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 2 dereferenceable(2) [[PTR:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx0 = getelementptr i9, i9* %ptr, i64 0 %arrayidx0 = getelementptr i9, i9* %ptr, i64 0
%t0 = load i9, ptr %arrayidx0 %t0 = load i9, ptr %arrayidx0
ret void ret void
} }
; Missing direct access from the pointer. ; Missing direct access from the pointer.
define void @no_pointer_deref(ptr %ptr) { define void @no_pointer_deref(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@no_pointer_deref ; CHECK-LABEL: define {{[^@]+}}@no_pointer_deref
; CHECK-SAME: (ptr nocapture nofree readnone align 2 [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree readnone align 2 [[PTR:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx1 = getelementptr i16, i16* %ptr, i64 1 %arrayidx1 = getelementptr i16, i16* %ptr, i64 1
%arrayidx2 = getelementptr i16, ptr %ptr, i64 2 %arrayidx2 = getelementptr i16, ptr %ptr, i64 2
%t1 = load i16, ptr %arrayidx1 %t1 = load i16, ptr %arrayidx1
%t2 = load i16, ptr %arrayidx2 %t2 = load i16, ptr %arrayidx2
ret void ret void
} }
; Out-of-order is ok, but missing access concludes dereferenceable range. ; Out-of-order is ok, but missing access concludes dereferenceable range.
define void @non_consecutive(ptr %ptr) { define void @non_consecutive(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@non_consecutive ; CHECK-LABEL: define {{[^@]+}}@non_consecutive
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(8) [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(8) [[PTR:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx1 = getelementptr i32, i32* %ptr, i64 1 %arrayidx1 = getelementptr i32, i32* %ptr, i64 1
%arrayidx3 = getelementptr i32, ptr %ptr, i64 3 %arrayidx3 = getelementptr i32, ptr %ptr, i64 3
%t1 = load i32, ptr %arrayidx1 %t1 = load i32, ptr %arrayidx1
%t0 = load i32, ptr %ptr %t0 = load i32, ptr %ptr
%t3 = load i32, ptr %arrayidx3 %t3 = load i32, ptr %arrayidx3
ret void ret void
} }
; Improve on existing dereferenceable attribute. ; Improve on existing dereferenceable attribute.
define void @more_bytes(ptr dereferenceable(8) %ptr) { define void @more_bytes(ptr dereferenceable(8) %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@more_bytes ; CHECK-LABEL: define {{[^@]+}}@more_bytes
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(16) [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(16) [[PTR:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx3 = getelementptr i32, i32* %ptr, i64 3 %arrayidx3 = getelementptr i32, i32* %ptr, i64 3
%arrayidx1 = getelementptr i32, ptr %ptr, i64 1 %arrayidx1 = getelementptr i32, ptr %ptr, i64 1
%arrayidx2 = getelementptr i32, ptr %ptr, i64 2 %arrayidx2 = getelementptr i32, ptr %ptr, i64 2
%t3 = load i32, ptr %arrayidx3 %t3 = load i32, ptr %arrayidx3
%t1 = load i32, ptr %arrayidx1 %t1 = load i32, ptr %arrayidx1
%t2 = load i32, ptr %arrayidx2 %t2 = load i32, ptr %arrayidx2
%t0 = load i32, ptr %ptr %t0 = load i32, ptr %ptr
ret void ret void
} }
; Improve on existing dereferenceable_or_null attribute. ; Improve on existing dereferenceable_or_null attribute.
define void @more_bytes_and_not_null(ptr dereferenceable_or_null(8) %ptr) { define void @more_bytes_and_not_null(ptr dereferenceable_or_null(8) %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@more_bytes_and_not_null ; CHECK-LABEL: define {{[^@]+}}@more_bytes_and_not_null
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(16) [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(16) [[PTR:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx3 = getelementptr i32, i32* %ptr, i64 3 %arrayidx3 = getelementptr i32, i32* %ptr, i64 3
%arrayidx1 = getelementptr i32, ptr %ptr, i64 1 %arrayidx1 = getelementptr i32, ptr %ptr, i64 1
%arrayidx2 = getelementptr i32, ptr %ptr, i64 2 %arrayidx2 = getelementptr i32, ptr %ptr, i64 2
%t3 = load i32, ptr %arrayidx3 %t3 = load i32, ptr %arrayidx3
%t1 = load i32, ptr %arrayidx1 %t1 = load i32, ptr %arrayidx1
%t2 = load i32, ptr %arrayidx2 %t2 = load i32, ptr %arrayidx2
%t0 = load i32, ptr %ptr %t0 = load i32, ptr %ptr
ret void ret void
} }
; But don't pessimize existing dereferenceable attribute. ; But don't pessimize existing dereferenceable attribute.
define void @better_bytes(ptr dereferenceable(100) %ptr) { define void @better_bytes(ptr dereferenceable(100) %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@better_bytes ; CHECK-LABEL: define {{[^@]+}}@better_bytes
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(100) [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(100) [[PTR:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx3 = getelementptr i32, i32* %ptr, i64 3 %arrayidx3 = getelementptr i32, i32* %ptr, i64 3
%arrayidx1 = getelementptr i32, ptr %ptr, i64 1 %arrayidx1 = getelementptr i32, ptr %ptr, i64 1
%arrayidx2 = getelementptr i32, ptr %ptr, i64 2 %arrayidx2 = getelementptr i32, ptr %ptr, i64 2
%t3 = load i32, ptr %arrayidx3 %t3 = load i32, ptr %arrayidx3
%t1 = load i32, ptr %arrayidx1 %t1 = load i32, ptr %arrayidx1
%t2 = load i32, ptr %arrayidx2 %t2 = load i32, ptr %arrayidx2
%t0 = load i32, ptr %ptr %t0 = load i32, ptr %ptr
ret void ret void
} }
define void @bitcast(ptr %arg) { define void @bitcast(ptr %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@bitcast ; CHECK-LABEL: define {{[^@]+}}@bitcast
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(8) [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(8) [[ARG:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%ptr = bitcast i32* %arg to float* %ptr = bitcast i32* %arg to float*
%arrayidx1 = getelementptr float, ptr %ptr, i64 1 %arrayidx1 = getelementptr float, ptr %ptr, i64 1
%t0 = load float, ptr %ptr %t0 = load float, ptr %ptr
%t1 = load float, ptr %arrayidx1 %t1 = load float, ptr %arrayidx1
ret void ret void
} }
define void @bitcast_different_sizes(ptr %arg1, ptr %arg2) { define void @bitcast_different_sizes(ptr %arg1, ptr %arg2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@bitcast_different_sizes ; CHECK-LABEL: define {{[^@]+}}@bitcast_different_sizes
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(12) [[ARG1:%.*]], ptr nocapture nofree nonnull readnone align 4 dereferenceable(16) [[ARG2:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(12) [[ARG1:%.*]], ptr nocapture nofree nonnull readnone align 4 dereferenceable(16) [[ARG2:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%ptr1 = bitcast double* %arg1 to float* %ptr1 = bitcast double* %arg1 to float*
%a11 = getelementptr float, ptr %ptr1, i64 1 %a11 = getelementptr float, ptr %ptr1, i64 1
%a12 = getelementptr float, ptr %ptr1, i64 2 %a12 = getelementptr float, ptr %ptr1, i64 2
%ld10 = load float, ptr %ptr1 %ld10 = load float, ptr %ptr1
%ld11 = load float, ptr %a11 %ld11 = load float, ptr %a11
%ld12 = load float, ptr %a12 %ld12 = load float, ptr %a12
%a21 = getelementptr i64, ptr %arg2, i64 1 %a21 = getelementptr i64, ptr %arg2, i64 1
%ld20 = load i64, ptr %arg2 %ld20 = load i64, ptr %arg2
%ld21 = load i64, ptr %a21 %ld21 = load i64, ptr %a21
ret void ret void
} }
define void @negative_offset(ptr %arg) { define void @negative_offset(ptr %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@negative_offset ; CHECK-LABEL: define {{[^@]+}}@negative_offset
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(4) [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(4) [[ARG:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%ptr = bitcast i32* %arg to float* %ptr = bitcast i32* %arg to float*
%arrayidx1 = getelementptr float, ptr %ptr, i64 -1 %arrayidx1 = getelementptr float, ptr %ptr, i64 -1
%t0 = load float, ptr %ptr %t0 = load float, ptr %ptr
%t1 = load float, ptr %arrayidx1 %t1 = load float, ptr %arrayidx1
ret void ret void
} }
define void @stores(ptr %arg) { define void @stores(ptr %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@stores ; CHECK-LABEL: define {{[^@]+}}@stores
; CHECK-SAME: (ptr nocapture nofree nonnull writeonly align 4 dereferenceable(8) [[ARG:%.*]]) #[[ATTR4:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree nonnull writeonly align 4 dereferenceable(8) [[ARG:%.*]]) #[[ATTR4:[0-9]+]] {
; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr float, ptr [[ARG]], i64 1 ; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr float, ptr [[ARG]], i64 1
; CHECK-NEXT: store float 1.000000e+00, ptr [[ARG]], align 4 ; CHECK-NEXT: store float 1.000000e+00, ptr [[ARG]], align 4
; CHECK-NEXT: store float 2.000000e+00, ptr [[ARRAYIDX1]], align 4 ; CHECK-NEXT: store float 2.000000e+00, ptr [[ARRAYIDX1]], align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%ptr = bitcast i32* %arg to float* %ptr = bitcast i32* %arg to float*
%arrayidx1 = getelementptr float, ptr %ptr, i64 1 %arrayidx1 = getelementptr float, ptr %ptr, i64 1
store float 1.0, ptr %ptr store float 1.0, ptr %ptr
store float 2.0, ptr %arrayidx1 store float 2.0, ptr %arrayidx1
ret void ret void
} }
define void @load_store(ptr %arg) { define void @load_store(ptr %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@load_store ; CHECK-LABEL: define {{[^@]+}}@load_store
; CHECK-SAME: (ptr nocapture nofree nonnull writeonly align 4 dereferenceable(8) [[ARG:%.*]]) #[[ATTR4]] { ; CHECK-SAME: (ptr nocapture nofree nonnull writeonly align 4 dereferenceable(8) [[ARG:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr float, ptr [[ARG]], i64 1 ; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr float, ptr [[ARG]], i64 1
; CHECK-NEXT: store float 2.000000e+00, ptr [[ARRAYIDX1]], align 4 ; CHECK-NEXT: store float 2.000000e+00, ptr [[ARRAYIDX1]], align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%ptr = bitcast i32* %arg to float* %ptr = bitcast i32* %arg to float*
%arrayidx1 = getelementptr float, ptr %ptr, i64 1 %arrayidx1 = getelementptr float, ptr %ptr, i64 1
%t1 = load float, ptr %ptr %t1 = load float, ptr %ptr
store float 2.0, ptr %arrayidx1 store float 2.0, ptr %arrayidx1
ret void ret void
} }
define void @different_size1(ptr %arg) { define void @different_size1(ptr %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@different_size1 ; CHECK-LABEL: define {{[^@]+}}@different_size1
; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[ARG:%.*]]) #[[ATTR4]] { ; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[ARG:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: store double 0.000000e+00, ptr [[ARG]], align 8 ; CHECK-NEXT: store double 0.000000e+00, ptr [[ARG]], align 8
; CHECK-NEXT: store i32 0, ptr [[ARG]], align 8 ; CHECK-NEXT: store i32 0, ptr [[ARG]], align 8
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arg-cast = bitcast i32* %arg to double* %arg-cast = bitcast i32* %arg to double*
store double 0.000000e+00, ptr %arg-cast store double 0.000000e+00, ptr %arg-cast
store i32 0, ptr %arg store i32 0, ptr %arg
ret void ret void
} }
define void @different_size2(ptr %arg) { define void @different_size2(ptr %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@different_size2 ; CHECK-LABEL: define {{[^@]+}}@different_size2
; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[ARG:%.*]]) #[[ATTR4]] { ; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[ARG:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: store i32 0, ptr [[ARG]], align 8 ; CHECK-NEXT: store i32 0, ptr [[ARG]], align 8
; CHECK-NEXT: store double 0.000000e+00, ptr [[ARG]], align 8 ; CHECK-NEXT: store double 0.000000e+00, ptr [[ARG]], align 8
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store i32 0, i32* %arg store i32 0, i32* %arg
store double 0.000000e+00, ptr %arg store double 0.000000e+00, ptr %arg
Show All 14 Lines
; l6 l7 ; l6 l7
; \ / ; \ /
; end ; end
; According to the above CFG, we can see that instructions in l5 Block must be executed. ; According to the above CFG, we can see that instructions in l5 Block must be executed.
; Therefore, %p must be dereferenced. ; Therefore, %p must be dereferenced.
; ;
; ATTRIBUTOR_CGSCC_NPM-LABEL: define i32 @require_cfg_analysis(i32 %c, i32* {{.*}} dereferenceable(4) %p) ; ATTRIBUTOR_CGSCC_NPM-LABEL: define i32 @require_cfg_analysis(i32 %c, i32* {{.*}} dereferenceable(4) %p)
define i32 @require_cfg_analysis(i32 %c, ptr %p) { define i32 @require_cfg_analysis(i32 %c, ptr %p) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@require_cfg_analysis ; CHECK-LABEL: define {{[^@]+}}@require_cfg_analysis
; CHECK-SAME: (i32 [[C:%.*]], ptr nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR4]] { ; CHECK-SAME: (i32 [[C:%.*]], ptr nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[TOBOOL1:%.*]] = icmp eq i32 [[C]], 0 ; CHECK-NEXT: [[TOBOOL1:%.*]] = icmp eq i32 [[C]], 0
; CHECK-NEXT: br i1 [[TOBOOL1]], label [[L1:%.*]], label [[L2:%.*]] ; CHECK-NEXT: br i1 [[TOBOOL1]], label [[L1:%.*]], label [[L2:%.*]]
; CHECK: l1: ; CHECK: l1:
; CHECK-NEXT: [[TOBOOL2:%.*]] = icmp eq i32 [[C]], 1 ; CHECK-NEXT: [[TOBOOL2:%.*]] = icmp eq i32 [[C]], 1
; CHECK-NEXT: br i1 [[TOBOOL2]], label [[L3:%.*]], label [[L4:%.*]] ; CHECK-NEXT: br i1 [[TOBOOL2]], label [[L3:%.*]], label [[L4:%.*]]
; CHECK: l2: ; CHECK: l2:
Show All 35 Linesl6:
br label %end br label %end
l7: l7:
store i32 1, ptr %p store i32 1, ptr %p
br label %end br label %end
end: end:
ret i32 1 ret i32 1
} }
;. ;.
; CHECK: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; CHECK: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; CHECK: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; CHECK: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; CHECK: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CHECK: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CHECK: attributes #[[ATTR3]] = { nofree norecurse nounwind willreturn memory(argmem: readwrite) } ; CHECK: attributes #[[ATTR3]] = { mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite) }
; CHECK: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; CHECK: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CGSCC: {{.*}} ; CGSCC: {{.*}}
; TUNIT: {{.*}} ; TUNIT: {{.*}}

llvm/test/Transforms/Attributor/dereferenceable-2.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; Determine dereference-ability before unused loads get deleted: ; Determine dereference-ability before unused loads get deleted:
; https://bugs.llvm.org/show_bug.cgi?id=21780 ; https://bugs.llvm.org/show_bug.cgi?id=21780
define <4 x double> @PR21780(ptr %ptr) { define <4 x double> @PR21780(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define {{[^@]+}}@PR21780 ; CHECK-LABEL: define {{[^@]+}}@PR21780
; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 8 dereferenceable(32) [[PTR:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 8 dereferenceable(32) [[PTR:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds double, ptr [[PTR]], i64 1 ; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds double, ptr [[PTR]], i64 1
; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds double, ptr [[PTR]], i64 2 ; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr inbounds double, ptr [[PTR]], i64 2
; CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr inbounds double, ptr [[PTR]], i64 3 ; CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr inbounds double, ptr [[PTR]], i64 3
; CHECK-NEXT: [[T0:%.*]] = load double, ptr [[PTR]], align 8 ; CHECK-NEXT: [[T0:%.*]] = load double, ptr [[PTR]], align 8
; CHECK-NEXT: [[T1:%.*]] = load double, ptr [[ARRAYIDX1]], align 8 ; CHECK-NEXT: [[T1:%.*]] = load double, ptr [[ARRAYIDX1]], align 8
; CHECK-NEXT: [[T2:%.*]] = load double, ptr [[ARRAYIDX2]], align 8 ; CHECK-NEXT: [[T2:%.*]] = load double, ptr [[ARRAYIDX2]], align 8
Show All 21 Lines;
%vecinit2 = insertelement <4 x double> %vecinit1, double %t2, i32 2 %vecinit2 = insertelement <4 x double> %vecinit1, double %t2, i32 2
%vecinit3 = insertelement <4 x double> %vecinit2, double %t3, i32 3 %vecinit3 = insertelement <4 x double> %vecinit2, double %t3, i32 3
%shuffle = shufflevector <4 x double> %vecinit3, <4 x double> %vecinit3, <4 x i32> <i32 0, i32 0, i32 2, i32 2> %shuffle = shufflevector <4 x double> %vecinit3, <4 x double> %vecinit3, <4 x i32> <i32 0, i32 0, i32 2, i32 2>
ret <4 x double> %shuffle ret <4 x double> %shuffle
} }
define double @PR21780_only_access3_with_inbounds(ptr %ptr) { define double @PR21780_only_access3_with_inbounds(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define {{[^@]+}}@PR21780_only_access3_with_inbounds ; CHECK-LABEL: define {{[^@]+}}@PR21780_only_access3_with_inbounds
; CHECK-SAME: (ptr nocapture nofree nonnull readonly align 8 dereferenceable(32) [[PTR:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readonly align 8 dereferenceable(32) [[PTR:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr inbounds double, ptr [[PTR]], i64 3 ; CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr inbounds double, ptr [[PTR]], i64 3
; CHECK-NEXT: [[T3:%.*]] = load double, ptr [[ARRAYIDX3]], align 8 ; CHECK-NEXT: [[T3:%.*]] = load double, ptr [[ARRAYIDX3]], align 8
; CHECK-NEXT: ret double [[T3]] ; CHECK-NEXT: ret double [[T3]]
; ;
%arrayidx3 = getelementptr inbounds double, double* %ptr, i64 3 %arrayidx3 = getelementptr inbounds double, double* %ptr, i64 3
%t3 = load double, ptr %arrayidx3, align 8 %t3 = load double, ptr %arrayidx3, align 8
ret double %t3 ret double %t3
} }
define double @PR21780_only_access3_without_inbounds(ptr %ptr) { define double @PR21780_only_access3_without_inbounds(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define {{[^@]+}}@PR21780_only_access3_without_inbounds ; CHECK-LABEL: define {{[^@]+}}@PR21780_only_access3_without_inbounds
; CHECK-SAME: (ptr nocapture nofree readonly align 8 [[PTR:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nocapture nofree readonly align 8 [[PTR:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr double, ptr [[PTR]], i64 3 ; CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr double, ptr [[PTR]], i64 3
; CHECK-NEXT: [[T3:%.*]] = load double, ptr [[ARRAYIDX3]], align 8 ; CHECK-NEXT: [[T3:%.*]] = load double, ptr [[ARRAYIDX3]], align 8
; CHECK-NEXT: ret double [[T3]] ; CHECK-NEXT: ret double [[T3]]
; ;
%arrayidx3 = getelementptr double, double* %ptr, i64 3 %arrayidx3 = getelementptr double, double* %ptr, i64 3
%t3 = load double, ptr %arrayidx3, align 8 %t3 = load double, ptr %arrayidx3, align 8
ret double %t3 ret double %t3
} }
define double @PR21780_without_inbounds(ptr %ptr) { define double @PR21780_without_inbounds(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define {{[^@]+}}@PR21780_without_inbounds ; CHECK-LABEL: define {{[^@]+}}@PR21780_without_inbounds
; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 8 dereferenceable(32) [[PTR:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 8 dereferenceable(32) [[PTR:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr double, ptr [[PTR]], i64 3 ; CHECK-NEXT: [[ARRAYIDX3:%.*]] = getelementptr double, ptr [[PTR]], i64 3
; CHECK-NEXT: [[T3:%.*]] = load double, ptr [[ARRAYIDX3]], align 8 ; CHECK-NEXT: [[T3:%.*]] = load double, ptr [[ARRAYIDX3]], align 8
; CHECK-NEXT: ret double [[T3]] ; CHECK-NEXT: ret double [[T3]]
; ;
%arrayidx1 = getelementptr double, double* %ptr, i64 1 %arrayidx1 = getelementptr double, double* %ptr, i64 1
%arrayidx2 = getelementptr double, ptr %ptr, i64 2 %arrayidx2 = getelementptr double, ptr %ptr, i64 2
%arrayidx3 = getelementptr double, ptr %ptr, i64 3 %arrayidx3 = getelementptr double, ptr %ptr, i64 3
%t0 = load double, ptr %ptr, align 8 %t0 = load double, ptr %ptr, align 8
%t1 = load double, ptr %arrayidx1, align 8 %t1 = load double, ptr %arrayidx1, align 8
%t2 = load double, ptr %arrayidx2, align 8 %t2 = load double, ptr %arrayidx2, align 8
%t3 = load double, ptr %arrayidx3, align 8 %t3 = load double, ptr %arrayidx3, align 8
ret double %t3 ret double %t3
} }
; Unsimplified, but still valid. Also, throw in some bogus arguments. ; Unsimplified, but still valid. Also, throw in some bogus arguments.
define void @gep0(ptr %unused, ptr %other, ptr %ptr) { define void @gep0(ptr %unused, ptr %other, ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; CHECK-LABEL: define {{[^@]+}}@gep0 ; CHECK-LABEL: define {{[^@]+}}@gep0
; CHECK-SAME: (ptr nocapture nofree readnone [[UNUSED:%.*]], ptr nocapture nofree noundef nonnull writeonly dereferenceable(1) [[OTHER:%.*]], ptr nocapture nofree nonnull readonly dereferenceable(3) [[PTR:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree readnone [[UNUSED:%.*]], ptr nocapture nofree noundef nonnull writeonly dereferenceable(1) [[OTHER:%.*]], ptr nocapture nofree nonnull readonly dereferenceable(3) [[PTR:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr i8, ptr [[PTR]], i64 2 ; CHECK-NEXT: [[ARRAYIDX2:%.*]] = getelementptr i8, ptr [[PTR]], i64 2
; CHECK-NEXT: [[T2:%.*]] = load i8, ptr [[ARRAYIDX2]], align 1 ; CHECK-NEXT: [[T2:%.*]] = load i8, ptr [[ARRAYIDX2]], align 1
; CHECK-NEXT: store i8 [[T2]], ptr [[OTHER]], align 1 ; CHECK-NEXT: store i8 [[T2]], ptr [[OTHER]], align 1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx0 = getelementptr i8, i8* %ptr, i64 0 %arrayidx0 = getelementptr i8, i8* %ptr, i64 0
%arrayidx1 = getelementptr i8, ptr %ptr, i64 1 %arrayidx1 = getelementptr i8, ptr %ptr, i64 1
%arrayidx2 = getelementptr i8, ptr %ptr, i64 2 %arrayidx2 = getelementptr i8, ptr %ptr, i64 2
%t0 = load i8, ptr %arrayidx0 %t0 = load i8, ptr %arrayidx0
%t1 = load i8, ptr %arrayidx1 %t1 = load i8, ptr %arrayidx1
%t2 = load i8, ptr %arrayidx2 %t2 = load i8, ptr %arrayidx2
store i8 %t2, ptr %other store i8 %t2, ptr %other
ret void ret void
} }
; Order of accesses does not change computation. ; Order of accesses does not change computation.
; Multiple arguments may be dereferenceable. ; Multiple arguments may be dereferenceable.
define void @ordering(ptr %ptr1, ptr %ptr2) { define void @ordering(ptr %ptr1, ptr %ptr2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@ordering ; CHECK-LABEL: define {{[^@]+}}@ordering
; CHECK-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(3) [[PTR1:%.*]], ptr nocapture nofree nonnull readnone align 4 dereferenceable(8) [[PTR2:%.*]]) #[[ATTR2:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(3) [[PTR1:%.*]], ptr nocapture nofree nonnull readnone align 4 dereferenceable(8) [[PTR2:%.*]]) #[[ATTR2:[0-9]+]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%a20 = getelementptr i32, i32* %ptr2, i64 0 %a20 = getelementptr i32, i32* %ptr2, i64 0
%a12 = getelementptr i8, ptr %ptr1, i64 2 %a12 = getelementptr i8, ptr %ptr1, i64 2
%t12 = load i8, ptr %a12 %t12 = load i8, ptr %a12
%a11 = getelementptr i8, ptr %ptr1, i64 1 %a11 = getelementptr i8, ptr %ptr1, i64 1
%t20 = load i32, ptr %a20 %t20 = load i32, ptr %a20
%t10 = load i8, ptr %ptr1 %t10 = load i8, ptr %ptr1
%t11 = load i8, ptr %a11 %t11 = load i8, ptr %a11
%a21 = getelementptr i32, ptr %ptr2, i64 1 %a21 = getelementptr i32, ptr %ptr2, i64 1
%t21 = load i32, ptr %a21 %t21 = load i32, ptr %a21
ret void ret void
} }
; Not in entry block. ; Not in entry block.
define void @not_entry_but_guaranteed_to_execute(ptr %ptr) { define void @not_entry_but_guaranteed_to_execute(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@not_entry_but_guaranteed_to_execute ; CHECK-LABEL: define {{[^@]+}}@not_entry_but_guaranteed_to_execute
; CHECK-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(3) [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(3) [[PTR:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[EXIT:%.*]] ; CHECK-NEXT: br label [[EXIT:%.*]]
; CHECK: exit: ; CHECK: exit:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
br label %exit br label %exit
exit: exit:
%arrayidx1 = getelementptr i8, ptr %ptr, i64 1 %arrayidx1 = getelementptr i8, ptr %ptr, i64 1
%arrayidx2 = getelementptr i8, ptr %ptr, i64 2 %arrayidx2 = getelementptr i8, ptr %ptr, i64 2
%t0 = load i8, ptr %ptr %t0 = load i8, ptr %ptr
%t1 = load i8, ptr %arrayidx1 %t1 = load i8, ptr %arrayidx1
%t2 = load i8, ptr %arrayidx2 %t2 = load i8, ptr %arrayidx2
ret void ret void
} }
; Not in entry block and not guaranteed to execute. ; Not in entry block and not guaranteed to execute.
define void @not_entry_not_guaranteed_to_execute(ptr %ptr, i1 %cond) { define void @not_entry_not_guaranteed_to_execute(ptr %ptr, i1 %cond) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@not_entry_not_guaranteed_to_execute ; CHECK-LABEL: define {{[^@]+}}@not_entry_not_guaranteed_to_execute
; CHECK-SAME: (ptr nocapture nofree readnone [[PTR:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree readnone [[PTR:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[COND]], label [[LOADS:%.*]], label [[EXIT:%.*]] ; CHECK-NEXT: br i1 [[COND]], label [[LOADS:%.*]], label [[EXIT:%.*]]
; CHECK: loads: ; CHECK: loads:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK: exit: ; CHECK: exit:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
Show All 9 Linesloads:
ret void ret void
exit: exit:
ret void ret void
} }
; The last load may not execute, so derefenceable bytes only covers the 1st two loads. ; The last load may not execute, so derefenceable bytes only covers the 1st two loads.
define void @partial_in_entry(ptr %ptr, i1 %cond) { define void @partial_in_entry(ptr %ptr, i1 %cond) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@partial_in_entry ; CHECK-LABEL: define {{[^@]+}}@partial_in_entry
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 2 dereferenceable(4) [[PTR:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 2 dereferenceable(4) [[PTR:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[COND]], label [[LOADS:%.*]], label [[EXIT:%.*]] ; CHECK-NEXT: br i1 [[COND]], label [[LOADS:%.*]], label [[EXIT:%.*]]
; CHECK: loads: ; CHECK: loads:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK: exit: ; CHECK: exit:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
Show All 10 Lines
exit: exit:
ret void ret void
} }
; The volatile load can't be used to prove a non-volatile access is allowed. ; The volatile load can't be used to prove a non-volatile access is allowed.
; The 2nd and 3rd loads may never execute. ; The 2nd and 3rd loads may never execute.
define void @volatile_is_not_dereferenceable(ptr %ptr) { define void @volatile_is_not_dereferenceable(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
; CHECK-LABEL: define {{[^@]+}}@volatile_is_not_dereferenceable ; CHECK-LABEL: define {{[^@]+}}@volatile_is_not_dereferenceable
; CHECK-SAME: (ptr nofree align 2 [[PTR:%.*]]) #[[ATTR3:[0-9]+]] { ; CHECK-SAME: (ptr nofree align 2 [[PTR:%.*]]) #[[ATTR3:[0-9]+]] {
; CHECK-NEXT: [[T0:%.*]] = load volatile i16, ptr [[PTR]], align 2 ; CHECK-NEXT: [[T0:%.*]] = load volatile i16, ptr [[PTR]], align 2
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx0 = getelementptr i16, i16* %ptr, i64 0 %arrayidx0 = getelementptr i16, i16* %ptr, i64 0
%arrayidx1 = getelementptr i16, ptr %ptr, i64 1 %arrayidx1 = getelementptr i16, ptr %ptr, i64 1
%arrayidx2 = getelementptr i16, ptr %ptr, i64 2 %arrayidx2 = getelementptr i16, ptr %ptr, i64 2
%t0 = load volatile i16, ptr %arrayidx0 %t0 = load volatile i16, ptr %arrayidx0
%t1 = load i16, ptr %arrayidx1 %t1 = load i16, ptr %arrayidx1
%t2 = load i16, ptr %arrayidx2 %t2 = load i16, ptr %arrayidx2
ret void ret void
} }
; TODO: We should allow inference for atomic (but not volatile) ops. ; TODO: We should allow inference for atomic (but not volatile) ops.
define void @atomic_is_alright(ptr %ptr) { define void @atomic_is_alright(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@atomic_is_alright ; CHECK-LABEL: define {{[^@]+}}@atomic_is_alright
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 2 dereferenceable(6) [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 2 dereferenceable(6) [[PTR:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx0 = getelementptr i16, i16* %ptr, i64 0 %arrayidx0 = getelementptr i16, i16* %ptr, i64 0
%arrayidx1 = getelementptr i16, ptr %ptr, i64 1 %arrayidx1 = getelementptr i16, ptr %ptr, i64 1
%arrayidx2 = getelementptr i16, ptr %ptr, i64 2 %arrayidx2 = getelementptr i16, ptr %ptr, i64 2
%t0 = load atomic i16, ptr %arrayidx0 unordered, align 2 %t0 = load atomic i16, ptr %arrayidx0 unordered, align 2
Show All 18 Lines;
%t1 = load i16, ptr %arrayidx1 %t1 = load i16, ptr %arrayidx1
%t2 = load i16, ptr %arrayidx2 %t2 = load i16, ptr %arrayidx2
ret void ret void
} }
; We must have consecutive accesses. ; We must have consecutive accesses.
define void @variable_gep_index(ptr %unused, ptr %ptr, i64 %variable_index) { define void @variable_gep_index(ptr %unused, ptr %ptr, i64 %variable_index) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@variable_gep_index ; CHECK-LABEL: define {{[^@]+}}@variable_gep_index
; CHECK-SAME: (ptr nocapture nofree readnone [[UNUSED:%.*]], ptr nocapture nofree nonnull readnone dereferenceable(1) [[PTR:%.*]], i64 [[VARIABLE_INDEX:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree readnone [[UNUSED:%.*]], ptr nocapture nofree nonnull readnone dereferenceable(1) [[PTR:%.*]], i64 [[VARIABLE_INDEX:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx1 = getelementptr i8, i8* %ptr, i64 %variable_index %arrayidx1 = getelementptr i8, i8* %ptr, i64 %variable_index
%arrayidx2 = getelementptr i8, ptr %ptr, i64 2 %arrayidx2 = getelementptr i8, ptr %ptr, i64 2
%t0 = load i8, ptr %ptr %t0 = load i8, ptr %ptr
%t1 = load i8, ptr %arrayidx1 %t1 = load i8, ptr %arrayidx1
%t2 = load i8, ptr %arrayidx2 %t2 = load i8, ptr %arrayidx2
ret void ret void
} }
; Deal with >1 GEP index. ; Deal with >1 GEP index.
define void @multi_index_gep(ptr %ptr) { define void @multi_index_gep(ptr %ptr) {
; FIXME: %ptr should be dereferenceable(4) ; FIXME: %ptr should be dereferenceable(4)
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@multi_index_gep ; CHECK-LABEL: define {{[^@]+}}@multi_index_gep
; CHECK-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(1) [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(1) [[PTR:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx00 = getelementptr <4 x i8>, <4 x i8>* %ptr, i64 0, i64 0 %arrayidx00 = getelementptr <4 x i8>, <4 x i8>* %ptr, i64 0, i64 0
%t0 = load i8, ptr %arrayidx00 %t0 = load i8, ptr %arrayidx00
ret void ret void
} }
; Could round weird bitwidths down? ; Could round weird bitwidths down?
define void @not_byte_multiple(ptr %ptr) { define void @not_byte_multiple(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@not_byte_multiple ; CHECK-LABEL: define {{[^@]+}}@not_byte_multiple
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 2 dereferenceable(2) [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 2 dereferenceable(2) [[PTR:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx0 = getelementptr i9, i9* %ptr, i64 0 %arrayidx0 = getelementptr i9, i9* %ptr, i64 0
%t0 = load i9, ptr %arrayidx0 %t0 = load i9, ptr %arrayidx0
ret void ret void
} }
; Missing direct access from the pointer. ; Missing direct access from the pointer.
define void @no_pointer_deref(ptr %ptr) { define void @no_pointer_deref(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@no_pointer_deref ; CHECK-LABEL: define {{[^@]+}}@no_pointer_deref
; CHECK-SAME: (ptr nocapture nofree readnone align 2 [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree readnone align 2 [[PTR:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx1 = getelementptr i16, i16* %ptr, i64 1 %arrayidx1 = getelementptr i16, i16* %ptr, i64 1
%arrayidx2 = getelementptr i16, ptr %ptr, i64 2 %arrayidx2 = getelementptr i16, ptr %ptr, i64 2
%t1 = load i16, ptr %arrayidx1 %t1 = load i16, ptr %arrayidx1
%t2 = load i16, ptr %arrayidx2 %t2 = load i16, ptr %arrayidx2
ret void ret void
} }
; Out-of-order is ok, but missing access concludes dereferenceable range. ; Out-of-order is ok, but missing access concludes dereferenceable range.
define void @non_consecutive(ptr %ptr) { define void @non_consecutive(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@non_consecutive ; CHECK-LABEL: define {{[^@]+}}@non_consecutive
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(8) [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(8) [[PTR:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx1 = getelementptr i32, i32* %ptr, i64 1 %arrayidx1 = getelementptr i32, i32* %ptr, i64 1
%arrayidx3 = getelementptr i32, ptr %ptr, i64 3 %arrayidx3 = getelementptr i32, ptr %ptr, i64 3
%t1 = load i32, ptr %arrayidx1 %t1 = load i32, ptr %arrayidx1
%t0 = load i32, ptr %ptr %t0 = load i32, ptr %ptr
%t3 = load i32, ptr %arrayidx3 %t3 = load i32, ptr %arrayidx3
ret void ret void
} }
; Improve on existing dereferenceable attribute. ; Improve on existing dereferenceable attribute.
define void @more_bytes(ptr dereferenceable(8) %ptr) { define void @more_bytes(ptr dereferenceable(8) %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@more_bytes ; CHECK-LABEL: define {{[^@]+}}@more_bytes
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(16) [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(16) [[PTR:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx3 = getelementptr i32, i32* %ptr, i64 3 %arrayidx3 = getelementptr i32, i32* %ptr, i64 3
%arrayidx1 = getelementptr i32, ptr %ptr, i64 1 %arrayidx1 = getelementptr i32, ptr %ptr, i64 1
%arrayidx2 = getelementptr i32, ptr %ptr, i64 2 %arrayidx2 = getelementptr i32, ptr %ptr, i64 2
%t3 = load i32, ptr %arrayidx3 %t3 = load i32, ptr %arrayidx3
%t1 = load i32, ptr %arrayidx1 %t1 = load i32, ptr %arrayidx1
%t2 = load i32, ptr %arrayidx2 %t2 = load i32, ptr %arrayidx2
%t0 = load i32, ptr %ptr %t0 = load i32, ptr %ptr
ret void ret void
} }
; Improve on existing dereferenceable_or_null attribute. ; Improve on existing dereferenceable_or_null attribute.
define void @more_bytes_and_not_null(ptr dereferenceable_or_null(8) %ptr) { define void @more_bytes_and_not_null(ptr dereferenceable_or_null(8) %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@more_bytes_and_not_null ; CHECK-LABEL: define {{[^@]+}}@more_bytes_and_not_null
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(16) [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(16) [[PTR:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx3 = getelementptr i32, i32* %ptr, i64 3 %arrayidx3 = getelementptr i32, i32* %ptr, i64 3
%arrayidx1 = getelementptr i32, ptr %ptr, i64 1 %arrayidx1 = getelementptr i32, ptr %ptr, i64 1
%arrayidx2 = getelementptr i32, ptr %ptr, i64 2 %arrayidx2 = getelementptr i32, ptr %ptr, i64 2
%t3 = load i32, ptr %arrayidx3 %t3 = load i32, ptr %arrayidx3
%t1 = load i32, ptr %arrayidx1 %t1 = load i32, ptr %arrayidx1
%t2 = load i32, ptr %arrayidx2 %t2 = load i32, ptr %arrayidx2
%t0 = load i32, ptr %ptr %t0 = load i32, ptr %ptr
ret void ret void
} }
; But don't pessimize existing dereferenceable attribute. ; But don't pessimize existing dereferenceable attribute.
define void @better_bytes(ptr dereferenceable(100) %ptr) { define void @better_bytes(ptr dereferenceable(100) %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@better_bytes ; CHECK-LABEL: define {{[^@]+}}@better_bytes
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(100) [[PTR:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(100) [[PTR:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arrayidx3 = getelementptr i32, i32* %ptr, i64 3 %arrayidx3 = getelementptr i32, i32* %ptr, i64 3
%arrayidx1 = getelementptr i32, ptr %ptr, i64 1 %arrayidx1 = getelementptr i32, ptr %ptr, i64 1
%arrayidx2 = getelementptr i32, ptr %ptr, i64 2 %arrayidx2 = getelementptr i32, ptr %ptr, i64 2
%t3 = load i32, ptr %arrayidx3 %t3 = load i32, ptr %arrayidx3
%t1 = load i32, ptr %arrayidx1 %t1 = load i32, ptr %arrayidx1
%t2 = load i32, ptr %arrayidx2 %t2 = load i32, ptr %arrayidx2
%t0 = load i32, ptr %ptr %t0 = load i32, ptr %ptr
ret void ret void
} }
define void @bitcast(ptr %arg) { define void @bitcast(ptr %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@bitcast ; CHECK-LABEL: define {{[^@]+}}@bitcast
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(8) [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(8) [[ARG:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%ptr = bitcast i32* %arg to float* %ptr = bitcast i32* %arg to float*
%arrayidx1 = getelementptr float, ptr %ptr, i64 1 %arrayidx1 = getelementptr float, ptr %ptr, i64 1
%t0 = load float, ptr %ptr %t0 = load float, ptr %ptr
%t1 = load float, ptr %arrayidx1 %t1 = load float, ptr %arrayidx1
ret void ret void
} }
define void @bitcast_different_sizes(ptr %arg1, ptr %arg2) { define void @bitcast_different_sizes(ptr %arg1, ptr %arg2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@bitcast_different_sizes ; CHECK-LABEL: define {{[^@]+}}@bitcast_different_sizes
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(12) [[ARG1:%.*]], ptr nocapture nofree nonnull readnone align 4 dereferenceable(16) [[ARG2:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(12) [[ARG1:%.*]], ptr nocapture nofree nonnull readnone align 4 dereferenceable(16) [[ARG2:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%ptr1 = bitcast double* %arg1 to float* %ptr1 = bitcast double* %arg1 to float*
%a11 = getelementptr float, ptr %ptr1, i64 1 %a11 = getelementptr float, ptr %ptr1, i64 1
%a12 = getelementptr float, ptr %ptr1, i64 2 %a12 = getelementptr float, ptr %ptr1, i64 2
%ld10 = load float, ptr %ptr1 %ld10 = load float, ptr %ptr1
%ld11 = load float, ptr %a11 %ld11 = load float, ptr %a11
%ld12 = load float, ptr %a12 %ld12 = load float, ptr %a12
%a21 = getelementptr i64, ptr %arg2, i64 1 %a21 = getelementptr i64, ptr %arg2, i64 1
%ld20 = load i64, ptr %arg2 %ld20 = load i64, ptr %arg2
%ld21 = load i64, ptr %a21 %ld21 = load i64, ptr %a21
ret void ret void
} }
define void @negative_offset(ptr %arg) { define void @negative_offset(ptr %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@negative_offset ; CHECK-LABEL: define {{[^@]+}}@negative_offset
; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(4) [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(4) [[ARG:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%ptr = bitcast i32* %arg to float* %ptr = bitcast i32* %arg to float*
%arrayidx1 = getelementptr float, ptr %ptr, i64 -1 %arrayidx1 = getelementptr float, ptr %ptr, i64 -1
%t0 = load float, ptr %ptr %t0 = load float, ptr %ptr
%t1 = load float, ptr %arrayidx1 %t1 = load float, ptr %arrayidx1
ret void ret void
} }
define void @stores(ptr %arg) { define void @stores(ptr %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@stores ; CHECK-LABEL: define {{[^@]+}}@stores
; CHECK-SAME: (ptr nocapture nofree nonnull writeonly align 4 dereferenceable(8) [[ARG:%.*]]) #[[ATTR4:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree nonnull writeonly align 4 dereferenceable(8) [[ARG:%.*]]) #[[ATTR4:[0-9]+]] {
; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr float, ptr [[ARG]], i64 1 ; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr float, ptr [[ARG]], i64 1
; CHECK-NEXT: store float 1.000000e+00, ptr [[ARG]], align 4 ; CHECK-NEXT: store float 1.000000e+00, ptr [[ARG]], align 4
; CHECK-NEXT: store float 2.000000e+00, ptr [[ARRAYIDX1]], align 4 ; CHECK-NEXT: store float 2.000000e+00, ptr [[ARRAYIDX1]], align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%ptr = bitcast i32* %arg to float* %ptr = bitcast i32* %arg to float*
%arrayidx1 = getelementptr float, ptr %ptr, i64 1 %arrayidx1 = getelementptr float, ptr %ptr, i64 1
store float 1.0, ptr %ptr store float 1.0, ptr %ptr
store float 2.0, ptr %arrayidx1 store float 2.0, ptr %arrayidx1
ret void ret void
} }
define void @load_store(ptr %arg) { define void @load_store(ptr %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@load_store ; CHECK-LABEL: define {{[^@]+}}@load_store
; CHECK-SAME: (ptr nocapture nofree nonnull writeonly align 4 dereferenceable(8) [[ARG:%.*]]) #[[ATTR4]] { ; CHECK-SAME: (ptr nocapture nofree nonnull writeonly align 4 dereferenceable(8) [[ARG:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr float, ptr [[ARG]], i64 1 ; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr float, ptr [[ARG]], i64 1
; CHECK-NEXT: store float 2.000000e+00, ptr [[ARRAYIDX1]], align 4 ; CHECK-NEXT: store float 2.000000e+00, ptr [[ARRAYIDX1]], align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%ptr = bitcast i32* %arg to float* %ptr = bitcast i32* %arg to float*
%arrayidx1 = getelementptr float, ptr %ptr, i64 1 %arrayidx1 = getelementptr float, ptr %ptr, i64 1
%t1 = load float, ptr %ptr %t1 = load float, ptr %ptr
store float 2.0, ptr %arrayidx1 store float 2.0, ptr %arrayidx1
ret void ret void
} }
define void @different_size1(ptr %arg) { define void @different_size1(ptr %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@different_size1 ; CHECK-LABEL: define {{[^@]+}}@different_size1
; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[ARG:%.*]]) #[[ATTR4]] { ; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[ARG:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: store double 0.000000e+00, ptr [[ARG]], align 8 ; CHECK-NEXT: store double 0.000000e+00, ptr [[ARG]], align 8
; CHECK-NEXT: store i32 0, ptr [[ARG]], align 8 ; CHECK-NEXT: store i32 0, ptr [[ARG]], align 8
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%arg-cast = bitcast i32* %arg to double* %arg-cast = bitcast i32* %arg to double*
store double 0.000000e+00, ptr %arg-cast store double 0.000000e+00, ptr %arg-cast
store i32 0, ptr %arg store i32 0, ptr %arg
ret void ret void
} }
define void @different_size2(ptr %arg) { define void @different_size2(ptr %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@different_size2 ; CHECK-LABEL: define {{[^@]+}}@different_size2
; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[ARG:%.*]]) #[[ATTR4]] { ; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[ARG:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: store i32 0, ptr [[ARG]], align 8 ; CHECK-NEXT: store i32 0, ptr [[ARG]], align 8
; CHECK-NEXT: store double 0.000000e+00, ptr [[ARG]], align 8 ; CHECK-NEXT: store double 0.000000e+00, ptr [[ARG]], align 8
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store i32 0, i32* %arg store i32 0, i32* %arg
store double 0.000000e+00, ptr %arg store double 0.000000e+00, ptr %arg
Show All 14 Lines
; l6 l7 ; l6 l7
; \ / ; \ /
; end ; end
; According to the above CFG, we can see that instructions in l5 Block must be executed. ; According to the above CFG, we can see that instructions in l5 Block must be executed.
; Therefore, %p must be dereferenced. ; Therefore, %p must be dereferenced.
; ;
; ATTRIBUTOR_CGSCC_NPM-LABEL: define i32 @require_cfg_analysis(i32 %c, i32* {{.*}} dereferenceable(4) %p) ; ATTRIBUTOR_CGSCC_NPM-LABEL: define i32 @require_cfg_analysis(i32 %c, i32* {{.*}} dereferenceable(4) %p)
define i32 @require_cfg_analysis(i32 %c, ptr %p) { define i32 @require_cfg_analysis(i32 %c, ptr %p) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@require_cfg_analysis ; CHECK-LABEL: define {{[^@]+}}@require_cfg_analysis
; CHECK-SAME: (i32 [[C:%.*]], ptr nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR4]] { ; CHECK-SAME: (i32 [[C:%.*]], ptr nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: [[TOBOOL1:%.*]] = icmp eq i32 [[C]], 0 ; CHECK-NEXT: [[TOBOOL1:%.*]] = icmp eq i32 [[C]], 0
; CHECK-NEXT: br i1 [[TOBOOL1]], label [[L1:%.*]], label [[L2:%.*]] ; CHECK-NEXT: br i1 [[TOBOOL1]], label [[L1:%.*]], label [[L2:%.*]]
; CHECK: l1: ; CHECK: l1:
; CHECK-NEXT: [[TOBOOL2:%.*]] = icmp eq i32 [[C]], 1 ; CHECK-NEXT: [[TOBOOL2:%.*]] = icmp eq i32 [[C]], 1
; CHECK-NEXT: br i1 [[TOBOOL2]], label [[L3:%.*]], label [[L4:%.*]] ; CHECK-NEXT: br i1 [[TOBOOL2]], label [[L3:%.*]], label [[L4:%.*]]
; CHECK: l2: ; CHECK: l2:
Show All 35 Linesl6:
br label %end br label %end
l7: l7:
store i32 1, ptr %p store i32 1, ptr %p
br label %end br label %end
end: end:
ret i32 1 ret i32 1
} }
;. ;.
; CHECK: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; CHECK: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; CHECK: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; CHECK: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; CHECK: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CHECK: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CHECK: attributes #[[ATTR3]] = { nofree norecurse nounwind willreturn memory(argmem: readwrite) } ; CHECK: attributes #[[ATTR3]] = { mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite) }
; CHECK: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; CHECK: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CGSCC: {{.*}} ; CGSCC: {{.*}}
; TUNIT: {{.*}} ; TUNIT: {{.*}}

llvm/test/Transforms/Attributor/internal-noalias.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=15 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=15 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
define dso_local i32 @visible(ptr noalias %A, ptr noalias %B) #0 { define dso_local i32 @visible(ptr noalias %A, ptr noalias %B) #0 {
; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable
; TUNIT-LABEL: define {{[^@]+}}@visible ; TUNIT-LABEL: define {{[^@]+}}@visible
; TUNIT-SAME: (ptr noalias nocapture nofree readonly [[A:%.*]], ptr noalias nocapture nofree readonly [[B:%.*]]) #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: (ptr noalias nocapture nofree readonly [[A:%.*]], ptr noalias nocapture nofree readonly [[B:%.*]]) #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[CALL1:%.*]] = call i32 @noalias_args(ptr noalias nocapture nofree readonly align 4 [[A]], ptr noalias nocapture nofree readonly align 4 [[B]]) #[[ATTR4:[0-9]+]] ; TUNIT-NEXT: [[CALL1:%.*]] = call i32 @noalias_args(ptr noalias nocapture nofree readonly align 4 [[A]], ptr noalias nocapture nofree readonly align 4 [[B]]) #[[ATTR4:[0-9]+]]
; TUNIT-NEXT: [[CALL2:%.*]] = call i32 @noalias_args_argmem(ptr noalias nocapture nofree readonly align 4 [[A]], ptr noalias nocapture nofree readonly align 4 [[B]]) #[[ATTR4]] ; TUNIT-NEXT: [[CALL2:%.*]] = call i32 @noalias_args_argmem(ptr noalias nocapture nofree readonly align 4 [[A]], ptr noalias nocapture nofree readonly align 4 [[B]]) #[[ATTR4]]
; TUNIT-NEXT: [[ADD:%.*]] = add nsw i32 [[CALL1]], [[CALL2]] ; TUNIT-NEXT: [[ADD:%.*]] = add nsw i32 [[CALL1]], [[CALL2]]
; TUNIT-NEXT: ret i32 [[ADD]] ; TUNIT-NEXT: ret i32 [[ADD]]
; ;
; CGSCC: Function Attrs: nofree noinline nosync nounwind willreturn memory(argmem: read) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(argmem: read) uwtable
; CGSCC-LABEL: define {{[^@]+}}@visible ; CGSCC-LABEL: define {{[^@]+}}@visible
; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A:%.*]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A:%.*]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CALL1:%.*]] = call i32 @noalias_args(ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B]]) ; CGSCC-NEXT: [[CALL1:%.*]] = call i32 @noalias_args(ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B]])
; CGSCC-NEXT: [[CALL2:%.*]] = call i32 @noalias_args_argmem(ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B]]) ; CGSCC-NEXT: [[CALL2:%.*]] = call i32 @noalias_args_argmem(ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B]])
; CGSCC-NEXT: [[ADD:%.*]] = add nsw i32 [[CALL1]], [[CALL2]] ; CGSCC-NEXT: [[ADD:%.*]] = add nsw i32 [[CALL1]], [[CALL2]]
; CGSCC-NEXT: ret i32 [[ADD]] ; CGSCC-NEXT: ret i32 [[ADD]]
; ;
entry: entry:
%call1 = call i32 @noalias_args(ptr %A, ptr %B) %call1 = call i32 @noalias_args(ptr %A, ptr %B)
%call2 = call i32 @noalias_args_argmem(ptr %A, ptr %B) %call2 = call i32 @noalias_args_argmem(ptr %A, ptr %B)
%add = add nsw i32 %call1, %call2 %add = add nsw i32 %call1, %call2
ret i32 %add ret i32 %add
} }
define private i32 @noalias_args(ptr %A, ptr %B) #0 { define private i32 @noalias_args(ptr %A, ptr %B) #0 {
; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable
; TUNIT-LABEL: define {{[^@]+}}@noalias_args ; TUNIT-LABEL: define {{[^@]+}}@noalias_args
; TUNIT-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A:%.*]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A:%.*]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[TMP0:%.*]] = load i32, ptr [[A]], align 4 ; TUNIT-NEXT: [[TMP0:%.*]] = load i32, ptr [[A]], align 4
; TUNIT-NEXT: [[TMP1:%.*]] = load i32, ptr [[B]], align 4 ; TUNIT-NEXT: [[TMP1:%.*]] = load i32, ptr [[B]], align 4
; TUNIT-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP0]], [[TMP1]] ; TUNIT-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP0]], [[TMP1]]
; TUNIT-NEXT: [[CALL:%.*]] = call i32 @noalias_args_argmem(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B]]) #[[ATTR4]] ; TUNIT-NEXT: [[CALL:%.*]] = call i32 @noalias_args_argmem(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B]]) #[[ATTR4]]
; TUNIT-NEXT: [[ADD2:%.*]] = add nsw i32 [[ADD]], [[CALL]] ; TUNIT-NEXT: [[ADD2:%.*]] = add nsw i32 [[ADD]], [[CALL]]
; TUNIT-NEXT: ret i32 [[ADD2]] ; TUNIT-NEXT: ret i32 [[ADD2]]
; ;
; CGSCC: Function Attrs: nofree noinline nosync nounwind willreturn memory(argmem: read) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(argmem: read) uwtable
; CGSCC-LABEL: define {{[^@]+}}@noalias_args ; CGSCC-LABEL: define {{[^@]+}}@noalias_args
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A:%.*]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A:%.*]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[TMP0:%.*]] = load i32, ptr [[A]], align 4 ; CGSCC-NEXT: [[TMP0:%.*]] = load i32, ptr [[A]], align 4
; CGSCC-NEXT: [[TMP1:%.*]] = load i32, ptr [[B]], align 4 ; CGSCC-NEXT: [[TMP1:%.*]] = load i32, ptr [[B]], align 4
; CGSCC-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP0]], [[TMP1]] ; CGSCC-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP0]], [[TMP1]]
; CGSCC-NEXT: [[CALL:%.*]] = call i32 @noalias_args_argmem(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B]]) #[[ATTR5:[0-9]+]] ; CGSCC-NEXT: [[CALL:%.*]] = call i32 @noalias_args_argmem(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B]]) #[[ATTR5:[0-9]+]]
; CGSCC-NEXT: [[ADD2:%.*]] = add nsw i32 [[ADD]], [[CALL]] ; CGSCC-NEXT: [[ADD2:%.*]] = add nsw i32 [[ADD]], [[CALL]]
; CGSCC-NEXT: ret i32 [[ADD2]] ; CGSCC-NEXT: ret i32 [[ADD2]]
; ;
entry: entry:
%0 = load i32, ptr %A, align 4 %0 = load i32, ptr %A, align 4
%1 = load i32, ptr %B, align 4 %1 = load i32, ptr %B, align 4
%add = add nsw i32 %0, %1 %add = add nsw i32 %0, %1
%call = call i32 @noalias_args_argmem(ptr %A, ptr %B) %call = call i32 @noalias_args_argmem(ptr %A, ptr %B)
%add2 = add nsw i32 %add, %call %add2 = add nsw i32 %add, %call
ret i32 %add2 ret i32 %add2
} }
define internal i32 @noalias_args_argmem(ptr %A, ptr %B) #1 { define internal i32 @noalias_args_argmem(ptr %A, ptr %B) #1 {
; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable
; TUNIT-LABEL: define {{[^@]+}}@noalias_args_argmem ; TUNIT-LABEL: define {{[^@]+}}@noalias_args_argmem
; TUNIT-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A:%.*]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A:%.*]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[TMP0:%.*]] = load i32, ptr [[A]], align 4 ; TUNIT-NEXT: [[TMP0:%.*]] = load i32, ptr [[A]], align 4
; TUNIT-NEXT: [[TMP1:%.*]] = load i32, ptr [[B]], align 4 ; TUNIT-NEXT: [[TMP1:%.*]] = load i32, ptr [[B]], align 4
; TUNIT-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP0]], [[TMP1]] ; TUNIT-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP0]], [[TMP1]]
; TUNIT-NEXT: ret i32 [[ADD]] ; TUNIT-NEXT: ret i32 [[ADD]]
; ;
; CGSCC: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable
; CGSCC-LABEL: define {{[^@]+}}@noalias_args_argmem ; CGSCC-LABEL: define {{[^@]+}}@noalias_args_argmem
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A:%.*]], ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A:%.*]], ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[TMP0:%.*]] = load i32, ptr [[A]], align 4 ; CGSCC-NEXT: [[TMP0:%.*]] = load i32, ptr [[A]], align 4
; CGSCC-NEXT: [[TMP1:%.*]] = load i32, ptr [[B]], align 4 ; CGSCC-NEXT: [[TMP1:%.*]] = load i32, ptr [[B]], align 4
; CGSCC-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP0]], [[TMP1]] ; CGSCC-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP0]], [[TMP1]]
; CGSCC-NEXT: ret i32 [[ADD]] ; CGSCC-NEXT: ret i32 [[ADD]]
; ;
entry: entry:
%0 = load i32, ptr %A, align 4 %0 = load i32, ptr %A, align 4
%1 = load i32, ptr %B, align 4 %1 = load i32, ptr %B, align 4
%add = add nsw i32 %0, %1 %add = add nsw i32 %0, %1
ret i32 %add ret i32 %add
} }
define dso_local i32 @visible_local(ptr %A) #0 { define dso_local i32 @visible_local(ptr %A) #0 {
; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; TUNIT-LABEL: define {{[^@]+}}@visible_local ; TUNIT-LABEL: define {{[^@]+}}@visible_local
; TUNIT-SAME: (ptr nocapture nofree readonly [[A:%.*]]) #[[ATTR1:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree readonly [[A:%.*]]) #[[ATTR1:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[B:%.*]] = alloca i32, align 4 ; TUNIT-NEXT: [[B:%.*]] = alloca i32, align 4
; TUNIT-NEXT: store i32 5, ptr [[B]], align 4 ; TUNIT-NEXT: store i32 5, ptr [[B]], align 4
; TUNIT-NEXT: [[CALL1:%.*]] = call i32 @noalias_args(ptr nocapture nofree readonly align 4 [[A]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B]]) #[[ATTR4]] ; TUNIT-NEXT: [[CALL1:%.*]] = call i32 @noalias_args(ptr nocapture nofree readonly align 4 [[A]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B]]) #[[ATTR4]]
; TUNIT-NEXT: [[CALL2:%.*]] = call i32 @noalias_args_argmem(ptr nocapture nofree readonly align 4 [[A]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B]]) #[[ATTR4]] ; TUNIT-NEXT: [[CALL2:%.*]] = call i32 @noalias_args_argmem(ptr nocapture nofree readonly align 4 [[A]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B]]) #[[ATTR4]]
; TUNIT-NEXT: [[ADD:%.*]] = add nsw i32 [[CALL1]], [[CALL2]] ; TUNIT-NEXT: [[ADD:%.*]] = add nsw i32 [[CALL1]], [[CALL2]]
; TUNIT-NEXT: ret i32 [[ADD]] ; TUNIT-NEXT: ret i32 [[ADD]]
; ;
; CGSCC: Function Attrs: nofree noinline nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CGSCC-LABEL: define {{[^@]+}}@visible_local ; CGSCC-LABEL: define {{[^@]+}}@visible_local
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR2:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR2:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[B:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[B:%.*]] = alloca i32, align 4
; CGSCC-NEXT: store i32 5, ptr [[B]], align 4 ; CGSCC-NEXT: store i32 5, ptr [[B]], align 4
; CGSCC-NEXT: [[CALL1:%.*]] = call i32 @noalias_args(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B]]) ; CGSCC-NEXT: [[CALL1:%.*]] = call i32 @noalias_args(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B]])
; CGSCC-NEXT: [[CALL2:%.*]] = call i32 @noalias_args_argmem(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B]]) ; CGSCC-NEXT: [[CALL2:%.*]] = call i32 @noalias_args_argmem(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[A]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[B]])
; CGSCC-NEXT: [[ADD:%.*]] = add nsw i32 [[CALL1]], [[CALL2]] ; CGSCC-NEXT: [[ADD:%.*]] = add nsw i32 [[CALL1]], [[CALL2]]
; CGSCC-NEXT: ret i32 [[ADD]] ; CGSCC-NEXT: ret i32 [[ADD]]
; ;
entry: entry:
%B = alloca i32, align 4 %B = alloca i32, align 4
store i32 5, ptr %B, align 4 store i32 5, ptr %B, align 4
%call1 = call i32 @noalias_args(ptr %A, ptr nonnull %B) %call1 = call i32 @noalias_args(ptr %A, ptr nonnull %B)
%call2 = call i32 @noalias_args_argmem(ptr %A, ptr nonnull %B) %call2 = call i32 @noalias_args_argmem(ptr %A, ptr nonnull %B)
%add = add nsw i32 %call1, %call2 %add = add nsw i32 %call1, %call2
ret i32 %add ret i32 %add
} }
define internal i32 @noalias_args_argmem_ro(ptr %A, ptr %B) #1 { define internal i32 @noalias_args_argmem_ro(ptr %A, ptr %B) #1 {
; CGSCC: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable
; CGSCC-LABEL: define {{[^@]+}}@noalias_args_argmem_ro ; CGSCC-LABEL: define {{[^@]+}}@noalias_args_argmem_ro
; CGSCC-SAME: (i32 [[TMP0:%.*]], i32 [[TMP1:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (i32 [[TMP0:%.*]], i32 [[TMP1:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: [[B_PRIV:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[B_PRIV:%.*]] = alloca i32, align 4
; CGSCC-NEXT: store i32 [[TMP1]], ptr [[B_PRIV]], align 4 ; CGSCC-NEXT: store i32 [[TMP1]], ptr [[B_PRIV]], align 4
; CGSCC-NEXT: [[A_PRIV:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[A_PRIV:%.*]] = alloca i32, align 4
; CGSCC-NEXT: store i32 [[TMP0]], ptr [[A_PRIV]], align 4 ; CGSCC-NEXT: store i32 [[TMP0]], ptr [[A_PRIV]], align 4
; CGSCC-NEXT: [[T0:%.*]] = load i32, ptr [[A_PRIV]], align 4 ; CGSCC-NEXT: [[T0:%.*]] = load i32, ptr [[A_PRIV]], align 4
; CGSCC-NEXT: [[T1:%.*]] = load i32, ptr [[B_PRIV]], align 4 ; CGSCC-NEXT: [[T1:%.*]] = load i32, ptr [[B_PRIV]], align 4
; CGSCC-NEXT: [[ADD:%.*]] = add nsw i32 [[T0]], [[T1]] ; CGSCC-NEXT: [[ADD:%.*]] = add nsw i32 [[T0]], [[T1]]
; CGSCC-NEXT: ret i32 [[ADD]] ; CGSCC-NEXT: ret i32 [[ADD]]
; ;
%t0 = load i32, ptr %A, align 4 %t0 = load i32, ptr %A, align 4
%t1 = load i32, ptr %B, align 4 %t1 = load i32, ptr %B, align 4
%add = add nsw i32 %t0, %t1 %add = add nsw i32 %t0, %t1
ret i32 %add ret i32 %add
} }
define i32 @visible_local_2() { define i32 @visible_local_2() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@visible_local_2 ; TUNIT-LABEL: define {{[^@]+}}@visible_local_2
; TUNIT-SAME: () #[[ATTR2:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR2:[0-9]+]] {
; TUNIT-NEXT: [[B:%.*]] = alloca i32, align 4 ; TUNIT-NEXT: [[B:%.*]] = alloca i32, align 4
; TUNIT-NEXT: ret i32 10 ; TUNIT-NEXT: ret i32 10
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@visible_local_2 ; CGSCC-LABEL: define {{[^@]+}}@visible_local_2
; CGSCC-SAME: () #[[ATTR3:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR3:[0-9]+]] {
; CGSCC-NEXT: [[CALL:%.*]] = call i32 @noalias_args_argmem_ro(i32 noundef 5, i32 noundef 5) #[[ATTR6:[0-9]+]] ; CGSCC-NEXT: [[CALL:%.*]] = call i32 @noalias_args_argmem_ro(i32 noundef 5, i32 noundef 5) #[[ATTR6:[0-9]+]]
; CGSCC-NEXT: ret i32 [[CALL]] ; CGSCC-NEXT: ret i32 [[CALL]]
; ;
%B = alloca i32, align 4 %B = alloca i32, align 4
store i32 5, ptr %B, align 4 store i32 5, ptr %B, align 4
%call = call i32 @noalias_args_argmem_ro(ptr %B, ptr %B) %call = call i32 @noalias_args_argmem_ro(ptr %B, ptr %B)
ret i32 %call ret i32 %call
} }
define internal i32 @noalias_args_argmem_rn(ptr %A, ptr %B) #1 { define internal i32 @noalias_args_argmem_rn(ptr %A, ptr %B) #1 {
; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable
; TUNIT-LABEL: define {{[^@]+}}@noalias_args_argmem_rn ; TUNIT-LABEL: define {{[^@]+}}@noalias_args_argmem_rn
; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR3:[0-9]+]] { ; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR3:[0-9]+]] {
; TUNIT-NEXT: ret i32 undef ; TUNIT-NEXT: ret i32 undef
; ;
; CGSCC: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CGSCC-LABEL: define {{[^@]+}}@noalias_args_argmem_rn ; CGSCC-LABEL: define {{[^@]+}}@noalias_args_argmem_rn
; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR4:[0-9]+]] { ; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[B:%.*]]) #[[ATTR4:[0-9]+]] {
; CGSCC-NEXT: [[T0:%.*]] = load i32, ptr [[B]], align 4 ; CGSCC-NEXT: [[T0:%.*]] = load i32, ptr [[B]], align 4
; CGSCC-NEXT: store i32 0, ptr [[B]], align 4 ; CGSCC-NEXT: store i32 0, ptr [[B]], align 4
; CGSCC-NEXT: ret i32 [[T0]] ; CGSCC-NEXT: ret i32 [[T0]]
; ;
%t0 = load i32, ptr %B, align 4 %t0 = load i32, ptr %B, align 4
store i32 0, ptr %B store i32 0, ptr %B
ret i32 %t0 ret i32 %t0
} }
define i32 @visible_local_3() { define i32 @visible_local_3() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@visible_local_3 ; TUNIT-LABEL: define {{[^@]+}}@visible_local_3
; TUNIT-SAME: () #[[ATTR2]] { ; TUNIT-SAME: () #[[ATTR2]] {
; TUNIT-NEXT: [[B:%.*]] = alloca i32, align 4 ; TUNIT-NEXT: [[B:%.*]] = alloca i32, align 4
; TUNIT-NEXT: [[CALL:%.*]] = call i32 @noalias_args_argmem_rn(ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) #[[ATTR5:[0-9]+]] ; TUNIT-NEXT: [[CALL:%.*]] = call i32 @noalias_args_argmem_rn(ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[B]]) #[[ATTR5:[0-9]+]]
; TUNIT-NEXT: ret i32 5 ; TUNIT-NEXT: ret i32 5
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@visible_local_3 ; CGSCC-LABEL: define {{[^@]+}}@visible_local_3
; CGSCC-SAME: () #[[ATTR3]] { ; CGSCC-SAME: () #[[ATTR3]] {
; CGSCC-NEXT: [[B:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[B:%.*]] = alloca i32, align 4
; CGSCC-NEXT: store i32 5, ptr [[B]], align 4 ; CGSCC-NEXT: store i32 5, ptr [[B]], align 4
; CGSCC-NEXT: [[CALL:%.*]] = call i32 @noalias_args_argmem_rn(ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[B]]) #[[ATTR7:[0-9]+]] ; CGSCC-NEXT: [[CALL:%.*]] = call i32 @noalias_args_argmem_rn(ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[B]]) #[[ATTR7:[0-9]+]]
; CGSCC-NEXT: ret i32 [[CALL]] ; CGSCC-NEXT: ret i32 [[CALL]]
; ;
%B = alloca i32, align 4 %B = alloca i32, align 4
store i32 5, ptr %B, align 4 store i32 5, ptr %B, align 4
%call = call i32 @noalias_args_argmem_rn(ptr %B, ptr %B) %call = call i32 @noalias_args_argmem_rn(ptr %B, ptr %B)
ret i32 %call ret i32 %call
} }
attributes #0 = { noinline nounwind uwtable willreturn } attributes #0 = { noinline nounwind uwtable willreturn }
attributes #1 = { argmemonly noinline nounwind uwtable willreturn} attributes #1 = { argmemonly noinline nounwind uwtable willreturn}
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable }
; TUNIT: attributes #[[ATTR1]] = { nofree noinline norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable }
; TUNIT: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR3]] = { nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable } ; TUNIT: attributes #[[ATTR3]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable }
; TUNIT: attributes #[[ATTR4]] = { nofree nosync nounwind } ; TUNIT: attributes #[[ATTR4]] = { nofree nosync nounwind }
; TUNIT: attributes #[[ATTR5]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR5]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree noinline nosync nounwind willreturn memory(argmem: read) uwtable } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree noinline nosync nounwind willreturn memory(argmem: read) uwtable }
; CGSCC: attributes #[[ATTR1]] = { nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable }
; CGSCC: attributes #[[ATTR2]] = { nofree noinline nosync nounwind willreturn memory(argmem: readwrite) uwtable } ; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree noinline nosync nounwind willreturn memory(argmem: readwrite) uwtable }
; CGSCC: attributes #[[ATTR3]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR4]] = { nofree noinline norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable } ; CGSCC: attributes #[[ATTR4]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable }
; CGSCC: attributes #[[ATTR5]] = { memory(read) } ; CGSCC: attributes #[[ATTR5]] = { memory(read) }
; CGSCC: attributes #[[ATTR6]] = { willreturn } ; CGSCC: attributes #[[ATTR6]] = { willreturn }
; CGSCC: attributes #[[ATTR7]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR7]] = { nounwind willreturn }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/internalize.ll

Show First 20 Lines • Show All 129 Lines • ▼ Show 20 Lines
define void @unused_arg_caller() { define void @unused_arg_caller() {
; CHECK_DISABLED: Function Attrs: norecurse ; CHECK_DISABLED: Function Attrs: norecurse
; CHECK_DISABLED-LABEL: define {{[^@]+}}@unused_arg_caller ; CHECK_DISABLED-LABEL: define {{[^@]+}}@unused_arg_caller
; CHECK_DISABLED-SAME: () #[[ATTR0]] { ; CHECK_DISABLED-SAME: () #[[ATTR0]] {
; CHECK_DISABLED-NEXT: call void @unused_arg(i8 noundef 0) ; CHECK_DISABLED-NEXT: call void @unused_arg(i8 noundef 0)
; CHECK_DISABLED-NEXT: ret void ; CHECK_DISABLED-NEXT: ret void
; ;
; CHECK_ENABLED: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK_ENABLED: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK_ENABLED-LABEL: define {{[^@]+}}@unused_arg_caller ; CHECK_ENABLED-LABEL: define {{[^@]+}}@unused_arg_caller
; CHECK_ENABLED-SAME: () #[[ATTR0:[0-9]+]] { ; CHECK_ENABLED-SAME: () #[[ATTR0:[0-9]+]] {
; CHECK_ENABLED-NEXT: unreachable ; CHECK_ENABLED-NEXT: unreachable
; ;
; CGSCC_ENABLED: Function Attrs: nofree norecurse noreturn nosync nounwind readnone willreturn ; CGSCC_ENABLED: Function Attrs: nofree norecurse noreturn nosync nounwind readnone willreturn
; CGSCC_ENABLED-LABEL: define {{[^@]+}}@unused_arg_caller ; CGSCC_ENABLED-LABEL: define {{[^@]+}}@unused_arg_caller
; CGSCC_ENABLED-SAME: () #[[ATTR2:[0-9]+]] { ; CGSCC_ENABLED-SAME: () #[[ATTR2:[0-9]+]] {
; CGSCC_ENABLED-NEXT: unreachable ; CGSCC_ENABLED-NEXT: unreachable
Show All 12 Lines
} }
; CGSCC_ENABLED: attributes #[[ATTR0:[0-9]+]] = { nofree nosync nounwind readnone willreturn } ; CGSCC_ENABLED: attributes #[[ATTR0:[0-9]+]] = { nofree nosync nounwind readnone willreturn }
; CGSCC_ENABLED: attributes #[[ATTR1:[0-9]+]] = { nofree noreturn nosync nounwind readnone willreturn } ; CGSCC_ENABLED: attributes #[[ATTR1:[0-9]+]] = { nofree noreturn nosync nounwind readnone willreturn }
; CGSCC_ENABLED: attributes #[[ATTR2]] = { nofree norecurse noreturn nosync nounwind readnone willreturn } ; CGSCC_ENABLED: attributes #[[ATTR2]] = { nofree norecurse noreturn nosync nounwind readnone willreturn }
;. ;.
; CHECK_DISABLED: attributes #[[ATTR0]] = { norecurse } ; CHECK_DISABLED: attributes #[[ATTR0]] = { norecurse }
;. ;.
; CHECK_ENABLED: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CHECK_ENABLED: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CHECK_ENABLED: attributes #[[ATTR1]] = { norecurse } ; CHECK_ENABLED: attributes #[[ATTR1]] = { norecurse }
; CHECK_ENABLED: attributes #[[ATTR2:[0-9]+]] = { nounwind } ; CHECK_ENABLED: attributes #[[ATTR2:[0-9]+]] = { nounwind }
;. ;.

llvm/test/Transforms/Attributor/liveness.ll

Show All 31 Lines
;. ;.
; CGSCC: @[[DEAD_WITH_BLOCKADDRESS_USERS_L:[a-zA-Z0-9_$"\\.-]+]] = constant [2 x i8*] [i8* blockaddress(@dead_with_blockaddress_users, [[LAB0:%.*]]), i8* blockaddress(@dead_with_blockaddress_users, [[END:%.*]])] ; CGSCC: @[[DEAD_WITH_BLOCKADDRESS_USERS_L:[a-zA-Z0-9_$"\\.-]+]] = constant [2 x i8*] [i8* blockaddress(@dead_with_blockaddress_users, [[LAB0:%.*]]), i8* blockaddress(@dead_with_blockaddress_users, [[END:%.*]])]
; CGSCC: @[[A1:[a-zA-Z0-9_$"\\.-]+]] = common global i8 0, align 8 ; CGSCC: @[[A1:[a-zA-Z0-9_$"\\.-]+]] = common global i8 0, align 8
; CGSCC: @[[A2:[a-zA-Z0-9_$"\\.-]+]] = common global i8 0, align 16 ; CGSCC: @[[A2:[a-zA-Z0-9_$"\\.-]+]] = common global i8 0, align 16
; CGSCC: @[[E:[a-zA-Z0-9_$"\\.-]+]] = global %struct.a* null ; CGSCC: @[[E:[a-zA-Z0-9_$"\\.-]+]] = global %struct.a* null
; CGSCC: @[[P:[a-zA-Z0-9_$"\\.-]+]] = global i8 0 ; CGSCC: @[[P:[a-zA-Z0-9_$"\\.-]+]] = global i8 0
;. ;.
define internal i32 @dead_internal_func(i32 %0) { define internal i32 @dead_internal_func(i32 %0) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@dead_internal_func ; CGSCC-LABEL: define {{[^@]+}}@dead_internal_func
; CGSCC-SAME: () #[[ATTR6:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR6:[0-9]+]] {
; CGSCC-NEXT: br label [[TMP2:%.*]] ; CGSCC-NEXT: br label [[TMP2:%.*]]
; CGSCC: 1: ; CGSCC: 1:
; CGSCC-NEXT: ret i32 undef ; CGSCC-NEXT: ret i32 undef
; CGSCC: 2: ; CGSCC: 2:
; CGSCC-NEXT: [[TMP3:%.*]] = phi i32 [ [[TMP6:%.*]], [[TMP2]] ], [ 1, [[TMP0:%.*]] ] ; CGSCC-NEXT: [[TMP3:%.*]] = phi i32 [ [[TMP6:%.*]], [[TMP2]] ], [ 1, [[TMP0:%.*]] ]
; CGSCC-NEXT: [[TMP4:%.*]] = phi i32 [ [[TMP5:%.*]], [[TMP2]] ], [ 1, [[TMP0]] ] ; CGSCC-NEXT: [[TMP4:%.*]] = phi i32 [ [[TMP5:%.*]], [[TMP2]] ], [ 1, [[TMP0]] ]
Show All 14 Lines; <label>:5: ; preds = %1, %5
%7 = phi i32 [ %8, %5 ], [ 1, %1 ] %7 = phi i32 [ %8, %5 ], [ 1, %1 ]
%8 = mul nsw i32 %6, %7 %8 = mul nsw i32 %6, %7
%9 = add nuw nsw i32 %6, 1 %9 = add nuw nsw i32 %6, 1
%10 = icmp eq i32 %6, %0 %10 = icmp eq i32 %6, %0
br i1 %10, label %3, label %5 br i1 %10, label %3, label %5
} }
define i32 @volatile_load(i32*) norecurse nounwind uwtable { define i32 @volatile_load(i32*) norecurse nounwind uwtable {
; TUNIT: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable ; TUNIT: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable
; TUNIT-LABEL: define {{[^@]+}}@volatile_load ; TUNIT-LABEL: define {{[^@]+}}@volatile_load
; TUNIT-SAME: (i32* nofree noundef align 4 [[TMP0:%.*]]) #[[ATTR6:[0-9]+]] { ; TUNIT-SAME: (i32* nofree noundef align 4 [[TMP0:%.*]]) #[[ATTR6:[0-9]+]] {
; TUNIT-NEXT: [[TMP2:%.*]] = load volatile i32, i32* [[TMP0]], align 4 ; TUNIT-NEXT: [[TMP2:%.*]] = load volatile i32, i32* [[TMP0]], align 4
; TUNIT-NEXT: ret i32 [[TMP2]] ; TUNIT-NEXT: ret i32 [[TMP2]]
; ;
; CGSCC: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable ; CGSCC: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable
; CGSCC-LABEL: define {{[^@]+}}@volatile_load ; CGSCC-LABEL: define {{[^@]+}}@volatile_load
; CGSCC-SAME: (i32* nofree noundef align 4 [[TMP0:%.*]]) #[[ATTR7:[0-9]+]] { ; CGSCC-SAME: (i32* nofree noundef align 4 [[TMP0:%.*]]) #[[ATTR7:[0-9]+]] {
; CGSCC-NEXT: [[TMP2:%.*]] = load volatile i32, i32* [[TMP0]], align 4 ; CGSCC-NEXT: [[TMP2:%.*]] = load volatile i32, i32* [[TMP0]], align 4
; CGSCC-NEXT: ret i32 [[TMP2]] ; CGSCC-NEXT: ret i32 [[TMP2]]
; ;
%2 = load volatile i32, i32* %0, align 4 %2 = load volatile i32, i32* %0, align 4
ret i32 %2 ret i32 %2
} }
define internal i32 @internal_load(i32*) norecurse nounwind uwtable { define internal i32 @internal_load(i32*) norecurse nounwind uwtable {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@internal_load ; CGSCC-LABEL: define {{[^@]+}}@internal_load
; CGSCC-SAME: () #[[ATTR8:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR8:[0-9]+]] {
; CGSCC-NEXT: ret i32 undef ; CGSCC-NEXT: ret i32 undef
; ;
%2 = load i32, i32* %0, align 4 %2 = load i32, i32* %0, align 4
ret i32 %2 ret i32 %2
} }
; TEST 1: Only first block is live. ; TEST 1: Only first block is live.
▲ Show 20 Lines • Show All 396 Lines • ▼ Show 20 Linescleanup:
%res = landingpad { i8*, i32 } catch i8* null %res = landingpad { i8*, i32 } catch i8* null
ret i32 0 ret i32 0
} }
; TEST 6: Undefined behvior, taken from LangRef. ; TEST 6: Undefined behvior, taken from LangRef.
; FIXME: Should be able to detect undefined behavior. ; FIXME: Should be able to detect undefined behavior.
define void @ub(i32* %0) { define void @ub(i32* %0) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@ub ; TUNIT-LABEL: define {{[^@]+}}@ub
; TUNIT-SAME: (i32* nocapture nofree writeonly [[TMP0:%.*]]) #[[ATTR7:[0-9]+]] { ; TUNIT-SAME: (i32* nocapture nofree writeonly [[TMP0:%.*]]) #[[ATTR7:[0-9]+]] {
; TUNIT-NEXT: [[POISON:%.*]] = sub nuw i32 0, 1 ; TUNIT-NEXT: [[POISON:%.*]] = sub nuw i32 0, 1
; TUNIT-NEXT: [[STILL_POISON:%.*]] = and i32 [[POISON]], 0 ; TUNIT-NEXT: [[STILL_POISON:%.*]] = and i32 [[POISON]], 0
; TUNIT-NEXT: [[POISON_YET_AGAIN:%.*]] = getelementptr i32, i32* [[TMP0]], i32 [[STILL_POISON]] ; TUNIT-NEXT: [[POISON_YET_AGAIN:%.*]] = getelementptr i32, i32* [[TMP0]], i32 [[STILL_POISON]]
; TUNIT-NEXT: store i32 0, i32* [[POISON_YET_AGAIN]], align 4 ; TUNIT-NEXT: store i32 0, i32* [[POISON_YET_AGAIN]], align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@ub ; CGSCC-LABEL: define {{[^@]+}}@ub
; CGSCC-SAME: (i32* nocapture nofree writeonly [[TMP0:%.*]]) #[[ATTR9:[0-9]+]] { ; CGSCC-SAME: (i32* nocapture nofree writeonly [[TMP0:%.*]]) #[[ATTR9:[0-9]+]] {
; CGSCC-NEXT: [[POISON:%.*]] = sub nuw i32 0, 1 ; CGSCC-NEXT: [[POISON:%.*]] = sub nuw i32 0, 1
; CGSCC-NEXT: [[STILL_POISON:%.*]] = and i32 [[POISON]], 0 ; CGSCC-NEXT: [[STILL_POISON:%.*]] = and i32 [[POISON]], 0
; CGSCC-NEXT: [[POISON_YET_AGAIN:%.*]] = getelementptr i32, i32* [[TMP0]], i32 [[STILL_POISON]] ; CGSCC-NEXT: [[POISON_YET_AGAIN:%.*]] = getelementptr i32, i32* [[TMP0]], i32 [[STILL_POISON]]
; CGSCC-NEXT: store i32 0, i32* [[POISON_YET_AGAIN]], align 4 ; CGSCC-NEXT: store i32 0, i32* [[POISON_YET_AGAIN]], align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Linescond.else: ; preds = %cond.elseif
br label %cond.end br label %cond.end
cond.end: ; preds = %cond.if, %cond.else, %cond.elseif cond.end: ; preds = %cond.if, %cond.else, %cond.elseif
%7 = phi i32 [ %1, %cond.elseif ], [ 0, %cond.else ], [ 0, %cond.if ] %7 = phi i32 [ %1, %cond.elseif ], [ 0, %cond.else ], [ 0, %cond.if ]
ret i32 %7 ret i32 %7
} }
define void @rec() #0 { define void @rec() #0 {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@rec ; TUNIT-LABEL: define {{[^@]+}}@rec
; TUNIT-SAME: () #[[ATTR9:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR9:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@rec ; CGSCC-LABEL: define {{[^@]+}}@rec
; CGSCC-SAME: () #[[ATTR11:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR11:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
entry: entry:
call void @rec() call void @rec()
ret void ret void
▲ Show 20 Lines • Show All 184 Lines • ▼ Show 20 Lines; <label>:5: ; preds = %1, %3
ret i8* %6 ret i8* %6
} }
declare void @sink() nofree nosync nounwind willreturn declare void @sink() nofree nosync nounwind willreturn
define void @test_unreachable() { define void @test_unreachable() {
; TUNIT: Function Attrs: nofree noreturn nosync nounwind ; TUNIT: Function Attrs: nofree noreturn nosync nounwind
; TUNIT-LABEL: define {{[^@]+}}@test_unreachable ; TUNIT-LABEL: define {{[^@]+}}@test_unreachable
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13:[0-9]+]] ; TUNIT-NEXT: call void @sink() #[[ATTR14:[0-9]+]]
; TUNIT-NEXT: call void @test_unreachable() #[[ATTR0]] ; TUNIT-NEXT: call void @test_unreachable() #[[ATTR0]]
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree noreturn nosync nounwind ; CGSCC: Function Attrs: nofree noreturn nosync nounwind
; CGSCC-LABEL: define {{[^@]+}}@test_unreachable ; CGSCC-LABEL: define {{[^@]+}}@test_unreachable
; CGSCC-SAME: () #[[ATTR0]] { ; CGSCC-SAME: () #[[ATTR0]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15:[0-9]+]] ; CGSCC-NEXT: call void @sink() #[[ATTR16:[0-9]+]]
; CGSCC-NEXT: call void @test_unreachable() #[[ATTR0]] ; CGSCC-NEXT: call void @test_unreachable() #[[ATTR0]]
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
call void @sink() call void @sink()
call void @test_unreachable() call void @test_unreachable()
unreachable unreachable
} }
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines
; TUNIT-NEXT: call void @non_dead_b15() #[[ATTR10]] ; TUNIT-NEXT: call void @non_dead_b15() #[[ATTR10]]
; TUNIT-NEXT: br label [[BB4:%.*]] ; TUNIT-NEXT: br label [[BB4:%.*]]
; TUNIT: bb4: ; TUNIT: bb4:
; TUNIT-NEXT: call void @non_exact2() ; TUNIT-NEXT: call void @non_exact2()
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC-LABEL: define {{[^@]+}}@middle() { ; CGSCC-LABEL: define {{[^@]+}}@middle() {
; CGSCC-NEXT: bb0: ; CGSCC-NEXT: bb0:
; CGSCC-NEXT: call void @non_dead_b0() #[[ATTR15]] ; CGSCC-NEXT: call void @non_dead_b0() #[[ATTR16]]
; CGSCC-NEXT: call void @non_dead_b1() #[[ATTR15]] ; CGSCC-NEXT: call void @non_dead_b1() #[[ATTR16]]
; CGSCC-NEXT: call void @non_dead_b2() #[[ATTR15]] ; CGSCC-NEXT: call void @non_dead_b2() #[[ATTR16]]
; CGSCC-NEXT: call void @non_dead_b3() #[[ATTR15]] ; CGSCC-NEXT: call void @non_dead_b3() #[[ATTR16]]
; CGSCC-NEXT: br label [[BB1:%.*]] ; CGSCC-NEXT: br label [[BB1:%.*]]
; CGSCC: bb1: ; CGSCC: bb1:
; CGSCC-NEXT: call void @non_dead_b4() #[[ATTR15]] ; CGSCC-NEXT: call void @non_dead_b4() #[[ATTR16]]
; CGSCC-NEXT: call void @non_dead_b5() #[[ATTR15]] ; CGSCC-NEXT: call void @non_dead_b5() #[[ATTR16]]
; CGSCC-NEXT: call void @non_dead_b6() #[[ATTR15]] ; CGSCC-NEXT: call void @non_dead_b6() #[[ATTR16]]
; CGSCC-NEXT: call void @non_dead_b7() #[[ATTR15]] ; CGSCC-NEXT: call void @non_dead_b7() #[[ATTR16]]
; CGSCC-NEXT: br label [[BB2:%.*]] ; CGSCC-NEXT: br label [[BB2:%.*]]
; CGSCC: bb2: ; CGSCC: bb2:
; CGSCC-NEXT: call void @non_dead_b8() #[[ATTR15]] ; CGSCC-NEXT: call void @non_dead_b8() #[[ATTR16]]
; CGSCC-NEXT: call void @non_dead_b9() #[[ATTR15]] ; CGSCC-NEXT: call void @non_dead_b9() #[[ATTR16]]
; CGSCC-NEXT: call void @non_dead_b10() #[[ATTR15]] ; CGSCC-NEXT: call void @non_dead_b10() #[[ATTR16]]
; CGSCC-NEXT: call void @non_dead_b11() #[[ATTR15]] ; CGSCC-NEXT: call void @non_dead_b11() #[[ATTR16]]
; CGSCC-NEXT: br label [[BB3:%.*]] ; CGSCC-NEXT: br label [[BB3:%.*]]
; CGSCC: bb3: ; CGSCC: bb3:
; CGSCC-NEXT: call void @non_dead_b12() #[[ATTR15]] ; CGSCC-NEXT: call void @non_dead_b12() #[[ATTR16]]
; CGSCC-NEXT: call void @non_dead_b13() #[[ATTR15]] ; CGSCC-NEXT: call void @non_dead_b13() #[[ATTR16]]
; CGSCC-NEXT: call void @non_dead_b14() #[[ATTR15]] ; CGSCC-NEXT: call void @non_dead_b14() #[[ATTR16]]
; CGSCC-NEXT: call void @non_dead_b15() #[[ATTR15]] ; CGSCC-NEXT: call void @non_dead_b15() #[[ATTR16]]
; CGSCC-NEXT: br label [[BB4:%.*]] ; CGSCC-NEXT: br label [[BB4:%.*]]
; CGSCC: bb4: ; CGSCC: bb4:
; CGSCC-NEXT: call void @non_exact2() ; CGSCC-NEXT: call void @non_exact2()
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
bb0: bb0:
call void @non_dead_b0() call void @non_dead_b0()
call void @non_dead_b1() call void @non_dead_b1()
▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Lines;
call void @non_dead_d14() call void @non_dead_d14()
call void @non_dead_d15() call void @non_dead_d15()
%nr = call i32 @foo_noreturn() %nr = call i32 @foo_noreturn()
call void @dead_e1() call void @dead_e1()
ret void ret void
} }
define internal void @non_dead_a0() { define internal void @non_dead_a0() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_a0 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_a0
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11:[0-9]+]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_a0 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_a0
; CGSCC-SAME: () #[[ATTR12:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR13:[0-9]+]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_a1() { define internal void @non_dead_a1() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_a1 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_a1
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_a1 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_a1
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_a2() { define internal void @non_dead_a2() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_a2 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_a2
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_a2 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_a2
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_a3() { define internal void @non_dead_a3() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_a3 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_a3
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_a3 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_a3
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_a4() { define internal void @non_dead_a4() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_a4 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_a4
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_a4 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_a4
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_a5() { define internal void @non_dead_a5() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_a5 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_a5
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_a5 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_a5
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_a6() { define internal void @non_dead_a6() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_a6 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_a6
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_a6 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_a6
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_a7() { define internal void @non_dead_a7() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_a7 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_a7
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_a7 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_a7
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_a8() { define internal void @non_dead_a8() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_a8 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_a8
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_a8 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_a8
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_a9() { define internal void @non_dead_a9() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_a9 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_a9
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_a9 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_a9
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_a10() { define internal void @non_dead_a10() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_a10 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_a10
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_a10 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_a10
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_a11() { define internal void @non_dead_a11() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_a11 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_a11
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_a11 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_a11
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_a12() { define internal void @non_dead_a12() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_a12 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_a12
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_a12 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_a12
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_a13() { define internal void @non_dead_a13() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_a13 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_a13
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_a13 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_a13
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_a14() { define internal void @non_dead_a14() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_a14 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_a14
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_a14 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_a14
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_a15() { define internal void @non_dead_a15() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_a15 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_a15
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_a15 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_a15
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_b0() { define internal void @non_dead_b0() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_b0 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_b0
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_b0 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_b0
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_b1() { define internal void @non_dead_b1() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_b1 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_b1
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_b1 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_b1
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_b2() { define internal void @non_dead_b2() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_b2 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_b2
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_b2 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_b2
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_b3() { define internal void @non_dead_b3() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_b3 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_b3
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_b3 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_b3
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_b4() { define internal void @non_dead_b4() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_b4 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_b4
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_b4 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_b4
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_b5() { define internal void @non_dead_b5() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_b5 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_b5
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_b5 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_b5
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_b6() { define internal void @non_dead_b6() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_b6 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_b6
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_b6 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_b6
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_b7() { define internal void @non_dead_b7() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_b7 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_b7
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_b7 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_b7
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_b8() { define internal void @non_dead_b8() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_b8 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_b8
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_b8 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_b8
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_b9() { define internal void @non_dead_b9() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_b9 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_b9
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_b9 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_b9
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_b10() { define internal void @non_dead_b10() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_b10 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_b10
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_b10 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_b10
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_b11() { define internal void @non_dead_b11() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_b11 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_b11
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_b11 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_b11
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_b12() { define internal void @non_dead_b12() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_b12 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_b12
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_b12 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_b12
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_b13() { define internal void @non_dead_b13() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_b13 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_b13
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_b13 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_b13
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_b14() { define internal void @non_dead_b14() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_b14 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_b14
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_b14 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_b14
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_b15() { define internal void @non_dead_b15() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_b15 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_b15
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_b15 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_b15
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_c0() { define internal void @non_dead_c0() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_c0 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_c0
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_c0 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_c0
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_c1() { define internal void @non_dead_c1() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_c1 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_c1
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_c1 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_c1
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_c2() { define internal void @non_dead_c2() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_c2 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_c2
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_c2 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_c2
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_c3() { define internal void @non_dead_c3() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_c3 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_c3
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_c3 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_c3
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_c4() { define internal void @non_dead_c4() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_c4 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_c4
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_c4 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_c4
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_c5() { define internal void @non_dead_c5() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_c5 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_c5
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_c5 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_c5
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_c6() { define internal void @non_dead_c6() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_c6 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_c6
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_c6 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_c6
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_c7() { define internal void @non_dead_c7() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_c7 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_c7
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_c7 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_c7
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_c8() { define internal void @non_dead_c8() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_c8 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_c8
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_c8 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_c8
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_c9() { define internal void @non_dead_c9() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_c9 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_c9
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_c9 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_c9
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_c10() { define internal void @non_dead_c10() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_c10 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_c10
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_c10 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_c10
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_c11() { define internal void @non_dead_c11() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_c11 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_c11
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_c11 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_c11
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_c12() { define internal void @non_dead_c12() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_c12 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_c12
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_c12 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_c12
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_c13() { define internal void @non_dead_c13() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_c13 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_c13
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_c13 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_c13
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_c14() { define internal void @non_dead_c14() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_c14 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_c14
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_c14 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_c14
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_c15() { define internal void @non_dead_c15() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_c15 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_c15
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_c15 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_c15
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_d0() { define internal void @non_dead_d0() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_d0 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_d0
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_d0 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_d0
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_d1() { define internal void @non_dead_d1() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_d1 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_d1
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_d1 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_d1
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_d2() { define internal void @non_dead_d2() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_d2 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_d2
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_d2 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_d2
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_d3() { define internal void @non_dead_d3() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_d3 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_d3
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_d3 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_d3
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_d4() { define internal void @non_dead_d4() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_d4 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_d4
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_d4 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_d4
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_d5() { define internal void @non_dead_d5() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_d5 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_d5
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_d5 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_d5
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_d6() { define internal void @non_dead_d6() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_d6 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_d6
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_d6 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_d6
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_d7() { define internal void @non_dead_d7() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_d7 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_d7
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_d7 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_d7
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_d8() { define internal void @non_dead_d8() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_d8 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_d8
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_d8 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_d8
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_d9() { define internal void @non_dead_d9() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_d9 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_d9
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_d9 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_d9
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_d10() { define internal void @non_dead_d10() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_d10 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_d10
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_d10 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_d10
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_d11() { define internal void @non_dead_d11() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_d11 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_d11
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_d11 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_d11
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_d12() { define internal void @non_dead_d12() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_d12 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_d12
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_d12 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_d12
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_d13() { define internal void @non_dead_d13() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_d13 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_d13
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_d13 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_d13
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_d14() { define internal void @non_dead_d14() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_d14 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_d14
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_d14 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_d14
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @non_dead_d15() { define internal void @non_dead_d15() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@non_dead_d15 ; TUNIT-LABEL: define {{[^@]+}}@non_dead_d15
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@non_dead_d15 ; CGSCC-LABEL: define {{[^@]+}}@non_dead_d15
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @dead_e0() { call void @dead_e1() ret void } define internal void @dead_e0() { call void @dead_e1() ret void }
; CGSCC-LABEL: define {{[^@]+}}@dead_e0() { ; CGSCC-LABEL: define {{[^@]+}}@dead_e0() {
; CGSCC-NEXT: call void @dead_e1() ; CGSCC-NEXT: call void @dead_e1()
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
lp2: lp2:
%0 = landingpad { i8*, i32 } catch i8* null %0 = landingpad { i8*, i32 } catch i8* null
br label %live_with_dead_entry br label %live_with_dead_entry
live_with_dead_entry: live_with_dead_entry:
ret void ret void
} }
define internal void @useless_arg_sink(i32* %a) { define internal void @useless_arg_sink(i32* %a) {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@useless_arg_sink ; TUNIT-LABEL: define {{[^@]+}}@useless_arg_sink
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@useless_arg_sink ; CGSCC-LABEL: define {{[^@]+}}@useless_arg_sink
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @sink() call void @sink()
ret void ret void
} }
define internal void @useless_arg_almost_sink(i32* %a) { define internal void @useless_arg_almost_sink(i32* %a) {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@useless_arg_almost_sink ; TUNIT-LABEL: define {{[^@]+}}@useless_arg_almost_sink
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: call void @useless_arg_sink() #[[ATTR10]] ; TUNIT-NEXT: call void @useless_arg_sink() #[[ATTR10]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@useless_arg_almost_sink ; CGSCC-LABEL: define {{[^@]+}}@useless_arg_almost_sink
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: call void @useless_arg_sink() #[[ATTR15]] ; CGSCC-NEXT: call void @useless_arg_sink() #[[ATTR16]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @useless_arg_sink(i32* %a) call void @useless_arg_sink(i32* %a)
ret void ret void
} }
; Check we do not annotate the function interface of this weak function. ; Check we do not annotate the function interface of this weak function.
define weak_odr void @useless_arg_ext(i32* %a) { define weak_odr void @useless_arg_ext(i32* %a) {
Show All 24 Lines
; ;
call void @useless_arg_ext_int(i32* %a) call void @useless_arg_ext_int(i32* %a)
ret void ret void
} }
; FIXME: We should fold terminators. ; FIXME: We should fold terminators.
define internal i32 @switch_default(i64 %i) nounwind { define internal i32 @switch_default(i64 %i) nounwind {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@switch_default ; TUNIT-LABEL: define {{[^@]+}}@switch_default
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: switch i64 0, label [[SW_DEFAULT:%.*]] [ ; TUNIT-NEXT: switch i64 0, label [[SW_DEFAULT:%.*]] [
; TUNIT-NEXT: i64 3, label [[RETURN:%.*]] ; TUNIT-NEXT: i64 3, label [[RETURN:%.*]]
; TUNIT-NEXT: i64 10, label [[RETURN]] ; TUNIT-NEXT: i64 10, label [[RETURN]]
; TUNIT-NEXT: ] ; TUNIT-NEXT: ]
; TUNIT: sw.default: ; TUNIT: sw.default:
; TUNIT-NEXT: call void @sink() #[[ATTR13]] ; TUNIT-NEXT: call void @sink() #[[ATTR14]]
; TUNIT-NEXT: ret i32 undef ; TUNIT-NEXT: ret i32 undef
; TUNIT: return: ; TUNIT: return:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@switch_default ; CGSCC-LABEL: define {{[^@]+}}@switch_default
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: switch i64 0, label [[SW_DEFAULT:%.*]] [ ; CGSCC-NEXT: switch i64 0, label [[SW_DEFAULT:%.*]] [
; CGSCC-NEXT: i64 3, label [[RETURN:%.*]] ; CGSCC-NEXT: i64 3, label [[RETURN:%.*]]
; CGSCC-NEXT: i64 10, label [[RETURN]] ; CGSCC-NEXT: i64 10, label [[RETURN]]
; CGSCC-NEXT: ] ; CGSCC-NEXT: ]
; CGSCC: sw.default: ; CGSCC: sw.default:
; CGSCC-NEXT: call void @sink() #[[ATTR15]] ; CGSCC-NEXT: call void @sink() #[[ATTR16]]
; CGSCC-NEXT: ret i32 123 ; CGSCC-NEXT: ret i32 123
; CGSCC: return: ; CGSCC: return:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
entry: entry:
switch i64 %i, label %sw.default [ switch i64 %i, label %sw.default [
i64 3, label %return i64 3, label %return
i64 10, label %return i64 10, label %return
] ]
sw.default: sw.default:
call void @sink() call void @sink()
ret i32 123 ret i32 123
return: return:
ret i32 0 ret i32 0
} }
define i32 @switch_default_caller() { define i32 @switch_default_caller() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@switch_default_caller ; TUNIT-LABEL: define {{[^@]+}}@switch_default_caller
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR11]] {
; TUNIT-NEXT: [[CALL2:%.*]] = tail call i32 @switch_default() #[[ATTR10]] ; TUNIT-NEXT: [[CALL2:%.*]] = tail call i32 @switch_default() #[[ATTR10]]
; TUNIT-NEXT: ret i32 123 ; TUNIT-NEXT: ret i32 123
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@switch_default_caller ; CGSCC-LABEL: define {{[^@]+}}@switch_default_caller
; CGSCC-SAME: () #[[ATTR12]] { ; CGSCC-SAME: () #[[ATTR13]] {
; CGSCC-NEXT: [[CALL2:%.*]] = tail call noundef i32 @switch_default() #[[ATTR15]] ; CGSCC-NEXT: [[CALL2:%.*]] = tail call noundef i32 @switch_default() #[[ATTR16]]
; CGSCC-NEXT: ret i32 [[CALL2]] ; CGSCC-NEXT: ret i32 [[CALL2]]
; ;
%call2 = tail call i32 @switch_default(i64 0) %call2 = tail call i32 @switch_default(i64 0)
ret i32 %call2 ret i32 %call2
} }
define internal i32 @switch_default_dead(i64 %i) nounwind { define internal i32 @switch_default_dead(i64 %i) nounwind {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@switch_default_dead ; CGSCC-LABEL: define {{[^@]+}}@switch_default_dead
; CGSCC-SAME: () #[[ATTR6]] { ; CGSCC-SAME: () #[[ATTR6]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: switch i64 0, label [[SW_DEFAULT:%.*]] [ ; CGSCC-NEXT: switch i64 0, label [[SW_DEFAULT:%.*]] [
; CGSCC-NEXT: i64 3, label [[RETURN:%.*]] ; CGSCC-NEXT: i64 3, label [[RETURN:%.*]]
; CGSCC-NEXT: i64 10, label [[RETURN]] ; CGSCC-NEXT: i64 10, label [[RETURN]]
; CGSCC-NEXT: ] ; CGSCC-NEXT: ]
; CGSCC: sw.default: ; CGSCC: sw.default:
Show All 10 Lines
sw.default: sw.default:
ret i32 123 ret i32 123
return: return:
ret i32 0 ret i32 0
} }
define i32 @switch_default_dead_caller() { define i32 @switch_default_dead_caller() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@switch_default_dead_caller ; TUNIT-LABEL: define {{[^@]+}}@switch_default_dead_caller
; TUNIT-SAME: () #[[ATTR11:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR12:[0-9]+]] {
; TUNIT-NEXT: ret i32 123 ; TUNIT-NEXT: ret i32 123
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@switch_default_dead_caller ; CGSCC-LABEL: define {{[^@]+}}@switch_default_dead_caller
; CGSCC-SAME: () #[[ATTR11]] { ; CGSCC-SAME: () #[[ATTR11]] {
; CGSCC-NEXT: [[CALL2:%.*]] = tail call noundef i32 @switch_default_dead() #[[ATTR16:[0-9]+]] ; CGSCC-NEXT: [[CALL2:%.*]] = tail call noundef i32 @switch_default_dead() #[[ATTR17:[0-9]+]]
; CGSCC-NEXT: ret i32 [[CALL2]] ; CGSCC-NEXT: ret i32 [[CALL2]]
; ;
%call2 = tail call i32 @switch_default_dead(i64 0) %call2 = tail call i32 @switch_default_dead(i64 0)
ret i32 %call2 ret i32 %call2
} }
define void @call_via_pointer_with_dead_args(i32* %a, i32* %b, void (i32*, i32*, i32*, i64, i32**)* %fp) { define void @call_via_pointer_with_dead_args(i32* %a, i32* %b, void (i32*, i32*, i32*, i64, i32**)* %fp) {
; CHECK-LABEL: define {{[^@]+}}@call_via_pointer_with_dead_args ; CHECK-LABEL: define {{[^@]+}}@call_via_pointer_with_dead_args
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Linesentry:
ret void ret void
} }
declare void @use_i32p(i32*) declare void @use_i32p(i32*)
; Allow blockaddress users ; Allow blockaddress users
define internal void @dead_with_blockaddress_users(i32* nocapture %pc) nounwind readonly { define internal void @dead_with_blockaddress_users(i32* nocapture %pc) nounwind readonly {
; CGSCC: Function Attrs: nounwind memory(read) ; CGSCC: Function Attrs: nounwind memory(read)
; CGSCC-LABEL: define {{[^@]+}}@dead_with_blockaddress_users ; CGSCC-LABEL: define {{[^@]+}}@dead_with_blockaddress_users
; CGSCC-SAME: (i32* nocapture [[PC:%.*]]) #[[ATTR13:[0-9]+]] { ; CGSCC-SAME: (i32* nocapture [[PC:%.*]]) #[[ATTR14:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: br label [[INDIRECTGOTO:%.*]] ; CGSCC-NEXT: br label [[INDIRECTGOTO:%.*]]
; CGSCC: lab0: ; CGSCC: lab0:
; CGSCC-NEXT: [[INDVAR_NEXT:%.*]] = add i32 [[INDVAR:%.*]], 1 ; CGSCC-NEXT: [[INDVAR_NEXT:%.*]] = add i32 [[INDVAR:%.*]], 1
; CGSCC-NEXT: br label [[INDIRECTGOTO]] ; CGSCC-NEXT: br label [[INDIRECTGOTO]]
; CGSCC: end: ; CGSCC: end:
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; CGSCC: indirectgoto: ; CGSCC: indirectgoto:
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
for.end.1: for.end.1:
ret i32 0 ret i32 0
} }
declare noalias i8* @malloc(i64) declare noalias i8* @malloc(i64)
define i32 @h(i32 %i) { define i32 @h(i32 %i) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@h ; TUNIT-LABEL: define {{[^@]+}}@h
; TUNIT-SAME: (i32 [[I:%.*]]) #[[ATTR11]] { ; TUNIT-SAME: (i32 [[I:%.*]]) #[[ATTR12]] {
; TUNIT-NEXT: ret i32 0 ; TUNIT-NEXT: ret i32 0
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@h ; CGSCC-LABEL: define {{[^@]+}}@h
; CGSCC-SAME: (i32 [[I:%.*]]) #[[ATTR6]] { ; CGSCC-SAME: (i32 [[I:%.*]]) #[[ATTR6]] {
; CGSCC-NEXT: ret i32 0 ; CGSCC-NEXT: ret i32 0
; ;
ret i32 0 ret i32 0
} }
; Verify we do not choke on the GEP in the unreachable block. ; Verify we do not choke on the GEP in the unreachable block.
@p = global i8 0 @p = global i8 0
define void @bad_gep() { define void @bad_gep() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@bad_gep ; TUNIT-LABEL: define {{[^@]+}}@bad_gep
; TUNIT-SAME: () #[[ATTR11]] { ; TUNIT-SAME: () #[[ATTR12]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[N:%.*]] = alloca i8, align 1 ; TUNIT-NEXT: [[N:%.*]] = alloca i8, align 1
; TUNIT-NEXT: [[M:%.*]] = alloca i8, align 1 ; TUNIT-NEXT: [[M:%.*]] = alloca i8, align 1
; TUNIT-NEXT: call void @llvm.lifetime.start.p0i8(i64 noundef 1, i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[N]]) #[[ATTR14:[0-9]+]] ; TUNIT-NEXT: call void @llvm.lifetime.start.p0i8(i64 noundef 1, i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[N]]) #[[ATTR15:[0-9]+]]
; TUNIT-NEXT: br label [[EXIT:%.*]] ; TUNIT-NEXT: br label [[EXIT:%.*]]
; TUNIT: while.body: ; TUNIT: while.body:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: if.then: ; TUNIT: if.then:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: if.end: ; TUNIT: if.end:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: exit: ; TUNIT: exit:
; TUNIT-NEXT: call void @llvm.lifetime.end.p0i8(i64 noundef 1, i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[N]]) #[[ATTR14]] ; TUNIT-NEXT: call void @llvm.lifetime.end.p0i8(i64 noundef 1, i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[N]]) #[[ATTR15]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@bad_gep ; CGSCC-LABEL: define {{[^@]+}}@bad_gep
; CGSCC-SAME: () #[[ATTR6]] { ; CGSCC-SAME: () #[[ATTR6]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[N:%.*]] = alloca i8, align 1 ; CGSCC-NEXT: [[N:%.*]] = alloca i8, align 1
; CGSCC-NEXT: [[M:%.*]] = alloca i8, align 1 ; CGSCC-NEXT: [[M:%.*]] = alloca i8, align 1
; CGSCC-NEXT: call void @llvm.lifetime.start.p0i8(i64 noundef 1, i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[N]]) #[[ATTR16]] ; CGSCC-NEXT: call void @llvm.lifetime.start.p0i8(i64 noundef 1, i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[N]]) #[[ATTR17]]
; CGSCC-NEXT: br label [[EXIT:%.*]] ; CGSCC-NEXT: br label [[EXIT:%.*]]
; CGSCC: while.body: ; CGSCC: while.body:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: if.then: ; CGSCC: if.then:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: if.end: ; CGSCC: if.end:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: exit: ; CGSCC: exit:
; CGSCC-NEXT: call void @llvm.lifetime.end.p0i8(i64 noundef 1, i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[N]]) #[[ATTR16]] ; CGSCC-NEXT: call void @llvm.lifetime.end.p0i8(i64 noundef 1, i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[N]]) #[[ATTR17]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
entry: entry:
%n = alloca i8 %n = alloca i8
%m = alloca i8 %m = alloca i8
call void @llvm.lifetime.start.p0i8(i64 1, i8* %n) call void @llvm.lifetime.start.p0i8(i64 1, i8* %n)
br label %exit br label %exit
Show All 12 Linesif.end:
br i1 %cmp, label %exit, label %while.body br i1 %cmp, label %exit, label %while.body
exit: exit:
call void @llvm.lifetime.end.p0i8(i64 1, i8* %n) call void @llvm.lifetime.end.p0i8(i64 1, i8* %n)
ret void ret void
} }
define i8 @edge_vs_block_liveness() { define i8 @edge_vs_block_liveness() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@edge_vs_block_liveness ; TUNIT-LABEL: define {{[^@]+}}@edge_vs_block_liveness
; TUNIT-SAME: () #[[ATTR11]] { ; TUNIT-SAME: () #[[ATTR12]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: br i1 true, label [[B1:%.*]], label [[B2:%.*]] ; TUNIT-NEXT: br i1 true, label [[B1:%.*]], label [[B2:%.*]]
; TUNIT: b1: ; TUNIT: b1:
; TUNIT-NEXT: br label [[B2]] ; TUNIT-NEXT: br label [[B2]]
; TUNIT: b2: ; TUNIT: b2:
; TUNIT-NEXT: [[PHI:%.*]] = phi i8 [ 0, [[ENTRY:%.*]] ], [ 1, [[B1]] ] ; TUNIT-NEXT: [[PHI:%.*]] = phi i8 [ 0, [[ENTRY:%.*]] ], [ 1, [[B1]] ]
; TUNIT-NEXT: ret i8 1 ; TUNIT-NEXT: ret i8 1
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@edge_vs_block_liveness ; CGSCC-LABEL: define {{[^@]+}}@edge_vs_block_liveness
; CGSCC-SAME: () #[[ATTR6]] { ; CGSCC-SAME: () #[[ATTR6]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: br i1 true, label [[B1:%.*]], label [[B2:%.*]] ; CGSCC-NEXT: br i1 true, label [[B1:%.*]], label [[B2:%.*]]
; CGSCC: b1: ; CGSCC: b1:
; CGSCC-NEXT: br label [[B2]] ; CGSCC-NEXT: br label [[B2]]
; CGSCC: b2: ; CGSCC: b2:
; CGSCC-NEXT: [[PHI:%.*]] = phi i8 [ 0, [[ENTRY:%.*]] ], [ 1, [[B1]] ] ; CGSCC-NEXT: [[PHI:%.*]] = phi i8 [ 0, [[ENTRY:%.*]] ], [ 1, [[B1]] ]
Show All 15 Lines
declare void @llvm.lifetime.end.p0i8(i64 %0, i8* %1) declare void @llvm.lifetime.end.p0i8(i64 %0, i8* %1)
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree noreturn nosync nounwind } ; TUNIT: attributes #[[ATTR0]] = { nofree noreturn nosync nounwind }
; TUNIT: attributes #[[ATTR1:[0-9]+]] = { memory(none) } ; TUNIT: attributes #[[ATTR1:[0-9]+]] = { memory(none) }
; TUNIT: attributes #[[ATTR2]] = { nounwind } ; TUNIT: attributes #[[ATTR2]] = { nounwind }
; TUNIT: attributes #[[ATTR3]] = { noreturn nounwind } ; TUNIT: attributes #[[ATTR3]] = { noreturn nounwind }
; TUNIT: attributes #[[ATTR4]] = { noreturn } ; TUNIT: attributes #[[ATTR4]] = { noreturn }
; TUNIT: attributes #[[ATTR5]] = { nosync memory(none) } ; TUNIT: attributes #[[ATTR5]] = { nosync memory(none) }
; TUNIT: attributes #[[ATTR6]] = { nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable } ; TUNIT: attributes #[[ATTR6]] = { mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable }
; TUNIT: attributes #[[ATTR7]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR7]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR8]] = { nofree norecurse noreturn nosync nounwind memory(none) } ; TUNIT: attributes #[[ATTR8]] = { nofree norecurse noreturn nosync nounwind memory(none) }
; TUNIT: attributes #[[ATTR9]] = { nofree nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR9]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR10]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR10]] = { nofree nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR11]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR11]] = { mustprogress nofree nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR12:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR12]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR13]] = { nounwind willreturn } ; TUNIT: attributes #[[ATTR13:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR14]] = { willreturn } ; TUNIT: attributes #[[ATTR14]] = { nounwind willreturn }
; TUNIT: attributes #[[ATTR15]] = { willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree noreturn nosync nounwind } ; CGSCC: attributes #[[ATTR0]] = { nofree noreturn nosync nounwind }
; CGSCC: attributes #[[ATTR1:[0-9]+]] = { memory(none) } ; CGSCC: attributes #[[ATTR1:[0-9]+]] = { memory(none) }
; CGSCC: attributes #[[ATTR2]] = { nounwind } ; CGSCC: attributes #[[ATTR2]] = { nounwind }
; CGSCC: attributes #[[ATTR3]] = { noreturn nounwind } ; CGSCC: attributes #[[ATTR3]] = { noreturn nounwind }
; CGSCC: attributes #[[ATTR4]] = { noreturn } ; CGSCC: attributes #[[ATTR4]] = { noreturn }
; CGSCC: attributes #[[ATTR5]] = { nosync memory(none) } ; CGSCC: attributes #[[ATTR5]] = { nosync memory(none) }
; CGSCC: attributes #[[ATTR6]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR6]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR7]] = { nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable } ; CGSCC: attributes #[[ATTR7]] = { mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable }
; CGSCC: attributes #[[ATTR8]] = { nofree norecurse nosync nounwind willreturn memory(none) uwtable } ; CGSCC: attributes #[[ATTR8]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) uwtable }
; CGSCC: attributes #[[ATTR9]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR9]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR10]] = { nofree norecurse noreturn nosync nounwind memory(none) } ; CGSCC: attributes #[[ATTR10]] = { nofree norecurse noreturn nosync nounwind memory(none) }
; CGSCC: attributes #[[ATTR11]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR11]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR12]] = { nofree nosync nounwind willreturn } ; CGSCC: attributes #[[ATTR12:[0-9]+]] = { nofree nosync nounwind willreturn }
; CGSCC: attributes #[[ATTR13]] = { nounwind memory(read) } ; CGSCC: attributes #[[ATTR13]] = { mustprogress nofree nosync nounwind willreturn }
; CGSCC: attributes #[[ATTR14:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR14]] = { nounwind memory(read) }
; CGSCC: attributes #[[ATTR15]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR15:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR16]] = { willreturn } ; CGSCC: attributes #[[ATTR16]] = { nounwind willreturn }
; CGSCC: attributes #[[ATTR17]] = { willreturn }
;. ;.

llvm/test/Transforms/Attributor/liveness_chains.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=1 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=1 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; Make sure we need a single iteration to determine the chains are dead/alive. ; Make sure we need a single iteration to determine the chains are dead/alive.
declare i32 @source() nounwind readonly declare i32 @source() nounwind readonly
define i32 @chain_dead(i32 %arg) { define i32 @chain_dead(i32 %arg) {
; CHECK: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@chain_dead ; CHECK-LABEL: define {{[^@]+}}@chain_dead
; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
%init = call i32 @source() %init = call i32 @source()
%v0 = add i32 %arg, %init %v0 = add i32 %arg, %init
%v1 = add i32 %init, %v0 %v1 = add i32 %init, %v0
%v2 = add i32 %v0, %v1 %v2 = add i32 %v0, %v1
Show All 34 Lines;
%v6 = add i32 %v4, %v5 %v6 = add i32 %v4, %v5
%v7 = add i32 %v5, %v6 %v7 = add i32 %v5, %v6
%v8 = add i32 %v6, %v7 %v8 = add i32 %v6, %v7
%v9 = add i32 %v7, %v8 %v9 = add i32 %v7, %v8
ret i32 %v9 ret i32 %v9
} }
;. ;.
; CHECK: attributes #[[ATTR0]] = { nounwind memory(read) } ; CHECK: attributes #[[ATTR0]] = { nounwind memory(read) }
; CHECK: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CHECK: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CHECK: attributes #[[ATTR2]] = { nounwind } ; CHECK: attributes #[[ATTR2]] = { nounwind }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CGSCC: {{.*}} ; CGSCC: {{.*}}
; TUNIT: {{.*}} ; TUNIT: {{.*}}

llvm/test/Transforms/Attributor/lvi-after-jumpthreading.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=6 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=6 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
define i8 @test1(i32 %a, i32 %length) { define i8 @test1(i32 %a, i32 %length) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test1 ; CHECK-LABEL: define {{[^@]+}}@test1
; CHECK-SAME: (i32 [[A:%.*]], i32 [[LENGTH:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (i32 [[A:%.*]], i32 [[LENGTH:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop: ; CHECK: loop:
; CHECK-NEXT: [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[BACKEDGE:%.*]] ] ; CHECK-NEXT: [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
; CHECK-NEXT: [[CND:%.*]] = icmp sge i32 [[IV]], 0 ; CHECK-NEXT: [[CND:%.*]] = icmp sge i32 [[IV]], 0
; CHECK-NEXT: br i1 [[CND]], label [[BACKEDGE]], label [[EXIT:%.*]] ; CHECK-NEXT: br i1 [[CND]], label [[BACKEDGE]], label [[EXIT:%.*]]
Show All 17 Linesbackedge:
%cont = icmp slt i32 %iv.next, 400 %cont = icmp slt i32 %iv.next, 400
br i1 %cont, label %loop, label %exit br i1 %cont, label %loop, label %exit
exit: exit:
ret i8 0 ret i8 0
} }
define i8 @test2(i32 %n) { define i8 @test2(i32 %n) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test2 ; CHECK-LABEL: define {{[^@]+}}@test2
; CHECK-SAME: (i32 [[N:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32 [[N:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop: ; CHECK: loop:
; CHECK-NEXT: [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[BACKEDGE:%.*]] ] ; CHECK-NEXT: [[IV:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[IV_NEXT:%.*]], [[BACKEDGE:%.*]] ]
; CHECK-NEXT: [[IV2:%.*]] = phi i32 [ [[N]], [[ENTRY]] ], [ [[IV2_NEXT:%.*]], [[BACKEDGE]] ] ; CHECK-NEXT: [[IV2:%.*]] = phi i32 [ [[N]], [[ENTRY]] ], [ [[IV2_NEXT:%.*]], [[BACKEDGE]] ]
; CHECK-NEXT: [[CND1:%.*]] = icmp sge i32 [[IV]], 0 ; CHECK-NEXT: [[CND1:%.*]] = icmp sge i32 [[IV]], 0
▲ Show 20 Lines • Show All 131 Lines • ▼ Show 20 Lines
} }
declare i32 @exit() declare i32 @exit()
declare i32 @consume(i1) declare i32 @consume(i1)
declare void @llvm.assume(i1) nounwind declare void @llvm.assume(i1) nounwind
declare void @dummy(i1) nounwind declare void @dummy(i1) nounwind
declare void @llvm.experimental.guard(i1, ...) declare void @llvm.experimental.guard(i1, ...)
;. ;.
; CHECK: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CHECK: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CHECK: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; CHECK: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
; CHECK: attributes #[[ATTR2]] = { nounwind } ; CHECK: attributes #[[ATTR2]] = { nounwind }
; CHECK: attributes #[[ATTR3:[0-9]+]] = { nocallback nofree nosync willreturn } ; CHECK: attributes #[[ATTR3:[0-9]+]] = { nocallback nofree nosync willreturn }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CGSCC: {{.*}} ; CGSCC: {{.*}}
; TUNIT: {{.*}} ; TUNIT: {{.*}}

llvm/test/Transforms/Attributor/lvi-for-ashr.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; FIXME: DOT should be replaced with 3 ; FIXME: DOT should be replaced with 3
define i32 @test-ashr(i32 %c) { define i32 @test-ashr(i32 %c) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test-ashr ; CHECK-LABEL: define {{[^@]+}}@test-ashr
; CHECK-SAME: (i32 [[C:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (i32 [[C:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: chk65: ; CHECK-NEXT: chk65:
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 [[C]], 65 ; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 [[C]], 65
; CHECK-NEXT: br i1 [[CMP]], label [[RETURN:%.*]], label [[CHK0:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[RETURN:%.*]], label [[CHK0:%.*]]
; CHECK: chk0: ; CHECK: chk0:
; CHECK-NEXT: [[CMP1:%.*]] = icmp slt i32 [[C]], 0 ; CHECK-NEXT: [[CMP1:%.*]] = icmp slt i32 [[C]], 0
; CHECK-NEXT: br i1 [[CMP]], label [[RETURN]], label [[BB_IF:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[RETURN]], label [[BB_IF:%.*]]
Show All 27 Linesbb_then:
%. = select i1 %cmp3, i32 3, i32 2 %. = select i1 %cmp3, i32 3, i32 2
br label %return br label %return
return: return:
%retval = phi i32 [0, %chk65], [1, %chk0], [%., %bb_then], [4, %bb_if] %retval = phi i32 [0, %chk65], [1, %chk0], [%., %bb_then], [4, %bb_if]
ret i32 %retval ret i32 %retval
} }
;. ;.
; CHECK: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CHECK: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CGSCC: {{.*}} ; CGSCC: {{.*}}
; TUNIT: {{.*}} ; TUNIT: {{.*}}

llvm/test/Transforms/Attributor/memory_locations.ll

Show First 20 Lines • Show All 382 Lines • ▼ Show 20 Lines
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%unknown = call ptr @inaccesible_argmem_only_decl(ptr null) %unknown = call ptr @inaccesible_argmem_only_decl(ptr null)
store i8 0, ptr %unknown store i8 0, ptr %unknown
ret void ret void
} }
define void @callerE(ptr %arg) { define void @callerE(ptr %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@callerE ; CHECK-LABEL: define {{[^@]+}}@callerE
; CHECK-SAME: (ptr nocapture nofree readnone [[ARG:%.*]]) #[[ATTR5:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree readnone [[ARG:%.*]]) #[[ATTR5:[0-9]+]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.lifetime.start.p0(i64 4, ptr %arg) call void @llvm.lifetime.start.p0(i64 4, ptr %arg)
ret void ret void
} }
define void @write_global() { define void @write_global() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CHECK-LABEL: define {{[^@]+}}@write_global ; CHECK-LABEL: define {{[^@]+}}@write_global
; CHECK-SAME: () #[[ATTR6:[0-9]+]] { ; CHECK-SAME: () #[[ATTR6:[0-9]+]] {
; CHECK-NEXT: store i32 0, ptr @G, align 4 ; CHECK-NEXT: store i32 0, ptr @G, align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store i32 0, ptr @G, align 4 store i32 0, ptr @G, align 4
ret void ret void
} }
define void @write_global_via_arg(ptr %GPtr) { define void @write_global_via_arg(ptr %GPtr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@write_global_via_arg ; CHECK-LABEL: define {{[^@]+}}@write_global_via_arg
; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[GPTR:%.*]]) #[[ATTR7:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[GPTR:%.*]]) #[[ATTR7:[0-9]+]] {
; CHECK-NEXT: store i32 0, ptr [[GPTR]], align 4 ; CHECK-NEXT: store i32 0, ptr [[GPTR]], align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store i32 0, ptr %GPtr, align 4 store i32 0, ptr %GPtr, align 4
ret void ret void
} }
define internal void @write_global_via_arg_internal(ptr %GPtr) { define internal void @write_global_via_arg_internal(ptr %GPtr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CHECK-LABEL: define {{[^@]+}}@write_global_via_arg_internal ; CHECK-LABEL: define {{[^@]+}}@write_global_via_arg_internal
; CHECK-SAME: () #[[ATTR6]] { ; CHECK-SAME: () #[[ATTR6]] {
; CHECK-NEXT: store i32 0, ptr @G, align 4 ; CHECK-NEXT: store i32 0, ptr @G, align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store i32 0, ptr %GPtr, align 4 store i32 0, ptr %GPtr, align 4
ret void ret void
} }
define void @writeonly_global() { define void @writeonly_global() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@writeonly_global ; TUNIT-LABEL: define {{[^@]+}}@writeonly_global
; TUNIT-SAME: () #[[ATTR6]] { ; TUNIT-SAME: () #[[ATTR6]] {
; TUNIT-NEXT: call void @write_global() #[[ATTR10:[0-9]+]] ; TUNIT-NEXT: call void @write_global() #[[ATTR10:[0-9]+]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@writeonly_global ; CGSCC-LABEL: define {{[^@]+}}@writeonly_global
; CGSCC-SAME: () #[[ATTR8:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR8:[0-9]+]] {
; CGSCC-NEXT: call void @write_global() #[[ATTR11:[0-9]+]] ; CGSCC-NEXT: call void @write_global() #[[ATTR11:[0-9]+]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @write_global() call void @write_global()
ret void ret void
} }
define void @writeonly_global_via_arg() { define void @writeonly_global_via_arg() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@writeonly_global_via_arg ; TUNIT-LABEL: define {{[^@]+}}@writeonly_global_via_arg
; TUNIT-SAME: () #[[ATTR6]] { ; TUNIT-SAME: () #[[ATTR6]] {
; TUNIT-NEXT: call void @write_global_via_arg(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) @G) #[[ATTR10]] ; TUNIT-NEXT: call void @write_global_via_arg(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) @G) #[[ATTR10]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@writeonly_global_via_arg ; CGSCC-LABEL: define {{[^@]+}}@writeonly_global_via_arg
; CGSCC-SAME: () #[[ATTR8]] { ; CGSCC-SAME: () #[[ATTR8]] {
; CGSCC-NEXT: call void @write_global_via_arg(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) @G) #[[ATTR11]] ; CGSCC-NEXT: call void @write_global_via_arg(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) @G) #[[ATTR11]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @write_global_via_arg(ptr @G) call void @write_global_via_arg(ptr @G)
ret void ret void
} }
define void @writeonly_global_via_arg_internal() { define void @writeonly_global_via_arg_internal() {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@writeonly_global_via_arg_internal ; TUNIT-LABEL: define {{[^@]+}}@writeonly_global_via_arg_internal
; TUNIT-SAME: () #[[ATTR6]] { ; TUNIT-SAME: () #[[ATTR6]] {
; TUNIT-NEXT: call void @write_global_via_arg_internal() #[[ATTR10]] ; TUNIT-NEXT: call void @write_global_via_arg_internal() #[[ATTR10]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@writeonly_global_via_arg_internal ; CGSCC-LABEL: define {{[^@]+}}@writeonly_global_via_arg_internal
; CGSCC-SAME: () #[[ATTR8]] { ; CGSCC-SAME: () #[[ATTR8]] {
; CGSCC-NEXT: call void @write_global_via_arg_internal() #[[ATTR11]] ; CGSCC-NEXT: call void @write_global_via_arg_internal() #[[ATTR11]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @write_global_via_arg_internal(ptr @G) call void @write_global_via_arg_internal(ptr @G)
ret void ret void
} }
▲ Show 20 Lines • Show All 195 Lines • ▼ Show 20 Lines
; CGSCC-NEXT: ret i8 [[R]] ; CGSCC-NEXT: ret i8 [[R]]
; ;
%alloc = alloca i8 %alloc = alloca i8
%r = call i8 @recursive_not_readnone_internal3(ptr %alloc, i1 %c) %r = call i8 @recursive_not_readnone_internal3(ptr %alloc, i1 %c)
ret i8 %r ret i8 %r
} }
define internal void @argmemonly_before_ipconstprop(ptr %p) argmemonly { define internal void @argmemonly_before_ipconstprop(ptr %p) argmemonly {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CHECK-LABEL: define {{[^@]+}}@argmemonly_before_ipconstprop ; CHECK-LABEL: define {{[^@]+}}@argmemonly_before_ipconstprop
; CHECK-SAME: () #[[ATTR6]] { ; CHECK-SAME: () #[[ATTR6]] {
; CHECK-NEXT: store i32 0, ptr @G, align 4 ; CHECK-NEXT: store i32 0, ptr @G, align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store i32 0, ptr %p store i32 0, ptr %p
ret void ret void
} }
define void @argmemonky_caller() { define void @argmemonky_caller() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@argmemonky_caller ; TUNIT-LABEL: define {{[^@]+}}@argmemonky_caller
; TUNIT-SAME: () #[[ATTR6]] { ; TUNIT-SAME: () #[[ATTR6]] {
; TUNIT-NEXT: call void @argmemonly_before_ipconstprop() #[[ATTR10]] ; TUNIT-NEXT: call void @argmemonly_before_ipconstprop() #[[ATTR10]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@argmemonky_caller ; CGSCC-LABEL: define {{[^@]+}}@argmemonky_caller
; CGSCC-SAME: () #[[ATTR8]] { ; CGSCC-SAME: () #[[ATTR8]] {
; CGSCC-NEXT: call void @argmemonly_before_ipconstprop() #[[ATTR11]] ; CGSCC-NEXT: call void @argmemonly_before_ipconstprop() #[[ATTR11]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @argmemonly_before_ipconstprop(ptr @G) call void @argmemonly_before_ipconstprop(ptr @G)
ret void ret void
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { memory(inaccessiblemem: readwrite) } ; TUNIT: attributes #[[ATTR0]] = { memory(inaccessiblemem: readwrite) }
; TUNIT: attributes #[[ATTR1]] = { memory(argmem: readwrite, inaccessiblemem: readwrite) } ; TUNIT: attributes #[[ATTR1]] = { memory(argmem: readwrite, inaccessiblemem: readwrite) }
; TUNIT: attributes #[[ATTR2]] = { memory(none) } ; TUNIT: attributes #[[ATTR2]] = { memory(none) }
; TUNIT: attributes #[[ATTR3]] = { memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR3]] = { memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR4:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR4:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR5]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR5]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR6]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; TUNIT: attributes #[[ATTR6]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; TUNIT: attributes #[[ATTR7]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR7]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR8]] = { nofree nosync nounwind memory(argmem: write) } ; TUNIT: attributes #[[ATTR8]] = { nofree nosync nounwind memory(argmem: write) }
; TUNIT: attributes #[[ATTR9]] = { nofree norecurse nosync nounwind memory(none) } ; TUNIT: attributes #[[ATTR9]] = { nofree norecurse nosync nounwind memory(none) }
; TUNIT: attributes #[[ATTR10]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR10]] = { nofree nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR11]] = { nofree nosync nounwind } ; TUNIT: attributes #[[ATTR11]] = { nofree nosync nounwind }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { memory(inaccessiblemem: readwrite) } ; CGSCC: attributes #[[ATTR0]] = { memory(inaccessiblemem: readwrite) }
; CGSCC: attributes #[[ATTR1]] = { memory(argmem: readwrite, inaccessiblemem: readwrite) } ; CGSCC: attributes #[[ATTR1]] = { memory(argmem: readwrite, inaccessiblemem: readwrite) }
; CGSCC: attributes #[[ATTR2]] = { memory(none) } ; CGSCC: attributes #[[ATTR2]] = { memory(none) }
; CGSCC: attributes #[[ATTR3]] = { memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR3]] = { memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR4:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR4:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR5]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR5]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR6]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR6]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR7]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR7]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR8]] = { nofree nosync nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR8]] = { mustprogress nofree nosync nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR9]] = { nofree nosync nounwind memory(argmem: write) } ; CGSCC: attributes #[[ATTR9]] = { nofree nosync nounwind memory(argmem: write) }
; CGSCC: attributes #[[ATTR10]] = { nofree nosync nounwind memory(none) } ; CGSCC: attributes #[[ATTR10]] = { nofree nosync nounwind memory(none) }
; CGSCC: attributes #[[ATTR11]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR11]] = { nounwind willreturn }
; CGSCC: attributes #[[ATTR12]] = { nofree nosync nounwind } ; CGSCC: attributes #[[ATTR12]] = { nofree nosync nounwind }
; CGSCC: attributes #[[ATTR13]] = { nounwind } ; CGSCC: attributes #[[ATTR13]] = { nounwind }
;. ;.

llvm/test/Transforms/Attributor/memory_locations_gpu.ll

Show All 9 Lines
declare ptr addrspace(4) @ptr_to_const() memory(none) declare ptr addrspace(4) @ptr_to_const() memory(none)
declare ptr addrspace(3) @ptr_to_shared() memory(none) declare ptr addrspace(3) @ptr_to_shared() memory(none)
; Should be memory(none) ; Should be memory(none)
;. ;.
; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = external dso_local addrspace(4) global i32, align 4 ; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = external dso_local addrspace(4) global i32, align 4
;. ;.
define i32 @test_const_as_global1() { define i32 @test_const_as_global1() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test_const_as_global1 ; CHECK-LABEL: define {{[^@]+}}@test_const_as_global1
; CHECK-SAME: () #[[ATTR1:[0-9]+]] { ; CHECK-SAME: () #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: [[L1:%.*]] = load i32, ptr addrspace(4) @G, align 4 ; CHECK-NEXT: [[L1:%.*]] = load i32, ptr addrspace(4) @G, align 4
; CHECK-NEXT: ret i32 [[L1]] ; CHECK-NEXT: ret i32 [[L1]]
; ;
%l1 = load i32, ptr addrspace(4) @G %l1 = load i32, ptr addrspace(4) @G
ret i32 %l1 ret i32 %l1
} }
; Should be memory(none) ; Should be memory(none)
define i32 @test_const_as_global2() { define i32 @test_const_as_global2() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test_const_as_global2 ; CHECK-LABEL: define {{[^@]+}}@test_const_as_global2
; CHECK-SAME: () #[[ATTR1]] { ; CHECK-SAME: () #[[ATTR1]] {
; CHECK-NEXT: [[L2:%.*]] = load i32, ptr addrspacecast (ptr addrspace(4) @G to ptr), align 4 ; CHECK-NEXT: [[L2:%.*]] = load i32, ptr addrspacecast (ptr addrspace(4) @G to ptr), align 4
; CHECK-NEXT: ret i32 [[L2]] ; CHECK-NEXT: ret i32 [[L2]]
; ;
%l2 = load i32, ptr addrspacecast (ptr addrspace(4) @G to ptr) %l2 = load i32, ptr addrspacecast (ptr addrspace(4) @G to ptr)
ret i32 %l2 ret i32 %l2
} }
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
; ;
%p2 = call ptr @ptr() %p2 = call ptr @ptr()
%c2 = addrspacecast ptr %p2 to ptr addrspace(3) %c2 = addrspacecast ptr %p2 to ptr addrspace(3)
%l2 = load i32, ptr addrspace(3) %c2 %l2 = load i32, ptr addrspace(3) %c2
ret i32 %l2 ret i32 %l2
} }
;. ;.
; CHECK: attributes #[[ATTR0:[0-9]+]] = { memory(none) } ; CHECK: attributes #[[ATTR0:[0-9]+]] = { memory(none) }
; CHECK: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CHECK: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CHECK: attributes #[[ATTR2]] = { nosync memory(read) } ; CHECK: attributes #[[ATTR2]] = { nosync memory(read) }
; CHECK: attributes #[[ATTR3]] = { nosync memory(none) } ; CHECK: attributes #[[ATTR3]] = { nosync memory(none) }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CGSCC: {{.*}} ; CGSCC: {{.*}}
; TUNIT: {{.*}} ; TUNIT: {{.*}}

llvm/test/Transforms/Attributor/misc.ll

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Linesentry:
call void %fp(ptr @foo) call void %fp(ptr @foo)
call void %fp(ptr %a) call void %fp(ptr %a)
call void @internal(ptr %fp) call void @internal(ptr %fp)
ret void ret void
} }
define internal void @foo(ptr %a) { define internal void @foo(ptr %a) {
; ;
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@foo ; CHECK-LABEL: define {{[^@]+}}@foo
; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: store i32 0, ptr [[A]], align 4 ; CHECK-NEXT: store i32 0, ptr [[A]], align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
store i32 0, ptr %a store i32 0, ptr %a
ret void ret void
} }
declare void @callback1(ptr) declare void @callback1(ptr)
declare void @callback2(ptr) declare void @callback2(ptr)
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR1]] = { nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR1]] = { nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn }
;. ;.

llvm/test/Transforms/Attributor/misc_crash.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -opaque-pointers=0 -passes=attributor -S %s | FileCheck %s ; RUN: opt -opaque-pointers=0 -passes=attributor -S %s | FileCheck %s
@var1 = internal global [1 x i32] undef @var1 = internal global [1 x i32] undef
@var2 = internal global i32 0 @var2 = internal global i32 0
;. ;.
; CHECK: @[[VAR1:[a-zA-Z0-9_$"\\.-]+]] = internal global [1 x i32] undef ; CHECK: @[[VAR1:[a-zA-Z0-9_$"\\.-]+]] = internal global [1 x i32] undef
; CHECK: @[[VAR2:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 0 ; CHECK: @[[VAR2:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 0
;. ;.
define i32 addrspace(1)* @foo(i32 addrspace(4)* %arg) { define i32 addrspace(1)* @foo(i32 addrspace(4)* %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@foo ; CHECK-LABEL: define {{[^@]+}}@foo
; CHECK-SAME: (i32 addrspace(4)* nofree readnone [[ARG:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (i32 addrspace(4)* nofree readnone [[ARG:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = addrspacecast i32 addrspace(4)* [[ARG]] to i32 addrspace(1)* ; CHECK-NEXT: [[TMP0:%.*]] = addrspacecast i32 addrspace(4)* [[ARG]] to i32 addrspace(1)*
; CHECK-NEXT: ret i32 addrspace(1)* [[TMP0]] ; CHECK-NEXT: ret i32 addrspace(1)* [[TMP0]]
; ;
entry: entry:
%0 = addrspacecast i32 addrspace(4)* %arg to i32 addrspace(1)* %0 = addrspacecast i32 addrspace(4)* %arg to i32 addrspace(1)*
ret i32 addrspace(1)* %0 ret i32 addrspace(1)* %0
} }
define i32* @func1() { define i32* @func1() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@func1 ; CHECK-LABEL: define {{[^@]+}}@func1
; CHECK-SAME: () #[[ATTR0]] { ; CHECK-SAME: () #[[ATTR0]] {
; CHECK-NEXT: ret i32* getelementptr inbounds ([1 x i32], [1 x i32]* @var1, i32 0, i32 0) ; CHECK-NEXT: ret i32* getelementptr inbounds ([1 x i32], [1 x i32]* @var1, i32 0, i32 0)
; ;
%ptr = call i32* @func1a([1 x i32]* @var1) %ptr = call i32* @func1a([1 x i32]* @var1)
ret i32* %ptr ret i32* %ptr
} }
define internal i32* @func1a([1 x i32]* %arg) { define internal i32* @func1a([1 x i32]* %arg) {
%ptr = getelementptr inbounds [1 x i32], [1 x i32]* %arg, i64 0, i64 0 %ptr = getelementptr inbounds [1 x i32], [1 x i32]* %arg, i64 0, i64 0
ret i32* %ptr ret i32* %ptr
} }
define internal void @func2a(i32* %0) { define internal void @func2a(i32* %0) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CHECK-LABEL: define {{[^@]+}}@func2a ; CHECK-LABEL: define {{[^@]+}}@func2a
; CHECK-SAME: (i32* nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[TMP0:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (i32* nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[TMP0:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: store i32 0, i32* @var2, align 4 ; CHECK-NEXT: store i32 0, i32* @var2, align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store i32 0, i32* %0 store i32 0, i32* %0
ret void ret void
} }
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines
; CHECK-SAME: () #[[ATTR2]] { ; CHECK-SAME: () #[[ATTR2]] {
; CHECK-NEXT: [[CALL:%.*]] = call i16 bitcast (i16 (i16*, i16)* @bar3 to i16 ()*)() ; CHECK-NEXT: [[CALL:%.*]] = call i16 bitcast (i16 (i16*, i16)* @bar3 to i16 ()*)()
; CHECK-NEXT: ret i16 [[CALL]] ; CHECK-NEXT: ret i16 [[CALL]]
; ;
%call = call i16 bitcast (i16 (i16*, i16) * @bar3 to i16 () *)() %call = call i16 bitcast (i16 (i16*, i16) * @bar3 to i16 () *)()
ret i16 %call ret i16 %call
} }
define internal i16 @bar3(i16* %p1, i16 %p2) { define internal i16 @bar3(i16* %p1, i16 %p2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@bar3 ; CHECK-LABEL: define {{[^@]+}}@bar3
; CHECK-SAME: (i16* nocapture nofree readnone [[P1:%.*]], i16 returned [[P2:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i16* nocapture nofree readnone [[P1:%.*]], i16 returned [[P2:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: ret i16 [[P2]] ; CHECK-NEXT: ret i16 [[P2]]
; ;
ret i16 %p2 ret i16 %p2
} }
; CHECK-LABEL: declare {{[^@]+}}@func6 ; CHECK-LABEL: declare {{[^@]+}}@func6
; CHECK-SAME: (i8*) ; CHECK-SAME: (i8*)
declare void @func6(i8*) declare void @func6(i8*)
;. ;.
; CHECK: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CHECK: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CHECK: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; CHECK: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; CHECK: attributes #[[ATTR2]] = { norecurse } ; CHECK: attributes #[[ATTR2]] = { norecurse }
;. ;.

llvm/test/Transforms/Attributor/multiple-offsets-pointer-info.ll

Show All 40 Linesentry:
%sel0 = select i1 %cnd1, i64 23, i64 29 %sel0 = select i1 %cnd1, i64 23, i64 29
%sel1 = select i1 %cnd2, i64 %sel0, i64 7 %sel1 = select i1 %cnd2, i64 %sel0, i64 7
%gep.sel = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 %sel1 %gep.sel = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 %sel1
%i = load i8, ptr %gep.sel, align 4 %i = load i8, ptr %gep.sel, align 4
ret i8 %i ret i8 %i
} }
define i8 @select_offsets_simplifiable_2(i1 %cnd1, i1 %cnd2) { define i8 @select_offsets_simplifiable_2(i1 %cnd1, i1 %cnd2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@select_offsets_simplifiable_2 ; CHECK-LABEL: define {{[^@]+}}@select_offsets_simplifiable_2
; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; CHECK-NEXT: [[GEP23:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 23 ; CHECK-NEXT: [[GEP23:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 23
; CHECK-NEXT: store i8 23, ptr [[GEP23]], align 4 ; CHECK-NEXT: store i8 23, ptr [[GEP23]], align 4
; CHECK-NEXT: [[GEP29:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 29 ; CHECK-NEXT: [[GEP29:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 29
; CHECK-NEXT: store i8 29, ptr [[GEP29]], align 4 ; CHECK-NEXT: store i8 29, ptr [[GEP29]], align 4
Show All 26 Linesentry:
%sel1 = select i1 %cnd2, i64 %sel0, i64 4 %sel1 = select i1 %cnd2, i64 %sel0, i64 4
%gep.sel = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 %sel1 %gep.sel = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 %sel1
%gep.plus = getelementptr inbounds i8, ptr %gep.sel, i64 3 %gep.plus = getelementptr inbounds i8, ptr %gep.sel, i64 3
%i = load i8, ptr %gep.plus, align 4 %i = load i8, ptr %gep.plus, align 4
ret i8 %i ret i8 %i
} }
define i8 @select_offsets_simplifiable_3(i1 %cnd1, i1 %cnd2) { define i8 @select_offsets_simplifiable_3(i1 %cnd1, i1 %cnd2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@select_offsets_simplifiable_3 ; CHECK-LABEL: define {{[^@]+}}@select_offsets_simplifiable_3
; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[BUNDLE:%.*]] = alloca [[STRUCT_T:%.*]], align 64 ; CHECK-NEXT: [[BUNDLE:%.*]] = alloca [[STRUCT_T:%.*]], align 64
; CHECK-NEXT: [[SEL1:%.*]] = select i1 [[CND1]], i64 1, i64 3 ; CHECK-NEXT: [[SEL1:%.*]] = select i1 [[CND1]], i64 1, i64 3
; CHECK-NEXT: [[SEL2:%.*]] = select i1 [[CND2]], i64 5, i64 11 ; CHECK-NEXT: [[SEL2:%.*]] = select i1 [[CND2]], i64 5, i64 11
; CHECK-NEXT: [[GEP_SEL:%.*]] = getelementptr inbounds [[STRUCT_T]], ptr [[BUNDLE]], i64 0, i32 1, i64 [[SEL1]], i64 [[SEL2]] ; CHECK-NEXT: [[GEP_SEL:%.*]] = getelementptr inbounds [[STRUCT_T]], ptr [[BUNDLE]], i64 0, i32 1, i64 [[SEL1]], i64 [[SEL2]]
; CHECK-NEXT: ret i8 100 ; CHECK-NEXT: ret i8 100
; ;
entry: entry:
%bundle = alloca %struct.T, align 64 %bundle = alloca %struct.T, align 64
%gep.fixed = getelementptr inbounds %struct.T, ptr %bundle, i64 0, i32 1, i64 1, i64 1 %gep.fixed = getelementptr inbounds %struct.T, ptr %bundle, i64 0, i32 1, i64 1, i64 1
store i8 100, ptr %gep.fixed, align 4 store i8 100, ptr %gep.fixed, align 4
%sel1 = select i1 %cnd1, i64 1, i64 3 %sel1 = select i1 %cnd1, i64 1, i64 3
%sel2 = select i1 %cnd2, i64 5, i64 11 %sel2 = select i1 %cnd2, i64 5, i64 11
%gep.sel = getelementptr inbounds %struct.T, ptr %bundle, i64 0, i32 1, i64 %sel1, i64 %sel2 %gep.sel = getelementptr inbounds %struct.T, ptr %bundle, i64 0, i32 1, i64 %sel1, i64 %sel2
store i8 42, ptr %gep.sel, align 4 store i8 42, ptr %gep.sel, align 4
%i = load i8, ptr %gep.fixed, align 4 %i = load i8, ptr %gep.fixed, align 4
ret i8 %i ret i8 %i
} }
; Similar to select_offsets_not_simplifiable_3 but with uninitialized memory. ; Similar to select_offsets_not_simplifiable_3 but with uninitialized memory.
define i8 @select_offsets_simplifiable_4(i1 %cnd1, i1 %cnd2) { define i8 @select_offsets_simplifiable_4(i1 %cnd1, i1 %cnd2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@select_offsets_simplifiable_4 ; CHECK-LABEL: define {{[^@]+}}@select_offsets_simplifiable_4
; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; CHECK-NEXT: [[SEL0:%.*]] = select i1 [[CND1]], i64 23, i64 29 ; CHECK-NEXT: [[SEL0:%.*]] = select i1 [[CND1]], i64 23, i64 29
; CHECK-NEXT: [[SEL1:%.*]] = select i1 [[CND2]], i64 [[SEL0]], i64 7 ; CHECK-NEXT: [[SEL1:%.*]] = select i1 [[CND2]], i64 [[SEL0]], i64 7
; CHECK-NEXT: [[GEP_SEL:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 [[SEL1]] ; CHECK-NEXT: [[GEP_SEL:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 [[SEL1]]
; CHECK-NEXT: ret i8 100 ; CHECK-NEXT: ret i8 100
; ;
entry: entry:
%Bytes = alloca [1024 x i8], align 16 %Bytes = alloca [1024 x i8], align 16
%sel0 = select i1 %cnd1, i64 23, i64 29 %sel0 = select i1 %cnd1, i64 23, i64 29
%sel1 = select i1 %cnd2, i64 %sel0, i64 7 %sel1 = select i1 %cnd2, i64 %sel0, i64 7
%gep.sel = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 %sel1 %gep.sel = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 %sel1
store i8 100, ptr %gep.sel, align 4 store i8 100, ptr %gep.sel, align 4
%gep29 = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 29 %gep29 = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 29
%i = load i8, ptr %gep29, align 4 %i = load i8, ptr %gep29, align 4
ret i8 %i ret i8 %i
} }
define i8 @select_offsets_not_simplifiable_1(i1 %cnd1, i1 %cnd2) { define i8 @select_offsets_not_simplifiable_1(i1 %cnd1, i1 %cnd2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@select_offsets_not_simplifiable_1 ; CHECK-LABEL: define {{[^@]+}}@select_offsets_not_simplifiable_1
; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; CHECK-NEXT: [[SEL0:%.*]] = select i1 [[CND1]], i64 23, i64 29 ; CHECK-NEXT: [[SEL0:%.*]] = select i1 [[CND1]], i64 23, i64 29
; CHECK-NEXT: [[SEL1:%.*]] = select i1 [[CND2]], i64 [[SEL0]], i64 7 ; CHECK-NEXT: [[SEL1:%.*]] = select i1 [[CND2]], i64 [[SEL0]], i64 7
; CHECK-NEXT: [[GEP23:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 23 ; CHECK-NEXT: [[GEP23:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 23
; CHECK-NEXT: store i8 100, ptr [[GEP23]], align 4 ; CHECK-NEXT: store i8 100, ptr [[GEP23]], align 4
; CHECK-NEXT: [[GEP_SEL:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 [[SEL1]] ; CHECK-NEXT: [[GEP_SEL:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 [[SEL1]]
; CHECK-NEXT: [[I:%.*]] = load i8, ptr [[GEP_SEL]], align 4 ; CHECK-NEXT: [[I:%.*]] = load i8, ptr [[GEP_SEL]], align 4
; CHECK-NEXT: ret i8 [[I]] ; CHECK-NEXT: ret i8 [[I]]
; ;
entry: entry:
%Bytes = alloca [1024 x i8], align 16 %Bytes = alloca [1024 x i8], align 16
%sel0 = select i1 %cnd1, i64 23, i64 29 %sel0 = select i1 %cnd1, i64 23, i64 29
%sel1 = select i1 %cnd2, i64 %sel0, i64 7 %sel1 = select i1 %cnd2, i64 %sel0, i64 7
%gep23 = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 23 %gep23 = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 23
store i8 100, ptr %gep23, align 4 store i8 100, ptr %gep23, align 4
%gep.sel = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 %sel1 %gep.sel = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 %sel1
%i = load i8, ptr %gep.sel, align 4 %i = load i8, ptr %gep.sel, align 4
ret i8 %i ret i8 %i
} }
define i8 @select_offsets_not_simplifiable_2(i1 %cnd1, i1 %cnd2) { define i8 @select_offsets_not_simplifiable_2(i1 %cnd1, i1 %cnd2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@select_offsets_not_simplifiable_2 ; CHECK-LABEL: define {{[^@]+}}@select_offsets_not_simplifiable_2
; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; CHECK-NEXT: [[SEL0:%.*]] = select i1 [[CND1]], i64 23, i64 29 ; CHECK-NEXT: [[SEL0:%.*]] = select i1 [[CND1]], i64 23, i64 29
; CHECK-NEXT: [[SEL1:%.*]] = select i1 [[CND2]], i64 [[SEL0]], i64 7 ; CHECK-NEXT: [[SEL1:%.*]] = select i1 [[CND2]], i64 [[SEL0]], i64 7
; CHECK-NEXT: [[GEP32:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 32 ; CHECK-NEXT: [[GEP32:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 32
; CHECK-NEXT: store i8 100, ptr [[GEP32]], align 16 ; CHECK-NEXT: store i8 100, ptr [[GEP32]], align 16
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Linesentry:
%gep.plus = getelementptr inbounds i8, ptr %gep.sel, i64 3 %gep.plus = getelementptr inbounds i8, ptr %gep.sel, i64 3
store i8 100, ptr %gep.plus, align 4 store i8 100, ptr %gep.plus, align 4
%gep32 = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 32 %gep32 = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 32
%i = load i8, ptr %gep32, align 4 %i = load i8, ptr %gep32, align 4
ret i8 %i ret i8 %i
} }
define i8 @select_offsets_not_simplifiable_5(i1 %cnd1, i1 %cnd2) { define i8 @select_offsets_not_simplifiable_5(i1 %cnd1, i1 %cnd2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@select_offsets_not_simplifiable_5 ; CHECK-LABEL: define {{[^@]+}}@select_offsets_not_simplifiable_5
; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[BUNDLE:%.*]] = alloca [[STRUCT_T:%.*]], align 64 ; CHECK-NEXT: [[BUNDLE:%.*]] = alloca [[STRUCT_T:%.*]], align 64
; CHECK-NEXT: [[GEP_FIXED:%.*]] = getelementptr inbounds [[STRUCT_T]], ptr [[BUNDLE]], i64 0, i32 1, i64 3, i64 5 ; CHECK-NEXT: [[GEP_FIXED:%.*]] = getelementptr inbounds [[STRUCT_T]], ptr [[BUNDLE]], i64 0, i32 1, i64 3, i64 5
; CHECK-NEXT: store i8 100, ptr [[GEP_FIXED]], align 4 ; CHECK-NEXT: store i8 100, ptr [[GEP_FIXED]], align 4
; CHECK-NEXT: [[SEL1:%.*]] = select i1 [[CND1]], i64 1, i64 3 ; CHECK-NEXT: [[SEL1:%.*]] = select i1 [[CND1]], i64 1, i64 3
; CHECK-NEXT: [[SEL2:%.*]] = select i1 [[CND2]], i64 5, i64 11 ; CHECK-NEXT: [[SEL2:%.*]] = select i1 [[CND2]], i64 5, i64 11
Show All 13 Linesentry:
;; This store prevents the constant 100 from being propagated to ret ;; This store prevents the constant 100 from being propagated to ret
store i8 42, ptr %gep.sel, align 4 store i8 42, ptr %gep.sel, align 4
%i = load i8, ptr %gep.fixed, align 4 %i = load i8, ptr %gep.fixed, align 4
ret i8 %i ret i8 %i
} }
define i8 @select_gep_simplifiable_1(i1 %cnd1, i1 %cnd2) { define i8 @select_gep_simplifiable_1(i1 %cnd1, i1 %cnd2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CHECK-LABEL: define {{[^@]+}}@select_gep_simplifiable_1 ; CHECK-LABEL: define {{[^@]+}}@select_gep_simplifiable_1
; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR2:[0-9]+]] { ; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR2:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; CHECK-NEXT: [[GEP7:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 7 ; CHECK-NEXT: [[GEP7:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 7
; CHECK-NEXT: [[GEP23:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 23 ; CHECK-NEXT: [[GEP23:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 23
; CHECK-NEXT: [[SEL_PTR:%.*]] = select i1 [[CND1]], ptr [[GEP7]], ptr [[GEP23]] ; CHECK-NEXT: [[SEL_PTR:%.*]] = select i1 [[CND1]], ptr [[GEP7]], ptr [[GEP23]]
; CHECK-NEXT: store i8 42, ptr [[SEL_PTR]], align 4 ; CHECK-NEXT: store i8 42, ptr [[SEL_PTR]], align 4
; CHECK-NEXT: ret i8 21 ; CHECK-NEXT: ret i8 21
; ;
entry: entry:
%Bytes = alloca [1024 x i8], align 16 %Bytes = alloca [1024 x i8], align 16
%gep3 = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 3 %gep3 = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 3
store i8 21, ptr %gep3, align 4 store i8 21, ptr %gep3, align 4
%gep7 = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 7 %gep7 = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 7
%gep23 = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 23 %gep23 = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 23
%sel.ptr = select i1 %cnd1, ptr %gep7, ptr %gep23 %sel.ptr = select i1 %cnd1, ptr %gep7, ptr %gep23
store i8 42, ptr %sel.ptr, align 4 store i8 42, ptr %sel.ptr, align 4
%i = load i8, ptr %gep3, align 4 %i = load i8, ptr %gep3, align 4
ret i8 %i ret i8 %i
} }
define i8 @select_gep_not_simplifiable_1(i1 %cnd1, i1 %cnd2) { define i8 @select_gep_not_simplifiable_1(i1 %cnd1, i1 %cnd2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CHECK-LABEL: define {{[^@]+}}@select_gep_not_simplifiable_1 ; CHECK-LABEL: define {{[^@]+}}@select_gep_not_simplifiable_1
; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR3:[0-9]+]] { ; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR3:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; CHECK-NEXT: [[GEP7:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 7 ; CHECK-NEXT: [[GEP7:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 7
; CHECK-NEXT: store i8 1, ptr [[GEP7]], align 4 ; CHECK-NEXT: store i8 1, ptr [[GEP7]], align 4
; CHECK-NEXT: [[GEP23:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 23 ; CHECK-NEXT: [[GEP23:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 23
; CHECK-NEXT: [[SEL_PTR:%.*]] = select i1 [[CND1]], ptr [[GEP7]], ptr [[GEP23]] ; CHECK-NEXT: [[SEL_PTR:%.*]] = select i1 [[CND1]], ptr [[GEP7]], ptr [[GEP23]]
Show All 10 Linesentry:
store i8 42, ptr %sel.ptr, align 4 store i8 42, ptr %sel.ptr, align 4
%i = load i8, ptr %gep7, align 4 %i = load i8, ptr %gep7, align 4
ret i8 %i ret i8 %i
} }
; FIXME: The whole function is just "ret i8 21". ; FIXME: The whole function is just "ret i8 21".
define i8 @phi_gep_simplifiable_1(i1 %cnd1, i1 %cnd2) { define i8 @phi_gep_simplifiable_1(i1 %cnd1, i1 %cnd2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CHECK-LABEL: define {{[^@]+}}@phi_gep_simplifiable_1 ; CHECK-LABEL: define {{[^@]+}}@phi_gep_simplifiable_1
; CHECK-SAME: (i1 noundef [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR3]] { ; CHECK-SAME: (i1 noundef [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR3]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; CHECK-NEXT: br i1 [[CND1]], label [[THEN:%.*]], label [[ELSE:%.*]] ; CHECK-NEXT: br i1 [[CND1]], label [[THEN:%.*]], label [[ELSE:%.*]]
; CHECK: then: ; CHECK: then:
; CHECK-NEXT: [[GEP23:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 23 ; CHECK-NEXT: [[GEP23:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 23
; CHECK-NEXT: store i8 21, ptr [[GEP23]], align 4 ; CHECK-NEXT: store i8 21, ptr [[GEP23]], align 4
Show All 29 Linesjoin:
store i8 42, ptr %gep29, align 4 store i8 42, ptr %gep29, align 4
%i = load i8, ptr %phi.ptr, align 4 %i = load i8, ptr %phi.ptr, align 4
ret i8 %i ret i8 %i
} }
; FIXME: The whole function is just "ret i8 42". ; FIXME: The whole function is just "ret i8 42".
define i8 @phi_gep_simplifiable_2(i1 %cnd1, i1 %cnd2) { define i8 @phi_gep_simplifiable_2(i1 %cnd1, i1 %cnd2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CHECK-LABEL: define {{[^@]+}}@phi_gep_simplifiable_2 ; CHECK-LABEL: define {{[^@]+}}@phi_gep_simplifiable_2
; CHECK-SAME: (i1 noundef [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (i1 noundef [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; CHECK-NEXT: br i1 [[CND1]], label [[THEN:%.*]], label [[ELSE:%.*]] ; CHECK-NEXT: br i1 [[CND1]], label [[THEN:%.*]], label [[ELSE:%.*]]
; CHECK: then: ; CHECK: then:
; CHECK-NEXT: [[GEP23:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 23 ; CHECK-NEXT: [[GEP23:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 23
; CHECK-NEXT: br label [[JOIN:%.*]] ; CHECK-NEXT: br label [[JOIN:%.*]]
Show All 24 Linesjoin:
%phi.ptr = phi ptr [%gep23, %then], [%gep31, %else] %phi.ptr = phi ptr [%gep23, %then], [%gep31, %else]
store i8 21, ptr %phi.ptr, align 4 store i8 21, ptr %phi.ptr, align 4
;; Replaced with the constant, and both store/load are eliminated. ;; Replaced with the constant, and both store/load are eliminated.
%i = load i8, ptr %gep29, align 4 %i = load i8, ptr %gep29, align 4
ret i8 %i ret i8 %i
} }
define i8 @phi_gep_not_simplifiable_1(i1 %cnd1, i1 %cnd2) { define i8 @phi_gep_not_simplifiable_1(i1 %cnd1, i1 %cnd2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CHECK-LABEL: define {{[^@]+}}@phi_gep_not_simplifiable_1 ; CHECK-LABEL: define {{[^@]+}}@phi_gep_not_simplifiable_1
; CHECK-SAME: (i1 noundef [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR3]] { ; CHECK-SAME: (i1 noundef [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR3]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; CHECK-NEXT: [[GEP23:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 23 ; CHECK-NEXT: [[GEP23:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 23
; CHECK-NEXT: br i1 [[CND1]], label [[THEN:%.*]], label [[ELSE:%.*]] ; CHECK-NEXT: br i1 [[CND1]], label [[THEN:%.*]], label [[ELSE:%.*]]
; CHECK: then: ; CHECK: then:
; CHECK-NEXT: br label [[JOIN:%.*]] ; CHECK-NEXT: br label [[JOIN:%.*]]
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
join: join:
%phi.ptr = phi ptr [%gep23, %then], [%gep31, %else] %phi.ptr = phi ptr [%gep23, %then], [%gep31, %else]
store i8 21, ptr %phi.ptr, align 4 store i8 21, ptr %phi.ptr, align 4
%i = load i8, ptr %gep23, align 4 %i = load i8, ptr %gep23, align 4
ret i8 %i ret i8 %i
} }
define i8 @phi_offsets(i1 %cnd1, i1 %cnd2) { define i8 @phi_offsets(i1 %cnd1, i1 %cnd2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@phi_offsets ; CHECK-LABEL: define {{[^@]+}}@phi_offsets
; CHECK-SAME: (i1 noundef [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (i1 noundef [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; CHECK-NEXT: br i1 [[CND1]], label [[THEN:%.*]], label [[ELSE:%.*]] ; CHECK-NEXT: br i1 [[CND1]], label [[THEN:%.*]], label [[ELSE:%.*]]
; CHECK: then: ; CHECK: then:
; CHECK-NEXT: br label [[JOIN:%.*]] ; CHECK-NEXT: br label [[JOIN:%.*]]
; CHECK: else: ; CHECK: else:
Show All 19 Linesjoin:
%gep.phi = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 %phi %gep.phi = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 %phi
store i8 42, ptr %gep.phi, align 4 store i8 42, ptr %gep.phi, align 4
%i = load i8, ptr %Bytes, align 4 %i = load i8, ptr %Bytes, align 4
ret i8 %i ret i8 %i
} }
;. ;.
; CHECK: attributes #[[ATTR0:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc" } ; CHECK: attributes #[[ATTR0:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc" }
; CHECK: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CHECK: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CHECK: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; CHECK: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; CHECK: attributes #[[ATTR3]] = { nofree norecurse nosync nounwind willreturn } ; CHECK: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CGSCC: {{.*}} ; CGSCC: {{.*}}
; TUNIT: {{.*}} ; TUNIT: {{.*}}

llvm/test/Transforms/Attributor/noalias.ll

Show All 37 Lines
; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias ptr @malloc(i64 noundef 4) ; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias ptr @malloc(i64 noundef 4)
; CHECK-NEXT: ret ptr [[TMP1]] ; CHECK-NEXT: ret ptr [[TMP1]]
; ;
%1 = tail call noalias ptr @malloc(i64 4) %1 = tail call noalias ptr @malloc(i64 4)
ret ptr %1 ret ptr %1
} }
define void @nocapture(ptr %a){ define void @nocapture(ptr %a){
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@nocapture ; CHECK-LABEL: define {{[^@]+}}@nocapture
; CHECK-SAME: (ptr nocapture nofree readnone [[A:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree readnone [[A:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
ret void ret void
} }
define ptr @return_noalias_looks_like_capture(){ define ptr @return_noalias_looks_like_capture(){
▲ Show 20 Lines • Show All 97 Lines • ▼ Show 20 Lines
} }
declare ptr @baz(...) nounwind uwtable declare ptr @baz(...) nounwind uwtable
; TEST 5 ; TEST 5
; Returning global pointer. Should not be noalias. ; Returning global pointer. Should not be noalias.
define ptr @getter() { define ptr @getter() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@getter ; CHECK-LABEL: define {{[^@]+}}@getter
; CHECK-SAME: () #[[ATTR0]] { ; CHECK-SAME: () #[[ATTR0]] {
; CHECK-NEXT: ret ptr @G ; CHECK-NEXT: ret ptr @G
; ;
ret ptr @G ret ptr @G
} }
; Returning global pointer. Should not be noalias. ; Returning global pointer. Should not be noalias.
define ptr @calle1(){ define ptr @calle1(){
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@calle1 ; TUNIT-LABEL: define {{[^@]+}}@calle1
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: ret ptr @G ; TUNIT-NEXT: ret ptr @G
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@calle1 ; CGSCC-LABEL: define {{[^@]+}}@calle1
; CGSCC-SAME: () #[[ATTR2:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR2:[0-9]+]] {
; CGSCC-NEXT: [[TMP1:%.*]] = call noundef nonnull align 8 dereferenceable(8) ptr @getter() #[[ATTR11:[0-9]+]] ; CGSCC-NEXT: [[TMP1:%.*]] = call noundef nonnull align 8 dereferenceable(8) ptr @getter() #[[ATTR11:[0-9]+]]
; CGSCC-NEXT: ret ptr [[TMP1]] ; CGSCC-NEXT: ret ptr [[TMP1]]
; ;
%1 = call ptr @getter() %1 = call ptr @getter()
ret ptr %1 ret ptr %1
} }
▲ Show 20 Lines • Show All 317 Lines • ▼ Show 20 Lines;
%m1 = tail call noalias ptr @malloc(i64 4) %m1 = tail call noalias ptr @malloc(i64 4)
call void @use_i8_internal(ptr %m1) call void @use_i8_internal(ptr %m1)
call void @use_i8_internal(ptr %m1) call void @use_i8_internal(ptr %m1)
ret void ret void
} }
; TEST 14 i2p casts ; TEST 14 i2p casts
define internal i32 @p2i(ptr %arg) { define internal i32 @p2i(ptr %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@p2i ; CHECK-LABEL: define {{[^@]+}}@p2i
; CHECK-SAME: (ptr noalias nofree readnone [[ARG:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr noalias nofree readnone [[ARG:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[P2I:%.*]] = ptrtoint ptr [[ARG]] to i32 ; CHECK-NEXT: [[P2I:%.*]] = ptrtoint ptr [[ARG]] to i32
; CHECK-NEXT: ret i32 [[P2I]] ; CHECK-NEXT: ret i32 [[P2I]]
; ;
%p2i = ptrtoint ptr %arg to i32 %p2i = ptrtoint ptr %arg to i32
ret i32 %p2i ret i32 %p2i
} }
define i32 @i2p(ptr %arg) { define i32 @i2p(ptr %arg) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
; TUNIT-LABEL: define {{[^@]+}}@i2p ; TUNIT-LABEL: define {{[^@]+}}@i2p
; TUNIT-SAME: (ptr nofree readonly [[ARG:%.*]]) #[[ATTR4:[0-9]+]] { ; TUNIT-SAME: (ptr nofree readonly [[ARG:%.*]]) #[[ATTR4:[0-9]+]] {
; TUNIT-NEXT: [[C:%.*]] = call i32 @p2i(ptr noalias nofree readnone [[ARG]]) #[[ATTR10:[0-9]+]] ; TUNIT-NEXT: [[C:%.*]] = call i32 @p2i(ptr noalias nofree readnone [[ARG]]) #[[ATTR10:[0-9]+]]
; TUNIT-NEXT: [[I2P:%.*]] = inttoptr i32 [[C]] to ptr ; TUNIT-NEXT: [[I2P:%.*]] = inttoptr i32 [[C]] to ptr
; TUNIT-NEXT: [[CALL:%.*]] = call i32 @ret(ptr nocapture nofree readonly align 4 [[I2P]]) #[[ATTR10]] ; TUNIT-NEXT: [[CALL:%.*]] = call i32 @ret(ptr nocapture nofree readonly align 4 [[I2P]]) #[[ATTR10]]
; TUNIT-NEXT: ret i32 [[CALL]] ; TUNIT-NEXT: ret i32 [[CALL]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(read) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(read)
; CGSCC-LABEL: define {{[^@]+}}@i2p ; CGSCC-LABEL: define {{[^@]+}}@i2p
; CGSCC-SAME: (ptr nofree readonly [[ARG:%.*]]) #[[ATTR5:[0-9]+]] { ; CGSCC-SAME: (ptr nofree readonly [[ARG:%.*]]) #[[ATTR5:[0-9]+]] {
; CGSCC-NEXT: [[C:%.*]] = call i32 @p2i(ptr noalias nofree readnone [[ARG]]) #[[ATTR11]] ; CGSCC-NEXT: [[C:%.*]] = call i32 @p2i(ptr noalias nofree readnone [[ARG]]) #[[ATTR11]]
; CGSCC-NEXT: [[I2P:%.*]] = inttoptr i32 [[C]] to ptr ; CGSCC-NEXT: [[I2P:%.*]] = inttoptr i32 [[C]] to ptr
; CGSCC-NEXT: [[CALL:%.*]] = call i32 @ret(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[I2P]]) #[[ATTR11]] ; CGSCC-NEXT: [[CALL:%.*]] = call i32 @ret(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[I2P]]) #[[ATTR11]]
; CGSCC-NEXT: ret i32 [[CALL]] ; CGSCC-NEXT: ret i32 [[CALL]]
; ;
%c = call i32 @p2i(ptr %arg) %c = call i32 @p2i(ptr %arg)
%i2p = inttoptr i32 %c to ptr %i2p = inttoptr i32 %c to ptr
%call = call i32 @ret(ptr %i2p) %call = call i32 @ret(ptr %i2p)
ret i32 %call ret i32 %call
} }
define internal i32 @ret(ptr %arg) { define internal i32 @ret(ptr %arg) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; TUNIT-LABEL: define {{[^@]+}}@ret ; TUNIT-LABEL: define {{[^@]+}}@ret
; TUNIT-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[ARG:%.*]]) #[[ATTR5:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[ARG:%.*]]) #[[ATTR5:[0-9]+]] {
; TUNIT-NEXT: [[L:%.*]] = load i32, ptr [[ARG]], align 4 ; TUNIT-NEXT: [[L:%.*]] = load i32, ptr [[ARG]], align 4
; TUNIT-NEXT: ret i32 [[L]] ; TUNIT-NEXT: ret i32 [[L]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@ret ; CGSCC-LABEL: define {{[^@]+}}@ret
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[ARG:%.*]]) #[[ATTR6:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[ARG:%.*]]) #[[ATTR6:[0-9]+]] {
; CGSCC-NEXT: [[L:%.*]] = load i32, ptr [[ARG]], align 4 ; CGSCC-NEXT: [[L:%.*]] = load i32, ptr [[ARG]], align 4
; CGSCC-NEXT: ret i32 [[L]] ; CGSCC-NEXT: ret i32 [[L]]
; ;
%l = load i32, ptr %arg %l = load i32, ptr %arg
ret i32 %l ret i32 %l
} }
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture)
; Test 15 ; Test 15
; propagate noalias to some callsite arguments that there is no possibly reachable capture before it ; propagate noalias to some callsite arguments that there is no possibly reachable capture before it
@alias_of_p = external global ptr @alias_of_p = external global ptr
define void @make_alias(ptr %p) { define void @make_alias(ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@make_alias ; TUNIT-LABEL: define {{[^@]+}}@make_alias
; TUNIT-SAME: (ptr nofree writeonly [[P:%.*]]) #[[ATTR7:[0-9]+]] { ; TUNIT-SAME: (ptr nofree writeonly [[P:%.*]]) #[[ATTR7:[0-9]+]] {
; TUNIT-NEXT: store ptr [[P]], ptr @alias_of_p, align 8 ; TUNIT-NEXT: store ptr [[P]], ptr @alias_of_p, align 8
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@make_alias ; CGSCC-LABEL: define {{[^@]+}}@make_alias
; CGSCC-SAME: (ptr nofree writeonly [[P:%.*]]) #[[ATTR8:[0-9]+]] { ; CGSCC-SAME: (ptr nofree writeonly [[P:%.*]]) #[[ATTR8:[0-9]+]] {
; CGSCC-NEXT: store ptr [[P]], ptr @alias_of_p, align 8 ; CGSCC-NEXT: store ptr [[P]], ptr @alias_of_p, align 8
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
store ptr %p, ptr @alias_of_p store ptr %p, ptr @alias_of_p
ret void ret void
} }
define void @only_store(ptr %p) { define void @only_store(ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@only_store ; TUNIT-LABEL: define {{[^@]+}}@only_store
; TUNIT-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR8:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR8:[0-9]+]] {
; TUNIT-NEXT: store i32 0, ptr [[P]], align 4 ; TUNIT-NEXT: store i32 0, ptr [[P]], align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@only_store ; CGSCC-LABEL: define {{[^@]+}}@only_store
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR9:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR9:[0-9]+]] {
; CGSCC-NEXT: store i32 0, ptr [[P]], align 4 ; CGSCC-NEXT: store i32 0, ptr [[P]], align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
store i32 0, ptr %p store i32 0, ptr %p
ret void ret void
} }
define void @test15_caller(ptr noalias %p, i32 %c) { define void @test15_caller(ptr noalias %p, i32 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@test15_caller ; TUNIT-LABEL: define {{[^@]+}}@test15_caller
; TUNIT-SAME: (ptr noalias nofree writeonly [[P:%.*]], i32 [[C:%.*]]) #[[ATTR7]] { ; TUNIT-SAME: (ptr noalias nofree writeonly [[P:%.*]], i32 [[C:%.*]]) #[[ATTR7]] {
; TUNIT-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[C]], 0 ; TUNIT-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[C]], 0
; TUNIT-NEXT: br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]] ; TUNIT-NEXT: br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
; TUNIT: if.then: ; TUNIT: if.then:
; TUNIT-NEXT: tail call void @only_store(ptr noalias nocapture nofree writeonly align 4 [[P]]) #[[ATTR10]] ; TUNIT-NEXT: tail call void @only_store(ptr noalias nocapture nofree writeonly align 4 [[P]]) #[[ATTR10]]
; TUNIT-NEXT: br label [[IF_END]] ; TUNIT-NEXT: br label [[IF_END]]
; TUNIT: if.end: ; TUNIT: if.end:
; TUNIT-NEXT: tail call void @make_alias(ptr nofree writeonly [[P]]) #[[ATTR10]] ; TUNIT-NEXT: tail call void @make_alias(ptr nofree writeonly [[P]]) #[[ATTR10]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@test15_caller ; CGSCC-LABEL: define {{[^@]+}}@test15_caller
; CGSCC-SAME: (ptr noalias nofree writeonly [[P:%.*]], i32 [[C:%.*]]) #[[ATTR10:[0-9]+]] { ; CGSCC-SAME: (ptr noalias nofree writeonly [[P:%.*]], i32 [[C:%.*]]) #[[ATTR10:[0-9]+]] {
; CGSCC-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[C]], 0 ; CGSCC-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[C]], 0
; CGSCC-NEXT: br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]] ; CGSCC-NEXT: br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
; CGSCC: if.then: ; CGSCC: if.then:
; CGSCC-NEXT: tail call void @only_store(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P]]) #[[ATTR13:[0-9]+]] ; CGSCC-NEXT: tail call void @only_store(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P]]) #[[ATTR13:[0-9]+]]
; CGSCC-NEXT: br label [[IF_END]] ; CGSCC-NEXT: br label [[IF_END]]
; CGSCC: if.end: ; CGSCC: if.end:
Show All 28 Lines
; test16_sub(p, c, c); ; test16_sub(p, c, c);
; } ; }
; ;
; FIXME: this should be tail @only_store(ptr noalias %p) ; FIXME: this should be tail @only_store(ptr noalias %p)
; when test16_caller is called, c1 always equals to c2. (Note that linkage is internal) ; when test16_caller is called, c1 always equals to c2. (Note that linkage is internal)
; Therefore, only one of the two conditions of if statementes will be fulfilled. ; Therefore, only one of the two conditions of if statementes will be fulfilled.
define internal void @test16_sub(ptr noalias %p, i32 %c1, i32 %c2) { define internal void @test16_sub(ptr noalias %p, i32 %c1, i32 %c2) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@test16_sub ; TUNIT-LABEL: define {{[^@]+}}@test16_sub
; TUNIT-SAME: (ptr noalias nofree writeonly [[P:%.*]], i32 [[C1:%.*]], i32 [[C2:%.*]]) #[[ATTR7]] { ; TUNIT-SAME: (ptr noalias nofree writeonly [[P:%.*]], i32 [[C1:%.*]], i32 [[C2:%.*]]) #[[ATTR7]] {
; TUNIT-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[C1]], 0 ; TUNIT-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[C1]], 0
; TUNIT-NEXT: br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]] ; TUNIT-NEXT: br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
; TUNIT: if.then: ; TUNIT: if.then:
; TUNIT-NEXT: tail call void @only_store(ptr noalias nocapture nofree writeonly align 4 [[P]]) #[[ATTR10]] ; TUNIT-NEXT: tail call void @only_store(ptr noalias nocapture nofree writeonly align 4 [[P]]) #[[ATTR10]]
; TUNIT-NEXT: tail call void @make_alias(ptr nofree writeonly align 4 [[P]]) #[[ATTR10]] ; TUNIT-NEXT: tail call void @make_alias(ptr nofree writeonly align 4 [[P]]) #[[ATTR10]]
; TUNIT-NEXT: br label [[IF_END]] ; TUNIT-NEXT: br label [[IF_END]]
; TUNIT: if.end: ; TUNIT: if.end:
; TUNIT-NEXT: [[TOBOOL1:%.*]] = icmp eq i32 [[C2]], 0 ; TUNIT-NEXT: [[TOBOOL1:%.*]] = icmp eq i32 [[C2]], 0
; TUNIT-NEXT: br i1 [[TOBOOL1]], label [[IF_THEN2:%.*]], label [[IF_END3:%.*]] ; TUNIT-NEXT: br i1 [[TOBOOL1]], label [[IF_THEN2:%.*]], label [[IF_END3:%.*]]
; TUNIT: if.then2: ; TUNIT: if.then2:
; TUNIT-NEXT: tail call void @only_store(ptr nocapture nofree writeonly align 4 [[P]]) #[[ATTR10]] ; TUNIT-NEXT: tail call void @only_store(ptr nocapture nofree writeonly align 4 [[P]]) #[[ATTR10]]
; TUNIT-NEXT: br label [[IF_END3]] ; TUNIT-NEXT: br label [[IF_END3]]
; TUNIT: if.end3: ; TUNIT: if.end3:
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@test16_sub ; CGSCC-LABEL: define {{[^@]+}}@test16_sub
; CGSCC-SAME: (ptr noalias nofree writeonly [[P:%.*]], i32 [[C1:%.*]], i32 [[C2:%.*]]) #[[ATTR10]] { ; CGSCC-SAME: (ptr noalias nofree writeonly [[P:%.*]], i32 [[C1:%.*]], i32 [[C2:%.*]]) #[[ATTR10]] {
; CGSCC-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[C1]], 0 ; CGSCC-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[C1]], 0
; CGSCC-NEXT: br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]] ; CGSCC-NEXT: br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
; CGSCC: if.then: ; CGSCC: if.then:
; CGSCC-NEXT: tail call void @only_store(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P]]) #[[ATTR14:[0-9]+]] ; CGSCC-NEXT: tail call void @only_store(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P]]) #[[ATTR14:[0-9]+]]
; CGSCC-NEXT: tail call void @make_alias(ptr nofree nonnull writeonly align 4 dereferenceable(4) [[P]]) #[[ATTR13]] ; CGSCC-NEXT: tail call void @make_alias(ptr nofree nonnull writeonly align 4 dereferenceable(4) [[P]]) #[[ATTR13]]
; CGSCC-NEXT: br label [[IF_END]] ; CGSCC-NEXT: br label [[IF_END]]
Show All 22 Linesif.then2:
tail call void @only_store(ptr %p) tail call void @only_store(ptr %p)
br label %if.end3 br label %if.end3
if.end3: if.end3:
ret void ret void
} }
define void @test16_caller(ptr %p, i32 %c) { define void @test16_caller(ptr %p, i32 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@test16_caller ; TUNIT-LABEL: define {{[^@]+}}@test16_caller
; TUNIT-SAME: (ptr nofree writeonly [[P:%.*]], i32 [[C:%.*]]) #[[ATTR7]] { ; TUNIT-SAME: (ptr nofree writeonly [[P:%.*]], i32 [[C:%.*]]) #[[ATTR7]] {
; TUNIT-NEXT: tail call void @test16_sub(ptr noalias nofree writeonly [[P]], i32 [[C]], i32 [[C]]) #[[ATTR10]] ; TUNIT-NEXT: tail call void @test16_sub(ptr noalias nofree writeonly [[P]], i32 [[C]], i32 [[C]]) #[[ATTR10]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@test16_caller ; CGSCC-LABEL: define {{[^@]+}}@test16_caller
; CGSCC-SAME: (ptr nofree writeonly [[P:%.*]], i32 [[C:%.*]]) #[[ATTR10]] { ; CGSCC-SAME: (ptr nofree writeonly [[P:%.*]], i32 [[C:%.*]]) #[[ATTR10]] {
; CGSCC-NEXT: tail call void @test16_sub(ptr noalias nofree writeonly [[P]], i32 [[C]], i32 [[C]]) #[[ATTR13]] ; CGSCC-NEXT: tail call void @test16_sub(ptr noalias nofree writeonly [[P]], i32 [[C]], i32 [[C]]) #[[ATTR13]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
tail call void @test16_sub(ptr %p, i32 %c, i32 %c) tail call void @test16_sub(ptr %p, i32 %c, i32 %c)
ret void ret void
} }
Show All 13 Lines
; } ; }
; l2: ; l2:
; only_store(p); ; only_store(p);
; l3: ; l3:
; return; ; return;
; } ; }
define void @test17_caller(ptr noalias %p, i32 %c) { define void @test17_caller(ptr noalias %p, i32 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@test17_caller ; TUNIT-LABEL: define {{[^@]+}}@test17_caller
; TUNIT-SAME: (ptr noalias nofree writeonly [[P:%.*]], i32 [[C:%.*]]) #[[ATTR7]] { ; TUNIT-SAME: (ptr noalias nofree writeonly [[P:%.*]], i32 [[C:%.*]]) #[[ATTR7]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[C]], 0 ; TUNIT-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[C]], 0
; TUNIT-NEXT: br i1 [[TOBOOL]], label [[L1:%.*]], label [[L2:%.*]] ; TUNIT-NEXT: br i1 [[TOBOOL]], label [[L1:%.*]], label [[L2:%.*]]
; TUNIT: l1: ; TUNIT: l1:
; TUNIT-NEXT: tail call void @make_alias(ptr nofree writeonly [[P]]) #[[ATTR10]] ; TUNIT-NEXT: tail call void @make_alias(ptr nofree writeonly [[P]]) #[[ATTR10]]
; TUNIT-NEXT: br label [[L3:%.*]] ; TUNIT-NEXT: br label [[L3:%.*]]
; TUNIT: l2: ; TUNIT: l2:
; TUNIT-NEXT: tail call void @only_store(ptr noalias nocapture nofree writeonly align 4 [[P]]) #[[ATTR10]] ; TUNIT-NEXT: tail call void @only_store(ptr noalias nocapture nofree writeonly align 4 [[P]]) #[[ATTR10]]
; TUNIT-NEXT: br label [[L3]] ; TUNIT-NEXT: br label [[L3]]
; TUNIT: l3: ; TUNIT: l3:
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@test17_caller ; CGSCC-LABEL: define {{[^@]+}}@test17_caller
; CGSCC-SAME: (ptr noalias nofree writeonly [[P:%.*]], i32 [[C:%.*]]) #[[ATTR10]] { ; CGSCC-SAME: (ptr noalias nofree writeonly [[P:%.*]], i32 [[C:%.*]]) #[[ATTR10]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[C]], 0 ; CGSCC-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[C]], 0
; CGSCC-NEXT: br i1 [[TOBOOL]], label [[L1:%.*]], label [[L2:%.*]] ; CGSCC-NEXT: br i1 [[TOBOOL]], label [[L1:%.*]], label [[L2:%.*]]
; CGSCC: l1: ; CGSCC: l1:
; CGSCC-NEXT: tail call void @make_alias(ptr nofree writeonly [[P]]) #[[ATTR13]] ; CGSCC-NEXT: tail call void @make_alias(ptr nofree writeonly [[P]]) #[[ATTR13]]
; CGSCC-NEXT: br label [[L3:%.*]] ; CGSCC-NEXT: br label [[L3:%.*]]
Show All 26 Lines
; make_alias(p); ; make_alias(p);
; noreturn(); ; noreturn();
; } ; }
; only_store(p); ; only_store(p);
; return; ; return;
; } ; }
define void @noreturn() { define void @noreturn() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@noreturn ; TUNIT-LABEL: define {{[^@]+}}@noreturn
; TUNIT-SAME: () #[[ATTR9:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR9:[0-9]+]] {
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@noreturn ; CGSCC-LABEL: define {{[^@]+}}@noreturn
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @noreturn() call void @noreturn()
ret void ret void
} }
define void @test18_caller(ptr noalias %p, i32 %c) { define void @test18_caller(ptr noalias %p, i32 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@test18_caller ; TUNIT-LABEL: define {{[^@]+}}@test18_caller
; TUNIT-SAME: (ptr noalias nofree writeonly [[P:%.*]], i32 [[C:%.*]]) #[[ATTR7]] { ; TUNIT-SAME: (ptr noalias nofree writeonly [[P:%.*]], i32 [[C:%.*]]) #[[ATTR7]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[C]], 0 ; TUNIT-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[C]], 0
; TUNIT-NEXT: br i1 [[TOBOOL]], label [[L1:%.*]], label [[L2:%.*]] ; TUNIT-NEXT: br i1 [[TOBOOL]], label [[L1:%.*]], label [[L2:%.*]]
; TUNIT: l1: ; TUNIT: l1:
; TUNIT-NEXT: tail call void @make_alias(ptr nofree writeonly [[P]]) #[[ATTR10]] ; TUNIT-NEXT: tail call void @make_alias(ptr nofree writeonly [[P]]) #[[ATTR10]]
; TUNIT-NEXT: br label [[L2]] ; TUNIT-NEXT: br label [[L2]]
; TUNIT: l2: ; TUNIT: l2:
; TUNIT-NEXT: tail call void @only_store(ptr nocapture nofree writeonly align 4 [[P]]) #[[ATTR10]] ; TUNIT-NEXT: tail call void @only_store(ptr nocapture nofree writeonly align 4 [[P]]) #[[ATTR10]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@test18_caller ; CGSCC-LABEL: define {{[^@]+}}@test18_caller
; CGSCC-SAME: (ptr noalias nofree nonnull writeonly align 4 dereferenceable(4) [[P:%.*]], i32 [[C:%.*]]) #[[ATTR10]] { ; CGSCC-SAME: (ptr noalias nofree nonnull writeonly align 4 dereferenceable(4) [[P:%.*]], i32 [[C:%.*]]) #[[ATTR10]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[C]], 0 ; CGSCC-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[C]], 0
; CGSCC-NEXT: br i1 [[TOBOOL]], label [[L1:%.*]], label [[L2:%.*]] ; CGSCC-NEXT: br i1 [[TOBOOL]], label [[L1:%.*]], label [[L2:%.*]]
; CGSCC: l1: ; CGSCC: l1:
; CGSCC-NEXT: tail call void @make_alias(ptr nofree nonnull writeonly align 4 dereferenceable(4) [[P]]) #[[ATTR13]] ; CGSCC-NEXT: tail call void @make_alias(ptr nofree nonnull writeonly align 4 dereferenceable(4) [[P]]) #[[ATTR13]]
; CGSCC-NEXT: br label [[L2]] ; CGSCC-NEXT: br label [[L2]]
Show All 10 Linesl1:
tail call void @noreturn() tail call void @noreturn()
br label %l2 br label %l2
l2: l2:
tail call void @only_store(ptr %p) tail call void @only_store(ptr %p)
ret void ret void
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1]] = { nounwind uwtable } ; TUNIT: attributes #[[ATTR1]] = { nounwind uwtable }
; TUNIT: attributes #[[ATTR2]] = { nounwind } ; TUNIT: attributes #[[ATTR2]] = { nounwind }
; TUNIT: attributes #[[ATTR3]] = { nounwind ssp uwtable } ; TUNIT: attributes #[[ATTR3]] = { nounwind ssp uwtable }
; TUNIT: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind willreturn memory(read) } ; TUNIT: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(read) }
; TUNIT: attributes #[[ATTR5]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; TUNIT: attributes #[[ATTR5]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; TUNIT: attributes #[[ATTR6:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR6:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR7]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; TUNIT: attributes #[[ATTR7]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; TUNIT: attributes #[[ATTR8]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR8]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR9]] = { nofree nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR9]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR10]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR10]] = { nofree nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR11]] = { willreturn memory(readwrite) } ; TUNIT: attributes #[[ATTR11]] = { willreturn memory(readwrite) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nounwind uwtable } ; CGSCC: attributes #[[ATTR1]] = { nounwind uwtable }
; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR3]] = { nounwind } ; CGSCC: attributes #[[ATTR3]] = { nounwind }
; CGSCC: attributes #[[ATTR4]] = { nounwind ssp uwtable } ; CGSCC: attributes #[[ATTR4]] = { nounwind ssp uwtable }
; CGSCC: attributes #[[ATTR5]] = { nofree nosync nounwind willreturn memory(read) } ; CGSCC: attributes #[[ATTR5]] = { mustprogress nofree nosync nounwind willreturn memory(read) }
; CGSCC: attributes #[[ATTR6]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR6]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR7:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR7:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR8]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR8]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR9]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR9]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR10]] = { nofree nosync nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR10]] = { mustprogress nofree nosync nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR11]] = { willreturn } ; CGSCC: attributes #[[ATTR11]] = { willreturn }
; CGSCC: attributes #[[ATTR12]] = { willreturn memory(readwrite) } ; CGSCC: attributes #[[ATTR12]] = { willreturn memory(readwrite) }
; CGSCC: attributes #[[ATTR13]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR13]] = { nounwind willreturn }
; CGSCC: attributes #[[ATTR14]] = { nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR14]] = { nounwind willreturn memory(write) }
;. ;.

llvm/test/Transforms/Attributor/nocapture-1.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=3 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=3 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
@g = global ptr null ; <ptr> [#uses=1] @g = global ptr null ; <ptr> [#uses=1]
;. ;.
; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = global ptr null ; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = global ptr null
; CHECK: @[[LOOKUP_TABLE:[a-zA-Z0-9_$"\\.-]+]] = global [2 x i1] [i1 false, i1 true] ; CHECK: @[[LOOKUP_TABLE:[a-zA-Z0-9_$"\\.-]+]] = global [2 x i1] [i1 false, i1 true]
; CHECK: @[[G2:[a-zA-Z0-9_$"\\.-]+]] = global ptr null ; CHECK: @[[G2:[a-zA-Z0-9_$"\\.-]+]] = global ptr null
; CHECK: @[[G3:[a-zA-Z0-9_$"\\.-]+]] = global ptr null ; CHECK: @[[G3:[a-zA-Z0-9_$"\\.-]+]] = global ptr null
;. ;.
define ptr @c1(ptr %q) { define ptr @c1(ptr %q) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@c1 ; CHECK-LABEL: define {{[^@]+}}@c1
; CHECK-SAME: (ptr nofree readnone returned "no-capture-maybe-returned" [[Q:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr nofree readnone returned "no-capture-maybe-returned" [[Q:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: ret ptr [[Q]] ; CHECK-NEXT: ret ptr [[Q]]
; ;
ret ptr %q ret ptr %q
} }
; It would also be acceptable to mark %q as readnone. Update @c3 too. ; It would also be acceptable to mark %q as readnone. Update @c3 too.
define void @c2(ptr %q) { define void @c2(ptr %q) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CHECK-LABEL: define {{[^@]+}}@c2 ; CHECK-LABEL: define {{[^@]+}}@c2
; CHECK-SAME: (ptr nofree writeonly [[Q:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (ptr nofree writeonly [[Q:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: store ptr [[Q]], ptr @g, align 8 ; CHECK-NEXT: store ptr [[Q]], ptr @g, align 8
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store ptr %q, ptr @g store ptr %q, ptr @g
ret void ret void
} }
define void @c3(ptr %q) { define void @c3(ptr %q) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@c3 ; TUNIT-LABEL: define {{[^@]+}}@c3
; TUNIT-SAME: (ptr nofree writeonly [[Q:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (ptr nofree writeonly [[Q:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: call void @c2(ptr nofree writeonly [[Q]]) #[[ATTR14:[0-9]+]] ; TUNIT-NEXT: call void @c2(ptr nofree writeonly [[Q]]) #[[ATTR14:[0-9]+]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@c3 ; CGSCC-LABEL: define {{[^@]+}}@c3
; CGSCC-SAME: (ptr nofree writeonly [[Q:%.*]]) #[[ATTR2:[0-9]+]] { ; CGSCC-SAME: (ptr nofree writeonly [[Q:%.*]]) #[[ATTR2:[0-9]+]] {
; CGSCC-NEXT: call void @c2(ptr nofree writeonly [[Q]]) #[[ATTR14:[0-9]+]] ; CGSCC-NEXT: call void @c2(ptr nofree writeonly [[Q]]) #[[ATTR17:[0-9]+]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @c2(ptr %q) call void @c2(ptr %q)
ret void ret void
} }
define i1 @c4(ptr %q, i32 %bitno) { define i1 @c4(ptr %q, i32 %bitno) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@c4 ; CHECK-LABEL: define {{[^@]+}}@c4
; CHECK-SAME: (ptr nofree readnone [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nofree readnone [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32 ; CHECK-NEXT: [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32
; CHECK-NEXT: [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]] ; CHECK-NEXT: [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]]
; CHECK-NEXT: [[BIT:%.*]] = trunc i32 [[TMP2]] to i1 ; CHECK-NEXT: [[BIT:%.*]] = trunc i32 [[TMP2]] to i1
; CHECK-NEXT: br i1 [[BIT]], label [[L1:%.*]], label [[L0:%.*]] ; CHECK-NEXT: br i1 [[BIT]], label [[L1:%.*]], label [[L0:%.*]]
; CHECK: l0: ; CHECK: l0:
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; CHECK: l1: ; CHECK: l1:
; CHECK-NEXT: ret i1 true ; CHECK-NEXT: ret i1 true
; ;
%tmp = ptrtoint ptr %q to i32 %tmp = ptrtoint ptr %q to i32
%tmp2 = lshr i32 %tmp, %bitno %tmp2 = lshr i32 %tmp, %bitno
%bit = trunc i32 %tmp2 to i1 %bit = trunc i32 %tmp2 to i1
br i1 %bit, label %l1, label %l0 br i1 %bit, label %l1, label %l0
l0: l0:
ret i1 0 ; escaping value not caught by def-use chaining. ret i1 0 ; escaping value not caught by def-use chaining.
l1: l1:
ret i1 1 ; escaping value not caught by def-use chaining. ret i1 1 ; escaping value not caught by def-use chaining.
} }
; c4b is c4 but without the escaping part ; c4b is c4 but without the escaping part
define i1 @c4b(ptr %q, i32 %bitno) { define i1 @c4b(ptr %q, i32 %bitno) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@c4b ; CHECK-LABEL: define {{[^@]+}}@c4b
; CHECK-SAME: (ptr nocapture nofree readnone [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nocapture nofree readnone [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32 ; CHECK-NEXT: [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32
; CHECK-NEXT: [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]] ; CHECK-NEXT: [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]]
; CHECK-NEXT: [[BIT:%.*]] = trunc i32 [[TMP2]] to i1 ; CHECK-NEXT: [[BIT:%.*]] = trunc i32 [[TMP2]] to i1
; CHECK-NEXT: br i1 [[BIT]], label [[L1:%.*]], label [[L0:%.*]] ; CHECK-NEXT: br i1 [[BIT]], label [[L1:%.*]], label [[L0:%.*]]
; CHECK: l0: ; CHECK: l0:
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; CHECK: l1: ; CHECK: l1:
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; ;
%tmp = ptrtoint ptr %q to i32 %tmp = ptrtoint ptr %q to i32
%tmp2 = lshr i32 %tmp, %bitno %tmp2 = lshr i32 %tmp, %bitno
%bit = trunc i32 %tmp2 to i1 %bit = trunc i32 %tmp2 to i1
br i1 %bit, label %l1, label %l0 br i1 %bit, label %l1, label %l0
l0: l0:
ret i1 0 ; not escaping! ret i1 0 ; not escaping!
l1: l1:
ret i1 0 ; not escaping! ret i1 0 ; not escaping!
} }
@lookup_table = global [2 x i1] [ i1 0, i1 1 ] @lookup_table = global [2 x i1] [ i1 0, i1 1 ]
define i1 @c5(ptr %q, i32 %bitno) { define i1 @c5(ptr %q, i32 %bitno) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
; TUNIT-LABEL: define {{[^@]+}}@c5 ; TUNIT-LABEL: define {{[^@]+}}@c5
; TUNIT-SAME: (ptr nofree readonly [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR2:[0-9]+]] { ; TUNIT-SAME: (ptr nofree readonly [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR2:[0-9]+]] {
; TUNIT-NEXT: [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32 ; TUNIT-NEXT: [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32
; TUNIT-NEXT: [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]] ; TUNIT-NEXT: [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]]
; TUNIT-NEXT: [[BIT:%.*]] = and i32 [[TMP2]], 1 ; TUNIT-NEXT: [[BIT:%.*]] = and i32 [[TMP2]], 1
; TUNIT-NEXT: [[LOOKUP:%.*]] = getelementptr [2 x i1], ptr @lookup_table, i32 0, i32 [[BIT]] ; TUNIT-NEXT: [[LOOKUP:%.*]] = getelementptr [2 x i1], ptr @lookup_table, i32 0, i32 [[BIT]]
; TUNIT-NEXT: [[VAL:%.*]] = load i1, ptr [[LOOKUP]], align 1 ; TUNIT-NEXT: [[VAL:%.*]] = load i1, ptr [[LOOKUP]], align 1
; TUNIT-NEXT: ret i1 [[VAL]] ; TUNIT-NEXT: ret i1 [[VAL]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
; CGSCC-LABEL: define {{[^@]+}}@c5 ; CGSCC-LABEL: define {{[^@]+}}@c5
; CGSCC-SAME: (ptr nofree readonly [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR3:[0-9]+]] { ; CGSCC-SAME: (ptr nofree readonly [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR3:[0-9]+]] {
; CGSCC-NEXT: [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32 ; CGSCC-NEXT: [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32
; CGSCC-NEXT: [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]] ; CGSCC-NEXT: [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]]
; CGSCC-NEXT: [[BIT:%.*]] = and i32 [[TMP2]], 1 ; CGSCC-NEXT: [[BIT:%.*]] = and i32 [[TMP2]], 1
; CGSCC-NEXT: [[LOOKUP:%.*]] = getelementptr [2 x i1], ptr @lookup_table, i32 0, i32 [[BIT]] ; CGSCC-NEXT: [[LOOKUP:%.*]] = getelementptr [2 x i1], ptr @lookup_table, i32 0, i32 [[BIT]]
; CGSCC-NEXT: [[VAL:%.*]] = load i1, ptr [[LOOKUP]], align 1 ; CGSCC-NEXT: [[VAL:%.*]] = load i1, ptr [[LOOKUP]], align 1
; CGSCC-NEXT: ret i1 [[VAL]] ; CGSCC-NEXT: ret i1 [[VAL]]
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Linesret1:
%exn = landingpad {ptr, i32} %exn = landingpad {ptr, i32}
cleanup cleanup
ret i1 1 ret i1 1
} }
declare i32 @__gxx_personality_v0(...) declare i32 @__gxx_personality_v0(...)
define ptr @lookup_bit(ptr %q, i32 %bitno) readnone nounwind { define ptr @lookup_bit(ptr %q, i32 %bitno) readnone nounwind {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@lookup_bit ; CHECK-LABEL: define {{[^@]+}}@lookup_bit
; CHECK-SAME: (ptr nofree readnone [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nofree readnone [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32 ; CHECK-NEXT: [[TMP:%.*]] = ptrtoint ptr [[Q]] to i32
; CHECK-NEXT: [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]] ; CHECK-NEXT: [[TMP2:%.*]] = lshr i32 [[TMP]], [[BITNO]]
; CHECK-NEXT: [[BIT:%.*]] = and i32 [[TMP2]], 1 ; CHECK-NEXT: [[BIT:%.*]] = and i32 [[TMP2]], 1
; CHECK-NEXT: [[LOOKUP:%.*]] = getelementptr [2 x i1], ptr @lookup_table, i32 0, i32 [[BIT]] ; CHECK-NEXT: [[LOOKUP:%.*]] = getelementptr [2 x i1], ptr @lookup_table, i32 0, i32 [[BIT]]
; CHECK-NEXT: ret ptr [[LOOKUP]] ; CHECK-NEXT: ret ptr [[LOOKUP]]
; ;
%tmp = ptrtoint ptr %q to i32 %tmp = ptrtoint ptr %q to i32
%tmp2 = lshr i32 %tmp, %bitno %tmp2 = lshr i32 %tmp, %bitno
%bit = and i32 %tmp2, 1 %bit = and i32 %tmp2, 1
%lookup = getelementptr [2 x i1], ptr @lookup_table, i32 0, i32 %bit %lookup = getelementptr [2 x i1], ptr @lookup_table, i32 0, i32 %bit
ret ptr %lookup ret ptr %lookup
} }
define i1 @c7(ptr %q, i32 %bitno) { define i1 @c7(ptr %q, i32 %bitno) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
; TUNIT-LABEL: define {{[^@]+}}@c7 ; TUNIT-LABEL: define {{[^@]+}}@c7
; TUNIT-SAME: (ptr nofree readonly [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR2]] { ; TUNIT-SAME: (ptr nofree readonly [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR2]] {
; TUNIT-NEXT: [[PTR:%.*]] = call ptr @lookup_bit(ptr noalias nofree readnone [[Q]], i32 [[BITNO]]) #[[ATTR15:[0-9]+]] ; TUNIT-NEXT: [[PTR:%.*]] = call ptr @lookup_bit(ptr noalias nofree readnone [[Q]], i32 [[BITNO]]) #[[ATTR15:[0-9]+]]
; TUNIT-NEXT: [[VAL:%.*]] = load i1, ptr [[PTR]], align 1 ; TUNIT-NEXT: [[VAL:%.*]] = load i1, ptr [[PTR]], align 1
; TUNIT-NEXT: ret i1 [[VAL]] ; TUNIT-NEXT: ret i1 [[VAL]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(read) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(read)
; CGSCC-LABEL: define {{[^@]+}}@c7 ; CGSCC-LABEL: define {{[^@]+}}@c7
; CGSCC-SAME: (ptr nofree readonly [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR5:[0-9]+]] { ; CGSCC-SAME: (ptr nofree readonly [[Q:%.*]], i32 [[BITNO:%.*]]) #[[ATTR5:[0-9]+]] {
; CGSCC-NEXT: [[PTR:%.*]] = call ptr @lookup_bit(ptr noalias nofree readnone [[Q]], i32 [[BITNO]]) #[[ATTR17:[0-9]+]] ; CGSCC-NEXT: [[PTR:%.*]] = call ptr @lookup_bit(ptr noalias nofree readnone [[Q]], i32 [[BITNO]]) #[[ATTR18:[0-9]+]]
; CGSCC-NEXT: [[VAL:%.*]] = load i1, ptr [[PTR]], align 1 ; CGSCC-NEXT: [[VAL:%.*]] = load i1, ptr [[PTR]], align 1
; CGSCC-NEXT: ret i1 [[VAL]] ; CGSCC-NEXT: ret i1 [[VAL]]
; ;
%ptr = call ptr @lookup_bit(ptr %q, i32 %bitno) %ptr = call ptr @lookup_bit(ptr %q, i32 %bitno)
%val = load i1, ptr %ptr %val = load i1, ptr %ptr
ret i1 %val ret i1 %val
} }
define i32 @nc1(ptr %q, ptr %p, i1 %b) { define i32 @nc1(ptr %q, ptr %p, i1 %b) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@nc1 ; TUNIT-LABEL: define {{[^@]+}}@nc1
; TUNIT-SAME: (ptr nofree [[Q:%.*]], ptr nocapture nofree [[P:%.*]], i1 [[B:%.*]]) #[[ATTR4:[0-9]+]] { ; TUNIT-SAME: (ptr nofree [[Q:%.*]], ptr nocapture nofree [[P:%.*]], i1 [[B:%.*]]) #[[ATTR4:[0-9]+]] {
; TUNIT-NEXT: e: ; TUNIT-NEXT: e:
; TUNIT-NEXT: br label [[L:%.*]] ; TUNIT-NEXT: br label [[L:%.*]]
; TUNIT: l: ; TUNIT: l:
; TUNIT-NEXT: [[X:%.*]] = phi ptr [ [[P]], [[E:%.*]] ] ; TUNIT-NEXT: [[X:%.*]] = phi ptr [ [[P]], [[E:%.*]] ]
; TUNIT-NEXT: [[Y:%.*]] = phi ptr [ [[Q]], [[E]] ] ; TUNIT-NEXT: [[Y:%.*]] = phi ptr [ [[Q]], [[E]] ]
; TUNIT-NEXT: [[TMP2:%.*]] = select i1 [[B]], ptr [[P]], ptr [[Q]] ; TUNIT-NEXT: [[TMP2:%.*]] = select i1 [[B]], ptr [[P]], ptr [[Q]]
; TUNIT-NEXT: [[VAL:%.*]] = load i32, ptr [[TMP2]], align 4 ; TUNIT-NEXT: [[VAL:%.*]] = load i32, ptr [[TMP2]], align 4
; TUNIT-NEXT: store i32 0, ptr [[P]], align 4 ; TUNIT-NEXT: store i32 0, ptr [[P]], align 4
; TUNIT-NEXT: store ptr [[Q]], ptr @g, align 8 ; TUNIT-NEXT: store ptr [[Q]], ptr @g, align 8
; TUNIT-NEXT: ret i32 [[VAL]] ; TUNIT-NEXT: ret i32 [[VAL]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@nc1 ; CGSCC-LABEL: define {{[^@]+}}@nc1
; CGSCC-SAME: (ptr nofree [[Q:%.*]], ptr nocapture nofree [[P:%.*]], i1 [[B:%.*]]) #[[ATTR6:[0-9]+]] { ; CGSCC-SAME: (ptr nofree [[Q:%.*]], ptr nocapture nofree [[P:%.*]], i1 [[B:%.*]]) #[[ATTR6:[0-9]+]] {
; CGSCC-NEXT: e: ; CGSCC-NEXT: e:
; CGSCC-NEXT: br label [[L:%.*]] ; CGSCC-NEXT: br label [[L:%.*]]
; CGSCC: l: ; CGSCC: l:
; CGSCC-NEXT: [[X:%.*]] = phi ptr [ [[P]], [[E:%.*]] ] ; CGSCC-NEXT: [[X:%.*]] = phi ptr [ [[P]], [[E:%.*]] ]
; CGSCC-NEXT: [[Y:%.*]] = phi ptr [ [[Q]], [[E]] ] ; CGSCC-NEXT: [[Y:%.*]] = phi ptr [ [[Q]], [[E]] ]
; CGSCC-NEXT: [[TMP2:%.*]] = select i1 [[B]], ptr [[P]], ptr [[Q]] ; CGSCC-NEXT: [[TMP2:%.*]] = select i1 [[B]], ptr [[P]], ptr [[Q]]
Show All 10 Linesl:
%tmp2 = select i1 %b, ptr %x, ptr %y %tmp2 = select i1 %b, ptr %x, ptr %y
%val = load i32, ptr %tmp2 ; <i32> [#uses=1] %val = load i32, ptr %tmp2 ; <i32> [#uses=1]
store i32 0, ptr %x store i32 0, ptr %x
store ptr %y, ptr @g store ptr %y, ptr @g
ret i32 %val ret i32 %val
} }
define i32 @nc1_addrspace(ptr %q, ptr addrspace(1) %p, i1 %b) { define i32 @nc1_addrspace(ptr %q, ptr addrspace(1) %p, i1 %b) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@nc1_addrspace ; TUNIT-LABEL: define {{[^@]+}}@nc1_addrspace
; TUNIT-SAME: (ptr nofree [[Q:%.*]], ptr addrspace(1) nocapture nofree [[P:%.*]], i1 [[B:%.*]]) #[[ATTR4]] { ; TUNIT-SAME: (ptr nofree [[Q:%.*]], ptr addrspace(1) nocapture nofree [[P:%.*]], i1 [[B:%.*]]) #[[ATTR4]] {
; TUNIT-NEXT: e: ; TUNIT-NEXT: e:
; TUNIT-NEXT: br label [[L:%.*]] ; TUNIT-NEXT: br label [[L:%.*]]
; TUNIT: l: ; TUNIT: l:
; TUNIT-NEXT: [[X:%.*]] = phi ptr addrspace(1) [ [[P]], [[E:%.*]] ] ; TUNIT-NEXT: [[X:%.*]] = phi ptr addrspace(1) [ [[P]], [[E:%.*]] ]
; TUNIT-NEXT: [[Y:%.*]] = phi ptr [ [[Q]], [[E]] ] ; TUNIT-NEXT: [[Y:%.*]] = phi ptr [ [[Q]], [[E]] ]
; TUNIT-NEXT: [[TMP:%.*]] = addrspacecast ptr addrspace(1) [[P]] to ptr ; TUNIT-NEXT: [[TMP:%.*]] = addrspacecast ptr addrspace(1) [[P]] to ptr
; TUNIT-NEXT: [[TMP2:%.*]] = select i1 [[B]], ptr [[TMP]], ptr [[Q]] ; TUNIT-NEXT: [[TMP2:%.*]] = select i1 [[B]], ptr [[TMP]], ptr [[Q]]
; TUNIT-NEXT: [[VAL:%.*]] = load i32, ptr [[TMP2]], align 4 ; TUNIT-NEXT: [[VAL:%.*]] = load i32, ptr [[TMP2]], align 4
; TUNIT-NEXT: store i32 0, ptr [[TMP]], align 4 ; TUNIT-NEXT: store i32 0, ptr [[TMP]], align 4
; TUNIT-NEXT: store ptr [[Q]], ptr @g, align 8 ; TUNIT-NEXT: store ptr [[Q]], ptr @g, align 8
; TUNIT-NEXT: ret i32 [[VAL]] ; TUNIT-NEXT: ret i32 [[VAL]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@nc1_addrspace ; CGSCC-LABEL: define {{[^@]+}}@nc1_addrspace
; CGSCC-SAME: (ptr nofree [[Q:%.*]], ptr addrspace(1) nocapture nofree [[P:%.*]], i1 [[B:%.*]]) #[[ATTR6]] { ; CGSCC-SAME: (ptr nofree [[Q:%.*]], ptr addrspace(1) nocapture nofree [[P:%.*]], i1 [[B:%.*]]) #[[ATTR6]] {
; CGSCC-NEXT: e: ; CGSCC-NEXT: e:
; CGSCC-NEXT: br label [[L:%.*]] ; CGSCC-NEXT: br label [[L:%.*]]
; CGSCC: l: ; CGSCC: l:
; CGSCC-NEXT: [[X:%.*]] = phi ptr addrspace(1) [ [[P]], [[E:%.*]] ] ; CGSCC-NEXT: [[X:%.*]] = phi ptr addrspace(1) [ [[P]], [[E:%.*]] ]
; CGSCC-NEXT: [[Y:%.*]] = phi ptr [ [[Q]], [[E]] ] ; CGSCC-NEXT: [[Y:%.*]] = phi ptr [ [[Q]], [[E]] ]
; CGSCC-NEXT: [[TMP:%.*]] = addrspacecast ptr addrspace(1) [[P]] to ptr ; CGSCC-NEXT: [[TMP:%.*]] = addrspacecast ptr addrspace(1) [[P]] to ptr
Show All 12 Linesl:
%tmp2 = select i1 %b, ptr %tmp, ptr %y %tmp2 = select i1 %b, ptr %tmp, ptr %y
%val = load i32, ptr %tmp2 ; <i32> [#uses=1] %val = load i32, ptr %tmp2 ; <i32> [#uses=1]
store i32 0, ptr %tmp store i32 0, ptr %tmp
store ptr %y, ptr @g store ptr %y, ptr @g
ret i32 %val ret i32 %val
} }
define void @nc2(ptr %p, ptr %q) { define void @nc2(ptr %p, ptr %q) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@nc2 ; TUNIT-LABEL: define {{[^@]+}}@nc2
; TUNIT-SAME: (ptr nocapture nofree [[P:%.*]], ptr nofree [[Q:%.*]]) #[[ATTR4]] { ; TUNIT-SAME: (ptr nocapture nofree [[P:%.*]], ptr nofree [[Q:%.*]]) #[[ATTR4]] {
; TUNIT-NEXT: [[TMP1:%.*]] = call i32 @nc1(ptr nofree [[Q]], ptr nocapture nofree [[P]], i1 noundef false) #[[ATTR14]] ; TUNIT-NEXT: [[TMP1:%.*]] = call i32 @nc1(ptr nofree [[Q]], ptr nocapture nofree [[P]], i1 noundef false) #[[ATTR14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@nc2 ; CGSCC-LABEL: define {{[^@]+}}@nc2
; CGSCC-SAME: (ptr nocapture nofree align 4 [[P:%.*]], ptr nofree [[Q:%.*]]) #[[ATTR7:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree align 4 [[P:%.*]], ptr nofree [[Q:%.*]]) #[[ATTR7:[0-9]+]] {
; CGSCC-NEXT: [[TMP1:%.*]] = call i32 @nc1(ptr nofree [[Q]], ptr nocapture nofree align 4 [[P]], i1 noundef false) #[[ATTR14]] ; CGSCC-NEXT: [[TMP1:%.*]] = call i32 @nc1(ptr nofree [[Q]], ptr nocapture nofree align 4 [[P]], i1 noundef false) #[[ATTR17]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%1 = call i32 @nc1(ptr %q, ptr %p, i1 0) ; <i32> [#uses=0] %1 = call i32 @nc1(ptr %q, ptr %p, i1 0) ; <i32> [#uses=0]
ret void ret void
} }
define void @nc3(ptr %p) { define void @nc3(ptr %p) {
Show All 14 Lines
; TUNIT-LABEL: define {{[^@]+}}@nc4 ; TUNIT-LABEL: define {{[^@]+}}@nc4
; TUNIT-SAME: (ptr [[P:%.*]]) #[[ATTR5:[0-9]+]] { ; TUNIT-SAME: (ptr [[P:%.*]]) #[[ATTR5:[0-9]+]] {
; TUNIT-NEXT: call void @external(ptr readonly [[P]]) #[[ATTR16:[0-9]+]] ; TUNIT-NEXT: call void @external(ptr readonly [[P]]) #[[ATTR16:[0-9]+]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nounwind memory(argmem: readwrite) ; CGSCC: Function Attrs: nounwind memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@nc4 ; CGSCC-LABEL: define {{[^@]+}}@nc4
; CGSCC-SAME: (ptr [[P:%.*]]) #[[ATTR8:[0-9]+]] { ; CGSCC-SAME: (ptr [[P:%.*]]) #[[ATTR8:[0-9]+]] {
; CGSCC-NEXT: call void @external(ptr readonly [[P]]) #[[ATTR18:[0-9]+]] ; CGSCC-NEXT: call void @external(ptr readonly [[P]]) #[[ATTR19:[0-9]+]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @external(ptr %p) call void @external(ptr %p)
ret void ret void
} }
define void @nc5(ptr %f, ptr %p) { define void @nc5(ptr %f, ptr %p) {
; CHECK-LABEL: define {{[^@]+}}@nc5 ; CHECK-LABEL: define {{[^@]+}}@nc5
Show All 13 Lines
; TUNIT-SAME: (ptr nocapture nofree readnone [[X1_1:%.*]], ptr nocapture nofree readnone [[Y1_1:%.*]], i1 [[C:%.*]]) #[[ATTR6:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree readnone [[X1_1:%.*]], ptr nocapture nofree readnone [[Y1_1:%.*]], i1 [[C:%.*]]) #[[ATTR6:[0-9]+]] {
; TUNIT-NEXT: [[TMP1:%.*]] = call ptr @test1_2(ptr noalias nocapture nofree readnone undef, ptr noalias nofree readnone "no-capture-maybe-returned" [[Y1_1]], i1 [[C]]) #[[ATTR17:[0-9]+]] ; TUNIT-NEXT: [[TMP1:%.*]] = call ptr @test1_2(ptr noalias nocapture nofree readnone undef, ptr noalias nofree readnone "no-capture-maybe-returned" [[Y1_1]], i1 [[C]]) #[[ATTR17:[0-9]+]]
; TUNIT-NEXT: store ptr null, ptr @g, align 8 ; TUNIT-NEXT: store ptr null, ptr @g, align 8
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind memory(write) ; CGSCC: Function Attrs: nofree nosync nounwind memory(write)
; CGSCC-LABEL: define {{[^@]+}}@test1_1 ; CGSCC-LABEL: define {{[^@]+}}@test1_1
; CGSCC-SAME: (ptr nocapture nofree readnone [[X1_1:%.*]], ptr nocapture nofree readnone [[Y1_1:%.*]], i1 [[C:%.*]]) #[[ATTR9:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree readnone [[X1_1:%.*]], ptr nocapture nofree readnone [[Y1_1:%.*]], i1 [[C:%.*]]) #[[ATTR9:[0-9]+]] {
; CGSCC-NEXT: [[TMP1:%.*]] = call ptr @test1_2(ptr noalias nocapture nofree readnone undef, ptr noalias nofree readnone "no-capture-maybe-returned" [[Y1_1]], i1 [[C]]) #[[ATTR19:[0-9]+]] ; CGSCC-NEXT: [[TMP1:%.*]] = call ptr @test1_2(ptr noalias nocapture nofree readnone undef, ptr noalias nofree readnone "no-capture-maybe-returned" [[Y1_1]], i1 [[C]]) #[[ATTR20:[0-9]+]]
; CGSCC-NEXT: store ptr null, ptr @g, align 8 ; CGSCC-NEXT: store ptr null, ptr @g, align 8
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call ptr @test1_2(ptr %x1_1, ptr %y1_1, i1 %c) call ptr @test1_2(ptr %x1_1, ptr %y1_1, i1 %c)
store ptr null, ptr @g store ptr null, ptr @g
ret void ret void
} }
Show All 9 Lines
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: ret ptr [[Y1_2]] ; TUNIT-NEXT: ret ptr [[Y1_2]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind memory(write) ; CGSCC: Function Attrs: nofree nosync nounwind memory(write)
; CGSCC-LABEL: define {{[^@]+}}@test1_2 ; CGSCC-LABEL: define {{[^@]+}}@test1_2
; CGSCC-SAME: (ptr nocapture nofree readnone [[X1_2:%.*]], ptr nofree readnone returned "no-capture-maybe-returned" [[Y1_2:%.*]], i1 noundef [[C:%.*]]) #[[ATTR9]] { ; CGSCC-SAME: (ptr nocapture nofree readnone [[X1_2:%.*]], ptr nofree readnone returned "no-capture-maybe-returned" [[Y1_2:%.*]], i1 noundef [[C:%.*]]) #[[ATTR9]] {
; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: call void @test1_1(ptr noalias nocapture nofree readnone undef, ptr noalias nocapture nofree readnone [[Y1_2]], i1 noundef [[C]]) #[[ATTR19]] ; CGSCC-NEXT: call void @test1_1(ptr noalias nocapture nofree readnone undef, ptr noalias nocapture nofree readnone [[Y1_2]], i1 noundef [[C]]) #[[ATTR20]]
; CGSCC-NEXT: store ptr null, ptr @g, align 8 ; CGSCC-NEXT: store ptr null, ptr @g, align 8
; CGSCC-NEXT: br label [[F]] ; CGSCC-NEXT: br label [[F]]
; CGSCC: f: ; CGSCC: f:
; CGSCC-NEXT: ret ptr [[Y1_2]] ; CGSCC-NEXT: ret ptr [[Y1_2]]
; ;
br i1 %c, label %t, label %f br i1 %c, label %t, label %f
t: t:
call void @test1_1(ptr %x1_2, ptr %y1_2, i1 %c) call void @test1_1(ptr %x1_2, ptr %y1_2, i1 %c)
Show All 9 Lines
; TUNIT-SAME: (ptr nocapture nofree readnone [[X2:%.*]]) #[[ATTR6]] { ; TUNIT-SAME: (ptr nocapture nofree readnone [[X2:%.*]]) #[[ATTR6]] {
; TUNIT-NEXT: call void @test2(ptr noalias nocapture nofree readnone undef) #[[ATTR17]] ; TUNIT-NEXT: call void @test2(ptr noalias nocapture nofree readnone undef) #[[ATTR17]]
; TUNIT-NEXT: store ptr null, ptr @g, align 8 ; TUNIT-NEXT: store ptr null, ptr @g, align 8
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind memory(write) ; CGSCC: Function Attrs: nofree nosync nounwind memory(write)
; CGSCC-LABEL: define {{[^@]+}}@test2 ; CGSCC-LABEL: define {{[^@]+}}@test2
; CGSCC-SAME: (ptr nocapture nofree readnone [[X2:%.*]]) #[[ATTR9]] { ; CGSCC-SAME: (ptr nocapture nofree readnone [[X2:%.*]]) #[[ATTR9]] {
; CGSCC-NEXT: call void @test2(ptr noalias nocapture nofree readnone undef) #[[ATTR19]] ; CGSCC-NEXT: call void @test2(ptr noalias nocapture nofree readnone undef) #[[ATTR20]]
; CGSCC-NEXT: store ptr null, ptr @g, align 8 ; CGSCC-NEXT: store ptr null, ptr @g, align 8
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @test2(ptr %x2) call void @test2(ptr %x2)
store ptr null, ptr @g store ptr null, ptr @g
ret void ret void
} }
define void @test3(ptr %x3, ptr %y3, ptr %z3) { define void @test3(ptr %x3, ptr %y3, ptr %z3) {
; TUNIT: Function Attrs: nofree nosync nounwind memory(write) ; TUNIT: Function Attrs: nofree nosync nounwind memory(write)
; TUNIT-LABEL: define {{[^@]+}}@test3 ; TUNIT-LABEL: define {{[^@]+}}@test3
; TUNIT-SAME: (ptr nocapture nofree readnone [[X3:%.*]], ptr nocapture nofree readnone [[Y3:%.*]], ptr nocapture nofree readnone [[Z3:%.*]]) #[[ATTR6]] { ; TUNIT-SAME: (ptr nocapture nofree readnone [[X3:%.*]], ptr nocapture nofree readnone [[Y3:%.*]], ptr nocapture nofree readnone [[Z3:%.*]]) #[[ATTR6]] {
; TUNIT-NEXT: call void @test3(ptr noalias nocapture nofree readnone undef, ptr noalias nocapture nofree readnone undef, ptr noalias nocapture nofree readnone undef) #[[ATTR17]] ; TUNIT-NEXT: call void @test3(ptr noalias nocapture nofree readnone undef, ptr noalias nocapture nofree readnone undef, ptr noalias nocapture nofree readnone undef) #[[ATTR17]]
; TUNIT-NEXT: store ptr null, ptr @g, align 8 ; TUNIT-NEXT: store ptr null, ptr @g, align 8
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind memory(write) ; CGSCC: Function Attrs: nofree nosync nounwind memory(write)
; CGSCC-LABEL: define {{[^@]+}}@test3 ; CGSCC-LABEL: define {{[^@]+}}@test3
; CGSCC-SAME: (ptr nocapture nofree readnone [[X3:%.*]], ptr nocapture nofree readnone [[Y3:%.*]], ptr nocapture nofree readnone [[Z3:%.*]]) #[[ATTR9]] { ; CGSCC-SAME: (ptr nocapture nofree readnone [[X3:%.*]], ptr nocapture nofree readnone [[Y3:%.*]], ptr nocapture nofree readnone [[Z3:%.*]]) #[[ATTR9]] {
; CGSCC-NEXT: call void @test3(ptr noalias nocapture nofree readnone undef, ptr noalias nocapture nofree readnone undef, ptr noalias nocapture nofree readnone undef) #[[ATTR19]] ; CGSCC-NEXT: call void @test3(ptr noalias nocapture nofree readnone undef, ptr noalias nocapture nofree readnone undef, ptr noalias nocapture nofree readnone undef) #[[ATTR20]]
; CGSCC-NEXT: store ptr null, ptr @g, align 8 ; CGSCC-NEXT: store ptr null, ptr @g, align 8
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @test3(ptr %z3, ptr %y3, ptr %x3) call void @test3(ptr %z3, ptr %y3, ptr %x3)
store ptr null, ptr @g store ptr null, ptr @g
ret void ret void
} }
define void @test4_1(ptr %x4_1, i1 %c) { define void @test4_1(ptr %x4_1, i1 %c) {
; TUNIT: Function Attrs: nofree nosync nounwind memory(write) ; TUNIT: Function Attrs: nofree nosync nounwind memory(write)
; TUNIT-LABEL: define {{[^@]+}}@test4_1 ; TUNIT-LABEL: define {{[^@]+}}@test4_1
; TUNIT-SAME: (ptr nocapture nofree readnone [[X4_1:%.*]], i1 [[C:%.*]]) #[[ATTR6]] { ; TUNIT-SAME: (ptr nocapture nofree readnone [[X4_1:%.*]], i1 [[C:%.*]]) #[[ATTR6]] {
; TUNIT-NEXT: [[TMP1:%.*]] = call ptr @test4_2(ptr noalias nocapture nofree readnone undef, ptr noalias nofree readnone "no-capture-maybe-returned" [[X4_1]], ptr noalias nocapture nofree readnone undef, i1 [[C]]) #[[ATTR17]] ; TUNIT-NEXT: [[TMP1:%.*]] = call ptr @test4_2(ptr noalias nocapture nofree readnone undef, ptr noalias nofree readnone "no-capture-maybe-returned" [[X4_1]], ptr noalias nocapture nofree readnone undef, i1 [[C]]) #[[ATTR17]]
; TUNIT-NEXT: store ptr null, ptr @g, align 8 ; TUNIT-NEXT: store ptr null, ptr @g, align 8
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind memory(write) ; CGSCC: Function Attrs: nofree nosync nounwind memory(write)
; CGSCC-LABEL: define {{[^@]+}}@test4_1 ; CGSCC-LABEL: define {{[^@]+}}@test4_1
; CGSCC-SAME: (ptr nocapture nofree readnone [[X4_1:%.*]], i1 [[C:%.*]]) #[[ATTR9]] { ; CGSCC-SAME: (ptr nocapture nofree readnone [[X4_1:%.*]], i1 [[C:%.*]]) #[[ATTR9]] {
; CGSCC-NEXT: [[TMP1:%.*]] = call ptr @test4_2(ptr noalias nocapture nofree readnone undef, ptr noalias nofree readnone "no-capture-maybe-returned" [[X4_1]], ptr noalias nocapture nofree readnone undef, i1 [[C]]) #[[ATTR19]] ; CGSCC-NEXT: [[TMP1:%.*]] = call ptr @test4_2(ptr noalias nocapture nofree readnone undef, ptr noalias nofree readnone "no-capture-maybe-returned" [[X4_1]], ptr noalias nocapture nofree readnone undef, i1 [[C]]) #[[ATTR20]]
; CGSCC-NEXT: store ptr null, ptr @g, align 8 ; CGSCC-NEXT: store ptr null, ptr @g, align 8
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call ptr @test4_2(ptr %x4_1, ptr %x4_1, ptr %x4_1, i1 %c) call ptr @test4_2(ptr %x4_1, ptr %x4_1, ptr %x4_1, i1 %c)
store ptr null, ptr @g store ptr null, ptr @g
ret void ret void
} }
Show All 9 Lines
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: ret ptr [[Y4_2]] ; TUNIT-NEXT: ret ptr [[Y4_2]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind memory(write) ; CGSCC: Function Attrs: nofree nosync nounwind memory(write)
; CGSCC-LABEL: define {{[^@]+}}@test4_2 ; CGSCC-LABEL: define {{[^@]+}}@test4_2
; CGSCC-SAME: (ptr nocapture nofree readnone [[X4_2:%.*]], ptr nofree readnone returned "no-capture-maybe-returned" [[Y4_2:%.*]], ptr nocapture nofree readnone [[Z4_2:%.*]], i1 noundef [[C:%.*]]) #[[ATTR9]] { ; CGSCC-SAME: (ptr nocapture nofree readnone [[X4_2:%.*]], ptr nofree readnone returned "no-capture-maybe-returned" [[Y4_2:%.*]], ptr nocapture nofree readnone [[Z4_2:%.*]], i1 noundef [[C:%.*]]) #[[ATTR9]] {
; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: call void @test4_1(ptr noalias nocapture nofree noundef readnone align 4294967296 null, i1 noundef [[C]]) #[[ATTR19]] ; CGSCC-NEXT: call void @test4_1(ptr noalias nocapture nofree noundef readnone align 4294967296 null, i1 noundef [[C]]) #[[ATTR20]]
; CGSCC-NEXT: store ptr null, ptr @g, align 8 ; CGSCC-NEXT: store ptr null, ptr @g, align 8
; CGSCC-NEXT: br label [[F]] ; CGSCC-NEXT: br label [[F]]
; CGSCC: f: ; CGSCC: f:
; CGSCC-NEXT: ret ptr [[Y4_2]] ; CGSCC-NEXT: ret ptr [[Y4_2]]
; ;
br i1 %c, label %t, label %f br i1 %c, label %t, label %f
t: t:
call void @test4_1(ptr null, i1 %c) call void @test4_1(ptr null, i1 %c)
Show All 27 Lines
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void (ptr, ptr, ...) @test6_1(ptr %x6_2, ptr %y6_2, ptr %z6_2) call void (ptr, ptr, ...) @test6_1(ptr %x6_2, ptr %y6_2, ptr %z6_2)
store ptr null, ptr @g store ptr null, ptr @g
ret void ret void
} }
define void @test_cmpxchg(ptr %p) { define void @test_cmpxchg(ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@test_cmpxchg ; TUNIT-LABEL: define {{[^@]+}}@test_cmpxchg
; TUNIT-SAME: (ptr nocapture nofree noundef nonnull dereferenceable(4) [[P:%.*]]) #[[ATTR7:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree noundef nonnull dereferenceable(4) [[P:%.*]]) #[[ATTR7:[0-9]+]] {
; TUNIT-NEXT: [[TMP1:%.*]] = cmpxchg ptr [[P]], i32 0, i32 1 acquire monotonic, align 4 ; TUNIT-NEXT: [[TMP1:%.*]] = cmpxchg ptr [[P]], i32 0, i32 1 acquire monotonic, align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@test_cmpxchg ; CGSCC-LABEL: define {{[^@]+}}@test_cmpxchg
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull dereferenceable(4) [[P:%.*]]) #[[ATTR10:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull dereferenceable(4) [[P:%.*]]) #[[ATTR10:[0-9]+]] {
; CGSCC-NEXT: [[TMP1:%.*]] = cmpxchg ptr [[P]], i32 0, i32 1 acquire monotonic, align 4 ; CGSCC-NEXT: [[TMP1:%.*]] = cmpxchg ptr [[P]], i32 0, i32 1 acquire monotonic, align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
cmpxchg ptr %p, i32 0, i32 1 acquire monotonic cmpxchg ptr %p, i32 0, i32 1 acquire monotonic
ret void ret void
} }
define void @test_cmpxchg_ptr(ptr %p, ptr %q) { define void @test_cmpxchg_ptr(ptr %p, ptr %q) {
; TUNIT: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@test_cmpxchg_ptr ; TUNIT-LABEL: define {{[^@]+}}@test_cmpxchg_ptr
; TUNIT-SAME: (ptr nocapture nofree noundef nonnull dereferenceable(8) [[P:%.*]], ptr nofree [[Q:%.*]]) #[[ATTR7]] { ; TUNIT-SAME: (ptr nocapture nofree noundef nonnull dereferenceable(8) [[P:%.*]], ptr nofree [[Q:%.*]]) #[[ATTR7]] {
; TUNIT-NEXT: [[TMP1:%.*]] = cmpxchg ptr [[P]], ptr null, ptr [[Q]] acquire monotonic, align 8 ; TUNIT-NEXT: [[TMP1:%.*]] = cmpxchg ptr [[P]], ptr null, ptr [[Q]] acquire monotonic, align 8
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@test_cmpxchg_ptr ; CGSCC-LABEL: define {{[^@]+}}@test_cmpxchg_ptr
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull dereferenceable(8) [[P:%.*]], ptr nofree [[Q:%.*]]) #[[ATTR10]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull dereferenceable(8) [[P:%.*]], ptr nofree [[Q:%.*]]) #[[ATTR10]] {
; CGSCC-NEXT: [[TMP1:%.*]] = cmpxchg ptr [[P]], ptr null, ptr [[Q]] acquire monotonic, align 8 ; CGSCC-NEXT: [[TMP1:%.*]] = cmpxchg ptr [[P]], ptr null, ptr [[Q]] acquire monotonic, align 8
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
cmpxchg ptr %p, ptr null, ptr %q acquire monotonic cmpxchg ptr %p, ptr null, ptr %q acquire monotonic
ret void ret void
} }
define void @test_atomicrmw(ptr %p) { define void @test_atomicrmw(ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@test_atomicrmw ; TUNIT-LABEL: define {{[^@]+}}@test_atomicrmw
; TUNIT-SAME: (ptr nocapture nofree noundef nonnull dereferenceable(4) [[P:%.*]]) #[[ATTR7]] { ; TUNIT-SAME: (ptr nocapture nofree noundef nonnull dereferenceable(4) [[P:%.*]]) #[[ATTR7]] {
; TUNIT-NEXT: [[TMP1:%.*]] = atomicrmw add ptr [[P]], i32 1 seq_cst, align 4 ; TUNIT-NEXT: [[TMP1:%.*]] = atomicrmw add ptr [[P]], i32 1 seq_cst, align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@test_atomicrmw ; CGSCC-LABEL: define {{[^@]+}}@test_atomicrmw
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull dereferenceable(4) [[P:%.*]]) #[[ATTR10]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull dereferenceable(4) [[P:%.*]]) #[[ATTR10]] {
; CGSCC-NEXT: [[TMP1:%.*]] = atomicrmw add ptr [[P]], i32 1 seq_cst, align 4 ; CGSCC-NEXT: [[TMP1:%.*]] = atomicrmw add ptr [[P]], i32 1 seq_cst, align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
atomicrmw add ptr %p, i32 1 seq_cst atomicrmw add ptr %p, i32 1 seq_cst
ret void ret void
} }
define void @test_volatile(ptr %x) { define void @test_volatile(ptr %x) {
; TUNIT: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@test_volatile ; TUNIT-LABEL: define {{[^@]+}}@test_volatile
; TUNIT-SAME: (ptr nofree align 4 [[X:%.*]]) #[[ATTR7]] { ; TUNIT-SAME: (ptr nofree align 4 [[X:%.*]]) #[[ATTR7]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[GEP:%.*]] = getelementptr i32, ptr [[X]], i64 1 ; TUNIT-NEXT: [[GEP:%.*]] = getelementptr i32, ptr [[X]], i64 1
; TUNIT-NEXT: store volatile i32 0, ptr [[GEP]], align 4 ; TUNIT-NEXT: store volatile i32 0, ptr [[GEP]], align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@test_volatile ; CGSCC-LABEL: define {{[^@]+}}@test_volatile
; CGSCC-SAME: (ptr nofree align 4 [[X:%.*]]) #[[ATTR10]] { ; CGSCC-SAME: (ptr nofree align 4 [[X:%.*]]) #[[ATTR10]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[GEP:%.*]] = getelementptr i32, ptr [[X]], i64 1 ; CGSCC-NEXT: [[GEP:%.*]] = getelementptr i32, ptr [[X]], i64 1
; CGSCC-NEXT: store volatile i32 0, ptr [[GEP]], align 4 ; CGSCC-NEXT: store volatile i32 0, ptr [[GEP]], align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
entry: entry:
%gep = getelementptr i32, ptr %x, i64 1 %gep = getelementptr i32, ptr %x, i64 1
store volatile i32 0, ptr %gep, align 4 store volatile i32 0, ptr %gep, align 4
ret void ret void
} }
define void @nocaptureLaunder(ptr %p) { define void @nocaptureLaunder(ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@nocaptureLaunder ; TUNIT-LABEL: define {{[^@]+}}@nocaptureLaunder
; TUNIT-SAME: (ptr nocapture nofree [[P:%.*]]) #[[ATTR4]] { ; TUNIT-SAME: (ptr nocapture nofree [[P:%.*]]) #[[ATTR4]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[B:%.*]] = call ptr @llvm.launder.invariant.group.p0(ptr nofree [[P]]) #[[ATTR18:[0-9]+]] ; TUNIT-NEXT: [[B:%.*]] = call ptr @llvm.launder.invariant.group.p0(ptr nofree [[P]]) #[[ATTR18:[0-9]+]]
; TUNIT-NEXT: store i8 42, ptr [[B]], align 1 ; TUNIT-NEXT: store i8 42, ptr [[B]], align 1
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@nocaptureLaunder ; CGSCC-LABEL: define {{[^@]+}}@nocaptureLaunder
; CGSCC-SAME: (ptr nocapture nofree [[P:%.*]]) #[[ATTR6]] { ; CGSCC-SAME: (ptr nocapture nofree [[P:%.*]]) #[[ATTR6]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[B:%.*]] = call ptr @llvm.launder.invariant.group.p0(ptr nofree [[P]]) #[[ATTR17]] ; CGSCC-NEXT: [[B:%.*]] = call ptr @llvm.launder.invariant.group.p0(ptr nofree [[P]]) #[[ATTR18]]
; CGSCC-NEXT: store i8 42, ptr [[B]], align 1 ; CGSCC-NEXT: store i8 42, ptr [[B]], align 1
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
entry: entry:
%b = call ptr @llvm.launder.invariant.group.p0(ptr %p) %b = call ptr @llvm.launder.invariant.group.p0(ptr %p)
store i8 42, ptr %b store i8 42, ptr %b
ret void ret void
} }
@g2 = global ptr null @g2 = global ptr null
define void @captureLaunder(ptr %p) { define void @captureLaunder(ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@captureLaunder ; TUNIT-LABEL: define {{[^@]+}}@captureLaunder
; TUNIT-SAME: (ptr nofree [[P:%.*]]) #[[ATTR4]] { ; TUNIT-SAME: (ptr nofree [[P:%.*]]) #[[ATTR4]] {
; TUNIT-NEXT: [[B:%.*]] = call ptr @llvm.launder.invariant.group.p0(ptr nofree [[P]]) #[[ATTR18]] ; TUNIT-NEXT: [[B:%.*]] = call ptr @llvm.launder.invariant.group.p0(ptr nofree [[P]]) #[[ATTR18]]
; TUNIT-NEXT: store ptr [[B]], ptr @g2, align 8 ; TUNIT-NEXT: store ptr [[B]], ptr @g2, align 8
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@captureLaunder ; CGSCC-LABEL: define {{[^@]+}}@captureLaunder
; CGSCC-SAME: (ptr nofree [[P:%.*]]) #[[ATTR6]] { ; CGSCC-SAME: (ptr nofree [[P:%.*]]) #[[ATTR6]] {
; CGSCC-NEXT: [[B:%.*]] = call ptr @llvm.launder.invariant.group.p0(ptr nofree [[P]]) #[[ATTR17]] ; CGSCC-NEXT: [[B:%.*]] = call ptr @llvm.launder.invariant.group.p0(ptr nofree [[P]]) #[[ATTR18]]
; CGSCC-NEXT: store ptr [[B]], ptr @g2, align 8 ; CGSCC-NEXT: store ptr [[B]], ptr @g2, align 8
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%b = call ptr @llvm.launder.invariant.group.p0(ptr %p) %b = call ptr @llvm.launder.invariant.group.p0(ptr %p)
store ptr %b, ptr @g2 store ptr %b, ptr @g2
ret void ret void
} }
define void @nocaptureStrip(ptr %p) { define void @nocaptureStrip(ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@nocaptureStrip ; CHECK-LABEL: define {{[^@]+}}@nocaptureStrip
; TUNIT-SAME: (ptr nocapture nofree writeonly [[P:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ptr nocapture nofree writeonly [[P:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: entry: ; CHECK-NEXT: entry:
; TUNIT-NEXT: [[B:%.*]] = call ptr @llvm.strip.invariant.group.p0(ptr noalias nofree readnone [[P]]) #[[ATTR18]] ; CHECK-NEXT: [[B:%.*]] = call ptr @llvm.strip.invariant.group.p0(ptr noalias nofree readnone [[P]]) #[[ATTR18:[0-9]+]]
; TUNIT-NEXT: store i8 42, ptr [[B]], align 1 ; CHECK-NEXT: store i8 42, ptr [[B]], align 1
; TUNIT-NEXT: ret void ; CHECK-NEXT: ret void
;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@nocaptureStrip
; CGSCC-SAME: (ptr nocapture nofree writeonly [[P:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[B:%.*]] = call ptr @llvm.strip.invariant.group.p0(ptr noalias nofree readnone [[P]]) #[[ATTR17]]
; CGSCC-NEXT: store i8 42, ptr [[B]], align 1
; CGSCC-NEXT: ret void
; ;
entry: entry:
%b = call ptr @llvm.strip.invariant.group.p0(ptr %p) %b = call ptr @llvm.strip.invariant.group.p0(ptr %p)
store i8 42, ptr %b store i8 42, ptr %b
ret void ret void
} }
@g3 = global ptr null @g3 = global ptr null
define void @captureStrip(ptr %p) { define void @captureStrip(ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@captureStrip ; CHECK-LABEL: define {{[^@]+}}@captureStrip
; TUNIT-SAME: (ptr nofree writeonly [[P:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ptr nofree writeonly [[P:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: [[B:%.*]] = call ptr @llvm.strip.invariant.group.p0(ptr noalias nofree readnone [[P]]) #[[ATTR18]] ; CHECK-NEXT: [[B:%.*]] = call ptr @llvm.strip.invariant.group.p0(ptr noalias nofree readnone [[P]]) #[[ATTR18]]
; TUNIT-NEXT: store ptr [[B]], ptr @g3, align 8 ; CHECK-NEXT: store ptr [[B]], ptr @g3, align 8
; TUNIT-NEXT: ret void ; CHECK-NEXT: ret void
;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@captureStrip
; CGSCC-SAME: (ptr nofree writeonly [[P:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: [[B:%.*]] = call ptr @llvm.strip.invariant.group.p0(ptr noalias nofree readnone [[P]]) #[[ATTR17]]
; CGSCC-NEXT: store ptr [[B]], ptr @g3, align 8
; CGSCC-NEXT: ret void
; ;
%b = call ptr @llvm.strip.invariant.group.p0(ptr %p) %b = call ptr @llvm.strip.invariant.group.p0(ptr %p)
store ptr %b, ptr @g3 store ptr %b, ptr @g3
ret void ret void
} }
define i1 @captureICmp(ptr %x) { define i1 @captureICmp(ptr %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@captureICmp ; CHECK-LABEL: define {{[^@]+}}@captureICmp
; CHECK-SAME: (ptr nofree readnone [[X:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nofree readnone [[X:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[TMP1:%.*]] = icmp eq ptr [[X]], null ; CHECK-NEXT: [[TMP1:%.*]] = icmp eq ptr [[X]], null
; CHECK-NEXT: ret i1 [[TMP1]] ; CHECK-NEXT: ret i1 [[TMP1]]
; ;
%1 = icmp eq ptr %x, null %1 = icmp eq ptr %x, null
ret i1 %1 ret i1 %1
} }
define i1 @captureICmpRev(ptr %x) { define i1 @captureICmpRev(ptr %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@captureICmpRev ; CHECK-LABEL: define {{[^@]+}}@captureICmpRev
; CHECK-SAME: (ptr nofree readnone [[X:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nofree readnone [[X:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[TMP1:%.*]] = icmp eq ptr null, [[X]] ; CHECK-NEXT: [[TMP1:%.*]] = icmp eq ptr null, [[X]]
; CHECK-NEXT: ret i1 [[TMP1]] ; CHECK-NEXT: ret i1 [[TMP1]]
; ;
%1 = icmp eq ptr null, %x %1 = icmp eq ptr null, %x
ret i1 %1 ret i1 %1
} }
define i1 @nocaptureInboundsGEPICmp(ptr %x) { define i1 @nocaptureInboundsGEPICmp(ptr %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@nocaptureInboundsGEPICmp ; CHECK-LABEL: define {{[^@]+}}@nocaptureInboundsGEPICmp
; CHECK-SAME: (ptr nocapture nofree readnone [[X:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nocapture nofree readnone [[X:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; ;
%1 = getelementptr inbounds i32, ptr %x, i32 5 %1 = getelementptr inbounds i32, ptr %x, i32 5
%2 = icmp eq ptr %1, null %2 = icmp eq ptr %1, null
ret i1 %2 ret i1 %2
} }
define i1 @nocaptureInboundsGEPICmpRev(ptr %x) { define i1 @nocaptureInboundsGEPICmpRev(ptr %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@nocaptureInboundsGEPICmpRev ; CHECK-LABEL: define {{[^@]+}}@nocaptureInboundsGEPICmpRev
; CHECK-SAME: (ptr nocapture nofree readnone [[X:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nocapture nofree readnone [[X:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: ret i1 true ; CHECK-NEXT: ret i1 true
; ;
%1 = getelementptr inbounds i32, ptr %x, i32 5 %1 = getelementptr inbounds i32, ptr %x, i32 5
%2 = icmp ne ptr null, %1 %2 = icmp ne ptr null, %1
ret i1 %2 ret i1 %2
} }
define i1 @nocaptureDereferenceableOrNullICmp(ptr dereferenceable_or_null(4) %x) { define i1 @nocaptureDereferenceableOrNullICmp(ptr dereferenceable_or_null(4) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@nocaptureDereferenceableOrNullICmp ; CHECK-LABEL: define {{[^@]+}}@nocaptureDereferenceableOrNullICmp
; CHECK-SAME: (ptr nocapture nofree noundef readnone dereferenceable_or_null(4) [[X:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nocapture nofree noundef readnone dereferenceable_or_null(4) [[X:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[TMP1:%.*]] = icmp eq ptr [[X]], null ; CHECK-NEXT: [[TMP1:%.*]] = icmp eq ptr [[X]], null
; CHECK-NEXT: ret i1 [[TMP1]] ; CHECK-NEXT: ret i1 [[TMP1]]
; ;
%1 = icmp eq ptr %x, null %1 = icmp eq ptr %x, null
ret i1 %1 ret i1 %1
} }
define i1 @captureDereferenceableOrNullICmp(ptr dereferenceable_or_null(4) %x) null_pointer_is_valid { define i1 @captureDereferenceableOrNullICmp(ptr dereferenceable_or_null(4) %x) null_pointer_is_valid {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@captureDereferenceableOrNullICmp ; TUNIT-LABEL: define {{[^@]+}}@captureDereferenceableOrNullICmp
; TUNIT-SAME: (ptr nofree noundef readnone dereferenceable_or_null(4) [[X:%.*]]) #[[ATTR8:[0-9]+]] { ; TUNIT-SAME: (ptr nofree noundef readnone dereferenceable_or_null(4) [[X:%.*]]) #[[ATTR8:[0-9]+]] {
; TUNIT-NEXT: [[TMP1:%.*]] = icmp eq ptr [[X]], null ; TUNIT-NEXT: [[TMP1:%.*]] = icmp eq ptr [[X]], null
; TUNIT-NEXT: ret i1 [[TMP1]] ; TUNIT-NEXT: ret i1 [[TMP1]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@captureDereferenceableOrNullICmp ; CGSCC-LABEL: define {{[^@]+}}@captureDereferenceableOrNullICmp
; CGSCC-SAME: (ptr nofree noundef readnone dereferenceable_or_null(4) [[X:%.*]]) #[[ATTR11:[0-9]+]] { ; CGSCC-SAME: (ptr nofree noundef readnone dereferenceable_or_null(4) [[X:%.*]]) #[[ATTR11:[0-9]+]] {
; CGSCC-NEXT: [[TMP1:%.*]] = icmp eq ptr [[X]], null ; CGSCC-NEXT: [[TMP1:%.*]] = icmp eq ptr [[X]], null
; CGSCC-NEXT: ret i1 [[TMP1]] ; CGSCC-NEXT: ret i1 [[TMP1]]
; ;
%1 = icmp eq ptr %x, null %1 = icmp eq ptr %x, null
ret i1 %1 ret i1 %1
} }
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
} }
declare ptr @maybe_returned_ptr(ptr readonly %ptr) readonly nounwind willreturn declare ptr @maybe_returned_ptr(ptr readonly %ptr) readonly nounwind willreturn
declare i8 @maybe_returned_val(ptr %ptr) readonly nounwind willreturn declare i8 @maybe_returned_val(ptr %ptr) readonly nounwind willreturn
declare void @val_use(i8 %ptr) readonly nounwind willreturn declare void @val_use(i8 %ptr) readonly nounwind willreturn
; FIXME: Both pointers should be nocapture ; FIXME: Both pointers should be nocapture
define void @ptr_uses(ptr %ptr, ptr %wptr) { define void @ptr_uses(ptr %ptr, ptr %wptr) {
; TUNIT: Function Attrs: nounwind willreturn ; TUNIT: Function Attrs: mustprogress nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@ptr_uses ; TUNIT-LABEL: define {{[^@]+}}@ptr_uses
; TUNIT-SAME: (ptr [[PTR:%.*]], ptr nocapture nofree noundef nonnull writeonly dereferenceable(1) [[WPTR:%.*]]) #[[ATTR11:[0-9]+]] { ; TUNIT-SAME: (ptr [[PTR:%.*]], ptr nocapture nofree noundef nonnull writeonly dereferenceable(1) [[WPTR:%.*]]) #[[ATTR11:[0-9]+]] {
; TUNIT-NEXT: store i8 0, ptr [[WPTR]], align 1 ; TUNIT-NEXT: store i8 0, ptr [[WPTR]], align 1
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nounwind willreturn ; CGSCC: Function Attrs: mustprogress nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@ptr_uses ; CGSCC-LABEL: define {{[^@]+}}@ptr_uses
; CGSCC-SAME: (ptr [[PTR:%.*]], ptr nocapture nofree noundef nonnull writeonly dereferenceable(1) [[WPTR:%.*]]) #[[ATTR14]] { ; CGSCC-SAME: (ptr [[PTR:%.*]], ptr nocapture nofree noundef nonnull writeonly dereferenceable(1) [[WPTR:%.*]]) #[[ATTR14:[0-9]+]] {
; CGSCC-NEXT: store i8 0, ptr [[WPTR]], align 1 ; CGSCC-NEXT: store i8 0, ptr [[WPTR]], align 1
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%call_ptr = call ptr @maybe_returned_ptr(ptr %ptr) %call_ptr = call ptr @maybe_returned_ptr(ptr %ptr)
%call_val = call i8 @maybe_returned_val(ptr %call_ptr) %call_val = call i8 @maybe_returned_val(ptr %call_ptr)
call void @val_use(i8 %call_val) call void @val_use(i8 %call_val)
store i8 0, ptr %wptr store i8 0, ptr %wptr
ret void ret void
} }
declare ptr @llvm.launder.invariant.group.p0(ptr) declare ptr @llvm.launder.invariant.group.p0(ptr)
declare ptr @llvm.strip.invariant.group.p0(ptr) declare ptr @llvm.strip.invariant.group.p0(ptr)
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; TUNIT: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn memory(read) } ; TUNIT: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(read) }
; TUNIT: attributes #[[ATTR3]] = { memory(read) } ; TUNIT: attributes #[[ATTR3]] = { memory(read) }
; TUNIT: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR5]] = { nounwind memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR5]] = { nounwind memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR6]] = { nofree nosync nounwind memory(write) } ; TUNIT: attributes #[[ATTR6]] = { nofree nosync nounwind memory(write) }
; TUNIT: attributes #[[ATTR7]] = { nofree norecurse nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR7]] = { mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR8]] = { nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none) } ; TUNIT: attributes #[[ATTR8]] = { mustprogress nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none) }
; TUNIT: attributes #[[ATTR9]] = { nounwind memory(read) } ; TUNIT: attributes #[[ATTR9]] = { nounwind memory(read) }
; TUNIT: attributes #[[ATTR10:[0-9]+]] = { nounwind willreturn memory(read) } ; TUNIT: attributes #[[ATTR10:[0-9]+]] = { nounwind willreturn memory(read) }
; TUNIT: attributes #[[ATTR11]] = { nounwind willreturn } ; TUNIT: attributes #[[ATTR11]] = { mustprogress nounwind willreturn }
; TUNIT: attributes #[[ATTR12:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(inaccessiblemem: readwrite) } ; TUNIT: attributes #[[ATTR12:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(inaccessiblemem: readwrite) }
; TUNIT: attributes #[[ATTR13:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } ; TUNIT: attributes #[[ATTR13:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
; TUNIT: attributes #[[ATTR14]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR14]] = { nofree nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR15]] = { nofree nounwind willreturn } ; TUNIT: attributes #[[ATTR15]] = { nofree nounwind willreturn }
; TUNIT: attributes #[[ATTR16]] = { nounwind } ; TUNIT: attributes #[[ATTR16]] = { nounwind }
; TUNIT: attributes #[[ATTR17]] = { nofree nosync nounwind } ; TUNIT: attributes #[[ATTR17]] = { nofree nosync nounwind }
; TUNIT: attributes #[[ATTR18]] = { willreturn } ; TUNIT: attributes #[[ATTR18]] = { willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree nosync nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR3]] = { nofree norecurse nosync nounwind willreturn memory(read) } ; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(read) }
; CGSCC: attributes #[[ATTR4]] = { memory(read) } ; CGSCC: attributes #[[ATTR4]] = { memory(read) }
; CGSCC: attributes #[[ATTR5]] = { nofree nosync nounwind willreturn memory(read) } ; CGSCC: attributes #[[ATTR5]] = { mustprogress nofree nosync nounwind willreturn memory(read) }
; CGSCC: attributes #[[ATTR6]] = { nofree norecurse nosync nounwind willreturn } ; CGSCC: attributes #[[ATTR6]] = { mustprogress nofree norecurse nosync nounwind willreturn }
; CGSCC: attributes #[[ATTR7]] = { nofree nosync nounwind willreturn } ; CGSCC: attributes #[[ATTR7]] = { mustprogress nofree nosync nounwind willreturn }
; CGSCC: attributes #[[ATTR8]] = { nounwind memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR8]] = { nounwind memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR9]] = { nofree nosync nounwind memory(write) } ; CGSCC: attributes #[[ATTR9]] = { nofree nosync nounwind memory(write) }
; CGSCC: attributes #[[ATTR10]] = { nofree norecurse nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR10]] = { mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR11]] = { nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none) } ; CGSCC: attributes #[[ATTR11]] = { mustprogress nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none) }
; CGSCC: attributes #[[ATTR12]] = { nounwind memory(read) } ; CGSCC: attributes #[[ATTR12]] = { nounwind memory(read) }
; CGSCC: attributes #[[ATTR13:[0-9]+]] = { nounwind willreturn memory(read) } ; CGSCC: attributes #[[ATTR13:[0-9]+]] = { nounwind willreturn memory(read) }
; CGSCC: attributes #[[ATTR14]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR14]] = { mustprogress nounwind willreturn }
; CGSCC: attributes #[[ATTR15:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(inaccessiblemem: readwrite) } ; CGSCC: attributes #[[ATTR15:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(inaccessiblemem: readwrite) }
; CGSCC: attributes #[[ATTR16:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } ; CGSCC: attributes #[[ATTR16:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
; CGSCC: attributes #[[ATTR17]] = { willreturn } ; CGSCC: attributes #[[ATTR17]] = { nounwind willreturn }
; CGSCC: attributes #[[ATTR18]] = { nounwind } ; CGSCC: attributes #[[ATTR18]] = { willreturn }
; CGSCC: attributes #[[ATTR19]] = { nofree nosync nounwind } ; CGSCC: attributes #[[ATTR19]] = { nounwind }
; CGSCC: attributes #[[ATTR20]] = { nofree nosync nounwind }
;. ;.

llvm/test/Transforms/Attributor/nocapture-2.ll

Show All 10 Lines
; TEST comparison against NULL ; TEST comparison against NULL
; ;
; int is_null_return(int *p) { ; int is_null_return(int *p) {
; return p == 0; ; return p == 0;
; } ; }
; ;
; no-capture is missing on %p because it is not dereferenceable ; no-capture is missing on %p because it is not dereferenceable
define i32 @is_null_return(i32* %p) #0 { define i32 @is_null_return(i32* %p) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@is_null_return ; CHECK-LABEL: define {{[^@]+}}@is_null_return
; CHECK-SAME: (i32* nofree readnone [[P:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (i32* nofree readnone [[P:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32* [[P]], null ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32* [[P]], null
; CHECK-NEXT: [[CONV:%.*]] = zext i1 [[CMP]] to i32 ; CHECK-NEXT: [[CONV:%.*]] = zext i1 [[CMP]] to i32
; CHECK-NEXT: ret i32 [[CONV]] ; CHECK-NEXT: ret i32 [[CONV]]
; ;
entry: entry:
Show All 9 Lines
; return 1; ; return 1;
; if (0 == p) ; if (0 == p)
; return 1; ; return 1;
; return 0; ; return 0;
; } ; }
; ;
; no-capture is missing on %p because it is not dereferenceable ; no-capture is missing on %p because it is not dereferenceable
define i32 @is_null_control(i32* %p) #0 { define i32 @is_null_control(i32* %p) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@is_null_control ; CHECK-LABEL: define {{[^@]+}}@is_null_control
; CHECK-SAME: (i32* nofree [[P:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32* nofree [[P:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[RETVAL:%.*]] = alloca i32, align 4 ; CHECK-NEXT: [[RETVAL:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32* [[P]], null ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32* [[P]], null
; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then: ; CHECK: if.then:
; CHECK-NEXT: store i32 1, i32* [[RETVAL]], align 4 ; CHECK-NEXT: store i32 1, i32* [[RETVAL]], align 4
Show All 40 Lines
; TEST singleton SCC ; TEST singleton SCC
; ;
; double *srec0(double *a) { ; double *srec0(double *a) {
; srec0(a); ; srec0(a);
; return 0; ; return 0;
; } ; }
; ;
define double* @srec0(double* %a) #0 { define double* @srec0(double* %a) #0 {
; CHECK: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@srec0 ; CHECK-LABEL: define {{[^@]+}}@srec0
; CHECK-SAME: (double* nocapture nofree readnone [[A:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (double* nocapture nofree readnone [[A:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret double* null ; CHECK-NEXT: ret double* null
; ;
entry: entry:
%call = call double* @srec0(double* %a) %call = call double* @srec0(double* %a)
ret double* null ret double* null
} }
; TEST singleton SCC with lots of nested recursive calls ; TEST singleton SCC with lots of nested recursive calls
; ;
; int* srec16(int* a) { ; int* srec16(int* a) {
; return srec16(srec16(srec16(srec16( ; return srec16(srec16(srec16(srec16(
; srec16(srec16(srec16(srec16( ; srec16(srec16(srec16(srec16(
; srec16(srec16(srec16(srec16( ; srec16(srec16(srec16(srec16(
; srec16(srec16(srec16(srec16( ; srec16(srec16(srec16(srec16(
; a ; a
; )))))))))))))))); ; ))))))))))))))));
; } ; }
; ;
; Other arguments are possible here due to the no-return behavior. ; Other arguments are possible here due to the no-return behavior.
; ;
define i32* @srec16(i32* %a) #0 { define i32* @srec16(i32* %a) #0 {
; CHECK: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@srec16 ; CHECK-LABEL: define {{[^@]+}}@srec16
; CHECK-SAME: (i32* nocapture nofree readnone [[A:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (i32* nocapture nofree readnone [[A:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret i32* undef ; CHECK-NEXT: ret i32* undef
; ;
entry: entry:
%call = call i32* @srec16(i32* %a) %call = call i32* @srec16(i32* %a)
%call1 = call i32* @srec16(i32* %call) %call1 = call i32* @srec16(i32* %call)
▲ Show 20 Lines • Show All 287 Lines • ▼ Show 20 Lines
; ;
; long *not_captured_but_returned_0(long *a) { ; long *not_captured_but_returned_0(long *a) {
; *a1 = 0; ; *a1 = 0;
; return a; ; return a;
; } ; }
; ;
; There should *not* be a no-capture attribute on %a ; There should *not* be a no-capture attribute on %a
define i64* @not_captured_but_returned_0(i64* %a) #0 { define i64* @not_captured_but_returned_0(i64* %a) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable
; CHECK-LABEL: define {{[^@]+}}@not_captured_but_returned_0 ; CHECK-LABEL: define {{[^@]+}}@not_captured_but_returned_0
; CHECK-SAME: (i64* nofree noundef nonnull returned writeonly align 8 dereferenceable(8) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR4:[0-9]+]] { ; CHECK-SAME: (i64* nofree noundef nonnull returned writeonly align 8 dereferenceable(8) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR4:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: store i64 0, i64* [[A]], align 8 ; CHECK-NEXT: store i64 0, i64* [[A]], align 8
; CHECK-NEXT: ret i64* [[A]] ; CHECK-NEXT: ret i64* [[A]]
; ;
entry: entry:
store i64 0, i64* %a, align 8 store i64 0, i64* %a, align 8
ret i64* %a ret i64* %a
} }
; TEST "captured" only through return ; TEST "captured" only through return
; ;
; long *not_captured_but_returned_1(long *a) { ; long *not_captured_but_returned_1(long *a) {
; *(a+1) = 1; ; *(a+1) = 1;
; return a + 1; ; return a + 1;
; } ; }
; ;
; There should *not* be a no-capture attribute on %a ; There should *not* be a no-capture attribute on %a
define i64* @not_captured_but_returned_1(i64* %a) #0 { define i64* @not_captured_but_returned_1(i64* %a) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable
; CHECK-LABEL: define {{[^@]+}}@not_captured_but_returned_1 ; CHECK-LABEL: define {{[^@]+}}@not_captured_but_returned_1
; CHECK-SAME: (i64* nofree nonnull writeonly align 8 dereferenceable(16) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR4]] { ; CHECK-SAME: (i64* nofree nonnull writeonly align 8 dereferenceable(16) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i64, i64* [[A]], i64 1 ; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i64, i64* [[A]], i64 1
; CHECK-NEXT: store i64 1, i64* [[ADD_PTR]], align 8 ; CHECK-NEXT: store i64 1, i64* [[ADD_PTR]], align 8
; CHECK-NEXT: ret i64* [[ADD_PTR]] ; CHECK-NEXT: ret i64* [[ADD_PTR]]
; ;
entry: entry:
%add.ptr = getelementptr inbounds i64, i64* %a, i64 1 %add.ptr = getelementptr inbounds i64, i64* %a, i64 1
store i64 1, i64* %add.ptr, align 8 store i64 1, i64* %add.ptr, align 8
ret i64* %add.ptr ret i64* %add.ptr
} }
; TEST calls to "captured" only through return functions ; TEST calls to "captured" only through return functions
; ;
; void test_not_captured_but_returned_calls(long *a) { ; void test_not_captured_but_returned_calls(long *a) {
; not_captured_but_returned_0(a); ; not_captured_but_returned_0(a);
; not_captured_but_returned_1(a); ; not_captured_but_returned_1(a);
; } ; }
; ;
define void @test_not_captured_but_returned_calls(i64* %a) #0 { define void @test_not_captured_but_returned_calls(i64* %a) #0 {
; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable
; TUNIT-LABEL: define {{[^@]+}}@test_not_captured_but_returned_calls ; TUNIT-LABEL: define {{[^@]+}}@test_not_captured_but_returned_calls
; TUNIT-SAME: (i64* nocapture nofree writeonly align 8 [[A:%.*]]) #[[ATTR4]] { ; TUNIT-SAME: (i64* nocapture nofree writeonly align 8 [[A:%.*]]) #[[ATTR4]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[CALL:%.*]] = call i64* @not_captured_but_returned_0(i64* nofree writeonly align 8 "no-capture-maybe-returned" [[A]]) #[[ATTR10:[0-9]+]] ; TUNIT-NEXT: [[CALL:%.*]] = call i64* @not_captured_but_returned_0(i64* nofree writeonly align 8 "no-capture-maybe-returned" [[A]]) #[[ATTR10:[0-9]+]]
; TUNIT-NEXT: [[CALL1:%.*]] = call i64* @not_captured_but_returned_1(i64* nofree writeonly align 8 "no-capture-maybe-returned" [[A]]) #[[ATTR10]] ; TUNIT-NEXT: [[CALL1:%.*]] = call i64* @not_captured_but_returned_1(i64* nofree writeonly align 8 "no-capture-maybe-returned" [[A]]) #[[ATTR10]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree noinline nosync nounwind willreturn memory(argmem: write) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(argmem: write) uwtable
; CGSCC-LABEL: define {{[^@]+}}@test_not_captured_but_returned_calls ; CGSCC-LABEL: define {{[^@]+}}@test_not_captured_but_returned_calls
; CGSCC-SAME: (i64* nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A:%.*]]) #[[ATTR5:[0-9]+]] { ; CGSCC-SAME: (i64* nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A:%.*]]) #[[ATTR5:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CALL:%.*]] = call i64* @not_captured_but_returned_0(i64* nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A]]) #[[ATTR11:[0-9]+]] ; CGSCC-NEXT: [[CALL:%.*]] = call i64* @not_captured_but_returned_0(i64* nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A]]) #[[ATTR11:[0-9]+]]
; CGSCC-NEXT: [[CALL1:%.*]] = call i64* @not_captured_but_returned_1(i64* nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A]]) #[[ATTR11]] ; CGSCC-NEXT: [[CALL1:%.*]] = call i64* @not_captured_but_returned_1(i64* nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A]]) #[[ATTR11]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
entry: entry:
%call = call i64* @not_captured_but_returned_0(i64* %a) %call = call i64* @not_captured_but_returned_0(i64* %a)
%call1 = call i64* @not_captured_but_returned_1(i64* %a) %call1 = call i64* @not_captured_but_returned_1(i64* %a)
ret void ret void
} }
; TEST "captured" only through transitive return ; TEST "captured" only through transitive return
; ;
; long* negative_test_not_captured_but_returned_call_0a(long *a) { ; long* negative_test_not_captured_but_returned_call_0a(long *a) {
; return not_captured_but_returned_0(a); ; return not_captured_but_returned_0(a);
; } ; }
; ;
; There should *not* be a no-capture attribute on %a ; There should *not* be a no-capture attribute on %a
define i64* @negative_test_not_captured_but_returned_call_0a(i64* %a) #0 { define i64* @negative_test_not_captured_but_returned_call_0a(i64* %a) #0 {
; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable
; TUNIT-LABEL: define {{[^@]+}}@negative_test_not_captured_but_returned_call_0a ; TUNIT-LABEL: define {{[^@]+}}@negative_test_not_captured_but_returned_call_0a
; TUNIT-SAME: (i64* nofree returned writeonly align 8 "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR4]] { ; TUNIT-SAME: (i64* nofree returned writeonly align 8 "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR4]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[CALL:%.*]] = call i64* @not_captured_but_returned_0(i64* nofree writeonly align 8 "no-capture-maybe-returned" [[A]]) #[[ATTR10]] ; TUNIT-NEXT: [[CALL:%.*]] = call i64* @not_captured_but_returned_0(i64* nofree writeonly align 8 "no-capture-maybe-returned" [[A]]) #[[ATTR10]]
; TUNIT-NEXT: ret i64* [[A]] ; TUNIT-NEXT: ret i64* [[A]]
; ;
; CGSCC: Function Attrs: nofree noinline nosync nounwind willreturn memory(argmem: write) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(argmem: write) uwtable
; CGSCC-LABEL: define {{[^@]+}}@negative_test_not_captured_but_returned_call_0a ; CGSCC-LABEL: define {{[^@]+}}@negative_test_not_captured_but_returned_call_0a
; CGSCC-SAME: (i64* nofree noundef nonnull writeonly align 8 dereferenceable(8) [[A:%.*]]) #[[ATTR5]] { ; CGSCC-SAME: (i64* nofree noundef nonnull writeonly align 8 dereferenceable(8) [[A:%.*]]) #[[ATTR5]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CALL:%.*]] = call noundef nonnull align 8 dereferenceable(8) i64* @not_captured_but_returned_0(i64* nofree noundef nonnull writeonly align 8 dereferenceable(8) [[A]]) #[[ATTR11]] ; CGSCC-NEXT: [[CALL:%.*]] = call noundef nonnull align 8 dereferenceable(8) i64* @not_captured_but_returned_0(i64* nofree noundef nonnull writeonly align 8 dereferenceable(8) [[A]]) #[[ATTR11]]
; CGSCC-NEXT: ret i64* [[CALL]] ; CGSCC-NEXT: ret i64* [[CALL]]
; ;
entry: entry:
%call = call i64* @not_captured_but_returned_0(i64* %a) %call = call i64* @not_captured_but_returned_0(i64* %a)
ret i64* %call ret i64* %call
} }
; TEST captured through write ; TEST captured through write
; ;
; void negative_test_not_captured_but_returned_call_0b(long *a) { ; void negative_test_not_captured_but_returned_call_0b(long *a) {
; *a = (long)not_captured_but_returned_0(a); ; *a = (long)not_captured_but_returned_0(a);
; } ; }
; ;
; There should *not* be a no-capture attribute on %a ; There should *not* be a no-capture attribute on %a
define void @negative_test_not_captured_but_returned_call_0b(i64* %a) #0 { define void @negative_test_not_captured_but_returned_call_0b(i64* %a) #0 {
; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable
; TUNIT-LABEL: define {{[^@]+}}@negative_test_not_captured_but_returned_call_0b ; TUNIT-LABEL: define {{[^@]+}}@negative_test_not_captured_but_returned_call_0b
; TUNIT-SAME: (i64* nofree writeonly align 8 [[A:%.*]]) #[[ATTR4]] { ; TUNIT-SAME: (i64* nofree writeonly align 8 [[A:%.*]]) #[[ATTR4]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[CALL:%.*]] = call i64* @not_captured_but_returned_0(i64* nofree writeonly align 8 "no-capture-maybe-returned" [[A]]) #[[ATTR10]] ; TUNIT-NEXT: [[CALL:%.*]] = call i64* @not_captured_but_returned_0(i64* nofree writeonly align 8 "no-capture-maybe-returned" [[A]]) #[[ATTR10]]
; TUNIT-NEXT: [[TMP0:%.*]] = ptrtoint i64* [[A]] to i64 ; TUNIT-NEXT: [[TMP0:%.*]] = ptrtoint i64* [[A]] to i64
; TUNIT-NEXT: store i64 [[TMP0]], i64* [[A]], align 8 ; TUNIT-NEXT: store i64 [[TMP0]], i64* [[A]], align 8
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree noinline nosync nounwind willreturn memory(argmem: write) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(argmem: write) uwtable
; CGSCC-LABEL: define {{[^@]+}}@negative_test_not_captured_but_returned_call_0b ; CGSCC-LABEL: define {{[^@]+}}@negative_test_not_captured_but_returned_call_0b
; CGSCC-SAME: (i64* nofree noundef nonnull writeonly align 8 dereferenceable(8) [[A:%.*]]) #[[ATTR5]] { ; CGSCC-SAME: (i64* nofree noundef nonnull writeonly align 8 dereferenceable(8) [[A:%.*]]) #[[ATTR5]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CALL:%.*]] = call i64* @not_captured_but_returned_0(i64* nofree noundef nonnull writeonly align 8 dereferenceable(8) [[A]]) #[[ATTR11]] ; CGSCC-NEXT: [[CALL:%.*]] = call i64* @not_captured_but_returned_0(i64* nofree noundef nonnull writeonly align 8 dereferenceable(8) [[A]]) #[[ATTR11]]
; CGSCC-NEXT: [[TMP0:%.*]] = ptrtoint i64* [[CALL]] to i64 ; CGSCC-NEXT: [[TMP0:%.*]] = ptrtoint i64* [[CALL]] to i64
; CGSCC-NEXT: store i64 [[TMP0]], i64* [[A]], align 8 ; CGSCC-NEXT: store i64 [[TMP0]], i64* [[A]], align 8
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
entry: entry:
%call = call i64* @not_captured_but_returned_0(i64* %a) %call = call i64* @not_captured_but_returned_0(i64* %a)
%0 = ptrtoint i64* %call to i64 %0 = ptrtoint i64* %call to i64
store i64 %0, i64* %a, align 8 store i64 %0, i64* %a, align 8
ret void ret void
} }
; TEST "captured" only through transitive return ; TEST "captured" only through transitive return
; ;
; long* negative_test_not_captured_but_returned_call_1a(long *a) { ; long* negative_test_not_captured_but_returned_call_1a(long *a) {
; return not_captured_but_returned_1(a); ; return not_captured_but_returned_1(a);
; } ; }
; ;
; There should *not* be a no-capture attribute on %a ; There should *not* be a no-capture attribute on %a
define i64* @negative_test_not_captured_but_returned_call_1a(i64* %a) #0 { define i64* @negative_test_not_captured_but_returned_call_1a(i64* %a) #0 {
; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable
; TUNIT-LABEL: define {{[^@]+}}@negative_test_not_captured_but_returned_call_1a ; TUNIT-LABEL: define {{[^@]+}}@negative_test_not_captured_but_returned_call_1a
; TUNIT-SAME: (i64* nofree writeonly align 8 "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR4]] { ; TUNIT-SAME: (i64* nofree writeonly align 8 "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR4]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[CALL:%.*]] = call noundef nonnull align 8 dereferenceable(8) i64* @not_captured_but_returned_1(i64* nofree writeonly align 8 "no-capture-maybe-returned" [[A]]) #[[ATTR10]] ; TUNIT-NEXT: [[CALL:%.*]] = call noundef nonnull align 8 dereferenceable(8) i64* @not_captured_but_returned_1(i64* nofree writeonly align 8 "no-capture-maybe-returned" [[A]]) #[[ATTR10]]
; TUNIT-NEXT: ret i64* [[CALL]] ; TUNIT-NEXT: ret i64* [[CALL]]
; ;
; CGSCC: Function Attrs: nofree noinline nosync nounwind willreturn memory(argmem: write) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(argmem: write) uwtable
; CGSCC-LABEL: define {{[^@]+}}@negative_test_not_captured_but_returned_call_1a ; CGSCC-LABEL: define {{[^@]+}}@negative_test_not_captured_but_returned_call_1a
; CGSCC-SAME: (i64* nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A:%.*]]) #[[ATTR5]] { ; CGSCC-SAME: (i64* nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A:%.*]]) #[[ATTR5]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CALL:%.*]] = call noundef nonnull align 8 dereferenceable(8) i64* @not_captured_but_returned_1(i64* nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A]]) #[[ATTR11]] ; CGSCC-NEXT: [[CALL:%.*]] = call noundef nonnull align 8 dereferenceable(8) i64* @not_captured_but_returned_1(i64* nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A]]) #[[ATTR11]]
; CGSCC-NEXT: ret i64* [[CALL]] ; CGSCC-NEXT: ret i64* [[CALL]]
; ;
entry: entry:
%call = call i64* @not_captured_but_returned_1(i64* %a) %call = call i64* @not_captured_but_returned_1(i64* %a)
ret i64* %call ret i64* %call
} }
; TEST captured through write ; TEST captured through write
; ;
; void negative_test_not_captured_but_returned_call_1b(long *a) { ; void negative_test_not_captured_but_returned_call_1b(long *a) {
; *a = (long)not_captured_but_returned_1(a); ; *a = (long)not_captured_but_returned_1(a);
; } ; }
; ;
; There should *not* be a no-capture attribute on %a ; There should *not* be a no-capture attribute on %a
define void @negative_test_not_captured_but_returned_call_1b(i64* %a) #0 { define void @negative_test_not_captured_but_returned_call_1b(i64* %a) #0 {
; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(write) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(write) uwtable
; TUNIT-LABEL: define {{[^@]+}}@negative_test_not_captured_but_returned_call_1b ; TUNIT-LABEL: define {{[^@]+}}@negative_test_not_captured_but_returned_call_1b
; TUNIT-SAME: (i64* nofree writeonly align 8 [[A:%.*]]) #[[ATTR5:[0-9]+]] { ; TUNIT-SAME: (i64* nofree writeonly align 8 [[A:%.*]]) #[[ATTR5:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[CALL:%.*]] = call align 8 i64* @not_captured_but_returned_1(i64* nofree writeonly align 8 "no-capture-maybe-returned" [[A]]) #[[ATTR10]] ; TUNIT-NEXT: [[CALL:%.*]] = call align 8 i64* @not_captured_but_returned_1(i64* nofree writeonly align 8 "no-capture-maybe-returned" [[A]]) #[[ATTR10]]
; TUNIT-NEXT: [[TMP0:%.*]] = ptrtoint i64* [[CALL]] to i64 ; TUNIT-NEXT: [[TMP0:%.*]] = ptrtoint i64* [[CALL]] to i64
; TUNIT-NEXT: store i64 [[TMP0]], i64* [[CALL]], align 8 ; TUNIT-NEXT: store i64 [[TMP0]], i64* [[CALL]], align 8
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree noinline nosync nounwind willreturn memory(write) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(write) uwtable
; CGSCC-LABEL: define {{[^@]+}}@negative_test_not_captured_but_returned_call_1b ; CGSCC-LABEL: define {{[^@]+}}@negative_test_not_captured_but_returned_call_1b
; CGSCC-SAME: (i64* nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A:%.*]]) #[[ATTR6:[0-9]+]] { ; CGSCC-SAME: (i64* nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A:%.*]]) #[[ATTR6:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CALL:%.*]] = call align 8 i64* @not_captured_but_returned_1(i64* nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A]]) #[[ATTR11]] ; CGSCC-NEXT: [[CALL:%.*]] = call align 8 i64* @not_captured_but_returned_1(i64* nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A]]) #[[ATTR11]]
; CGSCC-NEXT: [[TMP0:%.*]] = ptrtoint i64* [[CALL]] to i64 ; CGSCC-NEXT: [[TMP0:%.*]] = ptrtoint i64* [[CALL]] to i64
; CGSCC-NEXT: store i64 [[TMP0]], i64* [[CALL]], align 8 ; CGSCC-NEXT: store i64 [[TMP0]], i64* [[CALL]], align 8
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
▲ Show 20 Lines • Show All 212 Lines • ▼ Show 20 Lines
entry: entry:
%call = call i32* @readonly_i32p(i32* %b) %call = call i32* @readonly_i32p(i32* %b)
store i32 0, i32* %call store i32 0, i32* %call
ret void ret void
} }
attributes #0 = { noinline nounwind uwtable } attributes #0 = { noinline nounwind uwtable }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable }
; TUNIT: attributes #[[ATTR1]] = { nofree noinline nosync nounwind willreturn memory(none) uwtable } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable }
; TUNIT: attributes #[[ATTR2]] = { nofree nosync nounwind memory(none) } ; TUNIT: attributes #[[ATTR2]] = { nofree nosync nounwind memory(none) }
; TUNIT: attributes #[[ATTR3]] = { noinline nounwind uwtable } ; TUNIT: attributes #[[ATTR3]] = { noinline nounwind uwtable }
; TUNIT: attributes #[[ATTR4]] = { nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable } ; TUNIT: attributes #[[ATTR4]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable }
; TUNIT: attributes #[[ATTR5]] = { nofree noinline norecurse nosync nounwind willreturn memory(write) uwtable } ; TUNIT: attributes #[[ATTR5]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(write) uwtable }
; TUNIT: attributes #[[ATTR6:[0-9]+]] = { memory(read) } ; TUNIT: attributes #[[ATTR6:[0-9]+]] = { memory(read) }
; TUNIT: attributes #[[ATTR7]] = { noinline nounwind memory(read) uwtable } ; TUNIT: attributes #[[ATTR7]] = { noinline nounwind memory(read) uwtable }
; TUNIT: attributes #[[ATTR8]] = { nounwind memory(read) } ; TUNIT: attributes #[[ATTR8]] = { nounwind memory(read) }
; TUNIT: attributes #[[ATTR9]] = { nofree nosync nounwind } ; TUNIT: attributes #[[ATTR9]] = { nofree nosync nounwind }
; TUNIT: attributes #[[ATTR10]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR10]] = { nofree nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR11]] = { nounwind } ; TUNIT: attributes #[[ATTR11]] = { nounwind }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable }
; CGSCC: attributes #[[ATTR1]] = { nofree noinline nosync nounwind willreturn memory(none) uwtable } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable }
; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind memory(none) } ; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind memory(none) }
; CGSCC: attributes #[[ATTR3]] = { noinline nounwind uwtable } ; CGSCC: attributes #[[ATTR3]] = { noinline nounwind uwtable }
; CGSCC: attributes #[[ATTR4]] = { nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable } ; CGSCC: attributes #[[ATTR4]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable }
; CGSCC: attributes #[[ATTR5]] = { nofree noinline nosync nounwind willreturn memory(argmem: write) uwtable } ; CGSCC: attributes #[[ATTR5]] = { mustprogress nofree noinline nosync nounwind willreturn memory(argmem: write) uwtable }
; CGSCC: attributes #[[ATTR6]] = { nofree noinline nosync nounwind willreturn memory(write) uwtable } ; CGSCC: attributes #[[ATTR6]] = { mustprogress nofree noinline nosync nounwind willreturn memory(write) uwtable }
; CGSCC: attributes #[[ATTR7:[0-9]+]] = { memory(read) } ; CGSCC: attributes #[[ATTR7:[0-9]+]] = { memory(read) }
; CGSCC: attributes #[[ATTR8]] = { noinline nounwind memory(read) uwtable } ; CGSCC: attributes #[[ATTR8]] = { noinline nounwind memory(read) uwtable }
; CGSCC: attributes #[[ATTR9]] = { nounwind memory(read) } ; CGSCC: attributes #[[ATTR9]] = { nounwind memory(read) }
; CGSCC: attributes #[[ATTR10]] = { nofree nosync nounwind } ; CGSCC: attributes #[[ATTR10]] = { nofree nosync nounwind }
; CGSCC: attributes #[[ATTR11]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR11]] = { nounwind willreturn }
; CGSCC: attributes #[[ATTR12]] = { nounwind } ; CGSCC: attributes #[[ATTR12]] = { nounwind }
;. ;.

llvm/test/Transforms/Attributor/nodelete.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=4 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=4 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
%"a" = type { i64 } %"a" = type { i64 }
%"b" = type { i8 } %"b" = type { i8 }
define hidden i64 @f1() align 2 { define hidden i64 @f1() align 2 {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@f1 ; TUNIT-LABEL: define {{[^@]+}}@f1
; TUNIT-SAME: () #[[ATTR0:[0-9]+]] align 2 { ; TUNIT-SAME: () #[[ATTR0:[0-9]+]] align 2 {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: ret i64 undef ; TUNIT-NEXT: ret i64 undef
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@f1 ; CGSCC-LABEL: define {{[^@]+}}@f1
; CGSCC-SAME: () #[[ATTR0:[0-9]+]] align 2 { ; CGSCC-SAME: () #[[ATTR0:[0-9]+]] align 2 {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[REF_TMP:%.*]] = alloca [[A:%.*]], align 8 ; CGSCC-NEXT: [[REF_TMP:%.*]] = alloca [[A:%.*]], align 8
; CGSCC-NEXT: [[CALL2:%.*]] = call i64 @f2() #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: [[CALL2:%.*]] = call i64 @f2() #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: ret i64 [[CALL2]] ; CGSCC-NEXT: ret i64 [[CALL2]]
; ;
entry: entry:
%ref.tmp = alloca %"a", align 8 %ref.tmp = alloca %"a", align 8
%call2 = call i64 @f2(%"a"* %ref.tmp) %call2 = call i64 @f2(%"a"* %ref.tmp)
ret i64 %call2 ret i64 %call2
} }
define internal i64 @f2(%"a"* %this) align 2 { define internal i64 @f2(%"a"* %this) align 2 {
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@f2 ; CGSCC-LABEL: define {{[^@]+}}@f2
; CGSCC-SAME: () #[[ATTR0]] align 2 { ; CGSCC-SAME: () #[[ATTR0]] align 2 {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: ret i64 undef ; CGSCC-NEXT: ret i64 undef
; ;
entry: entry:
%this.addr = alloca %"a"*, align 8 %this.addr = alloca %"a"*, align 8
store %"a"* %this, %"a"** %this.addr, align 8 store %"a"* %this, %"a"** %this.addr, align 8
%this1 = load %"a"*, %"a"** %this.addr, align 8 %this1 = load %"a"*, %"a"** %this.addr, align 8
%0 = bitcast %"a"* %this1 to %"b"* %0 = bitcast %"a"* %this1 to %"b"*
call void @f3(%"b"* %0) call void @f3(%"b"* %0)
ret i64 undef ret i64 undef
} }
define internal void @f3(%"b"* %this) align 2 { define internal void @f3(%"b"* %this) align 2 {
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@f3 ; CGSCC-LABEL: define {{[^@]+}}@f3
; CGSCC-SAME: () #[[ATTR0]] align 2 { ; CGSCC-SAME: () #[[ATTR0]] align 2 {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
entry: entry:
%this.addr = alloca %"b"*, align 8 %this.addr = alloca %"b"*, align 8
store %"b"* %this, %"b"** %this.addr, align 8 store %"b"* %this, %"b"** %this.addr, align 8
%this1 = load %"b"*, %"b"** %this.addr, align 8 %this1 = load %"b"*, %"b"** %this.addr, align 8
%call = call i1 @f4(%"b"* %this1) %call = call i1 @f4(%"b"* %this1)
ret void ret void
} }
define internal i1 @f4(%"b"* %this) align 2 { define internal i1 @f4(%"b"* %this) align 2 {
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@f4 ; CGSCC-LABEL: define {{[^@]+}}@f4
; CGSCC-SAME: () #[[ATTR0]] align 2 { ; CGSCC-SAME: () #[[ATTR0]] align 2 {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: ret i1 undef ; CGSCC-NEXT: ret i1 undef
; ;
entry: entry:
%this.addr = alloca %"b"*, align 8 %this.addr = alloca %"b"*, align 8
store %"b"* %this, %"b"** %this.addr, align 8 store %"b"* %this, %"b"** %this.addr, align 8
%this1 = load %"b"*, %"b"** %this.addr, align 8 %this1 = load %"b"*, %"b"** %this.addr, align 8
%call = call %"a"* @f5(%"b"* %this1) %call = call %"a"* @f5(%"b"* %this1)
ret i1 undef ret i1 undef
} }
define internal %"a"* @f5(%"b"* %this) align 2 { define internal %"a"* @f5(%"b"* %this) align 2 {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@f5 ; CGSCC-LABEL: define {{[^@]+}}@f5
; CGSCC-SAME: () #[[ATTR1:[0-9]+]] align 2 { ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] align 2 {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: ret %a* undef ; CGSCC-NEXT: ret %a* undef
; ;
entry: entry:
%this.addr = alloca %"b"*, align 8 %this.addr = alloca %"b"*, align 8
store %"b"* %this, %"b"** %this.addr, align 8 store %"b"* %this, %"b"** %this.addr, align 8
%this1 = load %"b"*, %"b"** %this.addr, align 8 %this1 = load %"b"*, %"b"** %this.addr, align 8
%0 = bitcast %"b"* %this1 to %"a"* %0 = bitcast %"b"* %this1 to %"a"*
ret %"a"* %0 ret %"a"* %0
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { willreturn } ; CGSCC: attributes #[[ATTR2]] = { willreturn }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CHECK: {{.*}} ; CHECK: {{.*}}

llvm/test/Transforms/Attributor/nofpclass.ll

Show First 20 Lines • Show All 123 Lines • ▼ Show 20 Lines
; CHECK-NEXT: ret float [[RET]] ; CHECK-NEXT: ret float [[RET]]
; ;
%ret = call float @ret_nofpclass_nan() %ret = call float @ret_nofpclass_nan()
ret float %ret ret float %ret
} }
; Return a float trivially nofpclass(nan) (argument attribute) ; Return a float trivially nofpclass(nan) (argument attribute)
define float @return_nofpclass_nan_arg(float returned nofpclass(nan) %p) { define float @return_nofpclass_nan_arg(float returned nofpclass(nan) %p) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan) float @return_nofpclass_nan_arg ; CHECK-LABEL: define nofpclass(nan) float @return_nofpclass_nan_arg
; CHECK-SAME: (float returned nofpclass(nan) [[P:%.*]]) #[[ATTR2:[0-9]+]] { ; CHECK-SAME: (float returned nofpclass(nan) [[P:%.*]]) #[[ATTR2:[0-9]+]] {
; CHECK-NEXT: ret float [[P]] ; CHECK-NEXT: ret float [[P]]
; ;
ret float %p ret float %p
} }
define [2 x [3 x float]] @return_nofpclass_inf_ret_array() { define [2 x [3 x float]] @return_nofpclass_inf_ret_array() {
; CHECK-LABEL: define nofpclass(inf) [2 x [3 x float]] @return_nofpclass_inf_ret_array() { ; CHECK-LABEL: define nofpclass(inf) [2 x [3 x float]] @return_nofpclass_inf_ret_array() {
; CHECK-NEXT: [[RET:%.*]] = call nofpclass(inf) [2 x [3 x float]] @ret_array() ; CHECK-NEXT: [[RET:%.*]] = call nofpclass(inf) [2 x [3 x float]] @ret_array()
; CHECK-NEXT: ret [2 x [3 x float]] [[RET]] ; CHECK-NEXT: ret [2 x [3 x float]] [[RET]]
; ;
%ret = call nofpclass(inf) [2 x [3 x float]] @ret_array() %ret = call nofpclass(inf) [2 x [3 x float]] @ret_array()
ret [2 x [3 x float]] %ret ret [2 x [3 x float]] %ret
} }
define float @returned_nnan_fadd(float %arg0, float %arg1) { define float @returned_nnan_fadd(float %arg0, float %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan) float @returned_nnan_fadd ; CHECK-LABEL: define nofpclass(nan) float @returned_nnan_fadd
; CHECK-SAME: (float [[ARG0:%.*]], float [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float [[ARG0:%.*]], float [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FADD:%.*]] = fadd nnan float [[ARG0]], [[ARG1]] ; CHECK-NEXT: [[FADD:%.*]] = fadd nnan float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[FADD]] ; CHECK-NEXT: ret float [[FADD]]
; ;
%fadd = fadd nnan float %arg0, %arg1 %fadd = fadd nnan float %arg0, %arg1
ret float %fadd ret float %fadd
} }
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @extern(float %arg) willreturn nounwind ; < annotate this use call void @extern(float %arg) willreturn nounwind ; < annotate this use
call void @extern(float nofpclass(nan inf) %arg) call void @extern(float nofpclass(nan inf) %arg)
ret void ret void
} }
define float @mutually_recursive0(float %arg) { define float @mutually_recursive0(float %arg) {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define nofpclass(all) float @mutually_recursive0 ; TUNIT-LABEL: define nofpclass(all) float @mutually_recursive0
; TUNIT-SAME: (float [[ARG:%.*]]) #[[ATTR3:[0-9]+]] { ; TUNIT-SAME: (float [[ARG:%.*]]) #[[ATTR3:[0-9]+]] {
; TUNIT-NEXT: ret float undef ; TUNIT-NEXT: ret float undef
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define nofpclass(all) float @mutually_recursive0 ; CGSCC-LABEL: define nofpclass(all) float @mutually_recursive0
; CGSCC-SAME: (float [[ARG:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (float [[ARG:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: ret float undef ; CGSCC-NEXT: ret float undef
; ;
%call = call float @mutually_recursive1(float %arg) %call = call float @mutually_recursive1(float %arg)
ret float %call ret float %call
} }
define float @mutually_recursive1(float %arg) { define float @mutually_recursive1(float %arg) {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define nofpclass(all) float @mutually_recursive1 ; TUNIT-LABEL: define nofpclass(all) float @mutually_recursive1
; TUNIT-SAME: (float [[ARG:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (float [[ARG:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: ret float undef ; TUNIT-NEXT: ret float undef
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define nofpclass(all) float @mutually_recursive1 ; CGSCC-LABEL: define nofpclass(all) float @mutually_recursive1
; CGSCC-SAME: (float [[ARG:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (float [[ARG:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: ret float undef ; CGSCC-NEXT: ret float undef
; ;
%call = call float @mutually_recursive0(float %arg) %call = call float @mutually_recursive0(float %arg)
ret float %call ret float %call
} }
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[TMP1:%.*]] = call float @returned_dead() ; CHECK-NEXT: [[TMP1:%.*]] = call float @returned_dead()
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call float @returned_dead() call float @returned_dead()
ret void ret void
} }
define internal float @only_nofpclass_inf_callers(float %arg) { define internal float @only_nofpclass_inf_callers(float %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define internal float @only_nofpclass_inf_callers ; CHECK-LABEL: define internal float @only_nofpclass_inf_callers
; CHECK-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG]], [[ARG]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG]], [[ARG]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg, %arg %add = fadd float %arg, %arg
ret float %add ret float %add
} }
define float @call_noinf_0(float nofpclass(inf) %arg) { define float @call_noinf_0(float nofpclass(inf) %arg) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define float @call_noinf_0 ; TUNIT-LABEL: define float @call_noinf_0
; TUNIT-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR2]] { ; TUNIT-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR2]] {
; TUNIT-NEXT: [[RESULT:%.*]] = call float @only_nofpclass_inf_callers(float nofpclass(inf) [[ARG]]) #[[ATTR14:[0-9]+]] ; TUNIT-NEXT: [[RESULT:%.*]] = call float @only_nofpclass_inf_callers(float nofpclass(inf) [[ARG]]) #[[ATTR14:[0-9]+]]
; TUNIT-NEXT: ret float [[RESULT]] ; TUNIT-NEXT: ret float [[RESULT]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define float @call_noinf_0 ; CGSCC-LABEL: define float @call_noinf_0
; CGSCC-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR3:[0-9]+]] { ; CGSCC-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR3:[0-9]+]] {
; CGSCC-NEXT: [[RESULT:%.*]] = call float @only_nofpclass_inf_callers(float nofpclass(inf) [[ARG]]) #[[ATTR13]] ; CGSCC-NEXT: [[RESULT:%.*]] = call float @only_nofpclass_inf_callers(float nofpclass(inf) [[ARG]]) #[[ATTR13]]
; CGSCC-NEXT: ret float [[RESULT]] ; CGSCC-NEXT: ret float [[RESULT]]
; ;
%result = call float @only_nofpclass_inf_callers(float %arg) %result = call float @only_nofpclass_inf_callers(float %arg)
ret float %result ret float %result
} }
define float @call_noinf_1(float %arg) { define float @call_noinf_1(float %arg) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define float @call_noinf_1 ; TUNIT-LABEL: define float @call_noinf_1
; TUNIT-SAME: (float [[ARG:%.*]]) #[[ATTR2]] { ; TUNIT-SAME: (float [[ARG:%.*]]) #[[ATTR2]] {
; TUNIT-NEXT: [[RESULT:%.*]] = call float @only_nofpclass_inf_callers(float nofpclass(inf) [[ARG]]) #[[ATTR14]] ; TUNIT-NEXT: [[RESULT:%.*]] = call float @only_nofpclass_inf_callers(float nofpclass(inf) [[ARG]]) #[[ATTR14]]
; TUNIT-NEXT: ret float [[RESULT]] ; TUNIT-NEXT: ret float [[RESULT]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define float @call_noinf_1 ; CGSCC-LABEL: define float @call_noinf_1
; CGSCC-SAME: (float [[ARG:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (float [[ARG:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[RESULT:%.*]] = call float @only_nofpclass_inf_callers(float nofpclass(inf) [[ARG]]) #[[ATTR13]] ; CGSCC-NEXT: [[RESULT:%.*]] = call float @only_nofpclass_inf_callers(float nofpclass(inf) [[ARG]]) #[[ATTR13]]
; CGSCC-NEXT: ret float [[RESULT]] ; CGSCC-NEXT: ret float [[RESULT]]
; ;
%result = call float @only_nofpclass_inf_callers(float nofpclass(inf) %arg) %result = call float @only_nofpclass_inf_callers(float nofpclass(inf) %arg)
ret float %result ret float %result
} }
; TODO: Should be able to infer nofpclass(inf) on return ; TODO: Should be able to infer nofpclass(inf) on return
define internal float @only_nofpclass_inf_return_users(float %arg) { define internal float @only_nofpclass_inf_return_users(float %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define internal float @only_nofpclass_inf_return_users ; CHECK-LABEL: define internal float @only_nofpclass_inf_return_users
; CHECK-SAME: (float [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float [[ARG:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG]], [[ARG]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG]], [[ARG]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg, %arg %add = fadd float %arg, %arg
ret float %add ret float %add
} }
define float @call_noinf_return_0(float %arg) { define float @call_noinf_return_0(float %arg) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define nofpclass(inf) float @call_noinf_return_0 ; TUNIT-LABEL: define nofpclass(inf) float @call_noinf_return_0
; TUNIT-SAME: (float [[ARG:%.*]]) #[[ATTR2]] { ; TUNIT-SAME: (float [[ARG:%.*]]) #[[ATTR2]] {
; TUNIT-NEXT: [[RESULT:%.*]] = call nofpclass(inf) float @only_nofpclass_inf_return_users(float [[ARG]]) #[[ATTR14]] ; TUNIT-NEXT: [[RESULT:%.*]] = call nofpclass(inf) float @only_nofpclass_inf_return_users(float [[ARG]]) #[[ATTR14]]
; TUNIT-NEXT: ret float [[RESULT]] ; TUNIT-NEXT: ret float [[RESULT]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define nofpclass(inf) float @call_noinf_return_0 ; CGSCC-LABEL: define nofpclass(inf) float @call_noinf_return_0
; CGSCC-SAME: (float [[ARG:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (float [[ARG:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[RESULT:%.*]] = call nofpclass(inf) float @only_nofpclass_inf_return_users(float [[ARG]]) #[[ATTR13]] ; CGSCC-NEXT: [[RESULT:%.*]] = call nofpclass(inf) float @only_nofpclass_inf_return_users(float [[ARG]]) #[[ATTR13]]
; CGSCC-NEXT: ret float [[RESULT]] ; CGSCC-NEXT: ret float [[RESULT]]
; ;
%result = call nofpclass(inf) float @only_nofpclass_inf_return_users(float %arg) %result = call nofpclass(inf) float @only_nofpclass_inf_return_users(float %arg)
ret float %result ret float %result
} }
define float @call_noinf_return_1(float %arg) { define float @call_noinf_return_1(float %arg) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define nofpclass(inf) float @call_noinf_return_1 ; TUNIT-LABEL: define nofpclass(inf) float @call_noinf_return_1
; TUNIT-SAME: (float [[ARG:%.*]]) #[[ATTR2]] { ; TUNIT-SAME: (float [[ARG:%.*]]) #[[ATTR2]] {
; TUNIT-NEXT: [[RESULT:%.*]] = call nofpclass(inf) float @only_nofpclass_inf_return_users(float [[ARG]]) #[[ATTR14]] ; TUNIT-NEXT: [[RESULT:%.*]] = call nofpclass(inf) float @only_nofpclass_inf_return_users(float [[ARG]]) #[[ATTR14]]
; TUNIT-NEXT: ret float [[RESULT]] ; TUNIT-NEXT: ret float [[RESULT]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define nofpclass(inf) float @call_noinf_return_1 ; CGSCC-LABEL: define nofpclass(inf) float @call_noinf_return_1
; CGSCC-SAME: (float [[ARG:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (float [[ARG:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[RESULT:%.*]] = call nofpclass(inf) float @only_nofpclass_inf_return_users(float [[ARG]]) #[[ATTR13]] ; CGSCC-NEXT: [[RESULT:%.*]] = call nofpclass(inf) float @only_nofpclass_inf_return_users(float [[ARG]]) #[[ATTR13]]
; CGSCC-NEXT: ret float [[RESULT]] ; CGSCC-NEXT: ret float [[RESULT]]
; ;
%result = call nofpclass(inf) float @only_nofpclass_inf_return_users(float %arg) %result = call nofpclass(inf) float @only_nofpclass_inf_return_users(float %arg)
ret float %result ret float %result
} }
▲ Show 20 Lines • Show All 191 Lines • ▼ Show 20 Lines
B: B:
call void @llvm.assume(i1 true) [ "nofpclass"(float %ret, i32 12) ] call void @llvm.assume(i1 true) [ "nofpclass"(float %ret, i32 12) ]
call void @extern.use(float %ret) call void @extern.use(float %ret)
ret float %ret ret float %ret
} }
define float @returned_load(ptr %ptr) { define float @returned_load(ptr %ptr) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define float @returned_load ; CHECK-LABEL: define float @returned_load
; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[PTR:%.*]]) #[[ATTR4:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[PTR:%.*]]) #[[ATTR4:[0-9]+]] {
; CHECK-NEXT: [[LOAD:%.*]] = load float, ptr [[PTR]], align 4 ; CHECK-NEXT: [[LOAD:%.*]] = load float, ptr [[PTR]], align 4
; CHECK-NEXT: ret float [[LOAD]] ; CHECK-NEXT: ret float [[LOAD]]
; ;
%load = load float, ptr %ptr %load = load float, ptr %ptr
ret float %load ret float %load
} }
define float @pass_nofpclass_inf_through_memory(float nofpclass(inf) %arg) { define float @pass_nofpclass_inf_through_memory(float nofpclass(inf) %arg) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define float @pass_nofpclass_inf_through_memory ; TUNIT-LABEL: define float @pass_nofpclass_inf_through_memory
; TUNIT-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR2]] { ; TUNIT-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR2]] {
; TUNIT-NEXT: [[ALLOCA:%.*]] = alloca float, align 4 ; TUNIT-NEXT: [[ALLOCA:%.*]] = alloca float, align 4
; TUNIT-NEXT: store float [[ARG]], ptr [[ALLOCA]], align 4 ; TUNIT-NEXT: store float [[ARG]], ptr [[ALLOCA]], align 4
; TUNIT-NEXT: [[RET:%.*]] = call float @returned_load(ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[ALLOCA]]) #[[ATTR14]] ; TUNIT-NEXT: [[RET:%.*]] = call float @returned_load(ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[ALLOCA]]) #[[ATTR14]]
; TUNIT-NEXT: ret float [[RET]] ; TUNIT-NEXT: ret float [[RET]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define float @pass_nofpclass_inf_through_memory ; CGSCC-LABEL: define float @pass_nofpclass_inf_through_memory
; CGSCC-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[ALLOCA:%.*]] = alloca float, align 4 ; CGSCC-NEXT: [[ALLOCA:%.*]] = alloca float, align 4
; CGSCC-NEXT: store float [[ARG]], ptr [[ALLOCA]], align 4 ; CGSCC-NEXT: store float [[ARG]], ptr [[ALLOCA]], align 4
; CGSCC-NEXT: [[RET:%.*]] = call float @returned_load(ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[ALLOCA]]) #[[ATTR13]] ; CGSCC-NEXT: [[RET:%.*]] = call float @returned_load(ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[ALLOCA]]) #[[ATTR13]]
; CGSCC-NEXT: ret float [[RET]] ; CGSCC-NEXT: ret float [[RET]]
; ;
%alloca = alloca float %alloca = alloca float
store float %arg, ptr %alloca store float %arg, ptr %alloca
%ret = call float @returned_load(ptr %alloca) %ret = call float @returned_load(ptr %alloca)
ret float %ret ret float %ret
} }
define float @returned_fabs(float %x) { define float @returned_fabs(float %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs ; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs
; CHECK-SAME: (float [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR13]]
; CHECK-NEXT: ret float [[FABS]] ; CHECK-NEXT: ret float [[FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
ret float %fabs ret float %fabs
} }
define float @returned_fabs_nosnan(float nofpclass(snan) %x) { define float @returned_fabs_nosnan(float nofpclass(snan) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(snan ninf nzero nsub nnorm) float @returned_fabs_nosnan ; CHECK-LABEL: define nofpclass(snan ninf nzero nsub nnorm) float @returned_fabs_nosnan
; CHECK-SAME: (float nofpclass(snan) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(snan) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(snan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(snan) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(snan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(snan) [[X]]) #[[ATTR13]]
; CHECK-NEXT: ret float [[FABS]] ; CHECK-NEXT: ret float [[FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
ret float %fabs ret float %fabs
} }
define float @returned_fabs_noqnan(float nofpclass(qnan) %x) { define float @returned_fabs_noqnan(float nofpclass(qnan) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(qnan ninf nzero nsub nnorm) float @returned_fabs_noqnan ; CHECK-LABEL: define nofpclass(qnan ninf nzero nsub nnorm) float @returned_fabs_noqnan
; CHECK-SAME: (float nofpclass(qnan) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(qnan) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(qnan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(qnan) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(qnan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(qnan) [[X]]) #[[ATTR13]]
; CHECK-NEXT: ret float [[FABS]] ; CHECK-NEXT: ret float [[FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
ret float %fabs ret float %fabs
} }
define float @returned_fabs_nonan(float nofpclass(nan) %x) { define float @returned_fabs_nonan(float nofpclass(nan) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @returned_fabs_nonan ; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @returned_fabs_nonan
; CHECK-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan) [[X]]) #[[ATTR13]]
; CHECK-NEXT: ret float [[FABS]] ; CHECK-NEXT: ret float [[FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
ret float %fabs ret float %fabs
} }
define float @returned_fabs_noinf(float nofpclass(inf) %x) { define float @returned_fabs_noinf(float nofpclass(inf) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(inf nzero nsub nnorm) float @returned_fabs_noinf ; CHECK-LABEL: define nofpclass(inf nzero nsub nnorm) float @returned_fabs_noinf
; CHECK-SAME: (float nofpclass(inf) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(inf) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(inf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(inf) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(inf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(inf) [[X]]) #[[ATTR13]]
; CHECK-NEXT: ret float [[FABS]] ; CHECK-NEXT: ret float [[FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
ret float %fabs ret float %fabs
} }
define float @returned_fabs_nopos(float nofpclass(psub pnorm pinf) %x) { define float @returned_fabs_nopos(float nofpclass(psub pnorm pinf) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nopos ; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nopos
; CHECK-SAME: (float nofpclass(pinf psub pnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(pinf psub pnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf psub pnorm) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf psub pnorm) [[X]]) #[[ATTR13]]
; CHECK-NEXT: ret float [[FABS]] ; CHECK-NEXT: ret float [[FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
ret float %fabs ret float %fabs
} }
define float @returned_fabs_nopos_nopzero(float nofpclass(psub pnorm pinf pzero) %x) { define float @returned_fabs_nopos_nopzero(float nofpclass(psub pnorm pinf pzero) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nopos_nopzero ; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nopos_nopzero
; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf pzero psub pnorm) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf pzero psub pnorm) [[X]]) #[[ATTR13]]
; CHECK-NEXT: ret float [[FABS]] ; CHECK-NEXT: ret float [[FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
ret float %fabs ret float %fabs
} }
define float @returned_fabs_nopos_nozero(float nofpclass(psub pnorm pinf zero) %x) { define float @returned_fabs_nopos_nozero(float nofpclass(psub pnorm pinf zero) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(ninf zero nsub nnorm) float @returned_fabs_nopos_nozero ; CHECK-LABEL: define nofpclass(ninf zero nsub nnorm) float @returned_fabs_nopos_nozero
; CHECK-SAME: (float nofpclass(pinf zero psub pnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(pinf zero psub pnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf zero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf zero psub pnorm) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf zero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf zero psub pnorm) [[X]]) #[[ATTR13]]
; CHECK-NEXT: ret float [[FABS]] ; CHECK-NEXT: ret float [[FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
ret float %fabs ret float %fabs
} }
define float @returned_fabs_nopos_nonan(float nofpclass(psub pnorm pinf nan) %x) { define float @returned_fabs_nopos_nonan(float nofpclass(psub pnorm pinf nan) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @returned_fabs_nopos_nonan ; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @returned_fabs_nopos_nonan
; CHECK-SAME: (float nofpclass(nan pinf psub pnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(nan pinf psub pnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan pinf psub pnorm) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan pinf psub pnorm) [[X]]) #[[ATTR13]]
; CHECK-NEXT: ret float [[FABS]] ; CHECK-NEXT: ret float [[FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
ret float %fabs ret float %fabs
} }
define float @returned_fabs_noneg(float nofpclass(nsub nnorm ninf) %x) { define float @returned_fabs_noneg(float nofpclass(nsub nnorm ninf) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_noneg ; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_noneg
; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf nsub nnorm) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf nsub nnorm) [[X]]) #[[ATTR13]]
; CHECK-NEXT: ret float [[FABS]] ; CHECK-NEXT: ret float [[FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
ret float %fabs ret float %fabs
} }
define float @returned_fabs_noneg_nonzero(float nofpclass(nsub nnorm ninf nzero) %x) { define float @returned_fabs_noneg_nonzero(float nofpclass(nsub nnorm ninf nzero) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_noneg_nonzero ; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_noneg_nonzero
; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf nzero nsub nnorm) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf nzero nsub nnorm) [[X]]) #[[ATTR13]]
; CHECK-NEXT: ret float [[FABS]] ; CHECK-NEXT: ret float [[FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
ret float %fabs ret float %fabs
} }
define float @returned_fabs_noneg_nozero(float nofpclass(nsub nnorm ninf zero) %x) { define float @returned_fabs_noneg_nozero(float nofpclass(nsub nnorm ninf zero) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(ninf zero nsub nnorm) float @returned_fabs_noneg_nozero ; CHECK-LABEL: define nofpclass(ninf zero nsub nnorm) float @returned_fabs_noneg_nozero
; CHECK-SAME: (float nofpclass(ninf zero nsub nnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(ninf zero nsub nnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf zero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf zero nsub nnorm) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf zero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf zero nsub nnorm) [[X]]) #[[ATTR13]]
; CHECK-NEXT: ret float [[FABS]] ; CHECK-NEXT: ret float [[FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
ret float %fabs ret float %fabs
} }
define float @returned_fabs_noneg_nonan(float nofpclass(nsub nnorm ninf nan) %x) { define float @returned_fabs_noneg_nonan(float nofpclass(nsub nnorm ninf nan) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @returned_fabs_noneg_nonan ; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @returned_fabs_noneg_nonan
; CHECK-SAME: (float nofpclass(nan ninf nsub nnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(nan ninf nsub nnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan ninf nsub nnorm) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan ninf nsub nnorm) [[X]]) #[[ATTR13]]
; CHECK-NEXT: ret float [[FABS]] ; CHECK-NEXT: ret float [[FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
ret float %fabs ret float %fabs
} }
define float @returned_fabs_nonsub_nopnorm_nonzero(float nofpclass(nsub pnorm nzero) %x) { define float @returned_fabs_nonsub_nopnorm_nonzero(float nofpclass(nsub pnorm nzero) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nonsub_nopnorm_nonzero ; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nonsub_nopnorm_nonzero
; CHECK-SAME: (float nofpclass(nzero nsub pnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(nzero nsub pnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nzero nsub pnorm) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nzero nsub pnorm) [[X]]) #[[ATTR13]]
; CHECK-NEXT: ret float [[FABS]] ; CHECK-NEXT: ret float [[FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
ret float %fabs ret float %fabs
} }
define float @returned_fabs_nopsub_nonnorm_nopzero(float nofpclass(psub nnorm pzero) %x) { define float @returned_fabs_nopsub_nonnorm_nopzero(float nofpclass(psub nnorm pzero) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nopsub_nonnorm_nopzero ; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nopsub_nonnorm_nopzero
; CHECK-SAME: (float nofpclass(pzero psub nnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(pzero psub nnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pzero psub nnorm) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pzero psub nnorm) [[X]]) #[[ATTR13]]
; CHECK-NEXT: ret float [[FABS]] ; CHECK-NEXT: ret float [[FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
ret float %fabs ret float %fabs
} }
define float @returned_fabs_nonnorm_nozero(float nofpclass(nnorm nzero) %x) { define float @returned_fabs_nonnorm_nozero(float nofpclass(nnorm nzero) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nonnorm_nozero ; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nonnorm_nozero
; CHECK-SAME: (float nofpclass(nzero nnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(nzero nnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nzero nnorm) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nzero nnorm) [[X]]) #[[ATTR13]]
; CHECK-NEXT: ret float [[FABS]] ; CHECK-NEXT: ret float [[FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
ret float %fabs ret float %fabs
} }
define float @returned_fneg(float %x) { define float @returned_fneg(float %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @returned_fneg ; CHECK-LABEL: define float @returned_fneg
; CHECK-SAME: (float [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]] ; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]]
; CHECK-NEXT: ret float [[FNEG]] ; CHECK-NEXT: ret float [[FNEG]]
; ;
%fneg = fneg float %x %fneg = fneg float %x
ret float %fneg ret float %fneg
} }
define float @returned_fneg_nosnan(float nofpclass(snan) %x) { define float @returned_fneg_nosnan(float nofpclass(snan) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(snan) float @returned_fneg_nosnan ; CHECK-LABEL: define nofpclass(snan) float @returned_fneg_nosnan
; CHECK-SAME: (float nofpclass(snan) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(snan) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]] ; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]]
; CHECK-NEXT: ret float [[FNEG]] ; CHECK-NEXT: ret float [[FNEG]]
; ;
%fneg = fneg float %x %fneg = fneg float %x
ret float %fneg ret float %fneg
} }
define float @returned_fneg_noqnan(float nofpclass(qnan) %x) { define float @returned_fneg_noqnan(float nofpclass(qnan) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(qnan) float @returned_fneg_noqnan ; CHECK-LABEL: define nofpclass(qnan) float @returned_fneg_noqnan
; CHECK-SAME: (float nofpclass(qnan) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(qnan) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]] ; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]]
; CHECK-NEXT: ret float [[FNEG]] ; CHECK-NEXT: ret float [[FNEG]]
; ;
%fneg = fneg float %x %fneg = fneg float %x
ret float %fneg ret float %fneg
} }
define float @returned_fneg_nosnan_ninf_flag(float nofpclass(snan) %x) { define float @returned_fneg_nosnan_ninf_flag(float nofpclass(snan) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(snan inf) float @returned_fneg_nosnan_ninf_flag ; CHECK-LABEL: define nofpclass(snan inf) float @returned_fneg_nosnan_ninf_flag
; CHECK-SAME: (float nofpclass(snan) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(snan) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FNEG:%.*]] = fneg ninf float [[X]] ; CHECK-NEXT: [[FNEG:%.*]] = fneg ninf float [[X]]
; CHECK-NEXT: ret float [[FNEG]] ; CHECK-NEXT: ret float [[FNEG]]
; ;
%fneg = fneg ninf float %x %fneg = fneg ninf float %x
ret float %fneg ret float %fneg
} }
define float @returned_fneg_nonan(float nofpclass(nan) %x) { define float @returned_fneg_nonan(float nofpclass(nan) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan) float @returned_fneg_nonan ; CHECK-LABEL: define nofpclass(nan) float @returned_fneg_nonan
; CHECK-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]] ; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]]
; CHECK-NEXT: ret float [[FNEG]] ; CHECK-NEXT: ret float [[FNEG]]
; ;
%fneg = fneg float %x %fneg = fneg float %x
ret float %fneg ret float %fneg
} }
define float @returned_fneg_noinf(float nofpclass(inf) %x) { define float @returned_fneg_noinf(float nofpclass(inf) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(inf) float @returned_fneg_noinf ; CHECK-LABEL: define nofpclass(inf) float @returned_fneg_noinf
; CHECK-SAME: (float nofpclass(inf) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(inf) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]] ; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]]
; CHECK-NEXT: ret float [[FNEG]] ; CHECK-NEXT: ret float [[FNEG]]
; ;
%fneg = fneg float %x %fneg = fneg float %x
ret float %fneg ret float %fneg
} }
define float @returned_fneg_noneg(float nofpclass(ninf nsub nnorm nzero) %x) { define float @returned_fneg_noneg(float nofpclass(ninf nsub nnorm nzero) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @returned_fneg_noneg ; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @returned_fneg_noneg
; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]] ; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]]
; CHECK-NEXT: ret float [[FNEG]] ; CHECK-NEXT: ret float [[FNEG]]
; ;
%fneg = fneg float %x %fneg = fneg float %x
ret float %fneg ret float %fneg
} }
define float @returned_fneg_noneg_nnan_flag(float nofpclass(ninf nsub nnorm nzero) %x) { define float @returned_fneg_noneg_nnan_flag(float nofpclass(ninf nsub nnorm nzero) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan pinf pzero psub pnorm) float @returned_fneg_noneg_nnan_flag ; CHECK-LABEL: define nofpclass(nan pinf pzero psub pnorm) float @returned_fneg_noneg_nnan_flag
; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FNEG:%.*]] = fneg nnan float [[X]] ; CHECK-NEXT: [[FNEG:%.*]] = fneg nnan float [[X]]
; CHECK-NEXT: ret float [[FNEG]] ; CHECK-NEXT: ret float [[FNEG]]
; ;
%fneg = fneg nnan float %x %fneg = fneg nnan float %x
ret float %fneg ret float %fneg
} }
define float @returned_fneg_nonsubnnorm(float nofpclass(nsub nnorm) %x) { define float @returned_fneg_nonsubnnorm(float nofpclass(nsub nnorm) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(psub pnorm) float @returned_fneg_nonsubnnorm ; CHECK-LABEL: define nofpclass(psub pnorm) float @returned_fneg_nonsubnnorm
; CHECK-SAME: (float nofpclass(nsub nnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(nsub nnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]] ; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]]
; CHECK-NEXT: ret float [[FNEG]] ; CHECK-NEXT: ret float [[FNEG]]
; ;
%fneg = fneg float %x %fneg = fneg float %x
ret float %fneg ret float %fneg
} }
define float @returned_fneg_nopos(float nofpclass(pinf psub pnorm pzero) %x) { define float @returned_fneg_nopos(float nofpclass(pinf psub pnorm pzero) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fneg_nopos ; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fneg_nopos
; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]] ; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]]
; CHECK-NEXT: ret float [[FNEG]] ; CHECK-NEXT: ret float [[FNEG]]
; ;
%fneg = fneg float %x %fneg = fneg float %x
ret float %fneg ret float %fneg
} }
define float @returned_fneg_nopnormpsub(float nofpclass(psub pnorm) %x) { define float @returned_fneg_nopnormpsub(float nofpclass(psub pnorm) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nsub nnorm) float @returned_fneg_nopnormpsub ; CHECK-LABEL: define nofpclass(nsub nnorm) float @returned_fneg_nopnormpsub
; CHECK-SAME: (float nofpclass(psub pnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(psub pnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]] ; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]]
; CHECK-NEXT: ret float [[FNEG]] ; CHECK-NEXT: ret float [[FNEG]]
; ;
%fneg = fneg float %x %fneg = fneg float %x
ret float %fneg ret float %fneg
} }
define float @returned_fneg_mixed(float nofpclass(psub nnorm nzero qnan ninf) %x) { define float @returned_fneg_mixed(float nofpclass(psub nnorm nzero qnan ninf) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(qnan pinf pzero nsub pnorm) float @returned_fneg_mixed ; CHECK-LABEL: define nofpclass(qnan pinf pzero nsub pnorm) float @returned_fneg_mixed
; CHECK-SAME: (float nofpclass(qnan ninf nzero psub nnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(qnan ninf nzero psub nnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]] ; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[X]]
; CHECK-NEXT: ret float [[FNEG]] ; CHECK-NEXT: ret float [[FNEG]]
; ;
%fneg = fneg float %x %fneg = fneg float %x
ret float %fneg ret float %fneg
} }
define float @returned_fneg_fabs(float %x) { define float @returned_fneg_fabs(float %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @returned_fneg_fabs ; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @returned_fneg_fabs
; CHECK-SAME: (float [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR13]]
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]]
; CHECK-NEXT: ret float [[FNEG_FABS]] ; CHECK-NEXT: ret float [[FNEG_FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
ret float %fneg.fabs ret float %fneg.fabs
} }
define float @returned_fneg_fabs_nosnan(float nofpclass(snan) %x) { define float @returned_fneg_fabs_nosnan(float nofpclass(snan) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(snan pinf pzero psub pnorm) float @returned_fneg_fabs_nosnan ; CHECK-LABEL: define nofpclass(snan pinf pzero psub pnorm) float @returned_fneg_fabs_nosnan
; CHECK-SAME: (float nofpclass(snan) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(snan) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(snan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(snan) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(snan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(snan) [[X]]) #[[ATTR13]]
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]]
; CHECK-NEXT: ret float [[FNEG_FABS]] ; CHECK-NEXT: ret float [[FNEG_FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
ret float %fneg.fabs ret float %fneg.fabs
} }
define float @returned_fneg_fabs_noqnan(float nofpclass(qnan) %x) { define float @returned_fneg_fabs_noqnan(float nofpclass(qnan) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(qnan pinf pzero psub pnorm) float @returned_fneg_fabs_noqnan ; CHECK-LABEL: define nofpclass(qnan pinf pzero psub pnorm) float @returned_fneg_fabs_noqnan
; CHECK-SAME: (float nofpclass(qnan) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(qnan) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(qnan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(qnan) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(qnan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(qnan) [[X]]) #[[ATTR13]]
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]]
; CHECK-NEXT: ret float [[FNEG_FABS]] ; CHECK-NEXT: ret float [[FNEG_FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
ret float %fneg.fabs ret float %fneg.fabs
} }
define float @returned_fneg_fabs_nonan(float nofpclass(nan) %x) { define float @returned_fneg_fabs_nonan(float nofpclass(nan) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan pinf pzero psub pnorm) float @returned_fneg_fabs_nonan ; CHECK-LABEL: define nofpclass(nan pinf pzero psub pnorm) float @returned_fneg_fabs_nonan
; CHECK-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan) [[X]]) #[[ATTR13]]
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]]
; CHECK-NEXT: ret float [[FNEG_FABS]] ; CHECK-NEXT: ret float [[FNEG_FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
ret float %fneg.fabs ret float %fneg.fabs
} }
define float @returned_fneg_fabs_noneg(float nofpclass(ninf nsub nnorm nzero) %x) { define float @returned_fneg_fabs_noneg(float nofpclass(ninf nsub nnorm nzero) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @returned_fneg_fabs_noneg ; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @returned_fneg_fabs_noneg
; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf nzero nsub nnorm) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf nzero nsub nnorm) [[X]]) #[[ATTR13]]
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]]
; CHECK-NEXT: ret float [[FNEG_FABS]] ; CHECK-NEXT: ret float [[FNEG_FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
ret float %fneg.fabs ret float %fneg.fabs
} }
define float @returned_fneg_fabs_nopos(float nofpclass(pinf psub pnorm pzero) %x) { define float @returned_fneg_fabs_nopos(float nofpclass(pinf psub pnorm pzero) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @returned_fneg_fabs_nopos ; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @returned_fneg_fabs_nopos
; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf pzero psub pnorm) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf pzero psub pnorm) [[X]]) #[[ATTR13]]
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]]
; CHECK-NEXT: ret float [[FNEG_FABS]] ; CHECK-NEXT: ret float [[FNEG_FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
ret float %fneg.fabs ret float %fneg.fabs
} }
define float @returned_fneg_fabs_mixed(float nofpclass(psub nnorm nzero qnan ninf) %x) { define float @returned_fneg_fabs_mixed(float nofpclass(psub nnorm nzero qnan ninf) %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(qnan pinf pzero psub pnorm) float @returned_fneg_fabs_mixed ; CHECK-LABEL: define nofpclass(qnan pinf pzero psub pnorm) float @returned_fneg_fabs_mixed
; CHECK-SAME: (float nofpclass(qnan ninf nzero psub nnorm) [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(qnan ninf nzero psub nnorm) [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(qnan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(qnan ninf nzero psub nnorm) [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(qnan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(qnan ninf nzero psub nnorm) [[X]]) #[[ATTR13]]
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]]
; CHECK-NEXT: ret float [[FNEG_FABS]] ; CHECK-NEXT: ret float [[FNEG_FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
ret float %fneg.fabs ret float %fneg.fabs
} }
define float @returned_fneg_fabs_ninf_flag_fabs(float %x) { define float @returned_fneg_fabs_ninf_flag_fabs(float %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(inf pzero psub pnorm) float @returned_fneg_fabs_ninf_flag_fabs ; CHECK-LABEL: define nofpclass(inf pzero psub pnorm) float @returned_fneg_fabs_ninf_flag_fabs
; CHECK-SAME: (float [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call ninf nofpclass(inf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call ninf nofpclass(inf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR13]]
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]] ; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg float [[FABS]]
; CHECK-NEXT: ret float [[FNEG_FABS]] ; CHECK-NEXT: ret float [[FNEG_FABS]]
; ;
%fabs = call ninf float @llvm.fabs.f32(float %x) %fabs = call ninf float @llvm.fabs.f32(float %x)
%fneg.fabs = fneg float %fabs %fneg.fabs = fneg float %fabs
ret float %fneg.fabs ret float %fneg.fabs
} }
define float @returned_fneg_fabs_ninf_flag_fneg(float %x) { define float @returned_fneg_fabs_ninf_flag_fneg(float %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(inf pzero psub pnorm) float @returned_fneg_fabs_ninf_flag_fneg ; CHECK-LABEL: define nofpclass(inf pzero psub pnorm) float @returned_fneg_fabs_ninf_flag_fneg
; CHECK-SAME: (float [[X:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float [[X:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR13]] ; CHECK-NEXT: [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR13]]
; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg ninf float [[FABS]] ; CHECK-NEXT: [[FNEG_FABS:%.*]] = fneg ninf float [[FABS]]
; CHECK-NEXT: ret float [[FNEG_FABS]] ; CHECK-NEXT: ret float [[FNEG_FABS]]
; ;
%fabs = call float @llvm.fabs.f32(float %x) %fabs = call float @llvm.fabs.f32(float %x)
%fneg.fabs = fneg ninf float %fabs %fneg.fabs = fneg ninf float %fabs
ret float %fneg.fabs ret float %fneg.fabs
} }
define float @uitofp_i32_to_f32(i32 %arg) { define float @uitofp_i32_to_f32(i32 %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan inf nzero sub nnorm) float @uitofp_i32_to_f32 ; CHECK-LABEL: define nofpclass(nan inf nzero sub nnorm) float @uitofp_i32_to_f32
; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[CVT:%.*]] = uitofp i32 [[ARG]] to float ; CHECK-NEXT: [[CVT:%.*]] = uitofp i32 [[ARG]] to float
; CHECK-NEXT: ret float [[CVT]] ; CHECK-NEXT: ret float [[CVT]]
; ;
%cvt = uitofp i32 %arg to float %cvt = uitofp i32 %arg to float
ret float %cvt ret float %cvt
} }
define float @sitofp_i32_to_f32(i32 %arg) { define float @sitofp_i32_to_f32(i32 %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan inf nzero sub) float @sitofp_i32_to_f32 ; CHECK-LABEL: define nofpclass(nan inf nzero sub) float @sitofp_i32_to_f32
; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[CVT:%.*]] = sitofp i32 [[ARG]] to float ; CHECK-NEXT: [[CVT:%.*]] = sitofp i32 [[ARG]] to float
; CHECK-NEXT: ret float [[CVT]] ; CHECK-NEXT: ret float [[CVT]]
; ;
%cvt = sitofp i32 %arg to float %cvt = sitofp i32 %arg to float
ret float %cvt ret float %cvt
} }
define <2 x float> @uitofp_v2i32_to_v2f32(<2 x i32> %arg) { define <2 x float> @uitofp_v2i32_to_v2f32(<2 x i32> %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan inf nzero sub nnorm) <2 x float> @uitofp_v2i32_to_v2f32 ; CHECK-LABEL: define nofpclass(nan inf nzero sub nnorm) <2 x float> @uitofp_v2i32_to_v2f32
; CHECK-SAME: (<2 x i32> [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<2 x i32> [[ARG:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[CVT:%.*]] = uitofp <2 x i32> [[ARG]] to <2 x float> ; CHECK-NEXT: [[CVT:%.*]] = uitofp <2 x i32> [[ARG]] to <2 x float>
; CHECK-NEXT: ret <2 x float> [[CVT]] ; CHECK-NEXT: ret <2 x float> [[CVT]]
; ;
%cvt = uitofp <2 x i32> %arg to <2 x float> %cvt = uitofp <2 x i32> %arg to <2 x float>
ret <2 x float> %cvt ret <2 x float> %cvt
} }
define <2 x float> @sitofp_v2i32_to_v2i32(<2 x i32> %arg) { define <2 x float> @sitofp_v2i32_to_v2i32(<2 x i32> %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan inf nzero sub) <2 x float> @sitofp_v2i32_to_v2i32 ; CHECK-LABEL: define nofpclass(nan inf nzero sub) <2 x float> @sitofp_v2i32_to_v2i32
; CHECK-SAME: (<2 x i32> [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<2 x i32> [[ARG:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[CVT:%.*]] = sitofp <2 x i32> [[ARG]] to <2 x float> ; CHECK-NEXT: [[CVT:%.*]] = sitofp <2 x i32> [[ARG]] to <2 x float>
; CHECK-NEXT: ret <2 x float> [[CVT]] ; CHECK-NEXT: ret <2 x float> [[CVT]]
; ;
%cvt = sitofp <2 x i32> %arg to <2 x float> %cvt = sitofp <2 x i32> %arg to <2 x float>
ret <2 x float> %cvt ret <2 x float> %cvt
} }
define half @uitofp_i17_to_f16(i17 %arg) { define half @uitofp_i17_to_f16(i17 %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) half @uitofp_i17_to_f16 ; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) half @uitofp_i17_to_f16
; CHECK-SAME: (i17 [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (i17 [[ARG:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[CVT:%.*]] = uitofp i17 [[ARG]] to half ; CHECK-NEXT: [[CVT:%.*]] = uitofp i17 [[ARG]] to half
; CHECK-NEXT: ret half [[CVT]] ; CHECK-NEXT: ret half [[CVT]]
; ;
%cvt = uitofp i17 %arg to half %cvt = uitofp i17 %arg to half
ret half %cvt ret half %cvt
} }
define half @sitofp_i17_to_f16(i17 %arg) { define half @sitofp_i17_to_f16(i17 %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan nzero sub) half @sitofp_i17_to_f16 ; CHECK-LABEL: define nofpclass(nan nzero sub) half @sitofp_i17_to_f16
; CHECK-SAME: (i17 [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (i17 [[ARG:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[CVT:%.*]] = sitofp i17 [[ARG]] to half ; CHECK-NEXT: [[CVT:%.*]] = sitofp i17 [[ARG]] to half
; CHECK-NEXT: ret half [[CVT]] ; CHECK-NEXT: ret half [[CVT]]
; ;
%cvt = sitofp i17 %arg to half %cvt = sitofp i17 %arg to half
ret half %cvt ret half %cvt
} }
define <2 x half> @uitofp_v2i17_to_v2f16(<2 x i17> %arg) { define <2 x half> @uitofp_v2i17_to_v2f16(<2 x i17> %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) <2 x half> @uitofp_v2i17_to_v2f16 ; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) <2 x half> @uitofp_v2i17_to_v2f16
; CHECK-SAME: (<2 x i17> [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<2 x i17> [[ARG:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[CVT:%.*]] = uitofp <2 x i17> [[ARG]] to <2 x half> ; CHECK-NEXT: [[CVT:%.*]] = uitofp <2 x i17> [[ARG]] to <2 x half>
; CHECK-NEXT: ret <2 x half> [[CVT]] ; CHECK-NEXT: ret <2 x half> [[CVT]]
; ;
%cvt = uitofp <2 x i17> %arg to <2 x half> %cvt = uitofp <2 x i17> %arg to <2 x half>
ret <2 x half> %cvt ret <2 x half> %cvt
} }
define <2 x half> @sitofp_v2i17_to_v2i17(<2 x i17> %arg) { define <2 x half> @sitofp_v2i17_to_v2i17(<2 x i17> %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan nzero sub) <2 x half> @sitofp_v2i17_to_v2i17 ; CHECK-LABEL: define nofpclass(nan nzero sub) <2 x half> @sitofp_v2i17_to_v2i17
; CHECK-SAME: (<2 x i17> [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<2 x i17> [[ARG:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[CVT:%.*]] = sitofp <2 x i17> [[ARG]] to <2 x half> ; CHECK-NEXT: [[CVT:%.*]] = sitofp <2 x i17> [[ARG]] to <2 x half>
; CHECK-NEXT: ret <2 x half> [[CVT]] ; CHECK-NEXT: ret <2 x half> [[CVT]]
; ;
%cvt = sitofp <2 x i17> %arg to <2 x half> %cvt = sitofp <2 x i17> %arg to <2 x half>
ret <2 x half> %cvt ret <2 x half> %cvt
} }
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Linesentry:
call void @llvm.assume(i1 %class1) call void @llvm.assume(i1 %class1)
%class2 = call i1 @llvm.is.fpclass.f32(float %arg, i32 341) %class2 = call i1 @llvm.is.fpclass.f32(float %arg, i32 341)
call void @llvm.assume(i1 %class2) call void @llvm.assume(i1 %class2)
call void @extern.use(float %arg) call void @extern.use(float %arg)
ret float %arg ret float %arg
} }
define float @returned_extractelement_dynamic_index(<4 x float> nofpclass(nan) %vec, i32 %idx) { define float @returned_extractelement_dynamic_index(<4 x float> nofpclass(nan) %vec, i32 %idx) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan) float @returned_extractelement_dynamic_index ; CHECK-LABEL: define nofpclass(nan) float @returned_extractelement_dynamic_index
; CHECK-SAME: (<4 x float> nofpclass(nan) [[VEC:%.*]], i32 [[IDX:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<4 x float> nofpclass(nan) [[VEC:%.*]], i32 [[IDX:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[VEC]], i32 [[IDX]] ; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[VEC]], i32 [[IDX]]
; CHECK-NEXT: ret float [[EXTRACT]] ; CHECK-NEXT: ret float [[EXTRACT]]
; ;
%extract = extractelement <4 x float> %vec, i32 %idx %extract = extractelement <4 x float> %vec, i32 %idx
ret float %extract ret float %extract
} }
define float @returned_extractelement_index0(<4 x float> nofpclass(nan) %vec) { define float @returned_extractelement_index0(<4 x float> nofpclass(nan) %vec) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan) float @returned_extractelement_index0 ; CHECK-LABEL: define nofpclass(nan) float @returned_extractelement_index0
; CHECK-SAME: (<4 x float> nofpclass(nan) [[VEC:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<4 x float> nofpclass(nan) [[VEC:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[VEC]], i32 0 ; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[VEC]], i32 0
; CHECK-NEXT: ret float [[EXTRACT]] ; CHECK-NEXT: ret float [[EXTRACT]]
; ;
%extract = extractelement <4 x float> %vec, i32 0 %extract = extractelement <4 x float> %vec, i32 0
ret float %extract ret float %extract
} }
define float @returned_extractelement_index_oob(<4 x float> nofpclass(nan) %vec) { define float @returned_extractelement_index_oob(<4 x float> nofpclass(nan) %vec) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan) float @returned_extractelement_index_oob ; CHECK-LABEL: define nofpclass(nan) float @returned_extractelement_index_oob
; CHECK-SAME: (<4 x float> nofpclass(nan) [[VEC:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<4 x float> nofpclass(nan) [[VEC:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[VEC]], i32 5 ; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[VEC]], i32 5
; CHECK-NEXT: ret float [[EXTRACT]] ; CHECK-NEXT: ret float [[EXTRACT]]
; ;
%extract = extractelement <4 x float> %vec, i32 5 %extract = extractelement <4 x float> %vec, i32 5
ret float %extract ret float %extract
} }
define float @returned_extractelement_scalable(<vscale x 4 x float> nofpclass(nan) %vec) { define float @returned_extractelement_scalable(<vscale x 4 x float> nofpclass(nan) %vec) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @returned_extractelement_scalable ; CHECK-LABEL: define float @returned_extractelement_scalable
; CHECK-SAME: (<vscale x 4 x float> nofpclass(nan) [[VEC:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<vscale x 4 x float> nofpclass(nan) [[VEC:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <vscale x 4 x float> [[VEC]], i32 0 ; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <vscale x 4 x float> [[VEC]], i32 0
; CHECK-NEXT: ret float [[EXTRACT]] ; CHECK-NEXT: ret float [[EXTRACT]]
; ;
%extract = extractelement <vscale x 4 x float> %vec, i32 0 %extract = extractelement <vscale x 4 x float> %vec, i32 0
ret float %extract ret float %extract
} }
define float @returned_extractvalue([4 x float] nofpclass(nan) %array) { define float @returned_extractvalue([4 x float] nofpclass(nan) %array) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan) float @returned_extractvalue ; CHECK-LABEL: define nofpclass(nan) float @returned_extractvalue
; CHECK-SAME: ([4 x float] nofpclass(nan) [[ARRAY:%.*]]) #[[ATTR2]] { ; CHECK-SAME: ([4 x float] nofpclass(nan) [[ARRAY:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[EXTRACT:%.*]] = extractvalue [4 x float] [[ARRAY]], 0 ; CHECK-NEXT: [[EXTRACT:%.*]] = extractvalue [4 x float] [[ARRAY]], 0
; CHECK-NEXT: ret float [[EXTRACT]] ; CHECK-NEXT: ret float [[EXTRACT]]
; ;
%extract = extractvalue [4 x float] %array, 0 %extract = extractvalue [4 x float] %array, 0
ret float %extract ret float %extract
} }
define float @return_nofpclass_freeze_nan_arg(float nofpclass(nan) %arg) { define float @return_nofpclass_freeze_nan_arg(float nofpclass(nan) %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define noundef float @return_nofpclass_freeze_nan_arg ; CHECK-LABEL: define noundef float @return_nofpclass_freeze_nan_arg
; CHECK-SAME: (float nofpclass(nan) [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(nan) [[ARG:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FREEZE:%.*]] = freeze float [[ARG]] ; CHECK-NEXT: [[FREEZE:%.*]] = freeze float [[ARG]]
; CHECK-NEXT: ret float [[FREEZE]] ; CHECK-NEXT: ret float [[FREEZE]]
; ;
%freeze = freeze float %arg %freeze = freeze float %arg
ret float %freeze ret float %freeze
} }
define float @return_nofpclass_extractelement_freeze_pinf_arg(<2 x float> nofpclass(pinf) %arg) { define float @return_nofpclass_extractelement_freeze_pinf_arg(<2 x float> nofpclass(pinf) %arg) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define noundef float @return_nofpclass_extractelement_freeze_pinf_arg ; CHECK-LABEL: define noundef float @return_nofpclass_extractelement_freeze_pinf_arg
; CHECK-SAME: (<2 x float> nofpclass(pinf) [[ARG:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<2 x float> nofpclass(pinf) [[ARG:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[FREEZE:%.*]] = freeze <2 x float> [[ARG]] ; CHECK-NEXT: [[FREEZE:%.*]] = freeze <2 x float> [[ARG]]
; CHECK-NEXT: [[ELT:%.*]] = extractelement <2 x float> [[FREEZE]], i32 0 ; CHECK-NEXT: [[ELT:%.*]] = extractelement <2 x float> [[FREEZE]], i32 0
; CHECK-NEXT: ret float [[ELT]] ; CHECK-NEXT: ret float [[ELT]]
; ;
%freeze = freeze <2 x float> %arg %freeze = freeze <2 x float> %arg
%elt = extractelement <2 x float> %freeze, i32 0 %elt = extractelement <2 x float> %freeze, i32 0
ret float %elt ret float %elt
} }
define <4 x float> @insertelement_constant_chain() { define <4 x float> @insertelement_constant_chain() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan ninf nzero sub) <4 x float> @insertelement_constant_chain ; CHECK-LABEL: define nofpclass(nan ninf nzero sub) <4 x float> @insertelement_constant_chain
; CHECK-SAME: () #[[ATTR2]] { ; CHECK-SAME: () #[[ATTR2]] {
; CHECK-NEXT: [[INS_0:%.*]] = insertelement <4 x float> poison, float 1.000000e+00, i32 0 ; CHECK-NEXT: [[INS_0:%.*]] = insertelement <4 x float> poison, float 1.000000e+00, i32 0
; CHECK-NEXT: [[INS_1:%.*]] = insertelement <4 x float> [[INS_0]], float 0.000000e+00, i32 1 ; CHECK-NEXT: [[INS_1:%.*]] = insertelement <4 x float> [[INS_0]], float 0.000000e+00, i32 1
; CHECK-NEXT: [[INS_2:%.*]] = insertelement <4 x float> [[INS_1]], float -9.000000e+00, i32 2 ; CHECK-NEXT: [[INS_2:%.*]] = insertelement <4 x float> [[INS_1]], float -9.000000e+00, i32 2
; CHECK-NEXT: [[INS_3:%.*]] = insertelement <4 x float> [[INS_2]], float 0x7FF0000000000000, i32 3 ; CHECK-NEXT: [[INS_3:%.*]] = insertelement <4 x float> [[INS_2]], float 0x7FF0000000000000, i32 3
; CHECK-NEXT: ret <4 x float> [[INS_3]] ; CHECK-NEXT: ret <4 x float> [[INS_3]]
; ;
%ins.0 = insertelement <4 x float> poison, float 1.0, i32 0 %ins.0 = insertelement <4 x float> poison, float 1.0, i32 0
%ins.1 = insertelement <4 x float> %ins.0, float 0.0, i32 1 %ins.1 = insertelement <4 x float> %ins.0, float 0.0, i32 1
%ins.2 = insertelement <4 x float> %ins.1, float -9.0, i32 2 %ins.2 = insertelement <4 x float> %ins.1, float -9.0, i32 2
%ins.3 = insertelement <4 x float> %ins.2, float 0x7FF0000000000000, i32 3 %ins.3 = insertelement <4 x float> %ins.2, float 0x7FF0000000000000, i32 3
ret <4 x float> %ins.3 ret <4 x float> %ins.3
} }
define <vscale x 4 x float> @insertelement_scalable_constant_chain() { define <vscale x 4 x float> @insertelement_scalable_constant_chain() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define <vscale x 4 x float> @insertelement_scalable_constant_chain ; CHECK-LABEL: define <vscale x 4 x float> @insertelement_scalable_constant_chain
; CHECK-SAME: () #[[ATTR2]] { ; CHECK-SAME: () #[[ATTR2]] {
; CHECK-NEXT: [[INS_0:%.*]] = insertelement <vscale x 4 x float> poison, float 1.000000e+00, i32 0 ; CHECK-NEXT: [[INS_0:%.*]] = insertelement <vscale x 4 x float> poison, float 1.000000e+00, i32 0
; CHECK-NEXT: [[INS_1:%.*]] = insertelement <vscale x 4 x float> [[INS_0]], float 0.000000e+00, i32 1 ; CHECK-NEXT: [[INS_1:%.*]] = insertelement <vscale x 4 x float> [[INS_0]], float 0.000000e+00, i32 1
; CHECK-NEXT: [[INS_2:%.*]] = insertelement <vscale x 4 x float> [[INS_1]], float -9.000000e+00, i32 2 ; CHECK-NEXT: [[INS_2:%.*]] = insertelement <vscale x 4 x float> [[INS_1]], float -9.000000e+00, i32 2
; CHECK-NEXT: [[INS_3:%.*]] = insertelement <vscale x 4 x float> [[INS_2]], float 0x7FF0000000000000, i32 3 ; CHECK-NEXT: [[INS_3:%.*]] = insertelement <vscale x 4 x float> [[INS_2]], float 0x7FF0000000000000, i32 3
; CHECK-NEXT: ret <vscale x 4 x float> [[INS_3]] ; CHECK-NEXT: ret <vscale x 4 x float> [[INS_3]]
; ;
%ins.0 = insertelement <vscale x 4 x float> poison, float 1.0, i32 0 %ins.0 = insertelement <vscale x 4 x float> poison, float 1.0, i32 0
%ins.1 = insertelement <vscale x 4 x float> %ins.0, float 0.0, i32 1 %ins.1 = insertelement <vscale x 4 x float> %ins.0, float 0.0, i32 1
%ins.2 = insertelement <vscale x 4 x float> %ins.1, float -9.0, i32 2 %ins.2 = insertelement <vscale x 4 x float> %ins.1, float -9.0, i32 2
%ins.3 = insertelement <vscale x 4 x float> %ins.2, float 0x7FF0000000000000, i32 3 %ins.3 = insertelement <vscale x 4 x float> %ins.2, float 0x7FF0000000000000, i32 3
ret <vscale x 4 x float> %ins.3 ret <vscale x 4 x float> %ins.3
} }
define <4 x float> @insertelement_unknown_base(<4 x float> %arg0) { define <4 x float> @insertelement_unknown_base(<4 x float> %arg0) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define <4 x float> @insertelement_unknown_base ; CHECK-LABEL: define <4 x float> @insertelement_unknown_base
; CHECK-SAME: (<4 x float> [[ARG0:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<4 x float> [[ARG0:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 1 ; CHECK-NEXT: [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 1
; CHECK-NEXT: ret <4 x float> [[INSERT]] ; CHECK-NEXT: ret <4 x float> [[INSERT]]
; ;
%insert = insertelement <4 x float> %arg0, float 0.0, i32 1 %insert = insertelement <4 x float> %arg0, float 0.0, i32 1
ret <4 x float> %insert ret <4 x float> %insert
} }
define float @insertelement_extractelement_same(<4 x float> %arg0) { define float @insertelement_extractelement_same(<4 x float> %arg0) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan inf nzero sub norm) float @insertelement_extractelement_same ; CHECK-LABEL: define nofpclass(nan inf nzero sub norm) float @insertelement_extractelement_same
; CHECK-SAME: (<4 x float> [[ARG0:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<4 x float> [[ARG0:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 1 ; CHECK-NEXT: [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 1
; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[INSERT]], i32 1 ; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[INSERT]], i32 1
; CHECK-NEXT: ret float [[EXTRACT]] ; CHECK-NEXT: ret float [[EXTRACT]]
; ;
%insert = insertelement <4 x float> %arg0, float 0.0, i32 1 %insert = insertelement <4 x float> %arg0, float 0.0, i32 1
%extract = extractelement <4 x float> %insert, i32 1 %extract = extractelement <4 x float> %insert, i32 1
ret float %extract ret float %extract
} }
define float @insertelement_extractelement_different(<4 x float> nofpclass(zero) %arg0) { define float @insertelement_extractelement_different(<4 x float> nofpclass(zero) %arg0) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(zero) float @insertelement_extractelement_different ; CHECK-LABEL: define nofpclass(zero) float @insertelement_extractelement_different
; CHECK-SAME: (<4 x float> nofpclass(zero) [[ARG0:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<4 x float> nofpclass(zero) [[ARG0:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 1 ; CHECK-NEXT: [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 1
; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[INSERT]], i32 2 ; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[INSERT]], i32 2
; CHECK-NEXT: ret float [[EXTRACT]] ; CHECK-NEXT: ret float [[EXTRACT]]
; ;
%insert = insertelement <4 x float> %arg0, float 0.0, i32 1 %insert = insertelement <4 x float> %arg0, float 0.0, i32 1
%extract = extractelement <4 x float> %insert, i32 2 %extract = extractelement <4 x float> %insert, i32 2
ret float %extract ret float %extract
} }
define float @insertelement_extractelement_unknown(<4 x float> nofpclass(zero) %arg0, i32 %idx) { define float @insertelement_extractelement_unknown(<4 x float> nofpclass(zero) %arg0, i32 %idx) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nzero) float @insertelement_extractelement_unknown ; CHECK-LABEL: define nofpclass(nzero) float @insertelement_extractelement_unknown
; CHECK-SAME: (<4 x float> nofpclass(zero) [[ARG0:%.*]], i32 [[IDX:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<4 x float> nofpclass(zero) [[ARG0:%.*]], i32 [[IDX:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 1 ; CHECK-NEXT: [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 1
; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[INSERT]], i32 [[IDX]] ; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[INSERT]], i32 [[IDX]]
; CHECK-NEXT: ret float [[EXTRACT]] ; CHECK-NEXT: ret float [[EXTRACT]]
; ;
%insert = insertelement <4 x float> %arg0, float 0.0, i32 1 %insert = insertelement <4 x float> %arg0, float 0.0, i32 1
%extract = extractelement <4 x float> %insert, i32 %idx %extract = extractelement <4 x float> %insert, i32 %idx
ret float %extract ret float %extract
} }
define <4 x float> @insertelement_index_oob_chain() { define <4 x float> @insertelement_index_oob_chain() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define <4 x float> @insertelement_index_oob_chain ; CHECK-LABEL: define <4 x float> @insertelement_index_oob_chain
; CHECK-SAME: () #[[ATTR2]] { ; CHECK-SAME: () #[[ATTR2]] {
; CHECK-NEXT: [[INSERT:%.*]] = insertelement <4 x float> zeroinitializer, float 0x7FF0000000000000, i32 4 ; CHECK-NEXT: [[INSERT:%.*]] = insertelement <4 x float> zeroinitializer, float 0x7FF0000000000000, i32 4
; CHECK-NEXT: ret <4 x float> [[INSERT]] ; CHECK-NEXT: ret <4 x float> [[INSERT]]
; ;
%insert = insertelement <4 x float> zeroinitializer, float 0x7FF0000000000000, i32 4 %insert = insertelement <4 x float> zeroinitializer, float 0x7FF0000000000000, i32 4
ret <4 x float> %insert ret <4 x float> %insert
} }
define <2 x float> @multiple_extractelement(<4 x float> nofpclass(zero) %arg0) { define <2 x float> @multiple_extractelement(<4 x float> nofpclass(zero) %arg0) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(zero) <2 x float> @multiple_extractelement ; CHECK-LABEL: define nofpclass(zero) <2 x float> @multiple_extractelement
; CHECK-SAME: (<4 x float> nofpclass(zero) [[ARG0:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<4 x float> nofpclass(zero) [[ARG0:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 1 ; CHECK-NEXT: [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 1
; CHECK-NEXT: [[EXTRACT2:%.*]] = extractelement <4 x float> [[INSERT]], i32 2 ; CHECK-NEXT: [[EXTRACT2:%.*]] = extractelement <4 x float> [[INSERT]], i32 2
; CHECK-NEXT: [[EXTRACT3:%.*]] = extractelement <4 x float> [[INSERT]], i32 3 ; CHECK-NEXT: [[EXTRACT3:%.*]] = extractelement <4 x float> [[INSERT]], i32 3
; CHECK-NEXT: [[INS_0:%.*]] = insertelement <2 x float> poison, float [[EXTRACT3]], i32 0 ; CHECK-NEXT: [[INS_0:%.*]] = insertelement <2 x float> poison, float [[EXTRACT3]], i32 0
; CHECK-NEXT: [[INS_1:%.*]] = insertelement <2 x float> [[INS_0]], float [[EXTRACT2]], i32 1 ; CHECK-NEXT: [[INS_1:%.*]] = insertelement <2 x float> [[INS_0]], float [[EXTRACT2]], i32 1
; CHECK-NEXT: ret <2 x float> [[INS_1]] ; CHECK-NEXT: ret <2 x float> [[INS_1]]
; ;
%insert = insertelement <4 x float> %arg0, float 0.0, i32 1 %insert = insertelement <4 x float> %arg0, float 0.0, i32 1
%extract2 = extractelement <4 x float> %insert, i32 2 %extract2 = extractelement <4 x float> %insert, i32 2
%extract3 = extractelement <4 x float> %insert, i32 3 %extract3 = extractelement <4 x float> %insert, i32 3
%ins.0 = insertelement <2 x float> poison, float %extract3, i32 0 %ins.0 = insertelement <2 x float> poison, float %extract3, i32 0
%ins.1 = insertelement <2 x float> %ins.0, float %extract2, i32 1 %ins.1 = insertelement <2 x float> %ins.0, float %extract2, i32 1
ret <2 x float> %ins.1 ret <2 x float> %ins.1
} }
; FIXME: Doesn't actually reach computeKnownFPClass ; FIXME: Doesn't actually reach computeKnownFPClass
define <4 x float> @shufflevector_constexpr() { define <4 x float> @shufflevector_constexpr() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define <4 x float> @shufflevector_constexpr ; CHECK-LABEL: define <4 x float> @shufflevector_constexpr
; CHECK-SAME: () #[[ATTR2]] { ; CHECK-SAME: () #[[ATTR2]] {
; CHECK-NEXT: ret <4 x float> <float 1.000000e+00, float bitcast (i32 ptrtoint (ptr @shufflevector_constexpr to i32) to float), float 4.000000e+00, float 0.000000e+00> ; CHECK-NEXT: ret <4 x float> <float 1.000000e+00, float bitcast (i32 ptrtoint (ptr @shufflevector_constexpr to i32) to float), float 4.000000e+00, float 0.000000e+00>
; ;
ret <4 x float> shufflevector (<2 x float> <float 1.0, float bitcast (i32 ptrtoint (ptr @shufflevector_constexpr to i32) to float)>, <2 x float> <float 4.0, float 0.0>, <4 x i32> <i32 0, i32 1, i32 2, i32 3>) ret <4 x float> shufflevector (<2 x float> <float 1.0, float bitcast (i32 ptrtoint (ptr @shufflevector_constexpr to i32) to float)>, <2 x float> <float 4.0, float 0.0>, <4 x i32> <i32 0, i32 1, i32 2, i32 3>)
} }
define <4 x float> @shufflevector_concat_disjoint(<2 x float> nofpclass(nan) %arg0, <2 x float> nofpclass(inf) %arg1) { define <4 x float> @shufflevector_concat_disjoint(<2 x float> nofpclass(nan) %arg0, <2 x float> nofpclass(inf) %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define <4 x float> @shufflevector_concat_disjoint ; CHECK-LABEL: define <4 x float> @shufflevector_concat_disjoint
; CHECK-SAME: (<2 x float> nofpclass(nan) [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<2 x float> nofpclass(nan) [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 0, i32 1, i32 2, i32 3> ; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 0, i32 1, i32 2, i32 3>
; CHECK-NEXT: ret <4 x float> [[SHUFFLE]] ; CHECK-NEXT: ret <4 x float> [[SHUFFLE]]
; ;
%shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 0, i32 1, i32 2, i32 3> %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
ret <4 x float> %shuffle ret <4 x float> %shuffle
} }
define <4 x float> @shufflevector_concat_overlap(<2 x float> nofpclass(nan norm psub) %arg0, <2 x float> nofpclass(inf nan sub) %arg1) { define <4 x float> @shufflevector_concat_overlap(<2 x float> nofpclass(nan norm psub) %arg0, <2 x float> nofpclass(inf nan sub) %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nan psub) <4 x float> @shufflevector_concat_overlap ; CHECK-LABEL: define nofpclass(nan psub) <4 x float> @shufflevector_concat_overlap
; CHECK-SAME: (<2 x float> nofpclass(nan psub norm) [[ARG0:%.*]], <2 x float> nofpclass(nan inf sub) [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<2 x float> nofpclass(nan psub norm) [[ARG0:%.*]], <2 x float> nofpclass(nan inf sub) [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 0, i32 1, i32 2, i32 3> ; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 0, i32 1, i32 2, i32 3>
; CHECK-NEXT: ret <4 x float> [[SHUFFLE]] ; CHECK-NEXT: ret <4 x float> [[SHUFFLE]]
; ;
%shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 0, i32 1, i32 2, i32 3> %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
ret <4 x float> %shuffle ret <4 x float> %shuffle
} }
define <4 x float> @shufflevector_unknown_lhs(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) { define <4 x float> @shufflevector_unknown_lhs(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define <4 x float> @shufflevector_unknown_lhs ; CHECK-LABEL: define <4 x float> @shufflevector_unknown_lhs
; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 3, i32 2, i32 1, i32 0> ; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 3, i32 2, i32 1, i32 0>
; CHECK-NEXT: ret <4 x float> [[SHUFFLE]] ; CHECK-NEXT: ret <4 x float> [[SHUFFLE]]
; ;
%shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 3, i32 2, i32 1, i32 0> %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
ret <4 x float> %shuffle ret <4 x float> %shuffle
} }
define <4 x float> @shufflevector_unknown_rhs(<2 x float> nofpclass(inf) %arg0, <2 x float> %arg1) { define <4 x float> @shufflevector_unknown_rhs(<2 x float> nofpclass(inf) %arg0, <2 x float> %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define <4 x float> @shufflevector_unknown_rhs ; CHECK-LABEL: define <4 x float> @shufflevector_unknown_rhs
; CHECK-SAME: (<2 x float> nofpclass(inf) [[ARG0:%.*]], <2 x float> [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<2 x float> nofpclass(inf) [[ARG0:%.*]], <2 x float> [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 3, i32 2, i32 1, i32 0> ; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 3, i32 2, i32 1, i32 0>
; CHECK-NEXT: ret <4 x float> [[SHUFFLE]] ; CHECK-NEXT: ret <4 x float> [[SHUFFLE]]
; ;
%shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 3, i32 2, i32 1, i32 0> %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
ret <4 x float> %shuffle ret <4 x float> %shuffle
} }
define <4 x float> @shufflevector_unknown_all(<2 x float> %arg0, <2 x float> %arg1) { define <4 x float> @shufflevector_unknown_all(<2 x float> %arg0, <2 x float> %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define <4 x float> @shufflevector_unknown_all ; CHECK-LABEL: define <4 x float> @shufflevector_unknown_all
; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 3, i32 2, i32 1, i32 0> ; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 3, i32 2, i32 1, i32 0>
; CHECK-NEXT: ret <4 x float> [[SHUFFLE]] ; CHECK-NEXT: ret <4 x float> [[SHUFFLE]]
; ;
%shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 3, i32 2, i32 1, i32 0> %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
ret <4 x float> %shuffle ret <4 x float> %shuffle
} }
define <4 x float> @shufflevector_only_demand_lhs(<2 x float> nofpclass(inf) %arg0, <2 x float> %arg1) { define <4 x float> @shufflevector_only_demand_lhs(<2 x float> nofpclass(inf) %arg0, <2 x float> %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(inf) <4 x float> @shufflevector_only_demand_lhs ; CHECK-LABEL: define nofpclass(inf) <4 x float> @shufflevector_only_demand_lhs
; CHECK-SAME: (<2 x float> nofpclass(inf) [[ARG0:%.*]], <2 x float> [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<2 x float> nofpclass(inf) [[ARG0:%.*]], <2 x float> [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 0, i32 1, i32 1, i32 0> ; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 0, i32 1, i32 1, i32 0>
; CHECK-NEXT: ret <4 x float> [[SHUFFLE]] ; CHECK-NEXT: ret <4 x float> [[SHUFFLE]]
; ;
%shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 0, i32 1, i32 1, i32 0> %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 0, i32 1, i32 1, i32 0>
ret <4 x float> %shuffle ret <4 x float> %shuffle
} }
define <4 x float> @shufflevector_only_demand_rhs(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) { define <4 x float> @shufflevector_only_demand_rhs(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(inf) <4 x float> @shufflevector_only_demand_rhs ; CHECK-LABEL: define nofpclass(inf) <4 x float> @shufflevector_only_demand_rhs
; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 2, i32 3, i32 3, i32 2> ; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 2, i32 3, i32 3, i32 2>
; CHECK-NEXT: ret <4 x float> [[SHUFFLE]] ; CHECK-NEXT: ret <4 x float> [[SHUFFLE]]
; ;
%shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 2, i32 3, i32 3, i32 2> %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 2, i32 3, i32 3, i32 2>
ret <4 x float> %shuffle ret <4 x float> %shuffle
} }
define <4 x float> @shufflevector_undef_demanded(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) { define <4 x float> @shufflevector_undef_demanded(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define <4 x float> @shufflevector_undef_demanded ; CHECK-LABEL: define <4 x float> @shufflevector_undef_demanded
; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> poison ; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> poison
; CHECK-NEXT: ret <4 x float> [[SHUFFLE]] ; CHECK-NEXT: ret <4 x float> [[SHUFFLE]]
; ;
%shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> undef %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> undef
ret <4 x float> %shuffle ret <4 x float> %shuffle
} }
define <4 x float> @shufflevector_zeroinit_demanded(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) { define <4 x float> @shufflevector_zeroinit_demanded(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define <4 x float> @shufflevector_zeroinit_demanded ; CHECK-LABEL: define <4 x float> @shufflevector_zeroinit_demanded
; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> zeroinitializer ; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> zeroinitializer
; CHECK-NEXT: ret <4 x float> [[SHUFFLE]] ; CHECK-NEXT: ret <4 x float> [[SHUFFLE]]
; ;
%shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> zeroinitializer %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> zeroinitializer
ret <4 x float> %shuffle ret <4 x float> %shuffle
} }
define float @shufflevector_extractelt0(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) { define float @shufflevector_extractelt0(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @shufflevector_extractelt0 ; CHECK-LABEL: define float @shufflevector_extractelt0
; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 1, i32 3, i32 0, i32 1> ; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 1, i32 3, i32 0, i32 1>
; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[SHUFFLE]], i32 0 ; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[SHUFFLE]], i32 0
; CHECK-NEXT: ret float [[EXTRACT]] ; CHECK-NEXT: ret float [[EXTRACT]]
; ;
%shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 1, i32 3, i32 0, i32 1> %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 1, i32 3, i32 0, i32 1>
%extract = extractelement <4 x float> %shuffle, i32 0 %extract = extractelement <4 x float> %shuffle, i32 0
ret float %extract ret float %extract
} }
define float @shufflevector_extractelt1(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) { define float @shufflevector_extractelt1(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(inf) float @shufflevector_extractelt1 ; CHECK-LABEL: define nofpclass(inf) float @shufflevector_extractelt1
; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 1, i32 3, i32 0, i32 1> ; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 1, i32 3, i32 0, i32 1>
; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[SHUFFLE]], i32 1 ; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[SHUFFLE]], i32 1
; CHECK-NEXT: ret float [[EXTRACT]] ; CHECK-NEXT: ret float [[EXTRACT]]
; ;
%shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 1, i32 3, i32 0, i32 1> %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 1, i32 3, i32 0, i32 1>
%extract = extractelement <4 x float> %shuffle, i32 1 %extract = extractelement <4 x float> %shuffle, i32 1
ret float %extract ret float %extract
} }
define float @shufflevector_extractelt2(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) { define float @shufflevector_extractelt2(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @shufflevector_extractelt2 ; CHECK-LABEL: define float @shufflevector_extractelt2
; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 1, i32 3, i32 0, i32 1> ; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 1, i32 3, i32 0, i32 1>
; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[SHUFFLE]], i32 2 ; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[SHUFFLE]], i32 2
; CHECK-NEXT: ret float [[EXTRACT]] ; CHECK-NEXT: ret float [[EXTRACT]]
; ;
%shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 1, i32 3, i32 0, i32 1> %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 1, i32 3, i32 0, i32 1>
%extract = extractelement <4 x float> %shuffle, i32 2 %extract = extractelement <4 x float> %shuffle, i32 2
ret float %extract ret float %extract
} }
define float @shufflevector_extractelt3(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) { define float @shufflevector_extractelt3(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @shufflevector_extractelt3 ; CHECK-LABEL: define float @shufflevector_extractelt3
; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 1, i32 3, i32 0, i32 1> ; CHECK-NEXT: [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 1, i32 3, i32 0, i32 1>
; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[SHUFFLE]], i32 3 ; CHECK-NEXT: [[EXTRACT:%.*]] = extractelement <4 x float> [[SHUFFLE]], i32 3
; CHECK-NEXT: ret float [[EXTRACT]] ; CHECK-NEXT: ret float [[EXTRACT]]
; ;
%shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 1, i32 3, i32 0, i32 1> %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 1, i32 3, i32 0, i32 1>
%extract = extractelement <4 x float> %shuffle, i32 3 %extract = extractelement <4 x float> %shuffle, i32 3
ret float %extract ret float %extract
} }
define float @constrained_sitofp(i32 %arg) strictfp { define float @constrained_sitofp(i32 %arg) strictfp {
; CHECK: Function Attrs: nofree norecurse nosync nounwind strictfp willreturn memory(inaccessiblemem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind strictfp willreturn memory(inaccessiblemem: readwrite)
; CHECK-LABEL: define nofpclass(nan nzero sub) float @constrained_sitofp ; CHECK-LABEL: define nofpclass(nan nzero sub) float @constrained_sitofp
; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR5:[0-9]+]] { ; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR5:[0-9]+]] {
; CHECK-NEXT: [[VAL:%.*]] = call nofpclass(nan nzero sub) float @llvm.experimental.constrained.sitofp.f32.i32(i32 [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR13]] ; CHECK-NEXT: [[VAL:%.*]] = call nofpclass(nan nzero sub) float @llvm.experimental.constrained.sitofp.f32.i32(i32 [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR13]]
; CHECK-NEXT: ret float [[VAL]] ; CHECK-NEXT: ret float [[VAL]]
; ;
%val = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 %arg, metadata !"round.dynamic", metadata !"fpexcept.strict") %val = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")
ret float %val ret float %val
} }
define float @constrained_uitofp(i32 %arg) strictfp { define float @constrained_uitofp(i32 %arg) strictfp {
; CHECK: Function Attrs: nofree norecurse nosync nounwind strictfp willreturn memory(inaccessiblemem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind strictfp willreturn memory(inaccessiblemem: readwrite)
; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @constrained_uitofp ; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @constrained_uitofp
; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR5]] { ; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR5]] {
; CHECK-NEXT: [[VAL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.experimental.constrained.uitofp.f32.i32(i32 [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR13]] ; CHECK-NEXT: [[VAL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.experimental.constrained.uitofp.f32.i32(i32 [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR13]]
; CHECK-NEXT: ret float [[VAL]] ; CHECK-NEXT: ret float [[VAL]]
; ;
%val = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 %arg, metadata !"round.dynamic", metadata !"fpexcept.strict") %val = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")
ret float %val ret float %val
} }
define float @fadd_p0(float %arg0) { define float @fadd_p0(float %arg0) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nzero) float @fadd_p0 ; CHECK-LABEL: define nofpclass(nzero) float @fadd_p0
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], 0.000000e+00 ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], 0.000000e+00
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, 0.0 %add = fadd float %arg0, 0.0
ret float %add ret float %add
} }
define float @fadd_n0(float %arg0) { define float @fadd_n0(float %arg0) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fadd_n0 ; CHECK-LABEL: define float @fadd_n0
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], -0.000000e+00 ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], -0.000000e+00
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, -0.0 %add = fadd float %arg0, -0.0
ret float %add ret float %add
} }
define float @fsub_p0(float %arg0) { define float @fsub_p0(float %arg0) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fsub_p0 ; CHECK-LABEL: define float @fsub_p0
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[SUB:%.*]] = fsub float [[ARG0]], 0.000000e+00 ; CHECK-NEXT: [[SUB:%.*]] = fsub float [[ARG0]], 0.000000e+00
; CHECK-NEXT: ret float [[SUB]] ; CHECK-NEXT: ret float [[SUB]]
; ;
%sub = fsub float %arg0, 0.0 %sub = fsub float %arg0, 0.0
ret float %sub ret float %sub
} }
define float @fsub_n0(float %arg0) { define float @fsub_n0(float %arg0) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nzero) float @fsub_n0 ; CHECK-LABEL: define nofpclass(nzero) float @fsub_n0
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[SUB:%.*]] = fsub float [[ARG0]], -0.000000e+00 ; CHECK-NEXT: [[SUB:%.*]] = fsub float [[ARG0]], -0.000000e+00
; CHECK-NEXT: ret float [[SUB]] ; CHECK-NEXT: ret float [[SUB]]
; ;
%sub = fsub float %arg0, -0.0 %sub = fsub float %arg0, -0.0
ret float %sub ret float %sub
} }
define float @fsub_p0_commute(float %arg0) { define float @fsub_p0_commute(float %arg0) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fsub_p0_commute ; CHECK-LABEL: define float @fsub_p0_commute
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[SUB:%.*]] = fsub float 0.000000e+00, [[ARG0]] ; CHECK-NEXT: [[SUB:%.*]] = fsub float 0.000000e+00, [[ARG0]]
; CHECK-NEXT: ret float [[SUB]] ; CHECK-NEXT: ret float [[SUB]]
; ;
%sub = fsub float 0.0, %arg0 %sub = fsub float 0.0, %arg0
ret float %sub ret float %sub
} }
define float @fsub_n0_commute(float %arg0) { define float @fsub_n0_commute(float %arg0) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fsub_n0_commute ; CHECK-LABEL: define float @fsub_n0_commute
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[SUB:%.*]] = fsub float -0.000000e+00, [[ARG0]] ; CHECK-NEXT: [[SUB:%.*]] = fsub float -0.000000e+00, [[ARG0]]
; CHECK-NEXT: ret float [[SUB]] ; CHECK-NEXT: ret float [[SUB]]
; ;
%sub = fsub float -0.0, %arg0 %sub = fsub float -0.0, %arg0
ret float %sub ret float %sub
} }
define float @fadd_p0_ftz_daz(float %arg0) #3 { define float @fadd_p0_ftz_daz(float %arg0) #3 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nzero) float @fadd_p0_ftz_daz ; CHECK-LABEL: define nofpclass(nzero) float @fadd_p0_ftz_daz
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR6:[0-9]+]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR6:[0-9]+]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], 0.000000e+00 ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], 0.000000e+00
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, 0.0 %add = fadd float %arg0, 0.0
ret float %add ret float %add
} }
define float @fadd_n0_ftz_daz(float %arg0) #0 { define float @fadd_n0_ftz_daz(float %arg0) #0 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fadd_n0_ftz_daz ; CHECK-LABEL: define float @fadd_n0_ftz_daz
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR7:[0-9]+]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR7:[0-9]+]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], -0.000000e+00 ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], -0.000000e+00
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, -0.0 %add = fadd float %arg0, -0.0
ret float %add ret float %add
} }
define float @fsub_p0_ftz_daz(float %arg0) #0 { define float @fsub_p0_ftz_daz(float %arg0) #0 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fsub_p0_ftz_daz ; CHECK-LABEL: define float @fsub_p0_ftz_daz
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR7]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR7]] {
; CHECK-NEXT: [[SUB:%.*]] = fsub float [[ARG0]], 0.000000e+00 ; CHECK-NEXT: [[SUB:%.*]] = fsub float [[ARG0]], 0.000000e+00
; CHECK-NEXT: ret float [[SUB]] ; CHECK-NEXT: ret float [[SUB]]
; ;
%sub = fsub float %arg0, 0.0 %sub = fsub float %arg0, 0.0
ret float %sub ret float %sub
} }
define float @fsub_n0_ftz_daz(float %arg0) #0 { define float @fsub_n0_ftz_daz(float %arg0) #0 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fsub_n0_ftz_daz ; CHECK-LABEL: define float @fsub_n0_ftz_daz
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR7]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR7]] {
; CHECK-NEXT: [[SUB:%.*]] = fsub float [[ARG0]], -0.000000e+00 ; CHECK-NEXT: [[SUB:%.*]] = fsub float [[ARG0]], -0.000000e+00
; CHECK-NEXT: ret float [[SUB]] ; CHECK-NEXT: ret float [[SUB]]
; ;
%sub = fsub float %arg0, -0.0 %sub = fsub float %arg0, -0.0
ret float %sub ret float %sub
} }
define float @fsub_p0_commute_ftz_daz(float %arg0) #0 { define float @fsub_p0_commute_ftz_daz(float %arg0) #0 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fsub_p0_commute_ftz_daz ; CHECK-LABEL: define float @fsub_p0_commute_ftz_daz
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR7]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR7]] {
; CHECK-NEXT: [[SUB:%.*]] = fsub float 0.000000e+00, [[ARG0]] ; CHECK-NEXT: [[SUB:%.*]] = fsub float 0.000000e+00, [[ARG0]]
; CHECK-NEXT: ret float [[SUB]] ; CHECK-NEXT: ret float [[SUB]]
; ;
%sub = fsub float 0.0, %arg0 %sub = fsub float 0.0, %arg0
ret float %sub ret float %sub
} }
define float @fsub_n0_commute_ftz_daz(float %arg0) #0 { define float @fsub_n0_commute_ftz_daz(float %arg0) #0 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fsub_n0_commute_ftz_daz ; CHECK-LABEL: define float @fsub_n0_commute_ftz_daz
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR7]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR7]] {
; CHECK-NEXT: [[SUB:%.*]] = fsub float -0.000000e+00, [[ARG0]] ; CHECK-NEXT: [[SUB:%.*]] = fsub float -0.000000e+00, [[ARG0]]
; CHECK-NEXT: ret float [[SUB]] ; CHECK-NEXT: ret float [[SUB]]
; ;
%sub = fsub float -0.0, %arg0 %sub = fsub float -0.0, %arg0
ret float %sub ret float %sub
} }
define float @fadd_p0_ieee_daz(float %arg0) #2 { define float @fadd_p0_ieee_daz(float %arg0) #2 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nzero) float @fadd_p0_ieee_daz ; CHECK-LABEL: define nofpclass(nzero) float @fadd_p0_ieee_daz
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR8:[0-9]+]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR8:[0-9]+]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], 0.000000e+00 ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], 0.000000e+00
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, 0.0 %add = fadd float %arg0, 0.0
ret float %add ret float %add
} }
define float @fadd_p0_dapz_ieee(float %arg0) #4 { define float @fadd_p0_dapz_ieee(float %arg0) #4 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nzero) float @fadd_p0_dapz_ieee ; CHECK-LABEL: define nofpclass(nzero) float @fadd_p0_dapz_ieee
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR9:[0-9]+]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR9:[0-9]+]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], 0.000000e+00 ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], 0.000000e+00
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, 0.0 %add = fadd float %arg0, 0.0
ret float %add ret float %add
} }
define float @fadd_n0_ieee_daz(float %arg0) #2 { define float @fadd_n0_ieee_daz(float %arg0) #2 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fadd_n0_ieee_daz ; CHECK-LABEL: define float @fadd_n0_ieee_daz
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR8]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR8]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], -0.000000e+00 ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], -0.000000e+00
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, -0.0 %add = fadd float %arg0, -0.0
ret float %add ret float %add
} }
define float @fsub_p0_ieee_daz(float %arg0) #2 { define float @fsub_p0_ieee_daz(float %arg0) #2 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fsub_p0_ieee_daz ; CHECK-LABEL: define float @fsub_p0_ieee_daz
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR8]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR8]] {
; CHECK-NEXT: [[SUB:%.*]] = fsub float [[ARG0]], 0.000000e+00 ; CHECK-NEXT: [[SUB:%.*]] = fsub float [[ARG0]], 0.000000e+00
; CHECK-NEXT: ret float [[SUB]] ; CHECK-NEXT: ret float [[SUB]]
; ;
%sub = fsub float %arg0, 0.0 %sub = fsub float %arg0, 0.0
ret float %sub ret float %sub
} }
define float @fsub_n0_ieee_daz(float %arg0) #2 { define float @fsub_n0_ieee_daz(float %arg0) #2 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nzero) float @fsub_n0_ieee_daz ; CHECK-LABEL: define nofpclass(nzero) float @fsub_n0_ieee_daz
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR8]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR8]] {
; CHECK-NEXT: [[SUB:%.*]] = fsub float [[ARG0]], -0.000000e+00 ; CHECK-NEXT: [[SUB:%.*]] = fsub float [[ARG0]], -0.000000e+00
; CHECK-NEXT: ret float [[SUB]] ; CHECK-NEXT: ret float [[SUB]]
; ;
%sub = fsub float %arg0, -0.0 %sub = fsub float %arg0, -0.0
ret float %sub ret float %sub
} }
define float @fsub_p0_commute_ieee_daz(float %arg0) #2 { define float @fsub_p0_commute_ieee_daz(float %arg0) #2 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fsub_p0_commute_ieee_daz ; CHECK-LABEL: define float @fsub_p0_commute_ieee_daz
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR8]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR8]] {
; CHECK-NEXT: [[SUB:%.*]] = fsub float 0.000000e+00, [[ARG0]] ; CHECK-NEXT: [[SUB:%.*]] = fsub float 0.000000e+00, [[ARG0]]
; CHECK-NEXT: ret float [[SUB]] ; CHECK-NEXT: ret float [[SUB]]
; ;
%sub = fsub float 0.0, %arg0 %sub = fsub float 0.0, %arg0
ret float %sub ret float %sub
} }
define float @fsub_n0_commute_ieee_daz(float %arg0) #1 { define float @fsub_n0_commute_ieee_daz(float %arg0) #1 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fsub_n0_commute_ieee_daz ; CHECK-LABEL: define float @fsub_n0_commute_ieee_daz
; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR10:[0-9]+]] { ; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR10:[0-9]+]] {
; CHECK-NEXT: [[SUB:%.*]] = fsub float -0.000000e+00, [[ARG0]] ; CHECK-NEXT: [[SUB:%.*]] = fsub float -0.000000e+00, [[ARG0]]
; CHECK-NEXT: ret float [[SUB]] ; CHECK-NEXT: ret float [[SUB]]
; ;
%sub = fsub float -0.0, %arg0 %sub = fsub float -0.0, %arg0
ret float %sub ret float %sub
} }
define float @fadd_never_negzero_or_negsub(float nofpclass(nzero nsub) %a, float nofpclass(nzero nsub) %b) { define float @fadd_never_negzero_or_negsub(float nofpclass(nzero nsub) %a, float nofpclass(nzero nsub) %b) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_negsub ; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_negsub
; CHECK-SAME: (float nofpclass(nzero nsub) [[A:%.*]], float nofpclass(nzero nsub) [[B:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(nzero nsub) [[A:%.*]], float nofpclass(nzero nsub) [[B:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[A]], [[B]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[A]], [[B]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %a, %b %add = fadd float %a, %b
ret float %add ret float %add
} }
define float @fadd_never_negzero_or_negsub_daz(float nofpclass(nzero nsub) %a, float nofpclass(nzero nsub) %b) #2 { define float @fadd_never_negzero_or_negsub_daz(float nofpclass(nzero nsub) %a, float nofpclass(nzero nsub) %b) #2 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_negsub_daz ; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_negsub_daz
; CHECK-SAME: (float nofpclass(nzero nsub) [[A:%.*]], float nofpclass(nzero nsub) [[B:%.*]]) #[[ATTR8]] { ; CHECK-SAME: (float nofpclass(nzero nsub) [[A:%.*]], float nofpclass(nzero nsub) [[B:%.*]]) #[[ATTR8]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[A]], [[B]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[A]], [[B]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %a, %b %add = fadd float %a, %b
ret float %add ret float %add
} }
define float @fadd_never_negzero_or_negsub_dapz(float nofpclass(nzero nsub) %a, float nofpclass(nzero nsub) %b) #5 { define float @fadd_never_negzero_or_negsub_dapz(float nofpclass(nzero nsub) %a, float nofpclass(nzero nsub) %b) #5 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_negsub_dapz ; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_negsub_dapz
; CHECK-SAME: (float nofpclass(nzero nsub) [[A:%.*]], float nofpclass(nzero nsub) [[B:%.*]]) #[[ATTR11:[0-9]+]] { ; CHECK-SAME: (float nofpclass(nzero nsub) [[A:%.*]], float nofpclass(nzero nsub) [[B:%.*]]) #[[ATTR11:[0-9]+]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[A]], [[B]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[A]], [[B]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %a, %b %add = fadd float %a, %b
ret float %add ret float %add
} }
define float @fadd_never_negzero_or_possub(float nofpclass(nzero psub) %a, float nofpclass(nzero psub) %b) { define float @fadd_never_negzero_or_possub(float nofpclass(nzero psub) %a, float nofpclass(nzero psub) %b) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_possub ; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_possub
; CHECK-SAME: (float nofpclass(nzero psub) [[A:%.*]], float nofpclass(nzero psub) [[B:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(nzero psub) [[A:%.*]], float nofpclass(nzero psub) [[B:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[A]], [[B]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[A]], [[B]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %a, %b %add = fadd float %a, %b
ret float %add ret float %add
} }
define float @fadd_never_negzero_or_possub_daz(float nofpclass(nzero psub) %a, float nofpclass(nzero psub) %b) #2 { define float @fadd_never_negzero_or_possub_daz(float nofpclass(nzero psub) %a, float nofpclass(nzero psub) %b) #2 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fadd_never_negzero_or_possub_daz ; CHECK-LABEL: define float @fadd_never_negzero_or_possub_daz
; CHECK-SAME: (float nofpclass(nzero psub) [[A:%.*]], float nofpclass(nzero psub) [[B:%.*]]) #[[ATTR8]] { ; CHECK-SAME: (float nofpclass(nzero psub) [[A:%.*]], float nofpclass(nzero psub) [[B:%.*]]) #[[ATTR8]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[A]], [[B]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[A]], [[B]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %a, %b %add = fadd float %a, %b
ret float %add ret float %add
} }
define float @fadd_never_negzero_or_possub_dapz(float nofpclass(nzero psub) %a, float nofpclass(nzero psub) %b) #5 { define float @fadd_never_negzero_or_possub_dapz(float nofpclass(nzero psub) %a, float nofpclass(nzero psub) %b) #5 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_possub_dapz ; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_possub_dapz
; CHECK-SAME: (float nofpclass(nzero psub) [[A:%.*]], float nofpclass(nzero psub) [[B:%.*]]) #[[ATTR11]] { ; CHECK-SAME: (float nofpclass(nzero psub) [[A:%.*]], float nofpclass(nzero psub) [[B:%.*]]) #[[ATTR11]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[A]], [[B]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[A]], [[B]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %a, %b %add = fadd float %a, %b
ret float %add ret float %add
} }
define float @fadd_never_negzero_or_sub_daz(float nofpclass(nzero sub) %a, float nofpclass(nzero sub) %b) #2 { define float @fadd_never_negzero_or_sub_daz(float nofpclass(nzero sub) %a, float nofpclass(nzero sub) %b) #2 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_sub_daz ; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_sub_daz
; CHECK-SAME: (float nofpclass(nzero sub) [[A:%.*]], float nofpclass(nzero sub) [[B:%.*]]) #[[ATTR8]] { ; CHECK-SAME: (float nofpclass(nzero sub) [[A:%.*]], float nofpclass(nzero sub) [[B:%.*]]) #[[ATTR8]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[A]], [[B]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[A]], [[B]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %a, %b %add = fadd float %a, %b
ret float %add ret float %add
} }
define float @fadd_never_negzero_or_sub_dapz(float nofpclass(nzero sub) %a, float nofpclass(nzero sub) %b) #5 { define float @fadd_never_negzero_or_sub_dapz(float nofpclass(nzero sub) %a, float nofpclass(nzero sub) %b) #5 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_sub_dapz ; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_sub_dapz
; CHECK-SAME: (float nofpclass(nzero sub) [[A:%.*]], float nofpclass(nzero sub) [[B:%.*]]) #[[ATTR11]] { ; CHECK-SAME: (float nofpclass(nzero sub) [[A:%.*]], float nofpclass(nzero sub) [[B:%.*]]) #[[ATTR11]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[A]], [[B]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[A]], [[B]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %a, %b %add = fadd float %a, %b
ret float %add ret float %add
} }
define float @fadd_known_positive_lhs(float nofpclass(ninf nsub nnorm) %arg0, float %arg1) { define float @fadd_known_positive_lhs(float nofpclass(ninf nsub nnorm) %arg0, float %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fadd_known_positive_lhs ; CHECK-LABEL: define float @fadd_known_positive_lhs
; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]], float [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]], float [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, %arg1 %add = fadd float %arg0, %arg1
ret float %add ret float %add
} }
define float @fadd_known_positive_rhs(float %arg0, float nofpclass(ninf nsub nnorm) %arg1) { define float @fadd_known_positive_rhs(float %arg0, float nofpclass(ninf nsub nnorm) %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fadd_known_positive_rhs ; CHECK-LABEL: define float @fadd_known_positive_rhs
; CHECK-SAME: (float [[ARG0:%.*]], float nofpclass(ninf nsub nnorm) [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float [[ARG0:%.*]], float nofpclass(ninf nsub nnorm) [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, %arg1 %add = fadd float %arg0, %arg1
ret float %add ret float %add
} }
define float @fadd_known_positive(float nofpclass(ninf nsub nnorm) %arg0, float nofpclass(ninf nsub nnorm) %arg1) { define float @fadd_known_positive(float nofpclass(ninf nsub nnorm) %arg0, float nofpclass(ninf nsub nnorm) %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fadd_known_positive ; CHECK-LABEL: define float @fadd_known_positive
; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nsub nnorm) [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nsub nnorm) [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, %arg1 %add = fadd float %arg0, %arg1
ret float %add ret float %add
} }
define float @fadd_known_positive_daz(float nofpclass(ninf nsub nnorm) %arg0, float nofpclass(ninf nsub nnorm) %arg1) #0 { define float @fadd_known_positive_daz(float nofpclass(ninf nsub nnorm) %arg0, float nofpclass(ninf nsub nnorm) %arg1) #0 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fadd_known_positive_daz ; CHECK-LABEL: define float @fadd_known_positive_daz
; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nsub nnorm) [[ARG1:%.*]]) #[[ATTR7]] { ; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nsub nnorm) [[ARG1:%.*]]) #[[ATTR7]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, %arg1 %add = fadd float %arg0, %arg1
ret float %add ret float %add
} }
define float @fadd_known_positive_nzero_lhs(float nofpclass(ninf nsub nnorm nzero) %arg0, float nofpclass(ninf nsub nnorm) %arg1) { define float @fadd_known_positive_nzero_lhs(float nofpclass(ninf nsub nnorm nzero) %arg0, float nofpclass(ninf nsub nnorm) %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fadd_known_positive_nzero_lhs ; CHECK-LABEL: define float @fadd_known_positive_nzero_lhs
; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nsub nnorm) [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nsub nnorm) [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, %arg1 %add = fadd float %arg0, %arg1
ret float %add ret float %add
} }
define float @fadd_known_positive_nzero_rhs(float nofpclass(ninf nsub nnorm) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) { define float @fadd_known_positive_nzero_rhs(float nofpclass(ninf nsub nnorm) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nzero) float @fadd_known_positive_nzero_rhs ; CHECK-LABEL: define nofpclass(nzero) float @fadd_known_positive_nzero_rhs
; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, %arg1 %add = fadd float %arg0, %arg1
ret float %add ret float %add
} }
define float @fadd_known_positive_nzero(float nofpclass(ninf nsub nnorm nzero) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) { define float @fadd_known_positive_nzero(float nofpclass(ninf nsub nnorm nzero) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nzero) float @fadd_known_positive_nzero ; CHECK-LABEL: define nofpclass(nzero) float @fadd_known_positive_nzero
; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, %arg1 %add = fadd float %arg0, %arg1
ret float %add ret float %add
} }
define float @fadd_known_positive_nzero_ftz_daz(float nofpclass(ninf nsub nnorm nzero) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) #0 { define float @fadd_known_positive_nzero_ftz_daz(float nofpclass(ninf nsub nnorm nzero) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) #0 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fadd_known_positive_nzero_ftz_daz ; CHECK-LABEL: define float @fadd_known_positive_nzero_ftz_daz
; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR7]] { ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR7]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, %arg1 %add = fadd float %arg0, %arg1
ret float %add ret float %add
} }
define float @fadd_known_positive_nzero_ftz(float nofpclass(ninf nsub nnorm nzero) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) #1 { define float @fadd_known_positive_nzero_ftz(float nofpclass(ninf nsub nnorm nzero) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) #1 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fadd_known_positive_nzero_ftz ; CHECK-LABEL: define float @fadd_known_positive_nzero_ftz
; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR10]] { ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR10]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, %arg1 %add = fadd float %arg0, %arg1
ret float %add ret float %add
} }
define float @fadd_known_positive_nzero_daz(float nofpclass(ninf nsub nnorm nzero) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) #2 { define float @fadd_known_positive_nzero_daz(float nofpclass(ninf nsub nnorm nzero) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) #2 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nzero) float @fadd_known_positive_nzero_daz ; CHECK-LABEL: define nofpclass(nzero) float @fadd_known_positive_nzero_daz
; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR8]] { ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR8]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, %arg1 %add = fadd float %arg0, %arg1
ret float %add ret float %add
} }
define float @fadd_known_positive_normal(float nofpclass(ninf nnorm nzero) %arg0, float nofpclass(ninf nnorm nzero) %arg1) { define float @fadd_known_positive_normal(float nofpclass(ninf nnorm nzero) %arg0, float nofpclass(ninf nnorm nzero) %arg1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nzero) float @fadd_known_positive_normal ; CHECK-LABEL: define nofpclass(nzero) float @fadd_known_positive_normal
; CHECK-SAME: (float nofpclass(ninf nzero nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nnorm) [[ARG1:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (float nofpclass(ninf nzero nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nnorm) [[ARG1:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, %arg1 %add = fadd float %arg0, %arg1
ret float %add ret float %add
} }
define float @fadd_known_positive_normal_daz(float nofpclass(ninf nnorm nzero) %arg0, float nofpclass(ninf nnorm nzero) %arg1) #0 { define float @fadd_known_positive_normal_daz(float nofpclass(ninf nnorm nzero) %arg0, float nofpclass(ninf nnorm nzero) %arg1) #0 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fadd_known_positive_normal_daz ; CHECK-LABEL: define float @fadd_known_positive_normal_daz
; CHECK-SAME: (float nofpclass(ninf nzero nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nnorm) [[ARG1:%.*]]) #[[ATTR7]] { ; CHECK-SAME: (float nofpclass(ninf nzero nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nnorm) [[ARG1:%.*]]) #[[ATTR7]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, %arg1 %add = fadd float %arg0, %arg1
ret float %add ret float %add
} }
define float @fadd_known_positive_normal_except0_daz(float nofpclass(ninf nnorm) %arg0, float nofpclass(ninf nnorm) %arg1) #0 { define float @fadd_known_positive_normal_except0_daz(float nofpclass(ninf nnorm) %arg0, float nofpclass(ninf nnorm) %arg1) #0 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define float @fadd_known_positive_normal_except0_daz ; CHECK-LABEL: define float @fadd_known_positive_normal_except0_daz
; CHECK-SAME: (float nofpclass(ninf nnorm) [[ARG0:%.*]], float nofpclass(ninf nnorm) [[ARG1:%.*]]) #[[ATTR7]] { ; CHECK-SAME: (float nofpclass(ninf nnorm) [[ARG0:%.*]], float nofpclass(ninf nnorm) [[ARG1:%.*]]) #[[ATTR7]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, %arg1 %add = fadd float %arg0, %arg1
ret float %add ret float %add
} }
define float @fadd_known_positive_normal_dapz(float nofpclass(ninf nnorm nzero) %arg0, float nofpclass(ninf nnorm nzero) %arg1) #3 { define float @fadd_known_positive_normal_dapz(float nofpclass(ninf nnorm nzero) %arg0, float nofpclass(ninf nnorm nzero) %arg1) #3 {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define nofpclass(nzero) float @fadd_known_positive_normal_dapz ; CHECK-LABEL: define nofpclass(nzero) float @fadd_known_positive_normal_dapz
; CHECK-SAME: (float nofpclass(ninf nzero nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nnorm) [[ARG1:%.*]]) #[[ATTR6]] { ; CHECK-SAME: (float nofpclass(ninf nzero nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nnorm) [[ARG1:%.*]]) #[[ATTR6]] {
; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]] ; CHECK-NEXT: [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]
; CHECK-NEXT: ret float [[ADD]] ; CHECK-NEXT: ret float [[ADD]]
; ;
%add = fadd float %arg0, %arg1 %add = fadd float %arg0, %arg1
ret float %add ret float %add
} }
attributes #0 = { "denormal-fp-math"="preserve-sign,preserve-sign" } attributes #0 = { "denormal-fp-math"="preserve-sign,preserve-sign" }
attributes #1 = { "denormal-fp-math"="preserve-sign,ieee" } attributes #1 = { "denormal-fp-math"="preserve-sign,ieee" }
attributes #2 = { "denormal-fp-math"="ieee,preserve-sign" } attributes #2 = { "denormal-fp-math"="ieee,preserve-sign" }
attributes #3 = { "denormal-fp-math"="positive-zero,positive-zero" } attributes #3 = { "denormal-fp-math"="positive-zero,positive-zero" }
attributes #4 = { "denormal-fp-math"="positive-zero,ieee" } attributes #4 = { "denormal-fp-math"="positive-zero,ieee" }
attributes #5 = { "denormal-fp-math"="ieee,positive-zero" } attributes #5 = { "denormal-fp-math"="ieee,positive-zero" }

llvm/test/Transforms/Attributor/nofree.ll

Show All 9 Lines
; Free functions ; Free functions
declare void @free(i8* nocapture) local_unnamed_addr #1 declare void @free(i8* nocapture) local_unnamed_addr #1
declare noalias i8* @realloc(i8* nocapture, i64) local_unnamed_addr #0 declare noalias i8* @realloc(i8* nocapture, i64) local_unnamed_addr #0
declare void @_ZdaPv(i8*) local_unnamed_addr #2 declare void @_ZdaPv(i8*) local_unnamed_addr #2
; TEST 1 (positive case) ; TEST 1 (positive case)
define void @only_return() #0 { define void @only_return() #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@only_return ; CHECK-LABEL: define {{[^@]+}}@only_return
; CHECK-SAME: () #[[ATTR3:[0-9]+]] { ; CHECK-SAME: () #[[ATTR3:[0-9]+]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
ret void ret void
} }
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines
; mutual_recursion2(); ; mutual_recursion2();
; } ; }
; void mutual_recursion2(){ ; void mutual_recursion2(){
; mutual_recursion1(); ; mutual_recursion1();
; } ; }
define void @mutual_recursion1() #0 { define void @mutual_recursion1() #0 {
; TUNIT: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
; TUNIT-LABEL: define {{[^@]+}}@mutual_recursion1 ; TUNIT-LABEL: define {{[^@]+}}@mutual_recursion1
; TUNIT-SAME: () #[[ATTR4:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR4:[0-9]+]] {
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@mutual_recursion1 ; CGSCC-LABEL: define {{[^@]+}}@mutual_recursion1
; CGSCC-SAME: () #[[ATTR3]] { ; CGSCC-SAME: () #[[ATTR3]] {
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @mutual_recursion2() call void @mutual_recursion2()
ret void ret void
} }
define void @mutual_recursion2() #0 { define void @mutual_recursion2() #0 {
; TUNIT: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
; TUNIT-LABEL: define {{[^@]+}}@mutual_recursion2 ; TUNIT-LABEL: define {{[^@]+}}@mutual_recursion2
; TUNIT-SAME: () #[[ATTR4]] { ; TUNIT-SAME: () #[[ATTR4]] {
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@mutual_recursion2 ; CGSCC-LABEL: define {{[^@]+}}@mutual_recursion2
; CGSCC-SAME: () #[[ATTR3]] { ; CGSCC-SAME: () #[[ATTR3]] {
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @mutual_recursion1() call void @mutual_recursion1()
ret void ret void
} }
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
; Call function declaration with "nofree" ; Call function declaration with "nofree"
; CHECK: Function Attrs: nofree noinline nounwind memory(none) uwtable ; CHECK: Function Attrs: nofree noinline nounwind memory(none) uwtable
; CHECK-NEXT: declare void @nofree_function() ; CHECK-NEXT: declare void @nofree_function()
declare void @nofree_function() nofree readnone #0 declare void @nofree_function() nofree readnone #0
define void @call_nofree_function() #0 { define void @call_nofree_function() #0 {
; TUNIT: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
; TUNIT-LABEL: define {{[^@]+}}@call_nofree_function ; TUNIT-LABEL: define {{[^@]+}}@call_nofree_function
; TUNIT-SAME: () #[[ATTR4]] { ; TUNIT-SAME: () #[[ATTR4]] {
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@call_nofree_function ; CGSCC-LABEL: define {{[^@]+}}@call_nofree_function
; CGSCC-SAME: () #[[ATTR5:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR5:[0-9]+]] {
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
tail call void @nofree_function() tail call void @nofree_function()
ret void ret void
} }
Show All 36 Lines
; TEST 10 (positive case) ; TEST 10 (positive case)
; Call intrinsic function ; Call intrinsic function
; CHECK: Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) ; CHECK: Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
; CHECK-NEXT: declare float @llvm.floor.f32(float) ; CHECK-NEXT: declare float @llvm.floor.f32(float)
declare float @llvm.floor.f32(float) declare float @llvm.floor.f32(float)
define void @call_floor(float %a) #0 { define void @call_floor(float %a) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@call_floor ; CHECK-LABEL: define {{[^@]+}}@call_floor
; CHECK-SAME: (float [[A:%.*]]) #[[ATTR3]] { ; CHECK-SAME: (float [[A:%.*]]) #[[ATTR3]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
tail call float @llvm.floor.f32(float %a) tail call float @llvm.floor.f32(float %a)
ret void ret void
} }
define float @call_floor2(float %a) #0 { define float @call_floor2(float %a) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@call_floor2 ; CHECK-LABEL: define {{[^@]+}}@call_floor2
; CHECK-SAME: (float [[A:%.*]]) #[[ATTR3]] { ; 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]]) #[[ATTR11:[0-9]+]]
; CHECK-NEXT: ret float [[C]] ; CHECK-NEXT: ret float [[C]]
; ;
%c = tail call float @llvm.floor.f32(float %a) %c = tail call float @llvm.floor.f32(float %a)
ret float %c ret float %c
} }
; TEST 11 (positive case) ; TEST 11 (positive case)
; Check propagation. ; Check propagation.
define void @f1() #0 { define void @f1() #0 {
; TUNIT: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
; TUNIT-LABEL: define {{[^@]+}}@f1 ; TUNIT-LABEL: define {{[^@]+}}@f1
; TUNIT-SAME: () #[[ATTR4]] { ; TUNIT-SAME: () #[[ATTR4]] {
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@f1 ; CGSCC-LABEL: define {{[^@]+}}@f1
; CGSCC-SAME: () #[[ATTR5]] { ; CGSCC-SAME: () #[[ATTR5]] {
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
tail call void @nofree_function() tail call void @nofree_function()
ret void ret void
} }
define void @f2() #0 { define void @f2() #0 {
; TUNIT: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
; TUNIT-LABEL: define {{[^@]+}}@f2 ; TUNIT-LABEL: define {{[^@]+}}@f2
; TUNIT-SAME: () #[[ATTR4]] { ; TUNIT-SAME: () #[[ATTR4]] {
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@f2 ; CGSCC-LABEL: define {{[^@]+}}@f2
; CGSCC-SAME: () #[[ATTR5]] { ; CGSCC-SAME: () #[[ATTR5]] {
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
tail call void @f1() tail call void @f1()
ret void ret void
} }
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines
attributes #0 = { nounwind uwtable noinline } attributes #0 = { nounwind uwtable noinline }
attributes #1 = { nounwind } attributes #1 = { nounwind }
attributes #2 = { nobuiltin nounwind } attributes #2 = { nobuiltin nounwind }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nounwind } ; TUNIT: attributes #[[ATTR0]] = { nounwind }
; TUNIT: attributes #[[ATTR1]] = { noinline nounwind uwtable } ; TUNIT: attributes #[[ATTR1]] = { noinline nounwind uwtable }
; TUNIT: attributes #[[ATTR2]] = { nobuiltin nounwind } ; TUNIT: attributes #[[ATTR2]] = { nobuiltin nounwind }
; TUNIT: attributes #[[ATTR3]] = { nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable } ; TUNIT: attributes #[[ATTR3]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable }
; TUNIT: attributes #[[ATTR4]] = { nofree noinline nosync nounwind willreturn memory(none) uwtable } ; TUNIT: attributes #[[ATTR4]] = { mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable }
; TUNIT: attributes #[[ATTR5:[0-9]+]] = { nofree noinline nounwind memory(none) uwtable } ; TUNIT: attributes #[[ATTR5:[0-9]+]] = { nofree noinline nounwind memory(none) uwtable }
; TUNIT: attributes #[[ATTR6:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } ; TUNIT: attributes #[[ATTR6:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
; TUNIT: attributes #[[ATTR7]] = { nofree nounwind } ; TUNIT: attributes #[[ATTR7]] = { nofree nounwind }
; TUNIT: attributes #[[ATTR8:[0-9]+]] = { nobuiltin nofree nounwind } ; TUNIT: attributes #[[ATTR8:[0-9]+]] = { nobuiltin nofree nounwind }
; TUNIT: attributes #[[ATTR9:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; TUNIT: attributes #[[ATTR9:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
; TUNIT: attributes #[[ATTR10:[0-9]+]] = { nounwind willreturn } ; TUNIT: attributes #[[ATTR10:[0-9]+]] = { nounwind willreturn }
; TUNIT: attributes #[[ATTR11]] = { willreturn } ; TUNIT: attributes #[[ATTR11]] = { willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nounwind } ; CGSCC: attributes #[[ATTR0]] = { nounwind }
; CGSCC: attributes #[[ATTR1]] = { noinline nounwind uwtable } ; CGSCC: attributes #[[ATTR1]] = { noinline nounwind uwtable }
; CGSCC: attributes #[[ATTR2]] = { nobuiltin nounwind } ; CGSCC: attributes #[[ATTR2]] = { nobuiltin nounwind }
; CGSCC: attributes #[[ATTR3]] = { nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable } ; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable }
; CGSCC: attributes #[[ATTR4:[0-9]+]] = { nofree noinline nounwind memory(none) uwtable } ; CGSCC: attributes #[[ATTR4:[0-9]+]] = { nofree noinline nounwind memory(none) uwtable }
; CGSCC: attributes #[[ATTR5]] = { nofree noinline nosync nounwind willreturn memory(none) uwtable } ; CGSCC: attributes #[[ATTR5]] = { mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable }
; CGSCC: attributes #[[ATTR6:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } ; CGSCC: attributes #[[ATTR6:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
; CGSCC: attributes #[[ATTR7]] = { nofree nounwind } ; CGSCC: attributes #[[ATTR7]] = { nofree nounwind }
; CGSCC: attributes #[[ATTR8:[0-9]+]] = { nobuiltin nofree nounwind } ; CGSCC: attributes #[[ATTR8:[0-9]+]] = { nobuiltin nofree nounwind }
; CGSCC: attributes #[[ATTR9:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; CGSCC: attributes #[[ATTR9:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
; CGSCC: attributes #[[ATTR10:[0-9]+]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR10:[0-9]+]] = { nounwind willreturn }
; CGSCC: attributes #[[ATTR11]] = { willreturn } ; CGSCC: attributes #[[ATTR11]] = { willreturn }
;. ;.

llvm/test/Transforms/Attributor/nonnull.ll

Show All 14 Lines
; CHECK-NEXT: ret ptr [[RET]] ; CHECK-NEXT: ret ptr [[RET]]
; ;
%ret = call ptr @ret_nonnull() %ret = call ptr @ret_nonnull()
ret ptr %ret ret ptr %ret
} }
; Return a pointer trivially nonnull (argument attribute) ; Return a pointer trivially nonnull (argument attribute)
define ptr @test2(ptr nonnull %p) { define ptr @test2(ptr nonnull %p) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test2 ; CHECK-LABEL: define {{[^@]+}}@test2
; CHECK-SAME: (ptr nofree nonnull readnone returned "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (ptr nofree nonnull readnone returned "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: ret ptr [[P]] ; CHECK-NEXT: ret ptr [[P]]
; ;
ret ptr %p ret ptr %p
} }
define ptr @test2A(i1 %c, ptr %ret) { define ptr @test2A(i1 %c, ptr %ret) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CHECK-LABEL: define {{[^@]+}}@test2A ; CHECK-LABEL: define {{[^@]+}}@test2A
; CHECK-SAME: (i1 noundef [[C:%.*]], ptr nofree nonnull readnone returned "no-capture-maybe-returned" [[RET:%.*]]) #[[ATTR2:[0-9]+]] { ; CHECK-SAME: (i1 noundef [[C:%.*]], ptr nofree nonnull readnone returned "no-capture-maybe-returned" [[RET:%.*]]) #[[ATTR2:[0-9]+]] {
; CHECK-NEXT: br i1 [[C]], label [[A:%.*]], label [[B:%.*]] ; CHECK-NEXT: br i1 [[C]], label [[A:%.*]], label [[B:%.*]]
; CHECK: A: ; CHECK: A:
; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR13:[0-9]+]] [ "nonnull"(ptr [[RET]]) ] ; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR15:[0-9]+]] [ "nonnull"(ptr [[RET]]) ]
; CHECK-NEXT: ret ptr [[RET]] ; CHECK-NEXT: ret ptr [[RET]]
; CHECK: B: ; CHECK: B:
; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR13]] [ "nonnull"(ptr [[RET]]) ] ; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR15]] [ "nonnull"(ptr [[RET]]) ]
; CHECK-NEXT: ret ptr [[RET]] ; CHECK-NEXT: ret ptr [[RET]]
; ;
br i1 %c, label %A, label %B br i1 %c, label %A, label %B
A: A:
call void @llvm.assume(i1 true) [ "nonnull"(ptr %ret) ] call void @llvm.assume(i1 true) [ "nonnull"(ptr %ret) ]
ret ptr %ret ret ptr %ret
B: B:
call void @llvm.assume(i1 true) [ "nonnull"(ptr %ret) ] call void @llvm.assume(i1 true) [ "nonnull"(ptr %ret) ]
ret ptr %ret ret ptr %ret
} }
define ptr @test2B(i1 %c, ptr %ret) { define ptr @test2B(i1 %c, ptr %ret) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CHECK-LABEL: define {{[^@]+}}@test2B ; CHECK-LABEL: define {{[^@]+}}@test2B
; CHECK-SAME: (i1 noundef [[C:%.*]], ptr nofree nonnull readnone returned dereferenceable(4) "no-capture-maybe-returned" [[RET:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (i1 noundef [[C:%.*]], ptr nofree nonnull readnone returned dereferenceable(4) "no-capture-maybe-returned" [[RET:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: br i1 [[C]], label [[A:%.*]], label [[B:%.*]] ; CHECK-NEXT: br i1 [[C]], label [[A:%.*]], label [[B:%.*]]
; CHECK: A: ; CHECK: A:
; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR13]] [ "dereferenceable"(ptr [[RET]], i32 4) ] ; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR15]] [ "dereferenceable"(ptr [[RET]], i32 4) ]
; CHECK-NEXT: ret ptr [[RET]] ; CHECK-NEXT: ret ptr [[RET]]
; CHECK: B: ; CHECK: B:
; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR13]] [ "dereferenceable"(ptr [[RET]], i32 4) ] ; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR15]] [ "dereferenceable"(ptr [[RET]], i32 4) ]
; CHECK-NEXT: ret ptr [[RET]] ; CHECK-NEXT: ret ptr [[RET]]
; ;
br i1 %c, label %A, label %B br i1 %c, label %A, label %B
A: A:
call void @llvm.assume(i1 true) [ "dereferenceable"(ptr %ret, i32 4) ] call void @llvm.assume(i1 true) [ "dereferenceable"(ptr %ret, i32 4) ]
ret ptr %ret ret ptr %ret
B: B:
call void @llvm.assume(i1 true) [ "dereferenceable"(ptr %ret, i32 4) ] call void @llvm.assume(i1 true) [ "dereferenceable"(ptr %ret, i32 4) ]
Show All 31 Lines;
%ret = call ptr @ret_nonnull() %ret = call ptr @ret_nonnull()
ret ptr %ret ret ptr %ret
} }
; Given a mutual recursive set of functions, we can mark them ; Given a mutual recursive set of functions, we can mark them
; nonnull if neither can ever return null. (In this case, they ; nonnull if neither can ever return null. (In this case, they
; just never return period.) ; just never return period.)
define ptr @test4_helper() { define ptr @test4_helper() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@test4_helper ; TUNIT-LABEL: define {{[^@]+}}@test4_helper
; TUNIT-SAME: () #[[ATTR3:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR3:[0-9]+]] {
; TUNIT-NEXT: ret ptr undef ; TUNIT-NEXT: ret ptr undef
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test4_helper ; CGSCC-LABEL: define {{[^@]+}}@test4_helper
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: ret ptr undef ; CGSCC-NEXT: ret ptr undef
; ;
%ret = call ptr @test4() %ret = call ptr @test4()
ret ptr %ret ret ptr %ret
} }
define ptr @test4() { define ptr @test4() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@test4 ; TUNIT-LABEL: define {{[^@]+}}@test4
; TUNIT-SAME: () #[[ATTR3]] { ; TUNIT-SAME: () #[[ATTR3]] {
; TUNIT-NEXT: ret ptr undef ; TUNIT-NEXT: ret ptr undef
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test4 ; CGSCC-LABEL: define {{[^@]+}}@test4
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: ret ptr undef ; CGSCC-NEXT: ret ptr undef
; ;
%ret = call ptr @test4_helper() %ret = call ptr @test4_helper()
ret ptr %ret ret ptr %ret
} }
; Given a mutual recursive set of functions which *can* return null ; Given a mutual recursive set of functions which *can* return null
; make sure we haven't marked them as nonnull. ; make sure we haven't marked them as nonnull.
define ptr @test5_helper(i1 %c) { define ptr @test5_helper(i1 %c) {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@test5_helper ; TUNIT-LABEL: define {{[^@]+}}@test5_helper
; TUNIT-SAME: (i1 noundef [[C:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i1 noundef [[C:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: br i1 [[C]], label [[REC:%.*]], label [[END:%.*]] ; TUNIT-NEXT: br i1 [[C]], label [[REC:%.*]], label [[END:%.*]]
; TUNIT: rec: ; TUNIT: rec:
; TUNIT-NEXT: br label [[END]] ; TUNIT-NEXT: br label [[END]]
; TUNIT: end: ; TUNIT: end:
; TUNIT-NEXT: ret ptr null ; TUNIT-NEXT: ret ptr null
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test5_helper ; CGSCC-LABEL: define {{[^@]+}}@test5_helper
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: br i1 [[C]], label [[REC:%.*]], label [[END:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[REC:%.*]], label [[END:%.*]]
; CGSCC: rec: ; CGSCC: rec:
; CGSCC-NEXT: br label [[END]] ; CGSCC-NEXT: br label [[END]]
; CGSCC: end: ; CGSCC: end:
; CGSCC-NEXT: ret ptr null ; CGSCC-NEXT: ret ptr null
; ;
br i1 %c, label %rec, label %end br i1 %c, label %rec, label %end
rec: rec:
%ret = call ptr @test5(i1 %c) %ret = call ptr @test5(i1 %c)
br label %end br label %end
end: end:
ret ptr null ret ptr null
} }
define ptr @test5(i1 %c) { define ptr @test5(i1 %c) {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@test5 ; TUNIT-LABEL: define {{[^@]+}}@test5
; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: ret ptr null ; TUNIT-NEXT: ret ptr null
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test5 ; CGSCC-LABEL: define {{[^@]+}}@test5
; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: ret ptr null ; CGSCC-NEXT: ret ptr null
; ;
%ret = call ptr @test5_helper(i1 %c) %ret = call ptr @test5_helper(i1 %c)
ret ptr %ret ret ptr %ret
} }
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
loop: loop:
%phi = phi ptr [%ret, %entry], [%phi, %loop] %phi = phi ptr [%ret, %entry], [%phi, %loop]
br i1 %c, label %loop, label %exit br i1 %c, label %loop, label %exit
exit: exit:
ret ptr %phi ret ptr %phi
} }
define ptr @test7(ptr %a) { define ptr @test7(ptr %a) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test7 ; CHECK-LABEL: define {{[^@]+}}@test7
; CHECK-SAME: (ptr nofree readnone returned "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ptr nofree readnone returned "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: ret ptr [[A]] ; CHECK-NEXT: ret ptr [[A]]
; ;
ret ptr %a ret ptr %a
} }
define ptr @test8(ptr %a) { define ptr @test8(ptr %a) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test8 ; CHECK-LABEL: define {{[^@]+}}@test8
; CHECK-SAME: (ptr nofree readnone "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ptr nofree readnone "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[B:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 1 ; CHECK-NEXT: [[B:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 1
; CHECK-NEXT: ret ptr [[B]] ; CHECK-NEXT: ret ptr [[B]]
; ;
%b = getelementptr inbounds i8, ptr %a, i64 1 %b = getelementptr inbounds i8, ptr %a, i64 1
ret ptr %b ret ptr %b
} }
define ptr @test9(ptr %a, i64 %n) { define ptr @test9(ptr %a, i64 %n) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test9 ; CHECK-LABEL: define {{[^@]+}}@test9
; CHECK-SAME: (ptr nofree readnone "no-capture-maybe-returned" [[A:%.*]], i64 [[N:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ptr nofree readnone "no-capture-maybe-returned" [[A:%.*]], i64 [[N:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[B:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[N]] ; CHECK-NEXT: [[B:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[N]]
; CHECK-NEXT: ret ptr [[B]] ; CHECK-NEXT: ret ptr [[B]]
; ;
%b = getelementptr inbounds i8, ptr %a, i64 %n %b = getelementptr inbounds i8, ptr %a, i64 %n
ret ptr %b ret ptr %b
} }
; ATTRIBUTOR_OPM: define ptr @test10 ; ATTRIBUTOR_OPM: define ptr @test10
; ATTRIBUTOR_NPM: define nonnull ptr @test10 ; ATTRIBUTOR_NPM: define nonnull ptr @test10
define ptr @test10(ptr %a, i64 %n) { define ptr @test10(ptr %a, i64 %n) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CHECK-LABEL: define {{[^@]+}}@test10 ; CHECK-LABEL: define {{[^@]+}}@test10
; CHECK-SAME: (ptr nofree readnone "no-capture-maybe-returned" [[A:%.*]], i64 [[N:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (ptr nofree readnone "no-capture-maybe-returned" [[A:%.*]], i64 [[N:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i64 [[N]], 0 ; CHECK-NEXT: [[CMP:%.*]] = icmp ne i64 [[N]], 0
; CHECK-NEXT: call void @llvm.assume(i1 noundef [[CMP]]) #[[ATTR13]] ; CHECK-NEXT: call void @llvm.assume(i1 noundef [[CMP]]) #[[ATTR15]]
; CHECK-NEXT: [[B:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[N]] ; CHECK-NEXT: [[B:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[N]]
; CHECK-NEXT: ret ptr [[B]] ; CHECK-NEXT: ret ptr [[B]]
; ;
%cmp = icmp ne i64 %n, 0 %cmp = icmp ne i64 %n, 0
call void @llvm.assume(i1 %cmp) call void @llvm.assume(i1 %cmp)
%b = getelementptr inbounds i8, ptr %a, i64 %n %b = getelementptr inbounds i8, ptr %a, i64 %n
ret ptr %b ret ptr %b
} }
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Lines
; TUNIT-NEXT: [[TMP:%.*]] = icmp eq ptr [[ARG]], null ; TUNIT-NEXT: [[TMP:%.*]] = icmp eq ptr [[ARG]], null
; TUNIT-NEXT: br i1 [[TMP]], label [[BB9:%.*]], label [[BB1:%.*]] ; TUNIT-NEXT: br i1 [[TMP]], label [[BB9:%.*]], label [[BB1:%.*]]
; TUNIT: bb1: ; TUNIT: bb1:
; TUNIT-NEXT: [[TMP2:%.*]] = load i32, ptr [[ARG]], align 4 ; TUNIT-NEXT: [[TMP2:%.*]] = load i32, ptr [[ARG]], align 4
; TUNIT-NEXT: [[TMP3:%.*]] = icmp eq i32 [[TMP2]], 0 ; TUNIT-NEXT: [[TMP3:%.*]] = icmp eq i32 [[TMP2]], 0
; TUNIT-NEXT: br i1 [[TMP3]], label [[BB6:%.*]], label [[BB4:%.*]] ; TUNIT-NEXT: br i1 [[TMP3]], label [[BB6:%.*]], label [[BB4:%.*]]
; TUNIT: bb4: ; TUNIT: bb4:
; TUNIT-NEXT: [[TMP5:%.*]] = getelementptr inbounds i32, ptr [[ARG]], i64 1 ; TUNIT-NEXT: [[TMP5:%.*]] = getelementptr inbounds i32, ptr [[ARG]], i64 1
; TUNIT-NEXT: [[TMP5B:%.*]] = tail call ptr @f3(ptr nofree nonnull readonly [[TMP5]]) #[[ATTR14:[0-9]+]] ; TUNIT-NEXT: [[TMP5B:%.*]] = tail call ptr @f3(ptr nofree nonnull readonly [[TMP5]]) #[[ATTR16:[0-9]+]]
; TUNIT-NEXT: [[TMP5C:%.*]] = getelementptr inbounds i32, ptr [[TMP5B]], i64 -1 ; TUNIT-NEXT: [[TMP5C:%.*]] = getelementptr inbounds i32, ptr [[TMP5B]], i64 -1
; TUNIT-NEXT: br label [[BB9]] ; TUNIT-NEXT: br label [[BB9]]
; TUNIT: bb6: ; TUNIT: bb6:
; TUNIT-NEXT: [[TMP7:%.*]] = tail call ptr @f2(ptr nofree nonnull readonly align 4 dereferenceable(4) [[ARG]]) #[[ATTR14]] ; TUNIT-NEXT: [[TMP7:%.*]] = tail call ptr @f2(ptr nofree nonnull readonly align 4 dereferenceable(4) [[ARG]]) #[[ATTR16]]
; TUNIT-NEXT: ret ptr [[TMP7]] ; TUNIT-NEXT: ret ptr [[TMP7]]
; TUNIT: bb9: ; TUNIT: bb9:
; TUNIT-NEXT: [[TMP10:%.*]] = phi ptr [ [[TMP5C]], [[BB4]] ], [ inttoptr (i64 4 to ptr), [[BB:%.*]] ] ; TUNIT-NEXT: [[TMP10:%.*]] = phi ptr [ [[TMP5C]], [[BB4]] ], [ inttoptr (i64 4 to ptr), [[BB:%.*]] ]
; TUNIT-NEXT: ret ptr [[TMP10]] ; TUNIT-NEXT: ret ptr [[TMP10]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind memory(argmem: read) ; CGSCC: Function Attrs: nofree nosync nounwind memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@f1 ; CGSCC-LABEL: define {{[^@]+}}@f1
; CGSCC-SAME: (ptr nofree readonly [[ARG:%.*]]) #[[ATTR5:[0-9]+]] { ; CGSCC-SAME: (ptr nofree readonly [[ARG:%.*]]) #[[ATTR5:[0-9]+]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: [[TMP:%.*]] = icmp eq ptr [[ARG]], null ; CGSCC-NEXT: [[TMP:%.*]] = icmp eq ptr [[ARG]], null
; CGSCC-NEXT: br i1 [[TMP]], label [[BB9:%.*]], label [[BB1:%.*]] ; CGSCC-NEXT: br i1 [[TMP]], label [[BB9:%.*]], label [[BB1:%.*]]
; CGSCC: bb1: ; CGSCC: bb1:
; CGSCC-NEXT: [[TMP2:%.*]] = load i32, ptr [[ARG]], align 4 ; CGSCC-NEXT: [[TMP2:%.*]] = load i32, ptr [[ARG]], align 4
; CGSCC-NEXT: [[TMP3:%.*]] = icmp eq i32 [[TMP2]], 0 ; CGSCC-NEXT: [[TMP3:%.*]] = icmp eq i32 [[TMP2]], 0
; CGSCC-NEXT: br i1 [[TMP3]], label [[BB6:%.*]], label [[BB4:%.*]] ; CGSCC-NEXT: br i1 [[TMP3]], label [[BB6:%.*]], label [[BB4:%.*]]
; CGSCC: bb4: ; CGSCC: bb4:
; CGSCC-NEXT: [[TMP5:%.*]] = getelementptr inbounds i32, ptr [[ARG]], i64 1 ; CGSCC-NEXT: [[TMP5:%.*]] = getelementptr inbounds i32, ptr [[ARG]], i64 1
; CGSCC-NEXT: [[TMP5B:%.*]] = tail call ptr @f3(ptr nofree nonnull readonly [[TMP5]]) #[[ATTR14:[0-9]+]] ; CGSCC-NEXT: [[TMP5B:%.*]] = tail call ptr @f3(ptr nofree nonnull readonly [[TMP5]]) #[[ATTR16:[0-9]+]]
; CGSCC-NEXT: [[TMP5C:%.*]] = getelementptr inbounds i32, ptr [[TMP5B]], i64 -1 ; CGSCC-NEXT: [[TMP5C:%.*]] = getelementptr inbounds i32, ptr [[TMP5B]], i64 -1
; CGSCC-NEXT: br label [[BB9]] ; CGSCC-NEXT: br label [[BB9]]
; CGSCC: bb6: ; CGSCC: bb6:
; CGSCC-NEXT: [[TMP7:%.*]] = tail call ptr @f2(ptr nofree nonnull readonly align 4 dereferenceable(4) [[ARG]]) #[[ATTR14]] ; CGSCC-NEXT: [[TMP7:%.*]] = tail call ptr @f2(ptr nofree nonnull readonly align 4 dereferenceable(4) [[ARG]]) #[[ATTR16]]
; CGSCC-NEXT: ret ptr [[TMP7]] ; CGSCC-NEXT: ret ptr [[TMP7]]
; CGSCC: bb9: ; CGSCC: bb9:
; CGSCC-NEXT: [[TMP10:%.*]] = phi ptr [ [[TMP5C]], [[BB4]] ], [ inttoptr (i64 4 to ptr), [[BB:%.*]] ] ; CGSCC-NEXT: [[TMP10:%.*]] = phi ptr [ [[TMP5C]], [[BB4]] ], [ inttoptr (i64 4 to ptr), [[BB:%.*]] ]
; CGSCC-NEXT: ret ptr [[TMP10]] ; CGSCC-NEXT: ret ptr [[TMP10]]
; ;
bb: bb:
%tmp = icmp eq ptr %arg, null %tmp = icmp eq ptr %arg, null
Show All 19 Linesbb9: ; preds = %bb4, %bb
ret ptr %tmp10 ret ptr %tmp10
} }
define internal ptr @f2(ptr %arg) { define internal ptr @f2(ptr %arg) {
; TUNIT: Function Attrs: nofree nosync nounwind memory(argmem: read) ; TUNIT: Function Attrs: nofree nosync nounwind memory(argmem: read)
; TUNIT-LABEL: define {{[^@]+}}@f2 ; TUNIT-LABEL: define {{[^@]+}}@f2
; TUNIT-SAME: (ptr nofree nonnull readonly align 4 dereferenceable(4) [[ARG:%.*]]) #[[ATTR6]] { ; TUNIT-SAME: (ptr nofree nonnull readonly align 4 dereferenceable(4) [[ARG:%.*]]) #[[ATTR6]] {
; TUNIT-NEXT: bb: ; TUNIT-NEXT: bb:
; TUNIT-NEXT: [[TMP:%.*]] = tail call ptr @f1(ptr nofree readonly [[ARG]]) #[[ATTR14]] ; TUNIT-NEXT: [[TMP:%.*]] = tail call ptr @f1(ptr nofree readonly [[ARG]]) #[[ATTR16]]
; TUNIT-NEXT: ret ptr [[TMP]] ; TUNIT-NEXT: ret ptr [[TMP]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind memory(argmem: read) ; CGSCC: Function Attrs: nofree nosync nounwind memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@f2 ; CGSCC-LABEL: define {{[^@]+}}@f2
; CGSCC-SAME: (ptr nofree nonnull readonly align 4 dereferenceable(4) [[ARG:%.*]]) #[[ATTR5]] { ; CGSCC-SAME: (ptr nofree nonnull readonly align 4 dereferenceable(4) [[ARG:%.*]]) #[[ATTR5]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: [[TMP:%.*]] = tail call ptr @f1(ptr nofree readonly [[ARG]]) #[[ATTR14]] ; CGSCC-NEXT: [[TMP:%.*]] = tail call ptr @f1(ptr nofree readonly [[ARG]]) #[[ATTR16]]
; CGSCC-NEXT: ret ptr [[TMP]] ; CGSCC-NEXT: ret ptr [[TMP]]
; ;
bb: bb:
%tmp = tail call ptr @f1(ptr %arg) %tmp = tail call ptr @f1(ptr %arg)
ret ptr %tmp ret ptr %tmp
} }
define dso_local noalias ptr @f3(ptr %arg) { define dso_local noalias ptr @f3(ptr %arg) {
; FIXME: missing nonnull. It should be nonnull @f3(ptr nonnull readonly %arg) ; FIXME: missing nonnull. It should be nonnull @f3(ptr nonnull readonly %arg)
; TUNIT: Function Attrs: nofree nosync nounwind memory(argmem: read) ; TUNIT: Function Attrs: nofree nosync nounwind memory(argmem: read)
; TUNIT-LABEL: define {{[^@]+}}@f3 ; TUNIT-LABEL: define {{[^@]+}}@f3
; TUNIT-SAME: (ptr nofree readonly [[ARG:%.*]]) #[[ATTR6]] { ; TUNIT-SAME: (ptr nofree readonly [[ARG:%.*]]) #[[ATTR6]] {
; TUNIT-NEXT: bb: ; TUNIT-NEXT: bb:
; TUNIT-NEXT: [[TMP:%.*]] = call ptr @f1(ptr nofree readonly [[ARG]]) #[[ATTR14]] ; TUNIT-NEXT: [[TMP:%.*]] = call ptr @f1(ptr nofree readonly [[ARG]]) #[[ATTR16]]
; TUNIT-NEXT: ret ptr [[TMP]] ; TUNIT-NEXT: ret ptr [[TMP]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind memory(argmem: read) ; CGSCC: Function Attrs: nofree nosync nounwind memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@f3 ; CGSCC-LABEL: define {{[^@]+}}@f3
; CGSCC-SAME: (ptr nofree readonly [[ARG:%.*]]) #[[ATTR5]] { ; CGSCC-SAME: (ptr nofree readonly [[ARG:%.*]]) #[[ATTR5]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: [[TMP:%.*]] = call ptr @f1(ptr nofree readonly [[ARG]]) #[[ATTR14]] ; CGSCC-NEXT: [[TMP:%.*]] = call ptr @f1(ptr nofree readonly [[ARG]]) #[[ATTR16]]
; CGSCC-NEXT: ret ptr [[TMP]] ; CGSCC-NEXT: ret ptr [[TMP]]
; ;
bb: bb:
; FIXME: missing nonnull. It should be @f1(ptr nonnull readonly %arg) ; FIXME: missing nonnull. It should be @f1(ptr nonnull readonly %arg)
%tmp = call ptr @f1(ptr %arg) %tmp = call ptr @f1(ptr %arg)
ret ptr %tmp ret ptr %tmp
} }
Show All 15 Lines
declare void @fun3(ptr, ptr, ptr) #1 declare void @fun3(ptr, ptr, ptr) #1
; TEST 16 simple path test ; TEST 16 simple path test
; if(..) ; if(..)
; fun2(nonnull %a, nonnull %b) ; fun2(nonnull %a, nonnull %b)
; else ; else
; fun2(nonnull %a, %b) ; fun2(nonnull %a, %b)
; We can say that %a is nonnull but %b is not. ; We can say that %a is nonnull but %b is not.
define void @f16(ptr %a, ptr %b, i8 %c) { define void @f16(ptr %a, ptr %b, i8 %c) {
; TUNIT: Function Attrs: nounwind willreturn ; TUNIT: Function Attrs: mustprogress nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@f16 ; TUNIT-LABEL: define {{[^@]+}}@f16
; TUNIT-SAME: (ptr nonnull [[A:%.*]], ptr [[B:%.*]], i8 [[C:%.*]]) #[[ATTR7:[0-9]+]] { ; TUNIT-SAME: (ptr nonnull [[A:%.*]], ptr [[B:%.*]], i8 [[C:%.*]]) #[[ATTR8:[0-9]+]] {
; TUNIT-NEXT: [[CMP:%.*]] = icmp eq i8 [[C]], 0 ; TUNIT-NEXT: [[CMP:%.*]] = icmp eq i8 [[C]], 0
; TUNIT-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]] ; TUNIT-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; TUNIT: if.then: ; TUNIT: if.then:
; TUNIT-NEXT: tail call void @fun2(ptr nonnull [[A]], ptr nonnull [[B]]) #[[ATTR7]] ; TUNIT-NEXT: tail call void @fun2(ptr nonnull [[A]], ptr nonnull [[B]]) #[[ATTR7:[0-9]+]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; TUNIT: if.else: ; TUNIT: if.else:
; TUNIT-NEXT: tail call void @fun2(ptr nonnull [[A]], ptr [[B]]) #[[ATTR7]] ; TUNIT-NEXT: tail call void @fun2(ptr nonnull [[A]], ptr [[B]]) #[[ATTR7]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nounwind willreturn ; CGSCC: Function Attrs: mustprogress nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@f16 ; CGSCC-LABEL: define {{[^@]+}}@f16
; CGSCC-SAME: (ptr nonnull [[A:%.*]], ptr [[B:%.*]], i8 [[C:%.*]]) #[[ATTR6:[0-9]+]] { ; CGSCC-SAME: (ptr nonnull [[A:%.*]], ptr [[B:%.*]], i8 [[C:%.*]]) #[[ATTR7:[0-9]+]] {
; CGSCC-NEXT: [[CMP:%.*]] = icmp eq i8 [[C]], 0 ; CGSCC-NEXT: [[CMP:%.*]] = icmp eq i8 [[C]], 0
; CGSCC-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]] ; CGSCC-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; CGSCC: if.then: ; CGSCC: if.then:
; CGSCC-NEXT: tail call void @fun2(ptr nonnull [[A]], ptr nonnull [[B]]) #[[ATTR6]] ; CGSCC-NEXT: tail call void @fun2(ptr nonnull [[A]], ptr nonnull [[B]]) #[[ATTR6:[0-9]+]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; CGSCC: if.else: ; CGSCC: if.else:
; CGSCC-NEXT: tail call void @fun2(ptr nonnull [[A]], ptr [[B]]) #[[ATTR6]] ; CGSCC-NEXT: tail call void @fun2(ptr nonnull [[A]], ptr [[B]]) #[[ATTR6]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%cmp = icmp eq i8 %c, 0 %cmp = icmp eq i8 %c, 0
br i1 %cmp, label %if.then, label %if.else br i1 %cmp, label %if.then, label %if.else
if.then: if.then:
tail call void @fun2(ptr nonnull %a, ptr nonnull %b) tail call void @fun2(ptr nonnull %a, ptr nonnull %b)
ret void ret void
if.else: if.else:
tail call void @fun2(ptr nonnull %a, ptr %b) tail call void @fun2(ptr nonnull %a, ptr %b)
ret void ret void
} }
; TEST 17 explore child BB test ; TEST 17 explore child BB test
; if(..) ; if(..)
; ... (willreturn & nounwind) ; ... (willreturn & nounwind)
; else ; else
; ... (willreturn & nounwind) ; ... (willreturn & nounwind)
; fun1(nonnull %a) ; fun1(nonnull %a)
; We can say that %a is nonnull ; We can say that %a is nonnull
define void @f17(ptr %a, i8 %c) { define void @f17(ptr %a, i8 %c) {
; ;
; TUNIT: Function Attrs: nounwind willreturn ; TUNIT: Function Attrs: mustprogress nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@f17 ; TUNIT-LABEL: define {{[^@]+}}@f17
; TUNIT-SAME: (ptr nonnull [[A:%.*]], i8 [[C:%.*]]) #[[ATTR7]] { ; TUNIT-SAME: (ptr nonnull [[A:%.*]], i8 [[C:%.*]]) #[[ATTR8]] {
; TUNIT-NEXT: [[CMP:%.*]] = icmp eq i8 [[C]], 0 ; TUNIT-NEXT: [[CMP:%.*]] = icmp eq i8 [[C]], 0
; TUNIT-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]] ; TUNIT-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; TUNIT: if.then: ; TUNIT: if.then:
; TUNIT-NEXT: tail call void @fun0() #[[ATTR7]] ; TUNIT-NEXT: tail call void @fun0() #[[ATTR7]]
; TUNIT-NEXT: br label [[CONT:%.*]] ; TUNIT-NEXT: br label [[CONT:%.*]]
; TUNIT: if.else: ; TUNIT: if.else:
; TUNIT-NEXT: tail call void @fun0() #[[ATTR7]] ; TUNIT-NEXT: tail call void @fun0() #[[ATTR7]]
; TUNIT-NEXT: br label [[CONT]] ; TUNIT-NEXT: br label [[CONT]]
; TUNIT: cont: ; TUNIT: cont:
; TUNIT-NEXT: tail call void @fun1(ptr nonnull [[A]]) #[[ATTR7]] ; TUNIT-NEXT: tail call void @fun1(ptr nonnull [[A]]) #[[ATTR7]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nounwind willreturn ; CGSCC: Function Attrs: mustprogress nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@f17 ; CGSCC-LABEL: define {{[^@]+}}@f17
; CGSCC-SAME: (ptr nonnull [[A:%.*]], i8 [[C:%.*]]) #[[ATTR6]] { ; CGSCC-SAME: (ptr nonnull [[A:%.*]], i8 [[C:%.*]]) #[[ATTR7]] {
; CGSCC-NEXT: [[CMP:%.*]] = icmp eq i8 [[C]], 0 ; CGSCC-NEXT: [[CMP:%.*]] = icmp eq i8 [[C]], 0
; CGSCC-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]] ; CGSCC-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; CGSCC: if.then: ; CGSCC: if.then:
; CGSCC-NEXT: tail call void @fun0() #[[ATTR6]] ; CGSCC-NEXT: tail call void @fun0() #[[ATTR6]]
; CGSCC-NEXT: br label [[CONT:%.*]] ; CGSCC-NEXT: br label [[CONT:%.*]]
; CGSCC: if.else: ; CGSCC: if.else:
; CGSCC-NEXT: tail call void @fun0() #[[ATTR6]] ; CGSCC-NEXT: tail call void @fun0() #[[ATTR6]]
; CGSCC-NEXT: br label [[CONT]] ; CGSCC-NEXT: br label [[CONT]]
Show All 20 Lines
; ... (willreturn & nounwind) ; ... (willreturn & nounwind)
; if(..) ; if(..)
; ... (willreturn & nounwind) ; ... (willreturn & nounwind)
; else ; else
; ... (willreturn & nounwind) ; ... (willreturn & nounwind)
; fun1(nonnull %a) ; fun1(nonnull %a)
define void @f18(ptr %a, ptr %b, i8 %c) { define void @f18(ptr %a, ptr %b, i8 %c) {
; TUNIT: Function Attrs: nounwind willreturn ; TUNIT: Function Attrs: mustprogress nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@f18 ; TUNIT-LABEL: define {{[^@]+}}@f18
; TUNIT-SAME: (ptr nonnull [[A:%.*]], ptr [[B:%.*]], i8 [[C:%.*]]) #[[ATTR7]] { ; TUNIT-SAME: (ptr nonnull [[A:%.*]], ptr [[B:%.*]], i8 [[C:%.*]]) #[[ATTR8]] {
; TUNIT-NEXT: [[CMP1:%.*]] = icmp eq i8 [[C]], 0 ; TUNIT-NEXT: [[CMP1:%.*]] = icmp eq i8 [[C]], 0
; TUNIT-NEXT: br i1 [[CMP1]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]] ; TUNIT-NEXT: br i1 [[CMP1]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; TUNIT: if.then: ; TUNIT: if.then:
; TUNIT-NEXT: tail call void @fun0() #[[ATTR7]] ; TUNIT-NEXT: tail call void @fun0() #[[ATTR7]]
; TUNIT-NEXT: br label [[CONT:%.*]] ; TUNIT-NEXT: br label [[CONT:%.*]]
; TUNIT: if.else: ; TUNIT: if.else:
; TUNIT-NEXT: tail call void @fun0() #[[ATTR7]] ; TUNIT-NEXT: tail call void @fun0() #[[ATTR7]]
; TUNIT-NEXT: br label [[CONT]] ; TUNIT-NEXT: br label [[CONT]]
; TUNIT: cont: ; TUNIT: cont:
; TUNIT-NEXT: [[CMP2:%.*]] = icmp eq i8 [[C]], 1 ; TUNIT-NEXT: [[CMP2:%.*]] = icmp eq i8 [[C]], 1
; TUNIT-NEXT: br i1 [[CMP2]], label [[CONT_THEN:%.*]], label [[CONT_ELSE:%.*]] ; TUNIT-NEXT: br i1 [[CMP2]], label [[CONT_THEN:%.*]], label [[CONT_ELSE:%.*]]
; TUNIT: cont.then: ; TUNIT: cont.then:
; TUNIT-NEXT: tail call void @fun1(ptr nonnull [[B]]) #[[ATTR7]] ; TUNIT-NEXT: tail call void @fun1(ptr nonnull [[B]]) #[[ATTR7]]
; TUNIT-NEXT: br label [[CONT2:%.*]] ; TUNIT-NEXT: br label [[CONT2:%.*]]
; TUNIT: cont.else: ; TUNIT: cont.else:
; TUNIT-NEXT: tail call void @fun0() #[[ATTR7]] ; TUNIT-NEXT: tail call void @fun0() #[[ATTR7]]
; TUNIT-NEXT: br label [[CONT2]] ; TUNIT-NEXT: br label [[CONT2]]
; TUNIT: cont2: ; TUNIT: cont2:
; TUNIT-NEXT: tail call void @fun1(ptr nonnull [[A]]) #[[ATTR7]] ; TUNIT-NEXT: tail call void @fun1(ptr nonnull [[A]]) #[[ATTR7]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nounwind willreturn ; CGSCC: Function Attrs: mustprogress nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@f18 ; CGSCC-LABEL: define {{[^@]+}}@f18
; CGSCC-SAME: (ptr nonnull [[A:%.*]], ptr [[B:%.*]], i8 [[C:%.*]]) #[[ATTR6]] { ; CGSCC-SAME: (ptr nonnull [[A:%.*]], ptr [[B:%.*]], i8 [[C:%.*]]) #[[ATTR7]] {
; CGSCC-NEXT: [[CMP1:%.*]] = icmp eq i8 [[C]], 0 ; CGSCC-NEXT: [[CMP1:%.*]] = icmp eq i8 [[C]], 0
; CGSCC-NEXT: br i1 [[CMP1]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]] ; CGSCC-NEXT: br i1 [[CMP1]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; CGSCC: if.then: ; CGSCC: if.then:
; CGSCC-NEXT: tail call void @fun0() #[[ATTR6]] ; CGSCC-NEXT: tail call void @fun0() #[[ATTR6]]
; CGSCC-NEXT: br label [[CONT:%.*]] ; CGSCC-NEXT: br label [[CONT:%.*]]
; CGSCC: if.else: ; CGSCC: if.else:
; CGSCC-NEXT: tail call void @fun0() #[[ATTR6]] ; CGSCC-NEXT: tail call void @fun0() #[[ATTR6]]
; CGSCC-NEXT: br label [[CONT]] ; CGSCC-NEXT: br label [[CONT]]
▲ Show 20 Lines • Show All 193 Lines • ▼ Show 20 Lines;
ret i8 %c ret i8 %c
} }
; The nonnull callsite is guaranteed to execute, so the argument must be nonnull throughout the parent. ; The nonnull callsite is guaranteed to execute, so the argument must be nonnull throughout the parent.
define i8 @parent7(ptr %a) { define i8 @parent7(ptr %a) {
; CHECK-LABEL: define {{[^@]+}}@parent7 ; CHECK-LABEL: define {{[^@]+}}@parent7
; CHECK-SAME: (ptr nonnull [[A:%.*]]) { ; CHECK-SAME: (ptr nonnull [[A:%.*]]) {
; CHECK-NEXT: [[RET:%.*]] = call i8 @use1safecall(ptr nonnull readonly [[A]]) #[[ATTR13]] ; CHECK-NEXT: [[RET:%.*]] = call i8 @use1safecall(ptr nonnull readonly [[A]]) #[[ATTR15]]
; CHECK-NEXT: call void @use1nonnull(ptr nonnull [[A]]) ; CHECK-NEXT: call void @use1nonnull(ptr nonnull [[A]])
; CHECK-NEXT: ret i8 [[RET]] ; CHECK-NEXT: ret i8 [[RET]]
; ;
%ret = call i8 @use1safecall(ptr %a) %ret = call i8 @use1safecall(ptr %a)
call void @use1nonnull(ptr %a) call void @use1nonnull(ptr %a)
ret i8 %ret ret i8 %ret
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
exc: exc:
%lp = landingpad { ptr, i32 } %lp = landingpad { ptr, i32 }
filter [0 x ptr] zeroinitializer filter [0 x ptr] zeroinitializer
unreachable unreachable
} }
define ptr @gep1(ptr %p) { define ptr @gep1(ptr %p) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@gep1 ; CHECK-LABEL: define {{[^@]+}}@gep1
; CHECK-SAME: (ptr nofree readnone "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ptr nofree readnone "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[Q:%.*]] = getelementptr inbounds i32, ptr [[P]], i32 1 ; CHECK-NEXT: [[Q:%.*]] = getelementptr inbounds i32, ptr [[P]], i32 1
; CHECK-NEXT: ret ptr [[Q]] ; CHECK-NEXT: ret ptr [[Q]]
; ;
%q = getelementptr inbounds i32, ptr %p, i32 1 %q = getelementptr inbounds i32, ptr %p, i32 1
ret ptr %q ret ptr %q
} }
define ptr @gep1_no_null_opt(ptr %p) #0 { define ptr @gep1_no_null_opt(ptr %p) #0 {
; Should't be able to derive nonnull based on gep. ; Should't be able to derive nonnull based on gep.
; TUNIT: Function Attrs: nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@gep1_no_null_opt ; TUNIT-LABEL: define {{[^@]+}}@gep1_no_null_opt
; TUNIT-SAME: (ptr nofree readnone "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR9:[0-9]+]] { ; TUNIT-SAME: (ptr nofree readnone "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR10:[0-9]+]] {
; TUNIT-NEXT: [[Q:%.*]] = getelementptr inbounds i32, ptr [[P]], i32 1 ; TUNIT-NEXT: [[Q:%.*]] = getelementptr inbounds i32, ptr [[P]], i32 1
; TUNIT-NEXT: ret ptr [[Q]] ; TUNIT-NEXT: ret ptr [[Q]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@gep1_no_null_opt ; CGSCC-LABEL: define {{[^@]+}}@gep1_no_null_opt
; CGSCC-SAME: (ptr nofree readnone "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR8:[0-9]+]] { ; CGSCC-SAME: (ptr nofree readnone "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR9:[0-9]+]] {
; CGSCC-NEXT: [[Q:%.*]] = getelementptr inbounds i32, ptr [[P]], i32 1 ; CGSCC-NEXT: [[Q:%.*]] = getelementptr inbounds i32, ptr [[P]], i32 1
; CGSCC-NEXT: ret ptr [[Q]] ; CGSCC-NEXT: ret ptr [[Q]]
; ;
%q = getelementptr inbounds i32, ptr %p, i32 1 %q = getelementptr inbounds i32, ptr %p, i32 1
ret ptr %q ret ptr %q
} }
define ptr addrspace(3) @gep2(ptr addrspace(3) %p) { define ptr addrspace(3) @gep2(ptr addrspace(3) %p) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@gep2 ; CHECK-LABEL: define {{[^@]+}}@gep2
; CHECK-SAME: (ptr addrspace(3) nofree readnone "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ptr addrspace(3) nofree readnone "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: [[Q:%.*]] = getelementptr inbounds i32, ptr addrspace(3) [[P]], i32 1 ; CHECK-NEXT: [[Q:%.*]] = getelementptr inbounds i32, ptr addrspace(3) [[P]], i32 1
; CHECK-NEXT: ret ptr addrspace(3) [[Q]] ; CHECK-NEXT: ret ptr addrspace(3) [[Q]]
; ;
%q = getelementptr inbounds i32, ptr addrspace(3) %p, i32 1 %q = getelementptr inbounds i32, ptr addrspace(3) %p, i32 1
ret ptr addrspace(3) %q ret ptr addrspace(3) %q
} }
; FIXME: We should propagate dereferenceable here but *not* nonnull ; FIXME: We should propagate dereferenceable here but *not* nonnull
define ptr addrspace(3) @as(ptr addrspace(3) dereferenceable(4) %p) { define ptr addrspace(3) @as(ptr addrspace(3) dereferenceable(4) %p) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@as ; CHECK-LABEL: define {{[^@]+}}@as
; CHECK-SAME: (ptr addrspace(3) nofree noundef nonnull readnone returned dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ptr addrspace(3) nofree noundef nonnull readnone returned dereferenceable(4) "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: ret ptr addrspace(3) [[P]] ; CHECK-NEXT: ret ptr addrspace(3) [[P]]
; ;
ret ptr addrspace(3) %p ret ptr addrspace(3) %p
} }
; CHECK-NOT: @g2() ; CHECK-NOT: @g2()
define internal ptr @g2() { define internal ptr @g2() {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@g2 ; CGSCC-LABEL: define {{[^@]+}}@g2
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: ret ptr inttoptr (i64 4 to ptr) ; CGSCC-NEXT: ret ptr inttoptr (i64 4 to ptr)
; ;
ret ptr inttoptr (i64 4 to ptr) ret ptr inttoptr (i64 4 to ptr)
} }
define ptr @g1() { define ptr @g1() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@g1 ; TUNIT-LABEL: define {{[^@]+}}@g1
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret ptr inttoptr (i64 4 to ptr) ; TUNIT-NEXT: ret ptr inttoptr (i64 4 to ptr)
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@g1 ; CGSCC-LABEL: define {{[^@]+}}@g1
; CGSCC-SAME: () #[[ATTR9:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR10:[0-9]+]] {
; CGSCC-NEXT: [[C:%.*]] = call noundef nonnull align 4 ptr @g2() #[[ATTR13]] ; CGSCC-NEXT: [[C:%.*]] = call noundef nonnull align 4 ptr @g2() #[[ATTR15]]
; CGSCC-NEXT: ret ptr [[C]] ; CGSCC-NEXT: ret ptr [[C]]
; ;
%c = call ptr @g2() %c = call ptr @g2()
ret ptr %c ret ptr %c
} }
declare void @use_i32_ptr(ptr readnone nocapture) nounwind declare void @use_i32_ptr(ptr readnone nocapture) nounwind
define internal void @called_by_weak(ptr %a) { define internal void @called_by_weak(ptr %a) {
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
; ;
call void @use_i32_ptr(ptr %a) call void @use_i32_ptr(ptr %a)
ret void ret void
} }
; Avoid nonnull as we do not touch naked functions ; Avoid nonnull as we do not touch naked functions
define internal void @naked(ptr dereferenceable(4) %a) naked { define internal void @naked(ptr dereferenceable(4) %a) naked {
; CHECK: Function Attrs: naked ; CHECK: Function Attrs: naked
; CHECK-LABEL: define {{[^@]+}}@naked ; CHECK-LABEL: define {{[^@]+}}@naked
; CHECK-SAME: (ptr dereferenceable(4) [[A:%.*]]) #[[ATTR10:[0-9]+]] { ; CHECK-SAME: (ptr dereferenceable(4) [[A:%.*]]) #[[ATTR11:[0-9]+]] {
; CHECK-NEXT: call void @use_i32_ptr(ptr [[A]]) ; CHECK-NEXT: call void @use_i32_ptr(ptr [[A]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @use_i32_ptr(ptr %a) call void @use_i32_ptr(ptr %a)
ret void ret void
} }
; Avoid nonnull as we do not touch optnone ; Avoid nonnull as we do not touch optnone
define internal void @optnone(ptr dereferenceable(4) %a) optnone noinline { define internal void @optnone(ptr dereferenceable(4) %a) optnone noinline {
; ;
; CHECK: Function Attrs: noinline optnone ; CHECK: Function Attrs: noinline optnone
; CHECK-LABEL: define {{[^@]+}}@optnone ; CHECK-LABEL: define {{[^@]+}}@optnone
; CHECK-SAME: (ptr dereferenceable(4) [[A:%.*]]) #[[ATTR11:[0-9]+]] { ; CHECK-SAME: (ptr dereferenceable(4) [[A:%.*]]) #[[ATTR12:[0-9]+]] {
; CHECK-NEXT: call void @use_i32_ptr(ptr [[A]]) ; CHECK-NEXT: call void @use_i32_ptr(ptr [[A]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @use_i32_ptr(ptr %a) call void @use_i32_ptr(ptr %a)
ret void ret void
} }
define void @make_live(ptr nonnull dereferenceable(8) %a) { define void @make_live(ptr nonnull dereferenceable(8) %a) {
; TUNIT-LABEL: define {{[^@]+}}@make_live ; TUNIT-LABEL: define {{[^@]+}}@make_live
Show All 22 Lines
; h(u); ; h(u);
; } ; }
; return g(nonnull u); ; return g(nonnull u);
;} ;}
declare void @h(ptr) willreturn nounwind declare void @h(ptr) willreturn nounwind
declare i32 @g(ptr) willreturn nounwind declare i32 @g(ptr) willreturn nounwind
define i32 @nonnull_exec_ctx_1(ptr %a, i32 %b) { define i32 @nonnull_exec_ctx_1(ptr %a, i32 %b) {
; ;
; TUNIT: Function Attrs: nounwind willreturn ; TUNIT: Function Attrs: mustprogress nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@nonnull_exec_ctx_1 ; TUNIT-LABEL: define {{[^@]+}}@nonnull_exec_ctx_1
; TUNIT-SAME: (ptr [[A:%.*]], i32 [[B:%.*]]) #[[ATTR7]] { ; TUNIT-SAME: (ptr [[A:%.*]], i32 [[B:%.*]]) #[[ATTR8]] {
; TUNIT-NEXT: en: ; TUNIT-NEXT: en:
; TUNIT-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0 ; TUNIT-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0
; TUNIT-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]] ; TUNIT-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
; TUNIT: ex: ; TUNIT: ex:
; TUNIT-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR7]] ; TUNIT-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR7]]
; TUNIT-NEXT: ret i32 [[TMP5]] ; TUNIT-NEXT: ret i32 [[TMP5]]
; TUNIT: hd: ; TUNIT: hd:
; TUNIT-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ] ; TUNIT-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ]
; TUNIT-NEXT: tail call void @h(ptr [[A]]) #[[ATTR7]] ; TUNIT-NEXT: tail call void @h(ptr [[A]]) #[[ATTR7]]
; TUNIT-NEXT: [[TMP8]] = add nuw i32 [[TMP7]], 1 ; TUNIT-NEXT: [[TMP8]] = add nuw i32 [[TMP7]], 1
; TUNIT-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]] ; TUNIT-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]]
; TUNIT-NEXT: br i1 [[TMP9]], label [[EX]], label [[HD]] ; TUNIT-NEXT: br i1 [[TMP9]], label [[EX]], label [[HD]]
; ;
; CGSCC: Function Attrs: nounwind willreturn ; CGSCC: Function Attrs: mustprogress nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@nonnull_exec_ctx_1 ; CGSCC-LABEL: define {{[^@]+}}@nonnull_exec_ctx_1
; CGSCC-SAME: (ptr [[A:%.*]], i32 [[B:%.*]]) #[[ATTR6]] { ; CGSCC-SAME: (ptr [[A:%.*]], i32 [[B:%.*]]) #[[ATTR7]] {
; CGSCC-NEXT: en: ; CGSCC-NEXT: en:
; CGSCC-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0 ; CGSCC-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0
; CGSCC-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]] ; CGSCC-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
; CGSCC: ex: ; CGSCC: ex:
; CGSCC-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR6]] ; CGSCC-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR6]]
; CGSCC-NEXT: ret i32 [[TMP5]] ; CGSCC-NEXT: ret i32 [[TMP5]]
; CGSCC: hd: ; CGSCC: hd:
; CGSCC-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ] ; CGSCC-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ]
Show All 15 Lineshd:
tail call void @h(ptr %a) tail call void @h(ptr %a)
%tmp8 = add nuw i32 %tmp7, 1 %tmp8 = add nuw i32 %tmp7, 1
%tmp9 = icmp eq i32 %tmp8, %b %tmp9 = icmp eq i32 %tmp8, %b
br i1 %tmp9, label %ex, label %hd br i1 %tmp9, label %ex, label %hd
} }
define i32 @nonnull_exec_ctx_1b(ptr %a, i32 %b) { define i32 @nonnull_exec_ctx_1b(ptr %a, i32 %b) {
; ;
; TUNIT: Function Attrs: nounwind willreturn ; TUNIT: Function Attrs: mustprogress nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@nonnull_exec_ctx_1b ; TUNIT-LABEL: define {{[^@]+}}@nonnull_exec_ctx_1b
; TUNIT-SAME: (ptr [[A:%.*]], i32 [[B:%.*]]) #[[ATTR7]] { ; TUNIT-SAME: (ptr [[A:%.*]], i32 [[B:%.*]]) #[[ATTR8]] {
; TUNIT-NEXT: en: ; TUNIT-NEXT: en:
; TUNIT-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0 ; TUNIT-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0
; TUNIT-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]] ; TUNIT-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
; TUNIT: ex: ; TUNIT: ex:
; TUNIT-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR7]] ; TUNIT-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR7]]
; TUNIT-NEXT: ret i32 [[TMP5]] ; TUNIT-NEXT: ret i32 [[TMP5]]
; TUNIT: hd: ; TUNIT: hd:
; TUNIT-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ] ; TUNIT-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ]
; TUNIT-NEXT: tail call void @h(ptr [[A]]) #[[ATTR7]] ; TUNIT-NEXT: tail call void @h(ptr [[A]]) #[[ATTR7]]
; TUNIT-NEXT: br label [[HD2]] ; TUNIT-NEXT: br label [[HD2]]
; TUNIT: hd2: ; TUNIT: hd2:
; TUNIT-NEXT: [[TMP8]] = add nuw i32 [[TMP7]], 1 ; TUNIT-NEXT: [[TMP8]] = add nuw i32 [[TMP7]], 1
; TUNIT-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]] ; TUNIT-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]]
; TUNIT-NEXT: br i1 [[TMP9]], label [[EX]], label [[HD]] ; TUNIT-NEXT: br i1 [[TMP9]], label [[EX]], label [[HD]]
; ;
; CGSCC: Function Attrs: nounwind willreturn ; CGSCC: Function Attrs: mustprogress nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@nonnull_exec_ctx_1b ; CGSCC-LABEL: define {{[^@]+}}@nonnull_exec_ctx_1b
; CGSCC-SAME: (ptr [[A:%.*]], i32 [[B:%.*]]) #[[ATTR6]] { ; CGSCC-SAME: (ptr [[A:%.*]], i32 [[B:%.*]]) #[[ATTR7]] {
; CGSCC-NEXT: en: ; CGSCC-NEXT: en:
; CGSCC-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0 ; CGSCC-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0
; CGSCC-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]] ; CGSCC-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
; CGSCC: ex: ; CGSCC: ex:
; CGSCC-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR6]] ; CGSCC-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR6]]
; CGSCC-NEXT: ret i32 [[TMP5]] ; CGSCC-NEXT: ret i32 [[TMP5]]
; CGSCC: hd: ; CGSCC: hd:
; CGSCC-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ] ; CGSCC-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ]
Show All 20 Lines
hd2: hd2:
%tmp8 = add nuw i32 %tmp7, 1 %tmp8 = add nuw i32 %tmp7, 1
%tmp9 = icmp eq i32 %tmp8, %b %tmp9 = icmp eq i32 %tmp8, %b
br i1 %tmp9, label %ex, label %hd br i1 %tmp9, label %ex, label %hd
} }
define i32 @nonnull_exec_ctx_2(ptr %a, i32 %b) willreturn nounwind { define i32 @nonnull_exec_ctx_2(ptr %a, i32 %b) willreturn nounwind {
; ;
; TUNIT: Function Attrs: nounwind willreturn ; TUNIT: Function Attrs: mustprogress nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@nonnull_exec_ctx_2 ; TUNIT-LABEL: define {{[^@]+}}@nonnull_exec_ctx_2
; TUNIT-SAME: (ptr nonnull [[A:%.*]], i32 [[B:%.*]]) #[[ATTR7]] { ; TUNIT-SAME: (ptr nonnull [[A:%.*]], i32 [[B:%.*]]) #[[ATTR8]] {
; TUNIT-NEXT: en: ; TUNIT-NEXT: en:
; TUNIT-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0 ; TUNIT-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0
; TUNIT-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]] ; TUNIT-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
; TUNIT: ex: ; TUNIT: ex:
; TUNIT-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR5]] ; TUNIT-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR5]]
; TUNIT-NEXT: ret i32 [[TMP5]] ; TUNIT-NEXT: ret i32 [[TMP5]]
; TUNIT: hd: ; TUNIT: hd:
; TUNIT-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ] ; TUNIT-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ]
; TUNIT-NEXT: tail call void @h(ptr nonnull [[A]]) #[[ATTR5]] ; TUNIT-NEXT: tail call void @h(ptr nonnull [[A]]) #[[ATTR5]]
; TUNIT-NEXT: [[TMP8]] = add nuw i32 [[TMP7]], 1 ; TUNIT-NEXT: [[TMP8]] = add nuw i32 [[TMP7]], 1
; TUNIT-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]] ; TUNIT-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]]
; TUNIT-NEXT: br i1 [[TMP9]], label [[EX]], label [[HD]] ; TUNIT-NEXT: br i1 [[TMP9]], label [[EX]], label [[HD]]
; ;
; CGSCC: Function Attrs: nounwind willreturn ; CGSCC: Function Attrs: mustprogress nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@nonnull_exec_ctx_2 ; CGSCC-LABEL: define {{[^@]+}}@nonnull_exec_ctx_2
; CGSCC-SAME: (ptr nonnull [[A:%.*]], i32 [[B:%.*]]) #[[ATTR6]] { ; CGSCC-SAME: (ptr nonnull [[A:%.*]], i32 [[B:%.*]]) #[[ATTR7]] {
; CGSCC-NEXT: en: ; CGSCC-NEXT: en:
; CGSCC-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0 ; CGSCC-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0
; CGSCC-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]] ; CGSCC-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
; CGSCC: ex: ; CGSCC: ex:
; CGSCC-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR4]] ; CGSCC-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR4]]
; CGSCC-NEXT: ret i32 [[TMP5]] ; CGSCC-NEXT: ret i32 [[TMP5]]
; CGSCC: hd: ; CGSCC: hd:
; CGSCC-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ] ; CGSCC-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD]] ], [ 0, [[EN:%.*]] ]
Show All 15 Lineshd:
tail call void @h(ptr %a) tail call void @h(ptr %a)
%tmp8 = add nuw i32 %tmp7, 1 %tmp8 = add nuw i32 %tmp7, 1
%tmp9 = icmp eq i32 %tmp8, %b %tmp9 = icmp eq i32 %tmp8, %b
br i1 %tmp9, label %ex, label %hd br i1 %tmp9, label %ex, label %hd
} }
define i32 @nonnull_exec_ctx_2b(ptr %a, i32 %b) willreturn nounwind { define i32 @nonnull_exec_ctx_2b(ptr %a, i32 %b) willreturn nounwind {
; ;
; TUNIT: Function Attrs: nounwind willreturn ; TUNIT: Function Attrs: mustprogress nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@nonnull_exec_ctx_2b ; TUNIT-LABEL: define {{[^@]+}}@nonnull_exec_ctx_2b
; TUNIT-SAME: (ptr nonnull [[A:%.*]], i32 [[B:%.*]]) #[[ATTR7]] { ; TUNIT-SAME: (ptr nonnull [[A:%.*]], i32 [[B:%.*]]) #[[ATTR8]] {
; TUNIT-NEXT: en: ; TUNIT-NEXT: en:
; TUNIT-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0 ; TUNIT-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0
; TUNIT-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]] ; TUNIT-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
; TUNIT: ex: ; TUNIT: ex:
; TUNIT-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR5]] ; TUNIT-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR5]]
; TUNIT-NEXT: ret i32 [[TMP5]] ; TUNIT-NEXT: ret i32 [[TMP5]]
; TUNIT: hd: ; TUNIT: hd:
; TUNIT-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ] ; TUNIT-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ]
; TUNIT-NEXT: tail call void @h(ptr nonnull [[A]]) #[[ATTR5]] ; TUNIT-NEXT: tail call void @h(ptr nonnull [[A]]) #[[ATTR5]]
; TUNIT-NEXT: br label [[HD2]] ; TUNIT-NEXT: br label [[HD2]]
; TUNIT: hd2: ; TUNIT: hd2:
; TUNIT-NEXT: [[TMP8]] = add nuw i32 [[TMP7]], 1 ; TUNIT-NEXT: [[TMP8]] = add nuw i32 [[TMP7]], 1
; TUNIT-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]] ; TUNIT-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], [[B]]
; TUNIT-NEXT: br i1 [[TMP9]], label [[EX]], label [[HD]] ; TUNIT-NEXT: br i1 [[TMP9]], label [[EX]], label [[HD]]
; ;
; CGSCC: Function Attrs: nounwind willreturn ; CGSCC: Function Attrs: mustprogress nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@nonnull_exec_ctx_2b ; CGSCC-LABEL: define {{[^@]+}}@nonnull_exec_ctx_2b
; CGSCC-SAME: (ptr nonnull [[A:%.*]], i32 [[B:%.*]]) #[[ATTR6]] { ; CGSCC-SAME: (ptr nonnull [[A:%.*]], i32 [[B:%.*]]) #[[ATTR7]] {
; CGSCC-NEXT: en: ; CGSCC-NEXT: en:
; CGSCC-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0 ; CGSCC-NEXT: [[TMP3:%.*]] = icmp eq i32 [[B]], 0
; CGSCC-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]] ; CGSCC-NEXT: br i1 [[TMP3]], label [[EX:%.*]], label [[HD:%.*]]
; CGSCC: ex: ; CGSCC: ex:
; CGSCC-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR4]] ; CGSCC-NEXT: [[TMP5:%.*]] = tail call i32 @g(ptr nonnull [[A]]) #[[ATTR4]]
; CGSCC-NEXT: ret i32 [[TMP5]] ; CGSCC-NEXT: ret i32 [[TMP5]]
; CGSCC: hd: ; CGSCC: hd:
; CGSCC-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ] ; CGSCC-NEXT: [[TMP7:%.*]] = phi i32 [ [[TMP8:%.*]], [[HD2:%.*]] ], [ 0, [[EN:%.*]] ]
▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Lines8: ; preds = %8, %4
%11 = icmp eq i32 %10, %1 %11 = icmp eq i32 %10, %1
br i1 %11, label %7, label %8 br i1 %11, label %7, label %8
} }
declare ptr @strrchr(ptr %0, i32 %1) nofree nounwind readonly willreturn declare ptr @strrchr(ptr %0, i32 %1) nofree nounwind readonly willreturn
; We should not mark the return of @strrchr as `nonnull`, it may well be NULL! ; We should not mark the return of @strrchr as `nonnull`, it may well be NULL!
define ptr @mybasename(ptr nofree readonly %str) { define ptr @mybasename(ptr nofree readonly %str) {
; CHECK: Function Attrs: nofree nounwind willreturn memory(read) ; CHECK: Function Attrs: mustprogress nofree nounwind willreturn memory(read)
; CHECK-LABEL: define {{[^@]+}}@mybasename ; CHECK-LABEL: define {{[^@]+}}@mybasename
; CHECK-SAME: (ptr nofree readonly [[STR:%.*]]) #[[ATTR12:[0-9]+]] { ; CHECK-SAME: (ptr nofree readonly [[STR:%.*]]) #[[ATTR14:[0-9]+]] {
; CHECK-NEXT: [[CALL:%.*]] = call ptr @strrchr(ptr nofree readonly [[STR]], i32 noundef 47) #[[ATTR13]] ; CHECK-NEXT: [[CALL:%.*]] = call ptr @strrchr(ptr nofree readonly [[STR]], i32 noundef 47) #[[ATTR15]]
; CHECK-NEXT: [[TOBOOL:%.*]] = icmp ne ptr [[CALL]], null ; CHECK-NEXT: [[TOBOOL:%.*]] = icmp ne ptr [[CALL]], null
; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i8, ptr [[CALL]], i64 1 ; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i8, ptr [[CALL]], i64 1
; CHECK-NEXT: [[COND:%.*]] = select i1 [[TOBOOL]], ptr [[ADD_PTR]], ptr [[STR]] ; CHECK-NEXT: [[COND:%.*]] = select i1 [[TOBOOL]], ptr [[ADD_PTR]], ptr [[STR]]
; CHECK-NEXT: ret ptr [[COND]] ; CHECK-NEXT: ret ptr [[COND]]
; ;
%call = call ptr @strrchr(ptr %str, i32 47) %call = call ptr @strrchr(ptr %str, i32 47)
%tobool = icmp ne ptr %call, null %tobool = icmp ne ptr %call, null
%add.ptr = getelementptr inbounds i8, ptr %call, i64 1 %add.ptr = getelementptr inbounds i8, ptr %call, i64 1
%cond = select i1 %tobool, ptr %add.ptr, ptr %str %cond = select i1 %tobool, ptr %add.ptr, ptr %str
ret ptr %cond ret ptr %cond
} }
define void @nonnull_assume_pos(ptr %arg) { define void @nonnull_assume_pos(ptr %arg) {
; ATTRIBUTOR-LABEL: define {{[^@]+}}@nonnull_assume_pos ; ATTRIBUTOR-LABEL: define {{[^@]+}}@nonnull_assume_pos
; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull readnone [[ARG:%.*]]) ; ATTRIBUTOR-SAME: (ptr nocapture nofree nonnull readnone [[ARG:%.*]])
; ATTRIBUTOR-NEXT: call void @llvm.assume(i1 true) #11 [ "nonnull"(ptr [[ARG]]) ] ; ATTRIBUTOR-NEXT: call void @llvm.assume(i1 true) #11 [ "nonnull"(ptr [[ARG]]) ]
; ATTRIBUTOR-NEXT: call void @use_i8_ptr(ptr noalias nocapture nofree nonnull readnone [[ARG]]) ; ATTRIBUTOR-NEXT: call void @use_i8_ptr(ptr noalias nocapture nofree nonnull readnone [[ARG]])
; ATTRIBUTOR-NEXT: [[TMP1:%.*]] = call ptr @unknown() ; ATTRIBUTOR-NEXT: [[TMP1:%.*]] = call ptr @unknown()
; ATTRIBUTOR-NEXT: ret void ; ATTRIBUTOR-NEXT: ret void
; ;
; TUNIT-LABEL: define {{[^@]+}}@nonnull_assume_pos ; TUNIT-LABEL: define {{[^@]+}}@nonnull_assume_pos
; TUNIT-SAME: (ptr nocapture nofree nonnull readnone [[ARG:%.*]]) { ; TUNIT-SAME: (ptr nocapture nofree nonnull readnone [[ARG:%.*]]) {
; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR13]] [ "nonnull"(ptr [[ARG]]) ] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR15]] [ "nonnull"(ptr [[ARG]]) ]
; TUNIT-NEXT: call void @use_i8_ptr(ptr noalias nocapture nofree nonnull readnone [[ARG]]) #[[ATTR5]] ; TUNIT-NEXT: call void @use_i8_ptr(ptr noalias nocapture nofree nonnull readnone [[ARG]]) #[[ATTR5]]
; TUNIT-NEXT: [[TMP1:%.*]] = call ptr @unknown() ; TUNIT-NEXT: [[TMP1:%.*]] = call ptr @unknown()
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC-LABEL: define {{[^@]+}}@nonnull_assume_pos ; CGSCC-LABEL: define {{[^@]+}}@nonnull_assume_pos
; CGSCC-SAME: (ptr nocapture nofree nonnull readnone [[ARG:%.*]]) { ; CGSCC-SAME: (ptr nocapture nofree nonnull readnone [[ARG:%.*]]) {
; CGSCC-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR13]] [ "nonnull"(ptr [[ARG]]) ] ; CGSCC-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR15]] [ "nonnull"(ptr [[ARG]]) ]
; CGSCC-NEXT: call void @use_i8_ptr(ptr noalias nocapture nofree nonnull readnone [[ARG]]) #[[ATTR4]] ; CGSCC-NEXT: call void @use_i8_ptr(ptr noalias nocapture nofree nonnull readnone [[ARG]]) #[[ATTR4]]
; CGSCC-NEXT: [[TMP1:%.*]] = call ptr @unknown() ; CGSCC-NEXT: [[TMP1:%.*]] = call ptr @unknown()
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @llvm.assume(i1 true) ["nonnull"(ptr %arg)] call void @llvm.assume(i1 true) ["nonnull"(ptr %arg)]
call void @use_i8_ptr(ptr %arg) call void @use_i8_ptr(ptr %arg)
call ptr @unknown() call ptr @unknown()
ret void ret void
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines;
call void @llvm.assume(i1 true) ["nonnull"(ptr %arg)] call void @llvm.assume(i1 true) ["nonnull"(ptr %arg)]
call void @use_i8_ptr_ret(ptr %arg) call void @use_i8_ptr_ret(ptr %arg)
ret void ret void
} }
declare void @use_i8_ptr(ptr nofree nocapture readnone) nounwind declare void @use_i8_ptr(ptr nofree nocapture readnone) nounwind
declare void @use_i8_ptr_ret(ptr nofree nocapture readnone) nounwind willreturn declare void @use_i8_ptr_ret(ptr nofree nocapture readnone) nounwind willreturn
define ptr @nonnull_function_ptr_1() { define ptr @nonnull_function_ptr_1() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@nonnull_function_ptr_1 ; CHECK-LABEL: define {{[^@]+}}@nonnull_function_ptr_1
; CHECK-SAME: () #[[ATTR1]] { ; CHECK-SAME: () #[[ATTR1]] {
; CHECK-NEXT: ret ptr @nonnull_function_ptr_1 ; CHECK-NEXT: ret ptr @nonnull_function_ptr_1
; ;
ret ptr @nonnull_function_ptr_1 ret ptr @nonnull_function_ptr_1
} }
declare ptr @function_decl() declare ptr @function_decl()
define ptr @nonnull_function_ptr_2() { define ptr @nonnull_function_ptr_2() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@nonnull_function_ptr_2 ; TUNIT-LABEL: define {{[^@]+}}@nonnull_function_ptr_2
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret ptr @function_decl ; TUNIT-NEXT: ret ptr @function_decl
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@nonnull_function_ptr_2 ; CGSCC-LABEL: define {{[^@]+}}@nonnull_function_ptr_2
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: ret ptr @function_decl ; CGSCC-NEXT: ret ptr @function_decl
; ;
ret ptr @function_decl ret ptr @function_decl
} }
; FIXME: nonnull should not be propagated to the caller's p unless there is noundef ; FIXME: nonnull should not be propagated to the caller's p unless there is noundef
define void @nonnull_caller(ptr %p) { define void @nonnull_caller(ptr %p) {
; CHECK-LABEL: define {{[^@]+}}@nonnull_caller ; CHECK-LABEL: define {{[^@]+}}@nonnull_caller
; CHECK-SAME: (ptr nonnull [[P:%.*]]) { ; CHECK-SAME: (ptr nonnull [[P:%.*]]) {
; CHECK-NEXT: call void @nonnull_callee(ptr nonnull [[P]]) ; CHECK-NEXT: call void @nonnull_callee(ptr nonnull [[P]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @nonnull_callee(ptr %p) call void @nonnull_callee(ptr %p)
ret void ret void
} }
declare void @nonnull_callee(ptr nonnull %p) declare void @nonnull_callee(ptr nonnull %p)
attributes #0 = { null_pointer_is_valid } attributes #0 = { null_pointer_is_valid }
attributes #1 = { nounwind willreturn} attributes #1 = { nounwind willreturn}
;. ;.
; TUNIT: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; TUNIT: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; TUNIT: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
; TUNIT: attributes #[[ATTR3]] = { nofree nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR3]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR4]] = { noreturn } ; TUNIT: attributes #[[ATTR4]] = { noreturn }
; TUNIT: attributes #[[ATTR5]] = { nounwind } ; TUNIT: attributes #[[ATTR5]] = { nounwind }
; TUNIT: attributes #[[ATTR6]] = { nofree nosync nounwind memory(argmem: read) } ; TUNIT: attributes #[[ATTR6]] = { nofree nosync nounwind memory(argmem: read) }
; TUNIT: attributes #[[ATTR7]] = { nounwind willreturn } ; TUNIT: attributes #[[ATTR7]] = { nounwind willreturn }
; TUNIT: attributes #[[ATTR8:[0-9]+]] = { nounwind willreturn memory(read) } ; TUNIT: attributes #[[ATTR8]] = { mustprogress nounwind willreturn }
; TUNIT: attributes #[[ATTR9]] = { nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none) } ; TUNIT: attributes #[[ATTR9:[0-9]+]] = { nounwind willreturn memory(read) }
; TUNIT: attributes #[[ATTR10]] = { naked } ; TUNIT: attributes #[[ATTR10]] = { mustprogress nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none) }
; TUNIT: attributes #[[ATTR11]] = { noinline optnone } ; TUNIT: attributes #[[ATTR11]] = { naked }
; TUNIT: attributes #[[ATTR12]] = { nofree nounwind willreturn memory(read) } ; TUNIT: attributes #[[ATTR12]] = { noinline optnone }
; TUNIT: attributes #[[ATTR13]] = { willreturn } ; TUNIT: attributes #[[ATTR13:[0-9]+]] = { nofree nounwind willreturn memory(read) }
; TUNIT: attributes #[[ATTR14]] = { nofree nosync nounwind } ; TUNIT: attributes #[[ATTR14]] = { mustprogress nofree nounwind willreturn memory(read) }
; TUNIT: attributes #[[ATTR15]] = { willreturn }
; TUNIT: attributes #[[ATTR16]] = { nofree nosync nounwind }
;. ;.
; CGSCC: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; CGSCC: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
; CGSCC: attributes #[[ATTR3]] = { noreturn } ; CGSCC: attributes #[[ATTR3]] = { noreturn }
; CGSCC: attributes #[[ATTR4]] = { nounwind } ; CGSCC: attributes #[[ATTR4]] = { nounwind }
; CGSCC: attributes #[[ATTR5]] = { nofree nosync nounwind memory(argmem: read) } ; CGSCC: attributes #[[ATTR5]] = { nofree nosync nounwind memory(argmem: read) }
; CGSCC: attributes #[[ATTR6]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR6]] = { nounwind willreturn }
; CGSCC: attributes #[[ATTR7:[0-9]+]] = { nounwind willreturn memory(read) } ; CGSCC: attributes #[[ATTR7]] = { mustprogress nounwind willreturn }
; CGSCC: attributes #[[ATTR8]] = { nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none) } ; CGSCC: attributes #[[ATTR8:[0-9]+]] = { nounwind willreturn memory(read) }
; CGSCC: attributes #[[ATTR9]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR9]] = { mustprogress nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none) }
; CGSCC: attributes #[[ATTR10]] = { naked } ; CGSCC: attributes #[[ATTR10]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR11]] = { noinline optnone } ; CGSCC: attributes #[[ATTR11]] = { naked }
; CGSCC: attributes #[[ATTR12]] = { nofree nounwind willreturn memory(read) } ; CGSCC: attributes #[[ATTR12]] = { noinline optnone }
; CGSCC: attributes #[[ATTR13]] = { willreturn } ; CGSCC: attributes #[[ATTR13:[0-9]+]] = { nofree nounwind willreturn memory(read) }
; CGSCC: attributes #[[ATTR14]] = { nofree nosync nounwind } ; CGSCC: attributes #[[ATTR14]] = { mustprogress nofree nounwind willreturn memory(read) }
; CGSCC: attributes #[[ATTR15]] = { willreturn }
; CGSCC: attributes #[[ATTR16]] = { nofree nosync nounwind }
;. ;.

llvm/test/Transforms/Attributor/norecurse.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=8 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=10 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
define i32 @leaf() { define i32 @leaf() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@leaf ; CHECK-LABEL: define {{[^@]+}}@leaf
; CHECK-SAME: () #[[ATTR0:[0-9]+]] { ; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: ret i32 1 ; CHECK-NEXT: ret i32 1
; ;
ret i32 1 ret i32 1
} }
define i32 @self_rec() { define i32 @self_rec() {
; CHECK: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@self_rec ; CHECK-LABEL: define {{[^@]+}}@self_rec
; CHECK-SAME: () #[[ATTR1:[0-9]+]] { ; CHECK-SAME: () #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: ret i32 4 ; CHECK-NEXT: ret i32 4
; ;
%a = call i32 @self_rec() %a = call i32 @self_rec()
ret i32 4 ret i32 4
} }
define i32 @indirect_rec() { define i32 @indirect_rec() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@indirect_rec ; TUNIT-LABEL: define {{[^@]+}}@indirect_rec
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret i32 undef ; TUNIT-NEXT: ret i32 undef
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@indirect_rec ; CGSCC-LABEL: define {{[^@]+}}@indirect_rec
; CGSCC-SAME: () #[[ATTR0]] { ; CGSCC-SAME: () #[[ATTR0]] {
; CGSCC-NEXT: ret i32 undef ; CGSCC-NEXT: ret i32 undef
; ;
%a = call i32 @indirect_rec2() %a = call i32 @indirect_rec2()
ret i32 %a ret i32 %a
} }
define i32 @indirect_rec2() { define i32 @indirect_rec2() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@indirect_rec2 ; TUNIT-LABEL: define {{[^@]+}}@indirect_rec2
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret i32 undef ; TUNIT-NEXT: ret i32 undef
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@indirect_rec2 ; CGSCC-LABEL: define {{[^@]+}}@indirect_rec2
; CGSCC-SAME: () #[[ATTR0]] { ; CGSCC-SAME: () #[[ATTR0]] {
; CGSCC-NEXT: ret i32 undef ; CGSCC-NEXT: ret i32 undef
; ;
%a = call i32 @indirect_rec() %a = call i32 @indirect_rec()
ret i32 %a ret i32 %a
} }
define i32 @extern() { define i32 @extern() {
; CHECK: Function Attrs: nosync memory(none) ; CHECK: Function Attrs: nosync memory(none)
; CHECK-LABEL: define {{[^@]+}}@extern ; CHECK-LABEL: define {{[^@]+}}@extern
; CHECK-SAME: () #[[ATTR2:[0-9]+]] { ; CHECK-SAME: () #[[ATTR2:[0-9]+]] {
; CHECK-NEXT: [[A:%.*]] = call i32 @k() ; CHECK-NEXT: [[A:%.*]] = call i32 @k()
; CHECK-NEXT: ret i32 [[A]] ; CHECK-NEXT: ret i32 [[A]]
; ;
%a = call i32 @k() %a = call i32 @k()
ret i32 %a ret i32 %a
} }
; CHECK: Function Attrs ; CHECK: Function Attrs
; CHECK-NEXT: declare i32 @k() ; CHECK-NEXT: declare i32 @k()
declare i32 @k() readnone declare i32 @k() readnone
define void @intrinsic(i8* %dest, i8* %src, i32 %len) { define void @intrinsic(i8* %dest, i8* %src, i32 %len) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; CHECK-LABEL: define {{[^@]+}}@intrinsic ; CHECK-LABEL: define {{[^@]+}}@intrinsic
; CHECK-SAME: (i8* nocapture nofree writeonly [[DEST:%.*]], i8* nocapture nofree readonly [[SRC:%.*]], i32 [[LEN:%.*]]) #[[ATTR4:[0-9]+]] { ; CHECK-SAME: (i8* nocapture nofree writeonly [[DEST:%.*]], i8* nocapture nofree readonly [[SRC:%.*]], i32 [[LEN:%.*]]) #[[ATTR4:[0-9]+]] {
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias nocapture nofree writeonly [[DEST]], i8* noalias nocapture nofree readonly [[SRC]], i32 [[LEN]], i1 noundef false) #[[ATTR9:[0-9]+]] ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias nocapture nofree writeonly [[DEST]], i8* noalias nocapture nofree readonly [[SRC]], i32 [[LEN]], i1 noundef false) #[[ATTR9:[0-9]+]]
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 %len, i1 false) call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 %len, i1 false)
ret void ret void
} }
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines
; CGSCC-NEXT: [[A:%.*]] = call i32 @o() ; CGSCC-NEXT: [[A:%.*]] = call i32 @o()
; CGSCC-NEXT: ret i32 [[A]] ; CGSCC-NEXT: ret i32 [[A]]
; ;
%a = call i32 @o() %a = call i32 @o()
ret i32 %a ret i32 %a
} }
define void @f(i32 %x) { define void @f(i32 %x) {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@f ; TUNIT-LABEL: define {{[^@]+}}@f
; TUNIT-SAME: (i32 [[X:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i32 [[X:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[X_ADDR:%.*]] = alloca i32, align 4 ; TUNIT-NEXT: [[X_ADDR:%.*]] = alloca i32, align 4
; TUNIT-NEXT: store i32 [[X]], i32* [[X_ADDR]], align 4 ; TUNIT-NEXT: store i32 [[X]], i32* [[X_ADDR]], align 4
; TUNIT-NEXT: [[TOBOOL:%.*]] = icmp ne i32 [[X]], 0 ; TUNIT-NEXT: [[TOBOOL:%.*]] = icmp ne i32 [[X]], 0
; TUNIT-NEXT: br i1 [[TOBOOL]], label [[IF_THEN:%.*]], label [[IF_END:%.*]] ; TUNIT-NEXT: br i1 [[TOBOOL]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; TUNIT: if.then: ; TUNIT: if.then:
; TUNIT-NEXT: br label [[IF_END]] ; TUNIT-NEXT: br label [[IF_END]]
; TUNIT: if.end: ; TUNIT: if.end:
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@f ; CGSCC-LABEL: define {{[^@]+}}@f
; CGSCC-SAME: (i32 [[X:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (i32 [[X:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[X_ADDR:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[X_ADDR:%.*]] = alloca i32, align 4
; CGSCC-NEXT: [[TOBOOL:%.*]] = icmp ne i32 [[X]], 0 ; CGSCC-NEXT: [[TOBOOL:%.*]] = icmp ne i32 [[X]], 0
; CGSCC-NEXT: br i1 [[TOBOOL]], label [[IF_THEN:%.*]], label [[IF_END:%.*]] ; CGSCC-NEXT: br i1 [[TOBOOL]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CGSCC: if.then: ; CGSCC: if.then:
; CGSCC-NEXT: br label [[IF_END]] ; CGSCC-NEXT: br label [[IF_END]]
Show All 11 Linesif.then:
call void @g() norecurse call void @g() norecurse
br label %if.end br label %if.end
if.end: if.end:
ret void ret void
} }
define void @g() norecurse { define void @g() norecurse {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@g ; CHECK-LABEL: define {{[^@]+}}@g
; CHECK-SAME: () #[[ATTR0]] { ; CHECK-SAME: () #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
call void @f(i32 0) call void @f(i32 0)
ret void ret void
Show All 26 Lines
; ;
%3 = tail call i32 %0(i32 %1) #2 %3 = tail call i32 %0(i32 %1) #2
ret i32 %3 ret i32 %3
} }
; Call an unknown function in a dead block. ; Call an unknown function in a dead block.
declare void @unknown() declare void @unknown()
define i32 @call_unknown_in_dead_block() local_unnamed_addr { define i32 @call_unknown_in_dead_block() local_unnamed_addr {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@call_unknown_in_dead_block ; CHECK-LABEL: define {{[^@]+}}@call_unknown_in_dead_block
; CHECK-SAME: () local_unnamed_addr #[[ATTR0]] { ; CHECK-SAME: () local_unnamed_addr #[[ATTR0]] {
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; CHECK: Dead: ; CHECK: Dead:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; ;
ret i32 0 ret i32 0
Dead: Dead:
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Linest:
ret i1 true ret i1 true
f: f:
%r = call i1 @rec(i1 true) %r = call i1 @rec(i1 true)
call void @unknown() call void @unknown()
ret i1 false ret i1 false
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR2]] = { nosync memory(none) } ; TUNIT: attributes #[[ATTR2]] = { nosync memory(none) }
; TUNIT: attributes #[[ATTR3:[0-9]+]] = { memory(none) } ; TUNIT: attributes #[[ATTR3:[0-9]+]] = { memory(none) }
; TUNIT: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR5:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR5:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR6]] = { norecurse nosync memory(none) } ; TUNIT: attributes #[[ATTR6]] = { norecurse nosync memory(none) }
; TUNIT: attributes #[[ATTR7]] = { null_pointer_is_valid } ; TUNIT: attributes #[[ATTR7]] = { null_pointer_is_valid }
; TUNIT: attributes #[[ATTR8]] = { norecurse } ; TUNIT: attributes #[[ATTR8]] = { norecurse }
; TUNIT: attributes #[[ATTR9]] = { willreturn } ; TUNIT: attributes #[[ATTR9]] = { willreturn }
; TUNIT: attributes #[[ATTR10]] = { nosync } ; TUNIT: attributes #[[ATTR10]] = { nosync }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { nosync memory(none) } ; CGSCC: attributes #[[ATTR2]] = { nosync memory(none) }
; CGSCC: attributes #[[ATTR3:[0-9]+]] = { memory(none) } ; CGSCC: attributes #[[ATTR3:[0-9]+]] = { memory(none) }
; CGSCC: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR5:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR5:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR6]] = { norecurse nosync memory(none) } ; CGSCC: attributes #[[ATTR6]] = { norecurse nosync memory(none) }
; CGSCC: attributes #[[ATTR7]] = { null_pointer_is_valid } ; CGSCC: attributes #[[ATTR7]] = { null_pointer_is_valid }
; CGSCC: attributes #[[ATTR8]] = { norecurse } ; CGSCC: attributes #[[ATTR8]] = { norecurse }
; CGSCC: attributes #[[ATTR9]] = { willreturn } ; CGSCC: attributes #[[ATTR9]] = { willreturn }
;. ;.

llvm/test/Transforms/Attributor/noreturn.ll

Show All 9 Lines
; TEST 1, singleton SCC void return type ; TEST 1, singleton SCC void return type
; ;
; void srec0() { ; void srec0() {
; return srec0(); ; return srec0();
; } ; }
; ;
define void @srec0() #0 { define void @srec0() #0 {
; CHECK: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@srec0 ; CHECK-LABEL: define {{[^@]+}}@srec0
; CHECK-SAME: () #[[ATTR0:[0-9]+]] { ; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
call void @srec0() call void @srec0()
ret void ret void
} }
; TEST 2: singleton SCC int return type with a lot of recursive calls ; TEST 2: singleton SCC int return type with a lot of recursive calls
; ;
; int srec16(int a) { ; int srec16(int a) {
; return srec16(srec16(srec16(srec16(srec16(srec16(srec16(srec16(srec16(srec16(srec16(srec16(srec16(srec16(srec16(srec16(a)))))))))))))))); ; return srec16(srec16(srec16(srec16(srec16(srec16(srec16(srec16(srec16(srec16(srec16(srec16(srec16(srec16(srec16(srec16(a))))))))))))))));
; } ; }
; ;
define i32 @srec16(i32 %a) #0 { define i32 @srec16(i32 %a) #0 {
; CHECK: Function Attrs: nofree noinline noreturn nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline noreturn nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@srec16 ; CHECK-LABEL: define {{[^@]+}}@srec16
; CHECK-SAME: (i32 [[A:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (i32 [[A:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; CHECK: exit: ; CHECK: exit:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; ;
entry: entry:
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
; TEST 5: all paths contain a no-return function call ; TEST 5: all paths contain a no-return function call
; ;
; int multiple_noreturn_calls(int a) { ; int multiple_noreturn_calls(int a) {
; return a == 0 ? endless_loop(a) : srec16(a); ; return a == 0 ? endless_loop(a) : srec16(a);
; } ; }
; ;
define i32 @multiple_noreturn_calls(i32 %a) #0 { define i32 @multiple_noreturn_calls(i32 %a) #0 {
; TUNIT: Function Attrs: nofree noinline norecurse noreturn nosync nounwind willreturn memory(none) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse noreturn nosync nounwind willreturn memory(none) uwtable
; TUNIT-LABEL: define {{[^@]+}}@multiple_noreturn_calls ; TUNIT-LABEL: define {{[^@]+}}@multiple_noreturn_calls
; TUNIT-SAME: (i32 [[A:%.*]]) #[[ATTR3:[0-9]+]] { ; TUNIT-SAME: (i32 [[A:%.*]]) #[[ATTR3:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[CMP:%.*]] = icmp eq i32 [[A]], 0 ; TUNIT-NEXT: [[CMP:%.*]] = icmp eq i32 [[A]], 0
; TUNIT-NEXT: br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]] ; TUNIT-NEXT: br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
; TUNIT: cond.true: ; TUNIT: cond.true:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: cond.false: ; TUNIT: cond.false:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: cond.end: ; TUNIT: cond.end:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree noinline noreturn nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline noreturn nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@multiple_noreturn_calls ; CGSCC-LABEL: define {{[^@]+}}@multiple_noreturn_calls
; CGSCC-SAME: (i32 [[A:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (i32 [[A:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CMP:%.*]] = icmp eq i32 [[A]], 0 ; CGSCC-NEXT: [[CMP:%.*]] = icmp eq i32 [[A]], 0
; CGSCC-NEXT: br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]] ; CGSCC-NEXT: br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
; CGSCC: cond.true: ; CGSCC: cond.true:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: cond.false: ; CGSCC: cond.false:
Show All 18 Linescond.end: ; preds = %cond.false, %cond.true
ret i32 %cond ret i32 %cond
} }
; TEST 6a: willreturn means *not* no-return or UB ; TEST 6a: willreturn means *not* no-return or UB
; FIXME: we should derive "UB" as an argument and report it to the user on request. ; FIXME: we should derive "UB" as an argument and report it to the user on request.
define i32 @endless_loop_but_willreturn() willreturn { define i32 @endless_loop_but_willreturn() willreturn {
; TUNIT: Function Attrs: nofree norecurse noreturn nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@endless_loop_but_willreturn ; TUNIT-LABEL: define {{[^@]+}}@endless_loop_but_willreturn
; TUNIT-SAME: () #[[ATTR4:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR4:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: br label [[WHILE_BODY:%.*]] ; TUNIT-NEXT: br label [[WHILE_BODY:%.*]]
; TUNIT: while.body: ; TUNIT: while.body:
; TUNIT-NEXT: br label [[WHILE_BODY]] ; TUNIT-NEXT: br label [[WHILE_BODY]]
; ;
; CGSCC: Function Attrs: nofree norecurse noreturn nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@endless_loop_but_willreturn ; CGSCC-LABEL: define {{[^@]+}}@endless_loop_but_willreturn
; CGSCC-SAME: () #[[ATTR3:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR3:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: br label [[WHILE_BODY:%.*]] ; CGSCC-NEXT: br label [[WHILE_BODY:%.*]]
; CGSCC: while.body: ; CGSCC: while.body:
; CGSCC-NEXT: br label [[WHILE_BODY]] ; CGSCC-NEXT: br label [[WHILE_BODY]]
; ;
entry: entry:
br label %while.body br label %while.body
while.body: ; preds = %entry, %while.body while.body: ; preds = %entry, %while.body
br label %while.body br label %while.body
} }
; TEST 6b: willreturn means *not* no-return or UB ; TEST 6b: willreturn means *not* no-return or UB
define i32 @UB_and_willreturn() willreturn { define i32 @UB_and_willreturn() willreturn {
; TUNIT: Function Attrs: nofree norecurse noreturn nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@UB_and_willreturn ; TUNIT-LABEL: define {{[^@]+}}@UB_and_willreturn
; TUNIT-SAME: () #[[ATTR4]] { ; TUNIT-SAME: () #[[ATTR4]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree norecurse noreturn nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@UB_and_willreturn ; CGSCC-LABEL: define {{[^@]+}}@UB_and_willreturn
; CGSCC-SAME: () #[[ATTR3]] { ; CGSCC-SAME: () #[[ATTR3]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
entry: entry:
unreachable unreachable
} }
attributes #0 = { noinline nounwind uwtable } attributes #0 = { noinline nounwind uwtable }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree noinline nosync nounwind willreturn memory(none) uwtable } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable }
; TUNIT: attributes #[[ATTR1]] = { nofree noinline noreturn nosync nounwind willreturn memory(none) uwtable } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree noinline noreturn nosync nounwind willreturn memory(none) uwtable }
; TUNIT: attributes #[[ATTR2]] = { nofree noinline norecurse noreturn nosync nounwind memory(none) uwtable } ; TUNIT: attributes #[[ATTR2]] = { nofree noinline norecurse noreturn nosync nounwind memory(none) uwtable }
; TUNIT: attributes #[[ATTR3]] = { nofree noinline norecurse noreturn nosync nounwind willreturn memory(none) uwtable } ; TUNIT: attributes #[[ATTR3]] = { mustprogress nofree noinline norecurse noreturn nosync nounwind willreturn memory(none) uwtable }
; TUNIT: attributes #[[ATTR4]] = { nofree norecurse noreturn nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR4]] = { mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree noinline nosync nounwind willreturn memory(none) uwtable } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable }
; CGSCC: attributes #[[ATTR1]] = { nofree noinline noreturn nosync nounwind willreturn memory(none) uwtable } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree noinline noreturn nosync nounwind willreturn memory(none) uwtable }
; CGSCC: attributes #[[ATTR2]] = { nofree noinline norecurse noreturn nosync nounwind memory(none) uwtable } ; CGSCC: attributes #[[ATTR2]] = { nofree noinline norecurse noreturn nosync nounwind memory(none) uwtable }
; CGSCC: attributes #[[ATTR3]] = { nofree norecurse noreturn nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none) }
;. ;.

llvm/test/Transforms/Attributor/nosync.ll

Show All 24 Lines
; non-convergent and readnone implies nosync ; non-convergent and readnone implies nosync
%struct.RT = type { i8, [10 x [20 x i32]], i8 } %struct.RT = type { i8, [10 x [20 x i32]], i8 }
%struct.ST = type { i32, double, %struct.RT } %struct.ST = type { i32, double, %struct.RT }
;. ;.
; CHECK: @[[A:[a-zA-Z0-9_$"\\.-]+]] = common global i32 0, align 4 ; CHECK: @[[A:[a-zA-Z0-9_$"\\.-]+]] = common global i32 0, align 4
;. ;.
define i32* @foo(%struct.ST* %s) nounwind uwtable readnone optsize ssp { define i32* @foo(%struct.ST* %s) nounwind uwtable readnone optsize ssp {
; CHECK: Function Attrs: nofree norecurse nosync nounwind optsize ssp willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind optsize ssp willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@foo ; CHECK-LABEL: define {{[^@]+}}@foo
; CHECK-SAME: (%struct.ST* nofree readnone "no-capture-maybe-returned" [[S:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (%struct.ST* nofree readnone "no-capture-maybe-returned" [[S:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[S]], i64 1, i32 2, i32 1, i64 5, i64 13 ; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[S]], i64 1, i32 2, i32 1, i64 5, i64 13
; CHECK-NEXT: ret i32* [[ARRAYIDX]] ; CHECK-NEXT: ret i32* [[ARRAYIDX]]
; ;
entry: entry:
%arrayidx = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 1, i32 2, i32 1, i64 5, i64 13 %arrayidx = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 1, i32 2, i32 1, i64 5, i64 13
ret i32* %arrayidx ret i32* %arrayidx
} }
; TEST 2 ; TEST 2
; atomic load with monotonic ordering ; atomic load with monotonic ordering
; int load_monotonic(_Atomic int *num) { ; int load_monotonic(_Atomic int *num) {
; int n = atomic_load_explicit(num, memory_order_relaxed); ; int n = atomic_load_explicit(num, memory_order_relaxed);
; return n; ; return n;
; } ; }
define i32 @load_monotonic(i32* nocapture readonly %0) norecurse nounwind uwtable { define i32 @load_monotonic(i32* nocapture readonly %0) norecurse nounwind uwtable {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CHECK-LABEL: define {{[^@]+}}@load_monotonic ; CHECK-LABEL: define {{[^@]+}}@load_monotonic
; CHECK-SAME: (i32* nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[TMP0:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (i32* nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[TMP0:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: [[TMP2:%.*]] = load atomic i32, i32* [[TMP0]] monotonic, align 4 ; CHECK-NEXT: [[TMP2:%.*]] = load atomic i32, i32* [[TMP0]] monotonic, align 4
; CHECK-NEXT: ret i32 [[TMP2]] ; CHECK-NEXT: ret i32 [[TMP2]]
; ;
%2 = load atomic i32, i32* %0 monotonic, align 4 %2 = load atomic i32, i32* %0 monotonic, align 4
ret i32 %2 ret i32 %2
} }
; TEST 3 ; TEST 3
; atomic store with monotonic ordering. ; atomic store with monotonic ordering.
; void store_monotonic(_Atomic int *num) { ; void store_monotonic(_Atomic int *num) {
; atomic_load_explicit(num, memory_order_relaxed); ; atomic_load_explicit(num, memory_order_relaxed);
; } ; }
define void @store_monotonic(i32* nocapture %0) norecurse nounwind uwtable { define void @store_monotonic(i32* nocapture %0) norecurse nounwind uwtable {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable
; CHECK-LABEL: define {{[^@]+}}@store_monotonic ; CHECK-LABEL: define {{[^@]+}}@store_monotonic
; CHECK-SAME: (i32* nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[TMP0:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (i32* nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[TMP0:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: store atomic i32 10, i32* [[TMP0]] monotonic, align 4 ; CHECK-NEXT: store atomic i32 10, i32* [[TMP0]] monotonic, align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store atomic i32 10, i32* %0 monotonic, align 4 store atomic i32 10, i32* %0 monotonic, align 4
ret void ret void
} }
; TEST 4 - negative, should not deduce nosync ; TEST 4 - negative, should not deduce nosync
; atomic load with acquire ordering. ; atomic load with acquire ordering.
; int load_acquire(_Atomic int *num) { ; int load_acquire(_Atomic int *num) {
; int n = atomic_load_explicit(num, memory_order_acquire); ; int n = atomic_load_explicit(num, memory_order_acquire);
; return n; ; return n;
; } ; }
define i32 @load_acquire(i32* nocapture readonly %0) norecurse nounwind uwtable { define i32 @load_acquire(i32* nocapture readonly %0) norecurse nounwind uwtable {
; CHECK: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable ; CHECK: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable
; CHECK-LABEL: define {{[^@]+}}@load_acquire ; CHECK-LABEL: define {{[^@]+}}@load_acquire
; CHECK-SAME: (i32* nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[TMP0:%.*]]) #[[ATTR2:[0-9]+]] { ; CHECK-SAME: (i32* nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[TMP0:%.*]]) #[[ATTR2:[0-9]+]] {
; CHECK-NEXT: [[TMP2:%.*]] = load atomic i32, i32* [[TMP0]] acquire, align 4 ; CHECK-NEXT: [[TMP2:%.*]] = load atomic i32, i32* [[TMP0]] acquire, align 4
; CHECK-NEXT: ret i32 [[TMP2]] ; CHECK-NEXT: ret i32 [[TMP2]]
; ;
%2 = load atomic i32, i32* %0 acquire, align 4 %2 = load atomic i32, i32* %0 acquire, align 4
ret i32 %2 ret i32 %2
} }
; TEST 5 - negative, should not deduce nosync ; TEST 5 - negative, should not deduce nosync
; atomic load with release ordering ; atomic load with release ordering
; void load_release(_Atomic int *num) { ; void load_release(_Atomic int *num) {
; atomic_store_explicit(num, 10, memory_order_release); ; atomic_store_explicit(num, 10, memory_order_release);
; } ; }
define void @load_release(i32* nocapture %0) norecurse nounwind uwtable { define void @load_release(i32* nocapture %0) norecurse nounwind uwtable {
; CHECK: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable ; CHECK: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable
; CHECK-LABEL: define {{[^@]+}}@load_release ; CHECK-LABEL: define {{[^@]+}}@load_release
; CHECK-SAME: (i32* nocapture nofree noundef writeonly align 4 [[TMP0:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (i32* nocapture nofree noundef writeonly align 4 [[TMP0:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: store atomic volatile i32 10, i32* [[TMP0]] release, align 4 ; CHECK-NEXT: store atomic volatile i32 10, i32* [[TMP0]] release, align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store atomic volatile i32 10, i32* %0 release, align 4 store atomic volatile i32 10, i32* %0 release, align 4
ret void ret void
} }
; TEST 6 - negative volatile, relaxed atomic ; TEST 6 - negative volatile, relaxed atomic
define void @load_volatile_release(i32* nocapture %0) norecurse nounwind uwtable { define void @load_volatile_release(i32* nocapture %0) norecurse nounwind uwtable {
; CHECK: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable ; CHECK: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable
; CHECK-LABEL: define {{[^@]+}}@load_volatile_release ; CHECK-LABEL: define {{[^@]+}}@load_volatile_release
; CHECK-SAME: (i32* nocapture nofree noundef writeonly align 4 [[TMP0:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (i32* nocapture nofree noundef writeonly align 4 [[TMP0:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: store atomic volatile i32 10, i32* [[TMP0]] release, align 4 ; CHECK-NEXT: store atomic volatile i32 10, i32* [[TMP0]] release, align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store atomic volatile i32 10, i32* %0 release, align 4 store atomic volatile i32 10, i32* %0 release, align 4
ret void ret void
} }
; TEST 7 - negative, should not deduce nosync ; TEST 7 - negative, should not deduce nosync
; volatile store. ; volatile store.
; void volatile_store(volatile int *num) { ; void volatile_store(volatile int *num) {
; *num = 14; ; *num = 14;
; } ; }
define void @volatile_store(i32* %0) norecurse nounwind uwtable { define void @volatile_store(i32* %0) norecurse nounwind uwtable {
; CHECK: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable ; CHECK: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable
; CHECK-LABEL: define {{[^@]+}}@volatile_store ; CHECK-LABEL: define {{[^@]+}}@volatile_store
; CHECK-SAME: (i32* nofree noundef align 4 [[TMP0:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (i32* nofree noundef align 4 [[TMP0:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: store volatile i32 14, i32* [[TMP0]], align 4 ; CHECK-NEXT: store volatile i32 14, i32* [[TMP0]], align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store volatile i32 14, i32* %0, align 4 store volatile i32 14, i32* %0, align 4
ret void ret void
} }
; TEST 8 - negative, should not deduce nosync ; TEST 8 - negative, should not deduce nosync
; volatile load. ; volatile load.
; int volatile_load(volatile int *num) { ; int volatile_load(volatile int *num) {
; int n = *num; ; int n = *num;
; return n; ; return n;
; } ; }
define i32 @volatile_load(i32* %0) norecurse nounwind uwtable { define i32 @volatile_load(i32* %0) norecurse nounwind uwtable {
; CHECK: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable ; CHECK: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable
; CHECK-LABEL: define {{[^@]+}}@volatile_load ; CHECK-LABEL: define {{[^@]+}}@volatile_load
; CHECK-SAME: (i32* nofree noundef align 4 [[TMP0:%.*]]) #[[ATTR2]] { ; CHECK-SAME: (i32* nofree noundef align 4 [[TMP0:%.*]]) #[[ATTR2]] {
; CHECK-NEXT: [[TMP2:%.*]] = load volatile i32, i32* [[TMP0]], align 4 ; CHECK-NEXT: [[TMP2:%.*]] = load volatile i32, i32* [[TMP0]], align 4
; CHECK-NEXT: ret i32 [[TMP2]] ; CHECK-NEXT: ret i32 [[TMP2]]
; ;
%2 = load volatile i32, i32* %0, align 4 %2 = load volatile i32, i32* %0, align 4
ret i32 %2 ret i32 %2
} }
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines
; atomic_thread_fence(std::memory_order_acquire); ; atomic_thread_fence(std::memory_order_acquire);
; int b = *a; ; int b = *a;
; } ; }
%"struct.std::atomic" = type { %"struct.std::__atomic_base" } %"struct.std::atomic" = type { %"struct.std::__atomic_base" }
%"struct.std::__atomic_base" = type { i8 } %"struct.std::__atomic_base" = type { i8 }
define void @foo1(i32* %0, %"struct.std::atomic"* %1) { define void @foo1(i32* %0, %"struct.std::atomic"* %1) {
; CHECK: Function Attrs: nofree norecurse nounwind willreturn ; CHECK: Function Attrs: mustprogress nofree norecurse nounwind willreturn
; CHECK-LABEL: define {{[^@]+}}@foo1 ; CHECK-LABEL: define {{[^@]+}}@foo1
; CHECK-SAME: (i32* nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[TMP0:%.*]], %"struct.std::atomic"* nocapture nofree nonnull writeonly dereferenceable(1) [[TMP1:%.*]]) #[[ATTR6:[0-9]+]] { ; CHECK-SAME: (i32* nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[TMP0:%.*]], %"struct.std::atomic"* nocapture nofree nonnull writeonly dereferenceable(1) [[TMP1:%.*]]) #[[ATTR6:[0-9]+]] {
; CHECK-NEXT: store i32 100, i32* [[TMP0]], align 4 ; CHECK-NEXT: store i32 100, i32* [[TMP0]], align 4
; CHECK-NEXT: fence release ; CHECK-NEXT: fence release
; CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds %"struct.std::atomic", %"struct.std::atomic"* [[TMP1]], i64 0, i32 0, i32 0 ; CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds %"struct.std::atomic", %"struct.std::atomic"* [[TMP1]], i64 0, i32 0, i32 0
; CHECK-NEXT: store atomic i8 1, i8* [[TMP3]] monotonic, align 1 ; CHECK-NEXT: store atomic i8 1, i8* [[TMP3]] monotonic, align 1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
Show All 30 Lines
8: ; preds = %4 8: ; preds = %4
fence acquire fence acquire
ret void ret void
} }
; TEST 13 - Fence syncscope("singlethread") seq_cst ; TEST 13 - Fence syncscope("singlethread") seq_cst
define void @foo1_singlethread(i32* %0, %"struct.std::atomic"* %1) { define void @foo1_singlethread(i32* %0, %"struct.std::atomic"* %1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CHECK-LABEL: define {{[^@]+}}@foo1_singlethread ; CHECK-LABEL: define {{[^@]+}}@foo1_singlethread
; CHECK-SAME: (i32* nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[TMP0:%.*]], %"struct.std::atomic"* nocapture nofree nonnull writeonly dereferenceable(1) [[TMP1:%.*]]) #[[ATTR8:[0-9]+]] { ; CHECK-SAME: (i32* nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[TMP0:%.*]], %"struct.std::atomic"* nocapture nofree nonnull writeonly dereferenceable(1) [[TMP1:%.*]]) #[[ATTR8:[0-9]+]] {
; CHECK-NEXT: store i32 100, i32* [[TMP0]], align 4 ; CHECK-NEXT: store i32 100, i32* [[TMP0]], align 4
; CHECK-NEXT: fence syncscope("singlethread") release ; CHECK-NEXT: fence syncscope("singlethread") release
; CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds %"struct.std::atomic", %"struct.std::atomic"* [[TMP1]], i64 0, i32 0, i32 0 ; CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds %"struct.std::atomic", %"struct.std::atomic"* [[TMP1]], i64 0, i32 0, i32 0
; CHECK-NEXT: store atomic i8 1, i8* [[TMP3]] monotonic, align 1 ; CHECK-NEXT: store atomic i8 1, i8* [[TMP3]] monotonic, align 1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
Show All 36 Lines
declare void @llvm.memcpy(i8* %dest, i8* %src, i32 %len, i1 %isvolatile) declare void @llvm.memcpy(i8* %dest, i8* %src, i32 %len, i1 %isvolatile)
declare void @llvm.memset(i8* %dest, i8 %val, i32 %len, i1 %isvolatile) declare void @llvm.memset(i8* %dest, i8 %val, i32 %len, i1 %isvolatile)
; TEST 14 - negative, checking volatile intrinsics. ; TEST 14 - negative, checking volatile intrinsics.
; It is odd to add nocapture but a result of the llvm.memcpy nocapture. ; It is odd to add nocapture but a result of the llvm.memcpy nocapture.
; ;
define i32 @memcpy_volatile(i8* %ptr1, i8* %ptr2) { define i32 @memcpy_volatile(i8* %ptr1, i8* %ptr2) {
; CHECK: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
; CHECK-LABEL: define {{[^@]+}}@memcpy_volatile ; CHECK-LABEL: define {{[^@]+}}@memcpy_volatile
; CHECK-SAME: (i8* nocapture nofree writeonly [[PTR1:%.*]], i8* nocapture nofree readonly [[PTR2:%.*]]) #[[ATTR10:[0-9]+]] { ; CHECK-SAME: (i8* nocapture nofree writeonly [[PTR1:%.*]], i8* nocapture nofree readonly [[PTR2:%.*]]) #[[ATTR10:[0-9]+]] {
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias nocapture nofree writeonly [[PTR1]], i8* noalias nocapture nofree readonly [[PTR2]], i32 noundef 8, i1 noundef true) #[[ATTR20:[0-9]+]] ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias nocapture nofree writeonly [[PTR1]], i8* noalias nocapture nofree readonly [[PTR2]], i32 noundef 8, i1 noundef true) #[[ATTR20:[0-9]+]]
; CHECK-NEXT: ret i32 4 ; CHECK-NEXT: ret i32 4
; ;
call void @llvm.memcpy(i8* %ptr1, i8* %ptr2, i32 8, i1 1) call void @llvm.memcpy(i8* %ptr1, i8* %ptr2, i32 8, i1 1)
ret i32 4 ret i32 4
} }
; TEST 15 - positive, non-volatile intrinsic. ; TEST 15 - positive, non-volatile intrinsic.
; It is odd to add nocapture but a result of the llvm.memset nocapture. ; It is odd to add nocapture but a result of the llvm.memset nocapture.
; ;
define i32 @memset_non_volatile(i8* %ptr1, i8 %val) { define i32 @memset_non_volatile(i8* %ptr1, i8 %val) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@memset_non_volatile ; CHECK-LABEL: define {{[^@]+}}@memset_non_volatile
; CHECK-SAME: (i8* nocapture nofree writeonly [[PTR1:%.*]], i8 [[VAL:%.*]]) #[[ATTR11:[0-9]+]] { ; CHECK-SAME: (i8* nocapture nofree writeonly [[PTR1:%.*]], i8 [[VAL:%.*]]) #[[ATTR11:[0-9]+]] {
; CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* nocapture nofree writeonly [[PTR1]], i8 [[VAL]], i32 noundef 8, i1 noundef false) #[[ATTR20]] ; CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* nocapture nofree writeonly [[PTR1]], i8 [[VAL]], i32 noundef 8, i1 noundef false) #[[ATTR20]]
; CHECK-NEXT: ret i32 4 ; CHECK-NEXT: ret i32 4
; ;
call void @llvm.memset(i8* %ptr1, i8 %val, i32 8, i1 0) call void @llvm.memset(i8* %ptr1, i8 %val, i32 8, i1 0)
ret i32 4 ret i32 4
} }
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines;
ret void ret void
} }
declare float @llvm.cos(float %val) readnone declare float @llvm.cos(float %val) readnone
; TEST 19 - positive, readnone & non-convergent intrinsic. ; TEST 19 - positive, readnone & non-convergent intrinsic.
define i32 @cos_test(float %x) { define i32 @cos_test(float %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@cos_test ; CHECK-LABEL: define {{[^@]+}}@cos_test
; CHECK-SAME: (float [[X:%.*]]) #[[ATTR15:[0-9]+]] { ; CHECK-SAME: (float [[X:%.*]]) #[[ATTR15:[0-9]+]] {
; CHECK-NEXT: ret i32 4 ; CHECK-NEXT: ret i32 4
; ;
call float @llvm.cos(float %x) call float @llvm.cos(float %x)
ret i32 4 ret i32 4
} }
define float @cos_test2(float %x) { define float @cos_test2(float %x) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@cos_test2 ; CHECK-LABEL: define {{[^@]+}}@cos_test2
; CHECK-SAME: (float [[X:%.*]]) #[[ATTR15]] { ; CHECK-SAME: (float [[X:%.*]]) #[[ATTR15]] {
; CHECK-NEXT: [[C:%.*]] = call nofpclass(inf) float @llvm.cos.f32(float [[X]]) #[[ATTR20]] ; CHECK-NEXT: [[C:%.*]] = call nofpclass(inf) float @llvm.cos.f32(float [[X]]) #[[ATTR20]]
; CHECK-NEXT: ret float [[C]] ; CHECK-NEXT: ret float [[C]]
; ;
%c = call float @llvm.cos(float %x) %c = call float @llvm.cos(float %x)
ret float %c ret float %c
} }
;. ;.
; CHECK: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind optsize ssp willreturn memory(none) uwtable } ; CHECK: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind optsize ssp willreturn memory(none) uwtable }
; CHECK: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable } ; CHECK: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) uwtable }
; CHECK: attributes #[[ATTR2]] = { nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable } ; CHECK: attributes #[[ATTR2]] = { mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite) uwtable }
; CHECK: attributes #[[ATTR3]] = { noinline nosync nounwind uwtable } ; CHECK: attributes #[[ATTR3]] = { noinline nosync nounwind uwtable }
; CHECK: attributes #[[ATTR4]] = { noinline nounwind uwtable } ; CHECK: attributes #[[ATTR4]] = { noinline nounwind uwtable }
; CHECK: attributes #[[ATTR5]] = { nofree noinline nounwind memory(argmem: readwrite) uwtable } ; CHECK: attributes #[[ATTR5]] = { nofree noinline nounwind memory(argmem: readwrite) uwtable }
; CHECK: attributes #[[ATTR6]] = { nofree norecurse nounwind willreturn } ; CHECK: attributes #[[ATTR6]] = { mustprogress nofree norecurse nounwind willreturn }
; CHECK: attributes #[[ATTR7]] = { nofree norecurse nounwind } ; CHECK: attributes #[[ATTR7]] = { nofree norecurse nounwind }
; CHECK: attributes #[[ATTR8]] = { nofree norecurse nosync nounwind willreturn } ; CHECK: attributes #[[ATTR8]] = { mustprogress nofree norecurse nosync nounwind willreturn }
; CHECK: attributes #[[ATTR9]] = { nofree norecurse nosync nounwind } ; CHECK: attributes #[[ATTR9]] = { nofree norecurse nosync nounwind }
; CHECK: attributes #[[ATTR10]] = { nofree norecurse nounwind willreturn memory(argmem: readwrite) } ; CHECK: attributes #[[ATTR10]] = { mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite) }
; CHECK: attributes #[[ATTR11]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; CHECK: attributes #[[ATTR11]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; CHECK: attributes #[[ATTR12:[0-9]+]] = { convergent memory(none) } ; CHECK: attributes #[[ATTR12:[0-9]+]] = { convergent memory(none) }
; CHECK: attributes #[[ATTR13]] = { memory(none) } ; CHECK: attributes #[[ATTR13]] = { memory(none) }
; CHECK: attributes #[[ATTR14]] = { nounwind } ; CHECK: attributes #[[ATTR14]] = { nounwind }
; CHECK: attributes #[[ATTR15]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CHECK: attributes #[[ATTR15]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CHECK: attributes #[[ATTR16:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } ; CHECK: attributes #[[ATTR16:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
; CHECK: attributes #[[ATTR17:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) } ; CHECK: attributes #[[ATTR17:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) }
; CHECK: attributes #[[ATTR18:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } ; CHECK: attributes #[[ATTR18:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
; CHECK: attributes #[[ATTR19]] = { nofree nounwind } ; CHECK: attributes #[[ATTR19]] = { nofree nounwind }
; CHECK: attributes #[[ATTR20]] = { willreturn } ; CHECK: attributes #[[ATTR20]] = { willreturn }
;. ;.

llvm/test/Transforms/Attributor/nounwind.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; TEST 1 ; TEST 1
define i32 @foo1() { define i32 @foo1() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@foo1 ; CHECK-LABEL: define {{[^@]+}}@foo1
; CHECK-SAME: () #[[ATTR0:[0-9]+]] { ; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: ret i32 1 ; CHECK-NEXT: ret i32 1
; ;
ret i32 1 ret i32 1
} }
; TEST 2 ; TEST 2
define i32 @scc1_foo() { define i32 @scc1_foo() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@scc1_foo ; TUNIT-LABEL: define {{[^@]+}}@scc1_foo
; TUNIT-SAME: () #[[ATTR1:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR1:[0-9]+]] {
; TUNIT-NEXT: ret i32 1 ; TUNIT-NEXT: ret i32 1
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@scc1_foo ; CGSCC-LABEL: define {{[^@]+}}@scc1_foo
; CGSCC-SAME: () #[[ATTR0]] { ; CGSCC-SAME: () #[[ATTR0]] {
; CGSCC-NEXT: ret i32 1 ; CGSCC-NEXT: ret i32 1
; ;
%1 = call i32 @scc1_bar() %1 = call i32 @scc1_bar()
ret i32 1 ret i32 1
} }
; TEST 3 ; TEST 3
define i32 @scc1_bar() { define i32 @scc1_bar() {
; TUNIT: Function Attrs: nofree nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@scc1_bar ; TUNIT-LABEL: define {{[^@]+}}@scc1_bar
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret i32 1 ; TUNIT-NEXT: ret i32 1
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@scc1_bar ; CGSCC-LABEL: define {{[^@]+}}@scc1_bar
; CGSCC-SAME: () #[[ATTR0]] { ; CGSCC-SAME: () #[[ATTR0]] {
; CGSCC-NEXT: ret i32 1 ; CGSCC-NEXT: ret i32 1
; ;
%1 = call i32 @scc1_foo() %1 = call i32 @scc1_foo()
ret i32 1 ret i32 1
} }
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Lines
declare i32 @__gxx_personality_v0(...) declare i32 @__gxx_personality_v0(...)
declare ptr @__cxa_begin_catch(ptr) declare ptr @__cxa_begin_catch(ptr)
declare void @__cxa_end_catch() declare void @__cxa_end_catch()
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.

llvm/test/Transforms/Attributor/pointer-info.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
%struct.test.b = type { i32, i32 } %struct.test.b = type { i32, i32 }
%struct.test.a = type { %struct.test.b, i32, ptr} %struct.test.a = type { %struct.test.b, i32, ptr}
define void @foo(ptr %ptr) { define void @foo(ptr %ptr) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@foo ; TUNIT-LABEL: define {{[^@]+}}@foo
; TUNIT-SAME: (ptr nocapture nofree readnone [[PTR:%.*]]) #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree readnone [[PTR:%.*]]) #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[TMP0:%.*]] = alloca [[STRUCT_TEST_A:%.*]], align 8 ; TUNIT-NEXT: [[TMP0:%.*]] = alloca [[STRUCT_TEST_A:%.*]], align 8
; TUNIT-NEXT: br label [[CALL_BR:%.*]] ; TUNIT-NEXT: br label [[CALL_BR:%.*]]
; TUNIT: call.br: ; TUNIT: call.br:
; TUNIT-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_TEST_A]], ptr [[TMP0]], i64 0, i32 2 ; TUNIT-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_TEST_A]], ptr [[TMP0]], i64 0, i32 2
; TUNIT-NEXT: tail call void @bar(ptr noalias nocapture nofree noundef nonnull readonly byval([[STRUCT_TEST_A]]) align 8 dereferenceable(24) [[TMP0]]) #[[ATTR2:[0-9]+]] ; TUNIT-NEXT: tail call void @bar(ptr noalias nocapture nofree noundef nonnull readonly byval([[STRUCT_TEST_A]]) align 8 dereferenceable(24) [[TMP0]]) #[[ATTR2:[0-9]+]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@foo ; CGSCC-LABEL: define {{[^@]+}}@foo
; CGSCC-SAME: (ptr nocapture nofree writeonly [[PTR:%.*]]) #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree writeonly [[PTR:%.*]]) #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[TMP0:%.*]] = alloca [[STRUCT_TEST_A:%.*]], align 8 ; CGSCC-NEXT: [[TMP0:%.*]] = alloca [[STRUCT_TEST_A:%.*]], align 8
; CGSCC-NEXT: br label [[CALL_BR:%.*]] ; CGSCC-NEXT: br label [[CALL_BR:%.*]]
; CGSCC: call.br: ; CGSCC: call.br:
; CGSCC-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_TEST_A]], ptr [[TMP0]], i64 0, i32 2 ; CGSCC-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_TEST_A]], ptr [[TMP0]], i64 0, i32 2
; CGSCC-NEXT: store ptr [[PTR]], ptr [[TMP1]], align 8 ; CGSCC-NEXT: store ptr [[PTR]], ptr [[TMP1]], align 8
; CGSCC-NEXT: tail call void @bar(ptr noalias nocapture nofree noundef nonnull readnone byval([[STRUCT_TEST_A]]) align 8 dereferenceable(24) [[TMP0]]) #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: tail call void @bar(ptr noalias nocapture nofree noundef nonnull readnone byval([[STRUCT_TEST_A]]) align 8 dereferenceable(24) [[TMP0]]) #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
entry: entry:
%0 = alloca %struct.test.a, align 8 %0 = alloca %struct.test.a, align 8
br label %call.br br label %call.br
call.br: call.br:
%1 = getelementptr inbounds %struct.test.a, ptr %0, i64 0, i32 2 %1 = getelementptr inbounds %struct.test.a, ptr %0, i64 0, i32 2
store ptr %ptr, ptr %1 store ptr %ptr, ptr %1
tail call void @bar(ptr noundef byval(%struct.test.a) align 8 %0) tail call void @bar(ptr noundef byval(%struct.test.a) align 8 %0)
ret void ret void
} }
define void @bar(ptr noundef byval(%struct.test.a) align 8 %dev) { define void @bar(ptr noundef byval(%struct.test.a) align 8 %dev) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@bar ; CHECK-LABEL: define {{[^@]+}}@bar
; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly byval([[STRUCT_TEST_A:%.*]]) align 8 dereferenceable(24) [[DEV:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly byval([[STRUCT_TEST_A:%.*]]) align 8 dereferenceable(24) [[DEV:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_TEST_B:%.*]], ptr [[DEV]], i64 0, i32 1 ; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_TEST_B:%.*]], ptr [[DEV]], i64 0, i32 1
; CHECK-NEXT: store i32 1, ptr [[TMP1]], align 4 ; CHECK-NEXT: store i32 1, ptr [[TMP1]], align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%1 = getelementptr inbounds %struct.test.b, ptr %dev, i64 0, i32 1 %1 = getelementptr inbounds %struct.test.b, ptr %dev, i64 0, i32 1
store i32 1, ptr %1 store i32 1, ptr %1
ret void ret void
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR2]] = { nounwind willreturn }
;. ;.

llvm/test/Transforms/Attributor/potential.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=6 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=6 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; ;
; Test for multiple potential values ; Test for multiple potential values
; ;
; potential-test 1 ; potential-test 1
; bool iszero(int c) { return c == 0; } ; bool iszero(int c) { return c == 0; }
; bool potential_test1(bool c) { return iszero(c ? 1 : -1); } ; bool potential_test1(bool c) { return iszero(c ? 1 : -1); }
define internal i1 @iszero1(i32 %c) { define internal i1 @iszero1(i32 %c) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@iszero1 ; CGSCC-LABEL: define {{[^@]+}}@iszero1
; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: [[CMP:%.*]] = icmp eq i32 [[C]], 0 ; CGSCC-NEXT: [[CMP:%.*]] = icmp eq i32 [[C]], 0
; CGSCC-NEXT: ret i1 [[CMP]] ; CGSCC-NEXT: ret i1 [[CMP]]
; ;
%cmp = icmp eq i32 %c, 0 %cmp = icmp eq i32 %c, 0
ret i1 %cmp ret i1 %cmp
} }
define i1 @potential_test1(i1 %c) { define i1 @potential_test1(i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@potential_test1 ; TUNIT-LABEL: define {{[^@]+}}@potential_test1
; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: ret i1 false ; TUNIT-NEXT: ret i1 false
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@potential_test1 ; CGSCC-LABEL: define {{[^@]+}}@potential_test1
; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: [[ARG:%.*]] = select i1 [[C]], i32 -1, i32 1 ; CGSCC-NEXT: [[ARG:%.*]] = select i1 [[C]], i32 -1, i32 1
; CGSCC-NEXT: [[RET:%.*]] = call i1 @iszero1(i32 noundef [[ARG]]) #[[ATTR2:[0-9]+]] ; CGSCC-NEXT: [[RET:%.*]] = call i1 @iszero1(i32 noundef [[ARG]]) #[[ATTR2:[0-9]+]]
; CGSCC-NEXT: ret i1 [[RET]] ; CGSCC-NEXT: ret i1 [[RET]]
; ;
%arg = select i1 %c, i32 -1, i32 1 %arg = select i1 %c, i32 -1, i32 1
%ret = call i1 @iszero1(i32 %arg) %ret = call i1 @iszero1(i32 %arg)
ret i1 %ret ret i1 %ret
} }
; potential-test 2 ; potential-test 2
; ;
; potential values of argument of iszero are {1,-1} ; potential values of argument of iszero are {1,-1}
; potential value of returned value of iszero is 0 ; potential value of returned value of iszero is 0
; ;
; int call_with_two_values(int x) { return iszero(x) + iszero(-x); } ; int call_with_two_values(int x) { return iszero(x) + iszero(-x); }
; int potential_test2(int x) { return call_with_two_values(1) + call_with_two_values(-1); } ; int potential_test2(int x) { return call_with_two_values(1) + call_with_two_values(-1); }
define internal i32 @iszero2(i32 %c) { define internal i32 @iszero2(i32 %c) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@iszero2 ; CHECK-LABEL: define {{[^@]+}}@iszero2
; CHECK-SAME: (i32 [[C:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (i32 [[C:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[C]], 0 ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[C]], 0
; CHECK-NEXT: [[RET:%.*]] = zext i1 [[CMP]] to i32 ; CHECK-NEXT: [[RET:%.*]] = zext i1 [[CMP]] to i32
; CHECK-NEXT: ret i32 [[RET]] ; CHECK-NEXT: ret i32 [[RET]]
; ;
%cmp = icmp eq i32 %c, 0 %cmp = icmp eq i32 %c, 0
%ret = zext i1 %cmp to i32 %ret = zext i1 %cmp to i32
ret i32 %ret ret i32 %ret
} }
define internal i32 @call_with_two_values(i32 %c) { define internal i32 @call_with_two_values(i32 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@call_with_two_values ; TUNIT-LABEL: define {{[^@]+}}@call_with_two_values
; TUNIT-SAME: (i32 noundef [[C:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i32 noundef [[C:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[CSRET1:%.*]] = call i32 @iszero2(i32 noundef [[C]]) #[[ATTR1:[0-9]+]], !range [[RNG0:![0-9]+]] ; TUNIT-NEXT: [[CSRET1:%.*]] = call i32 @iszero2(i32 noundef [[C]]) #[[ATTR1:[0-9]+]], !range [[RNG0:![0-9]+]]
; TUNIT-NEXT: [[MINUSC:%.*]] = sub i32 0, [[C]] ; TUNIT-NEXT: [[MINUSC:%.*]] = sub i32 0, [[C]]
; TUNIT-NEXT: [[CSRET2:%.*]] = call i32 @iszero2(i32 [[MINUSC]]) #[[ATTR1]], !range [[RNG0]] ; TUNIT-NEXT: [[CSRET2:%.*]] = call i32 @iszero2(i32 [[MINUSC]]) #[[ATTR1]], !range [[RNG0]]
; TUNIT-NEXT: [[RET:%.*]] = add i32 [[CSRET1]], [[CSRET2]] ; TUNIT-NEXT: [[RET:%.*]] = add i32 [[CSRET1]], [[CSRET2]]
; TUNIT-NEXT: ret i32 [[RET]] ; TUNIT-NEXT: ret i32 [[RET]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@call_with_two_values ; CGSCC-LABEL: define {{[^@]+}}@call_with_two_values
; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: [[CSRET1:%.*]] = call i32 @iszero2(i32 noundef [[C]]) #[[ATTR2]] ; CGSCC-NEXT: [[CSRET1:%.*]] = call i32 @iszero2(i32 noundef [[C]]) #[[ATTR2]]
; CGSCC-NEXT: [[MINUSC:%.*]] = sub i32 0, [[C]] ; CGSCC-NEXT: [[MINUSC:%.*]] = sub i32 0, [[C]]
; CGSCC-NEXT: [[CSRET2:%.*]] = call i32 @iszero2(i32 [[MINUSC]]) #[[ATTR2]] ; CGSCC-NEXT: [[CSRET2:%.*]] = call i32 @iszero2(i32 [[MINUSC]]) #[[ATTR2]]
; CGSCC-NEXT: [[RET:%.*]] = add i32 [[CSRET1]], [[CSRET2]] ; CGSCC-NEXT: [[RET:%.*]] = add i32 [[CSRET1]], [[CSRET2]]
; CGSCC-NEXT: ret i32 [[RET]] ; CGSCC-NEXT: ret i32 [[RET]]
; ;
%csret1 = call i32 @iszero2(i32 %c) %csret1 = call i32 @iszero2(i32 %c)
%minusc = sub i32 0, %c %minusc = sub i32 0, %c
%csret2 = call i32 @iszero2(i32 %minusc) %csret2 = call i32 @iszero2(i32 %minusc)
%ret = add i32 %csret1, %csret2 %ret = add i32 %csret1, %csret2
ret i32 %ret ret i32 %ret
} }
define i32 @potential_test2(i1 %c) { define i32 @potential_test2(i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@potential_test2 ; TUNIT-LABEL: define {{[^@]+}}@potential_test2
; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[CSRET1:%.*]] = call i32 @call_with_two_values(i32 noundef 1) #[[ATTR1]], !range [[RNG1:![0-9]+]] ; TUNIT-NEXT: [[CSRET1:%.*]] = call i32 @call_with_two_values(i32 noundef 1) #[[ATTR1]], !range [[RNG1:![0-9]+]]
; TUNIT-NEXT: [[CSRET2:%.*]] = call i32 @call_with_two_values(i32 noundef -1) #[[ATTR1]], !range [[RNG1]] ; TUNIT-NEXT: [[CSRET2:%.*]] = call i32 @call_with_two_values(i32 noundef -1) #[[ATTR1]], !range [[RNG1]]
; TUNIT-NEXT: [[RET:%.*]] = add i32 [[CSRET1]], [[CSRET2]] ; TUNIT-NEXT: [[RET:%.*]] = add i32 [[CSRET1]], [[CSRET2]]
; TUNIT-NEXT: ret i32 [[RET]] ; TUNIT-NEXT: ret i32 [[RET]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@potential_test2 ; CGSCC-LABEL: define {{[^@]+}}@potential_test2
; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: [[CSRET1:%.*]] = call i32 @call_with_two_values(i32 noundef 1) #[[ATTR2]] ; CGSCC-NEXT: [[CSRET1:%.*]] = call i32 @call_with_two_values(i32 noundef 1) #[[ATTR2]]
; CGSCC-NEXT: [[CSRET2:%.*]] = call i32 @call_with_two_values(i32 noundef -1) #[[ATTR2]] ; CGSCC-NEXT: [[CSRET2:%.*]] = call i32 @call_with_two_values(i32 noundef -1) #[[ATTR2]]
; CGSCC-NEXT: [[RET:%.*]] = add i32 [[CSRET1]], [[CSRET2]] ; CGSCC-NEXT: [[RET:%.*]] = add i32 [[CSRET1]], [[CSRET2]]
; CGSCC-NEXT: ret i32 [[RET]] ; CGSCC-NEXT: ret i32 [[RET]]
; ;
%csret1 = call i32 @call_with_two_values(i32 1) %csret1 = call i32 @call_with_two_values(i32 1)
Show All 9 Lines
; potential values of argument of g are {0,1} ; potential values of argument of g are {0,1}
; potential value of returned value of g is 1 ; potential value of returned value of g is 1
; then returned value of g can be simplified ; then returned value of g can be simplified
; ;
; int zero_or_one(int c) { return c < 2; } ; int zero_or_one(int c) { return c < 2; }
; int potential_test3() { return zero_or_one(iszero(0))+zero_or_one(iszero(1)); } ; int potential_test3() { return zero_or_one(iszero(0))+zero_or_one(iszero(1)); }
define internal i32 @iszero3(i32 %c) { define internal i32 @iszero3(i32 %c) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@iszero3 ; CGSCC-LABEL: define {{[^@]+}}@iszero3
; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: [[CMP:%.*]] = icmp eq i32 [[C]], 0 ; CGSCC-NEXT: [[CMP:%.*]] = icmp eq i32 [[C]], 0
; CGSCC-NEXT: [[RET:%.*]] = zext i1 [[CMP]] to i32 ; CGSCC-NEXT: [[RET:%.*]] = zext i1 [[CMP]] to i32
; CGSCC-NEXT: ret i32 [[RET]] ; CGSCC-NEXT: ret i32 [[RET]]
; ;
%cmp = icmp eq i32 %c, 0 %cmp = icmp eq i32 %c, 0
%ret = zext i1 %cmp to i32 %ret = zext i1 %cmp to i32
ret i32 %ret ret i32 %ret
} }
define internal i32 @less_than_two(i32 %c) { define internal i32 @less_than_two(i32 %c) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@less_than_two ; CGSCC-LABEL: define {{[^@]+}}@less_than_two
; CGSCC-SAME: (i32 [[C:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (i32 [[C:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: [[CMP:%.*]] = icmp slt i32 [[C]], 2 ; CGSCC-NEXT: [[CMP:%.*]] = icmp slt i32 [[C]], 2
; CGSCC-NEXT: [[RET:%.*]] = zext i1 [[CMP]] to i32 ; CGSCC-NEXT: [[RET:%.*]] = zext i1 [[CMP]] to i32
; CGSCC-NEXT: ret i32 [[RET]] ; CGSCC-NEXT: ret i32 [[RET]]
; ;
%cmp = icmp slt i32 %c, 2 %cmp = icmp slt i32 %c, 2
%ret = zext i1 %cmp to i32 %ret = zext i1 %cmp to i32
ret i32 %ret ret i32 %ret
} }
define i32 @potential_test3() { define i32 @potential_test3() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@potential_test3 ; TUNIT-LABEL: define {{[^@]+}}@potential_test3
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: ret i32 2 ; TUNIT-NEXT: ret i32 2
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@potential_test3 ; CGSCC-LABEL: define {{[^@]+}}@potential_test3
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: [[CMP1:%.*]] = call i32 @iszero3(i32 noundef 0) #[[ATTR2]] ; CGSCC-NEXT: [[CMP1:%.*]] = call i32 @iszero3(i32 noundef 0) #[[ATTR2]]
; CGSCC-NEXT: [[TRUE1:%.*]] = call i32 @less_than_two(i32 [[CMP1]]) #[[ATTR2]] ; CGSCC-NEXT: [[TRUE1:%.*]] = call i32 @less_than_two(i32 [[CMP1]]) #[[ATTR2]]
; CGSCC-NEXT: [[CMP2:%.*]] = call i32 @iszero3(i32 noundef 1) #[[ATTR2]] ; CGSCC-NEXT: [[CMP2:%.*]] = call i32 @iszero3(i32 noundef 1) #[[ATTR2]]
; CGSCC-NEXT: [[TRUE2:%.*]] = call i32 @less_than_two(i32 [[CMP2]]) #[[ATTR2]] ; CGSCC-NEXT: [[TRUE2:%.*]] = call i32 @less_than_two(i32 [[CMP2]]) #[[ATTR2]]
; CGSCC-NEXT: [[RET:%.*]] = add i32 [[TRUE1]], [[TRUE2]] ; CGSCC-NEXT: [[RET:%.*]] = add i32 [[TRUE1]], [[TRUE2]]
; CGSCC-NEXT: ret i32 [[RET]] ; CGSCC-NEXT: ret i32 [[RET]]
Show All 13 Lines
; int potential_test4(int c) { return return1or3(c) == 2; } ; int potential_test4(int c) { return return1or3(c) == 2; }
; int potential_test5(int c) { return return1or3(c) == return2or4(c); } ; int potential_test5(int c) { return return1or3(c) == return2or4(c); }
; ;
; not simplified ; not simplified
; int potential_test6(int c) { return return1or3(c) == 3; } ; int potential_test6(int c) { return return1or3(c) == 3; }
; int potential_test7(int c) { return return1or3(c) == return3or4(c); } ; int potential_test7(int c) { return return1or3(c) == return3or4(c); }
define i32 @potential_test4(i32 %c) { define i32 @potential_test4(i32 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@potential_test4 ; TUNIT-LABEL: define {{[^@]+}}@potential_test4
; TUNIT-SAME: (i32 [[C:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i32 [[C:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[CSRET:%.*]] = call i32 @return1or3(i32 [[C]]) #[[ATTR1]] ; TUNIT-NEXT: [[CSRET:%.*]] = call i32 @return1or3(i32 [[C]]) #[[ATTR1]]
; TUNIT-NEXT: [[FALSE:%.*]] = icmp eq i32 [[CSRET]], 2 ; TUNIT-NEXT: [[FALSE:%.*]] = icmp eq i32 [[CSRET]], 2
; TUNIT-NEXT: [[RET:%.*]] = zext i1 [[FALSE]] to i32 ; TUNIT-NEXT: [[RET:%.*]] = zext i1 [[FALSE]] to i32
; TUNIT-NEXT: ret i32 [[RET]] ; TUNIT-NEXT: ret i32 [[RET]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@potential_test4 ; CGSCC-LABEL: define {{[^@]+}}@potential_test4
; CGSCC-SAME: (i32 [[C:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (i32 [[C:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: [[CSRET:%.*]] = call i32 @return1or3(i32 [[C]]) #[[ATTR2]] ; CGSCC-NEXT: [[CSRET:%.*]] = call i32 @return1or3(i32 [[C]]) #[[ATTR2]]
; CGSCC-NEXT: [[FALSE:%.*]] = icmp eq i32 [[CSRET]], 2 ; CGSCC-NEXT: [[FALSE:%.*]] = icmp eq i32 [[CSRET]], 2
; CGSCC-NEXT: [[RET:%.*]] = zext i1 [[FALSE]] to i32 ; CGSCC-NEXT: [[RET:%.*]] = zext i1 [[FALSE]] to i32
; CGSCC-NEXT: ret i32 [[RET]] ; CGSCC-NEXT: ret i32 [[RET]]
; ;
%csret = call i32 @return1or3(i32 %c) %csret = call i32 @return1or3(i32 %c)
%false = icmp eq i32 %csret, 2 %false = icmp eq i32 %csret, 2
%ret = zext i1 %false to i32 %ret = zext i1 %false to i32
ret i32 %ret ret i32 %ret
} }
define i32 @potential_test5(i32 %c) { define i32 @potential_test5(i32 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@potential_test5 ; TUNIT-LABEL: define {{[^@]+}}@potential_test5
; TUNIT-SAME: (i32 [[C:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i32 [[C:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[CSRET1:%.*]] = call i32 @return1or3(i32 [[C]]) #[[ATTR1]] ; TUNIT-NEXT: [[CSRET1:%.*]] = call i32 @return1or3(i32 [[C]]) #[[ATTR1]]
; TUNIT-NEXT: [[CSRET2:%.*]] = call i32 @return2or4(i32 [[C]]) #[[ATTR1]] ; TUNIT-NEXT: [[CSRET2:%.*]] = call i32 @return2or4(i32 [[C]]) #[[ATTR1]]
; TUNIT-NEXT: [[FALSE:%.*]] = icmp eq i32 [[CSRET1]], [[CSRET2]] ; TUNIT-NEXT: [[FALSE:%.*]] = icmp eq i32 [[CSRET1]], [[CSRET2]]
; TUNIT-NEXT: [[RET:%.*]] = zext i1 [[FALSE]] to i32 ; TUNIT-NEXT: [[RET:%.*]] = zext i1 [[FALSE]] to i32
; TUNIT-NEXT: ret i32 [[RET]] ; TUNIT-NEXT: ret i32 [[RET]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@potential_test5 ; CGSCC-LABEL: define {{[^@]+}}@potential_test5
; CGSCC-SAME: (i32 [[C:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (i32 [[C:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: [[CSRET1:%.*]] = call i32 @return1or3(i32 [[C]]) #[[ATTR2]] ; CGSCC-NEXT: [[CSRET1:%.*]] = call i32 @return1or3(i32 [[C]]) #[[ATTR2]]
; CGSCC-NEXT: [[CSRET2:%.*]] = call i32 @return2or4(i32 [[C]]) #[[ATTR2]] ; CGSCC-NEXT: [[CSRET2:%.*]] = call i32 @return2or4(i32 [[C]]) #[[ATTR2]]
; CGSCC-NEXT: [[FALSE:%.*]] = icmp eq i32 [[CSRET1]], [[CSRET2]] ; CGSCC-NEXT: [[FALSE:%.*]] = icmp eq i32 [[CSRET1]], [[CSRET2]]
; CGSCC-NEXT: [[RET:%.*]] = zext i1 [[FALSE]] to i32 ; CGSCC-NEXT: [[RET:%.*]] = zext i1 [[FALSE]] to i32
; CGSCC-NEXT: ret i32 [[RET]] ; CGSCC-NEXT: ret i32 [[RET]]
; ;
%csret1 = call i32 @return1or3(i32 %c) %csret1 = call i32 @return1or3(i32 %c)
%csret2 = call i32 @return2or4(i32 %c) %csret2 = call i32 @return2or4(i32 %c)
%false = icmp eq i32 %csret1, %csret2 %false = icmp eq i32 %csret1, %csret2
%ret = zext i1 %false to i32 %ret = zext i1 %false to i32
ret i32 %ret ret i32 %ret
} }
define i1 @potential_test6(i32 %c) { define i1 @potential_test6(i32 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@potential_test6 ; TUNIT-LABEL: define {{[^@]+}}@potential_test6
; TUNIT-SAME: (i32 [[C:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i32 [[C:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[CSRET1:%.*]] = call i32 @return1or3(i32 [[C]]) #[[ATTR1]] ; TUNIT-NEXT: [[CSRET1:%.*]] = call i32 @return1or3(i32 [[C]]) #[[ATTR1]]
; TUNIT-NEXT: [[RET:%.*]] = icmp eq i32 [[CSRET1]], 3 ; TUNIT-NEXT: [[RET:%.*]] = icmp eq i32 [[CSRET1]], 3
; TUNIT-NEXT: ret i1 [[RET]] ; TUNIT-NEXT: ret i1 [[RET]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@potential_test6 ; CGSCC-LABEL: define {{[^@]+}}@potential_test6
; CGSCC-SAME: (i32 [[C:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (i32 [[C:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: [[CSRET1:%.*]] = call i32 @return1or3(i32 [[C]]) #[[ATTR2]] ; CGSCC-NEXT: [[CSRET1:%.*]] = call i32 @return1or3(i32 [[C]]) #[[ATTR2]]
; CGSCC-NEXT: [[RET:%.*]] = icmp eq i32 [[CSRET1]], 3 ; CGSCC-NEXT: [[RET:%.*]] = icmp eq i32 [[CSRET1]], 3
; CGSCC-NEXT: ret i1 [[RET]] ; CGSCC-NEXT: ret i1 [[RET]]
; ;
%csret1 = call i32 @return1or3(i32 %c) %csret1 = call i32 @return1or3(i32 %c)
%ret = icmp eq i32 %csret1, 3 %ret = icmp eq i32 %csret1, 3
ret i1 %ret ret i1 %ret
} }
define i1 @potential_test7(i32 %c) { define i1 @potential_test7(i32 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@potential_test7 ; TUNIT-LABEL: define {{[^@]+}}@potential_test7
; TUNIT-SAME: (i32 [[C:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i32 [[C:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[CSRET1:%.*]] = call i32 @return1or3(i32 [[C]]) #[[ATTR1]] ; TUNIT-NEXT: [[CSRET1:%.*]] = call i32 @return1or3(i32 [[C]]) #[[ATTR1]]
; TUNIT-NEXT: [[CSRET2:%.*]] = call i32 @return3or4(i32 [[C]]) #[[ATTR1]] ; TUNIT-NEXT: [[CSRET2:%.*]] = call i32 @return3or4(i32 [[C]]) #[[ATTR1]]
; TUNIT-NEXT: [[RET:%.*]] = icmp eq i32 [[CSRET1]], [[CSRET2]] ; TUNIT-NEXT: [[RET:%.*]] = icmp eq i32 [[CSRET1]], [[CSRET2]]
; TUNIT-NEXT: ret i1 [[RET]] ; TUNIT-NEXT: ret i1 [[RET]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@potential_test7 ; CGSCC-LABEL: define {{[^@]+}}@potential_test7
; CGSCC-SAME: (i32 [[C:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (i32 [[C:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: [[CSRET1:%.*]] = call i32 @return1or3(i32 [[C]]) #[[ATTR2]] ; CGSCC-NEXT: [[CSRET1:%.*]] = call i32 @return1or3(i32 [[C]]) #[[ATTR2]]
; CGSCC-NEXT: [[CSRET2:%.*]] = call i32 @return3or4(i32 [[C]]) #[[ATTR2]] ; CGSCC-NEXT: [[CSRET2:%.*]] = call i32 @return3or4(i32 [[C]]) #[[ATTR2]]
; CGSCC-NEXT: [[RET:%.*]] = icmp eq i32 [[CSRET1]], [[CSRET2]] ; CGSCC-NEXT: [[RET:%.*]] = icmp eq i32 [[CSRET1]], [[CSRET2]]
; CGSCC-NEXT: ret i1 [[RET]] ; CGSCC-NEXT: ret i1 [[RET]]
; ;
%csret1 = call i32 @return1or3(i32 %c) %csret1 = call i32 @return1or3(i32 %c)
%csret2 = call i32 @return3or4(i32 %c) %csret2 = call i32 @return3or4(i32 %c)
%ret = icmp eq i32 %csret1, %csret2 %ret = icmp eq i32 %csret1, %csret2
ret i1 %ret ret i1 %ret
} }
define internal i32 @return1or3(i32 %c) { define internal i32 @return1or3(i32 %c) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@return1or3 ; CHECK-LABEL: define {{[^@]+}}@return1or3
; CHECK-SAME: (i32 [[C:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32 [[C:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[C]], 0 ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[C]], 0
; CHECK-NEXT: [[RET:%.*]] = select i1 [[CMP]], i32 1, i32 3 ; CHECK-NEXT: [[RET:%.*]] = select i1 [[CMP]], i32 1, i32 3
; CHECK-NEXT: ret i32 [[RET]] ; CHECK-NEXT: ret i32 [[RET]]
; ;
%cmp = icmp eq i32 %c, 0 %cmp = icmp eq i32 %c, 0
%ret = select i1 %cmp, i32 1, i32 3 %ret = select i1 %cmp, i32 1, i32 3
ret i32 %ret ret i32 %ret
} }
define internal i32 @return2or4(i32 %c) { define internal i32 @return2or4(i32 %c) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@return2or4 ; CHECK-LABEL: define {{[^@]+}}@return2or4
; CHECK-SAME: (i32 [[C:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32 [[C:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[C]], 0 ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[C]], 0
; CHECK-NEXT: [[RET:%.*]] = select i1 [[CMP]], i32 2, i32 4 ; CHECK-NEXT: [[RET:%.*]] = select i1 [[CMP]], i32 2, i32 4
; CHECK-NEXT: ret i32 [[RET]] ; CHECK-NEXT: ret i32 [[RET]]
; ;
%cmp = icmp eq i32 %c, 0 %cmp = icmp eq i32 %c, 0
%ret = select i1 %cmp, i32 2, i32 4 %ret = select i1 %cmp, i32 2, i32 4
ret i32 %ret ret i32 %ret
} }
define internal i32 @return3or4(i32 %c) { define internal i32 @return3or4(i32 %c) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@return3or4 ; CHECK-LABEL: define {{[^@]+}}@return3or4
; CHECK-SAME: (i32 [[C:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32 [[C:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[C]], 0 ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[C]], 0
; CHECK-NEXT: [[RET:%.*]] = select i1 [[CMP]], i32 3, i32 4 ; CHECK-NEXT: [[RET:%.*]] = select i1 [[CMP]], i32 3, i32 4
; CHECK-NEXT: ret i32 [[RET]] ; CHECK-NEXT: ret i32 [[RET]]
; ;
%cmp = icmp eq i32 %c, 0 %cmp = icmp eq i32 %c, 0
%ret = select i1 %cmp, i32 3, i32 4 %ret = select i1 %cmp, i32 3, i32 4
ret i32 %ret ret i32 %ret
} }
; potential-test 8 ; potential-test 8
; ;
; propagate argument to callsite argument ; propagate argument to callsite argument
define internal i1 @cmp_with_four(i32 %c) { define internal i1 @cmp_with_four(i32 %c) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@cmp_with_four ; CGSCC-LABEL: define {{[^@]+}}@cmp_with_four
; CGSCC-SAME: (i32 [[C:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (i32 [[C:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: [[CMP:%.*]] = icmp eq i32 [[C]], 4 ; CGSCC-NEXT: [[CMP:%.*]] = icmp eq i32 [[C]], 4
; CGSCC-NEXT: ret i1 [[CMP]] ; CGSCC-NEXT: ret i1 [[CMP]]
; ;
%cmp = icmp eq i32 %c, 4 %cmp = icmp eq i32 %c, 4
ret i1 %cmp ret i1 %cmp
} }
define internal i1 @wrapper(i32 %c) { define internal i1 @wrapper(i32 %c) {
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@wrapper ; CGSCC-LABEL: define {{[^@]+}}@wrapper
; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: [[RET:%.*]] = call i1 @cmp_with_four(i32 noundef [[C]]) #[[ATTR2]] ; CGSCC-NEXT: [[RET:%.*]] = call i1 @cmp_with_four(i32 noundef [[C]]) #[[ATTR2]]
; CGSCC-NEXT: ret i1 [[RET]] ; CGSCC-NEXT: ret i1 [[RET]]
; ;
%ret = call i1 @cmp_with_four(i32 %c) %ret = call i1 @cmp_with_four(i32 %c)
ret i1 %ret ret i1 %ret
} }
define i1 @potential_test8() { define i1 @potential_test8() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@potential_test8 ; TUNIT-LABEL: define {{[^@]+}}@potential_test8
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: ret i1 false ; TUNIT-NEXT: ret i1 false
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@potential_test8 ; CGSCC-LABEL: define {{[^@]+}}@potential_test8
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: [[RES1:%.*]] = call i1 @wrapper(i32 noundef 1) #[[ATTR2]] ; CGSCC-NEXT: [[RES1:%.*]] = call i1 @wrapper(i32 noundef 1) #[[ATTR2]]
; CGSCC-NEXT: [[RES3:%.*]] = call i1 @wrapper(i32 noundef 3) #[[ATTR2]] ; CGSCC-NEXT: [[RES3:%.*]] = call i1 @wrapper(i32 noundef 3) #[[ATTR2]]
; CGSCC-NEXT: [[RES5:%.*]] = call i1 @wrapper(i32 noundef 5) #[[ATTR2]] ; CGSCC-NEXT: [[RES5:%.*]] = call i1 @wrapper(i32 noundef 5) #[[ATTR2]]
; CGSCC-NEXT: [[RES13:%.*]] = or i1 [[RES1]], [[RES3]] ; CGSCC-NEXT: [[RES13:%.*]] = or i1 [[RES1]], [[RES3]]
; CGSCC-NEXT: [[RES135:%.*]] = or i1 [[RES13]], [[RES5]] ; CGSCC-NEXT: [[RES135:%.*]] = or i1 [[RES13]], [[RES5]]
; CGSCC-NEXT: ret i1 [[RES135]] ; CGSCC-NEXT: ret i1 [[RES135]]
; ;
%res1 = call i1 @wrapper(i32 1) %res1 = call i1 @wrapper(i32 1)
%res3 = call i1 @wrapper(i32 3) %res3 = call i1 @wrapper(i32 3)
%res5 = call i1 @wrapper(i32 5) %res5 = call i1 @wrapper(i32 5)
%res13 = or i1 %res1, %res3 %res13 = or i1 %res1, %res3
%res135 = or i1 %res13, %res5 %res135 = or i1 %res13, %res5
ret i1 %res135 ret i1 %res135
} }
define i1 @potential_test9() { define i1 @potential_test9() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@potential_test9 ; CHECK-LABEL: define {{[^@]+}}@potential_test9
; CHECK-SAME: () #[[ATTR0]] { ; CHECK-SAME: () #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[COND:%.*]] ; CHECK-NEXT: br label [[COND:%.*]]
; CHECK: cond: ; CHECK: cond:
; CHECK-NEXT: [[I_0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[I_1:%.*]], [[INC:%.*]] ] ; CHECK-NEXT: [[I_0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[I_1:%.*]], [[INC:%.*]] ]
; CHECK-NEXT: [[C_0:%.*]] = phi i32 [ 1, [[ENTRY]] ], [ [[C_1:%.*]], [[INC]] ] ; CHECK-NEXT: [[C_0:%.*]] = phi i32 [ 1, [[ENTRY]] ], [ [[C_1:%.*]], [[INC]] ]
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[I_0]], 10 ; CHECK-NEXT: [[CMP:%.*]] = icmp slt i32 [[I_0]], 10
Show All 26 Linesend:
ret i1 %ret ret i1 %ret
} }
; Test 10 ; Test 10
; FIXME: potential returned values of @may_return_undef is {1, -1} ; FIXME: potential returned values of @may_return_undef is {1, -1}
; and returned value of @potential_test10 can be simplified to 0(false) ; and returned value of @potential_test10 can be simplified to 0(false)
define internal i32 @may_return_undef(i32 %c) { define internal i32 @may_return_undef(i32 %c) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@may_return_undef ; CHECK-LABEL: define {{[^@]+}}@may_return_undef
; CHECK-SAME: (i32 noundef [[C:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32 noundef [[C:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: switch i32 [[C]], label [[OTHERWISE:%.*]] [ ; CHECK-NEXT: switch i32 [[C]], label [[OTHERWISE:%.*]] [
; CHECK-NEXT: i32 1, label [[A:%.*]] ; CHECK-NEXT: i32 1, label [[A:%.*]]
; CHECK-NEXT: i32 -1, label [[B:%.*]] ; CHECK-NEXT: i32 -1, label [[B:%.*]]
; CHECK-NEXT: ] ; CHECK-NEXT: ]
; CHECK: a: ; CHECK: a:
; CHECK-NEXT: ret i32 1 ; CHECK-NEXT: ret i32 1
; CHECK: b: ; CHECK: b:
; CHECK-NEXT: ret i32 -1 ; CHECK-NEXT: ret i32 -1
; CHECK: otherwise: ; CHECK: otherwise:
; CHECK-NEXT: ret i32 undef ; CHECK-NEXT: ret i32 undef
; ;
switch i32 %c, label %otherwise [i32 1, label %a switch i32 %c, label %otherwise [i32 1, label %a
i32 -1, label %b] i32 -1, label %b]
a: a:
ret i32 1 ret i32 1
b: b:
ret i32 -1 ret i32 -1
otherwise: otherwise:
ret i32 undef ret i32 undef
} }
define i1 @potential_test10(i32 %c) { define i1 @potential_test10(i32 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@potential_test10 ; TUNIT-LABEL: define {{[^@]+}}@potential_test10
; TUNIT-SAME: (i32 [[C:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i32 [[C:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[RET:%.*]] = call i32 @may_return_undef(i32 [[C]]) #[[ATTR1]] ; TUNIT-NEXT: [[RET:%.*]] = call i32 @may_return_undef(i32 [[C]]) #[[ATTR1]]
; TUNIT-NEXT: [[CMP:%.*]] = icmp eq i32 [[RET]], 0 ; TUNIT-NEXT: [[CMP:%.*]] = icmp eq i32 [[RET]], 0
; TUNIT-NEXT: ret i1 [[CMP]] ; TUNIT-NEXT: ret i1 [[CMP]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@potential_test10 ; CGSCC-LABEL: define {{[^@]+}}@potential_test10
; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: [[RET:%.*]] = call i32 @may_return_undef(i32 noundef [[C]]) #[[ATTR2]] ; CGSCC-NEXT: [[RET:%.*]] = call i32 @may_return_undef(i32 noundef [[C]]) #[[ATTR2]]
; CGSCC-NEXT: [[CMP:%.*]] = icmp eq i32 [[RET]], 0 ; CGSCC-NEXT: [[CMP:%.*]] = icmp eq i32 [[RET]], 0
; CGSCC-NEXT: ret i1 [[CMP]] ; CGSCC-NEXT: ret i1 [[CMP]]
; ;
%ret = call i32 @may_return_undef(i32 %c) %ret = call i32 @may_return_undef(i32 %c)
%cmp = icmp eq i32 %ret, 0 %cmp = icmp eq i32 %ret, 0
ret i1 %cmp ret i1 %cmp
} }
define i32 @optimize_undef_1(i1 %c) { define i32 @optimize_undef_1(i1 %c) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@optimize_undef_1 ; CHECK-LABEL: define {{[^@]+}}@optimize_undef_1
; CHECK-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; CHECK-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; CHECK: t: ; CHECK: t:
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; CHECK: f: ; CHECK: f:
; CHECK-NEXT: [[UNDEF:%.*]] = add i32 undef, 1 ; CHECK-NEXT: [[UNDEF:%.*]] = add i32 undef, 1
; CHECK-NEXT: ret i32 [[UNDEF]] ; CHECK-NEXT: ret i32 [[UNDEF]]
; ;
br i1 %c, label %t, label %f br i1 %c, label %t, label %f
t: t:
ret i32 0 ret i32 0
f: f:
%undef = add i32 undef, 1 %undef = add i32 undef, 1
ret i32 %undef ret i32 %undef
} }
define i32 @optimize_undef_2(i1 %c) { define i32 @optimize_undef_2(i1 %c) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@optimize_undef_2 ; CHECK-LABEL: define {{[^@]+}}@optimize_undef_2
; CHECK-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; CHECK-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; CHECK: t: ; CHECK: t:
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; CHECK: f: ; CHECK: f:
; CHECK-NEXT: [[UNDEF:%.*]] = sub i32 undef, 1 ; CHECK-NEXT: [[UNDEF:%.*]] = sub i32 undef, 1
; CHECK-NEXT: ret i32 [[UNDEF]] ; CHECK-NEXT: ret i32 [[UNDEF]]
; ;
br i1 %c, label %t, label %f br i1 %c, label %t, label %f
t: t:
ret i32 0 ret i32 0
f: f:
%undef = sub i32 undef, 1 %undef = sub i32 undef, 1
ret i32 %undef ret i32 %undef
} }
define i32 @optimize_undef_3(i1 %c) { define i32 @optimize_undef_3(i1 %c) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@optimize_undef_3 ; CHECK-LABEL: define {{[^@]+}}@optimize_undef_3
; CHECK-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; CHECK-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; CHECK: t: ; CHECK: t:
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; CHECK: f: ; CHECK: f:
; CHECK-NEXT: [[UNDEF:%.*]] = icmp eq i32 undef, 0 ; CHECK-NEXT: [[UNDEF:%.*]] = icmp eq i32 undef, 0
; CHECK-NEXT: [[UNDEF2:%.*]] = zext i1 [[UNDEF]] to i32 ; CHECK-NEXT: [[UNDEF2:%.*]] = zext i1 [[UNDEF]] to i32
; CHECK-NEXT: ret i32 [[UNDEF2]] ; CHECK-NEXT: ret i32 [[UNDEF2]]
; ;
br i1 %c, label %t, label %f br i1 %c, label %t, label %f
t: t:
ret i32 0 ret i32 0
f: f:
%undef = icmp eq i32 undef, 0 %undef = icmp eq i32 undef, 0
%undef2 = zext i1 %undef to i32 %undef2 = zext i1 %undef to i32
ret i32 %undef2 ret i32 %undef2
} }
; FIXME: returned value can be simplified to 0 ; FIXME: returned value can be simplified to 0
define i32 @potential_test11(i1 %c) { define i32 @potential_test11(i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@potential_test11 ; TUNIT-LABEL: define {{[^@]+}}@potential_test11
; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[ZERO1:%.*]] = call i32 @optimize_undef_1(i1 [[C]]) #[[ATTR1]], !range [[RNG0]] ; TUNIT-NEXT: [[ZERO1:%.*]] = call i32 @optimize_undef_1(i1 [[C]]) #[[ATTR1]], !range [[RNG0]]
; TUNIT-NEXT: [[ZERO2:%.*]] = call i32 @optimize_undef_2(i1 [[C]]) #[[ATTR1]], !range [[RNG2:![0-9]+]] ; TUNIT-NEXT: [[ZERO2:%.*]] = call i32 @optimize_undef_2(i1 [[C]]) #[[ATTR1]], !range [[RNG2:![0-9]+]]
; TUNIT-NEXT: [[ZERO3:%.*]] = call i32 @optimize_undef_3(i1 [[C]]) #[[ATTR1]], !range [[RNG0]] ; TUNIT-NEXT: [[ZERO3:%.*]] = call i32 @optimize_undef_3(i1 [[C]]) #[[ATTR1]], !range [[RNG0]]
; TUNIT-NEXT: [[ACC1:%.*]] = add i32 [[ZERO1]], [[ZERO2]] ; TUNIT-NEXT: [[ACC1:%.*]] = add i32 [[ZERO1]], [[ZERO2]]
; TUNIT-NEXT: [[ACC2:%.*]] = add i32 [[ACC1]], [[ZERO3]] ; TUNIT-NEXT: [[ACC2:%.*]] = add i32 [[ACC1]], [[ZERO3]]
; TUNIT-NEXT: ret i32 [[ACC2]] ; TUNIT-NEXT: ret i32 [[ACC2]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@potential_test11 ; CGSCC-LABEL: define {{[^@]+}}@potential_test11
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: [[ZERO1:%.*]] = call i32 @optimize_undef_1(i1 noundef [[C]]) #[[ATTR2]] ; CGSCC-NEXT: [[ZERO1:%.*]] = call i32 @optimize_undef_1(i1 noundef [[C]]) #[[ATTR2]]
; CGSCC-NEXT: [[ZERO2:%.*]] = call i32 @optimize_undef_2(i1 noundef [[C]]) #[[ATTR2]] ; CGSCC-NEXT: [[ZERO2:%.*]] = call i32 @optimize_undef_2(i1 noundef [[C]]) #[[ATTR2]]
; CGSCC-NEXT: [[ZERO3:%.*]] = call i32 @optimize_undef_3(i1 noundef [[C]]) #[[ATTR2]] ; CGSCC-NEXT: [[ZERO3:%.*]] = call i32 @optimize_undef_3(i1 noundef [[C]]) #[[ATTR2]]
; CGSCC-NEXT: [[ACC1:%.*]] = add i32 [[ZERO1]], [[ZERO2]] ; CGSCC-NEXT: [[ACC1:%.*]] = add i32 [[ZERO1]], [[ZERO2]]
; CGSCC-NEXT: [[ACC2:%.*]] = add i32 [[ACC1]], [[ZERO3]] ; CGSCC-NEXT: [[ACC2:%.*]] = add i32 [[ACC1]], [[ZERO3]]
; CGSCC-NEXT: ret i32 [[ACC2]] ; CGSCC-NEXT: ret i32 [[ACC2]]
; ;
%zero1 = call i32 @optimize_undef_1(i1 %c) %zero1 = call i32 @optimize_undef_1(i1 %c)
%zero2 = call i32 @optimize_undef_2(i1 %c) %zero2 = call i32 @optimize_undef_2(i1 %c)
%zero3 = call i32 @optimize_undef_3(i1 %c) %zero3 = call i32 @optimize_undef_3(i1 %c)
%acc1 = add i32 %zero1, %zero2 %acc1 = add i32 %zero1, %zero2
%acc2 = add i32 %acc1, %zero3 %acc2 = add i32 %acc1, %zero3
ret i32 %acc2 ret i32 %acc2
} }
define i32 @optimize_poison_1(i1 %c) { define i32 @optimize_poison_1(i1 %c) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@optimize_poison_1 ; CHECK-LABEL: define {{[^@]+}}@optimize_poison_1
; CHECK-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; CHECK-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; CHECK: t: ; CHECK: t:
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; CHECK: f: ; CHECK: f:
; CHECK-NEXT: [[POISON:%.*]] = sub nuw i32 0, 1 ; CHECK-NEXT: [[POISON:%.*]] = sub nuw i32 0, 1
; CHECK-NEXT: ret i32 [[POISON]] ; CHECK-NEXT: ret i32 [[POISON]]
; ;
br i1 %c, label %t, label %f br i1 %c, label %t, label %f
t: t:
ret i32 0 ret i32 0
f: f:
%poison = sub nuw i32 0, 1 %poison = sub nuw i32 0, 1
ret i32 %poison ret i32 %poison
} }
; FIXME: returned value can be simplified to 0 ; FIXME: returned value can be simplified to 0
define i32 @potential_test12(i1 %c) { define i32 @potential_test12(i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@potential_test12 ; TUNIT-LABEL: define {{[^@]+}}@potential_test12
; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: ret i32 0 ; TUNIT-NEXT: ret i32 0
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@potential_test12 ; CGSCC-LABEL: define {{[^@]+}}@potential_test12
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: [[ZERO:%.*]] = call i32 @optimize_poison_1(i1 noundef [[C]]) #[[ATTR2]] ; CGSCC-NEXT: [[ZERO:%.*]] = call i32 @optimize_poison_1(i1 noundef [[C]]) #[[ATTR2]]
; CGSCC-NEXT: ret i32 [[ZERO]] ; CGSCC-NEXT: ret i32 [[ZERO]]
; ;
%zero = call i32 @optimize_poison_1(i1 %c) %zero = call i32 @optimize_poison_1(i1 %c)
ret i32 %zero ret i32 %zero
} }
; Test 13 ; Test 13
; Do not simplify %ret in the callee to `%c`. ; Do not simplify %ret in the callee to `%c`.
; The potential value of %c is {0, 1} (undef is merged). ; The potential value of %c is {0, 1} (undef is merged).
; However, we should not simplify `and i32 %c, 3` to `%c` ; However, we should not simplify `and i32 %c, 3` to `%c`
define internal i32 @potential_test13_callee(i32 %c) { define internal i32 @potential_test13_callee(i32 %c) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@potential_test13_callee ; CHECK-LABEL: define {{[^@]+}}@potential_test13_callee
; CHECK-SAME: (i32 [[C:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32 [[C:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[RET:%.*]] = and i32 [[C]], 3 ; CHECK-NEXT: [[RET:%.*]] = and i32 [[C]], 3
; CHECK-NEXT: ret i32 [[RET]] ; CHECK-NEXT: ret i32 [[RET]]
; ;
%ret = and i32 %c, 3 %ret = and i32 %c, 3
ret i32 %ret ret i32 %ret
} }
define i32 @potential_test13_caller1() { define i32 @potential_test13_caller1() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@potential_test13_caller1 ; TUNIT-LABEL: define {{[^@]+}}@potential_test13_caller1
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: [[RET:%.*]] = call i32 @potential_test13_callee(i32 noundef 0) #[[ATTR1]], !range [[RNG0]] ; TUNIT-NEXT: [[RET:%.*]] = call i32 @potential_test13_callee(i32 noundef 0) #[[ATTR1]], !range [[RNG0]]
; TUNIT-NEXT: ret i32 [[RET]] ; TUNIT-NEXT: ret i32 [[RET]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@potential_test13_caller1 ; CGSCC-LABEL: define {{[^@]+}}@potential_test13_caller1
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: [[RET:%.*]] = call i32 @potential_test13_callee(i32 noundef 0) #[[ATTR2]] ; CGSCC-NEXT: [[RET:%.*]] = call i32 @potential_test13_callee(i32 noundef 0) #[[ATTR2]]
; CGSCC-NEXT: ret i32 [[RET]] ; CGSCC-NEXT: ret i32 [[RET]]
; ;
%ret = call i32 @potential_test13_callee(i32 0) %ret = call i32 @potential_test13_callee(i32 0)
ret i32 %ret ret i32 %ret
} }
define i32 @potential_test13_caller2() { define i32 @potential_test13_caller2() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@potential_test13_caller2 ; TUNIT-LABEL: define {{[^@]+}}@potential_test13_caller2
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: [[RET:%.*]] = call i32 @potential_test13_callee(i32 noundef 1) #[[ATTR1]], !range [[RNG0]] ; TUNIT-NEXT: [[RET:%.*]] = call i32 @potential_test13_callee(i32 noundef 1) #[[ATTR1]], !range [[RNG0]]
; TUNIT-NEXT: ret i32 [[RET]] ; TUNIT-NEXT: ret i32 [[RET]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@potential_test13_caller2 ; CGSCC-LABEL: define {{[^@]+}}@potential_test13_caller2
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: [[RET:%.*]] = call i32 @potential_test13_callee(i32 noundef 1) #[[ATTR2]] ; CGSCC-NEXT: [[RET:%.*]] = call i32 @potential_test13_callee(i32 noundef 1) #[[ATTR2]]
; CGSCC-NEXT: ret i32 [[RET]] ; CGSCC-NEXT: ret i32 [[RET]]
; ;
%ret = call i32 @potential_test13_callee(i32 1) %ret = call i32 @potential_test13_callee(i32 1)
ret i32 %ret ret i32 %ret
} }
define i32 @potential_test13_caller3() { define i32 @potential_test13_caller3() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@potential_test13_caller3 ; TUNIT-LABEL: define {{[^@]+}}@potential_test13_caller3
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: [[RET:%.*]] = call i32 @potential_test13_callee(i32 undef) #[[ATTR1]], !range [[RNG0]] ; TUNIT-NEXT: [[RET:%.*]] = call i32 @potential_test13_callee(i32 undef) #[[ATTR1]], !range [[RNG0]]
; TUNIT-NEXT: ret i32 [[RET]] ; TUNIT-NEXT: ret i32 [[RET]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@potential_test13_caller3 ; CGSCC-LABEL: define {{[^@]+}}@potential_test13_caller3
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: [[RET:%.*]] = call i32 @potential_test13_callee(i32 undef) #[[ATTR2]] ; CGSCC-NEXT: [[RET:%.*]] = call i32 @potential_test13_callee(i32 undef) #[[ATTR2]]
; CGSCC-NEXT: ret i32 [[RET]] ; CGSCC-NEXT: ret i32 [[RET]]
; ;
%ret = call i32 @potential_test13_callee(i32 undef) %ret = call i32 @potential_test13_callee(i32 undef)
ret i32 %ret ret i32 %ret
} }
define i1 @potential_test14(i1 %c0, i1 %c1, i1 %c2, i1 %c3) { define i1 @potential_test14(i1 %c0, i1 %c1, i1 %c2, i1 %c3) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@potential_test14 ; CHECK-LABEL: define {{[^@]+}}@potential_test14
; CHECK-SAME: (i1 [[C0:%.*]], i1 [[C1:%.*]], i1 [[C2:%.*]], i1 [[C3:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i1 [[C0:%.*]], i1 [[C1:%.*]], i1 [[C2:%.*]], i1 [[C3:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[X0:%.*]] = select i1 [[C0]], i32 0, i32 1 ; CHECK-NEXT: [[X0:%.*]] = select i1 [[C0]], i32 0, i32 1
; CHECK-NEXT: [[X1:%.*]] = select i1 [[C1]], i32 [[X0]], i32 undef ; CHECK-NEXT: [[X1:%.*]] = select i1 [[C1]], i32 [[X0]], i32 undef
; CHECK-NEXT: [[Y2:%.*]] = select i1 [[C2]], i32 0, i32 7 ; CHECK-NEXT: [[Y2:%.*]] = select i1 [[C2]], i32 0, i32 7
; CHECK-NEXT: [[Z3:%.*]] = select i1 [[C3]], i32 [[X1]], i32 [[Y2]] ; CHECK-NEXT: [[Z3:%.*]] = select i1 [[C3]], i32 [[X1]], i32 [[Y2]]
; CHECK-NEXT: [[RET:%.*]] = icmp slt i32 [[Z3]], 7 ; CHECK-NEXT: [[RET:%.*]] = icmp slt i32 [[Z3]], 7
; CHECK-NEXT: ret i1 [[RET]] ; CHECK-NEXT: ret i1 [[RET]]
; ;
%x0 = select i1 %c0, i32 0, i32 1 %x0 = select i1 %c0, i32 0, i32 1
%x1 = select i1 %c1, i32 %x0, i32 undef %x1 = select i1 %c1, i32 %x0, i32 undef
%y2 = select i1 %c2, i32 0, i32 7 %y2 = select i1 %c2, i32 0, i32 7
%z3 = select i1 %c3, i32 %x1, i32 %y2 %z3 = select i1 %c3, i32 %x1, i32 %y2
%ret = icmp slt i32 %z3, 7 %ret = icmp slt i32 %z3, 7
ret i1 %ret ret i1 %ret
} }
define i1 @potential_test15(i1 %c0, i1 %c1) { define i1 @potential_test15(i1 %c0, i1 %c1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@potential_test15 ; CHECK-LABEL: define {{[^@]+}}@potential_test15
; CHECK-SAME: (i1 [[C0:%.*]], i1 [[C1:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i1 [[C0:%.*]], i1 [[C1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[X0:%.*]] = select i1 [[C0]], i32 0, i32 1 ; CHECK-NEXT: [[X0:%.*]] = select i1 [[C0]], i32 0, i32 1
; CHECK-NEXT: [[X1:%.*]] = select i1 [[C1]], i32 [[X0]], i32 undef ; CHECK-NEXT: [[X1:%.*]] = select i1 [[C1]], i32 [[X0]], i32 undef
; CHECK-NEXT: [[RET:%.*]] = icmp eq i32 [[X1]], 7 ; CHECK-NEXT: [[RET:%.*]] = icmp eq i32 [[X1]], 7
; CHECK-NEXT: ret i1 [[RET]] ; CHECK-NEXT: ret i1 [[RET]]
; ;
%x0 = select i1 %c0, i32 0, i32 1 %x0 = select i1 %c0, i32 0, i32 1
%x1 = select i1 %c1, i32 %x0, i32 undef %x1 = select i1 %c1, i32 %x0, i32 undef
%ret = icmp eq i32 %x1, 7 %ret = icmp eq i32 %x1, 7
ret i1 %ret ret i1 %ret
} }
define i1 @potential_test16(i1 %c0, i1 %c1) { define i1 @potential_test16(i1 %c0, i1 %c1) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@potential_test16 ; CHECK-LABEL: define {{[^@]+}}@potential_test16
; CHECK-SAME: (i1 [[C0:%.*]], i1 [[C1:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i1 [[C0:%.*]], i1 [[C1:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[X1:%.*]] = select i1 [[C1]], i32 0, i32 1 ; CHECK-NEXT: [[X1:%.*]] = select i1 [[C1]], i32 0, i32 1
; CHECK-NEXT: [[RET:%.*]] = icmp eq i32 [[X1]], 7 ; CHECK-NEXT: [[RET:%.*]] = icmp eq i32 [[X1]], 7
; CHECK-NEXT: ret i1 [[RET]] ; CHECK-NEXT: ret i1 [[RET]]
; ;
%x0 = select i1 %c0, i32 0, i32 undef %x0 = select i1 %c0, i32 0, i32 undef
%x1 = select i1 %c1, i32 %x0, i32 1 %x1 = select i1 %c1, i32 %x0, i32 1
%ret = icmp eq i32 %x1, 7 %ret = icmp eq i32 %x1, 7
ret i1 %ret ret i1 %ret
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { willreturn } ; CGSCC: attributes #[[ATTR2]] = { willreturn }
;. ;.
; TUNIT: [[RNG0]] = !{i32 0, i32 2} ; TUNIT: [[RNG0]] = !{i32 0, i32 2}
; TUNIT: [[RNG1]] = !{i32 0, i32 3} ; TUNIT: [[RNG1]] = !{i32 0, i32 3}
; TUNIT: [[RNG2]] = !{i32 -1, i32 1} ; TUNIT: [[RNG2]] = !{i32 -1, i32 1}
;. ;.

llvm/test/Transforms/Attributor/range.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=12 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=12 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; FIXME: CGSCC is not looking at callees and calleers even though it could be allowed. ; FIXME: CGSCC is not looking at callees and calleers even though it could be allowed.
define i32 @test0(ptr %p) { define i32 @test0(ptr %p) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define {{[^@]+}}@test0 ; CHECK-LABEL: define {{[^@]+}}@test0
; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: [[A:%.*]] = load i32, ptr [[P]], align 4, !range [[RNG0:![0-9]+]] ; CHECK-NEXT: [[A:%.*]] = load i32, ptr [[P]], align 4, !range [[RNG0:![0-9]+]]
; CHECK-NEXT: ret i32 [[A]] ; CHECK-NEXT: ret i32 [[A]]
; ;
%a = load i32, ptr %p, !range !0 %a = load i32, ptr %p, !range !0
ret i32 %a ret i32 %a
} }
define i32 @test0-range-check(ptr %p) { define i32 @test0-range-check(ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; TUNIT-LABEL: define {{[^@]+}}@test0-range-check ; TUNIT-LABEL: define {{[^@]+}}@test0-range-check
; TUNIT-SAME: (ptr nocapture nofree readonly align 4 [[P:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr nocapture nofree readonly align 4 [[P:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[A:%.*]] = tail call i32 @test0(ptr nocapture nofree readonly align 4 [[P]]) #[[ATTR3:[0-9]+]], !range [[RNG0]] ; TUNIT-NEXT: [[A:%.*]] = tail call i32 @test0(ptr nocapture nofree readonly align 4 [[P]]) #[[ATTR3:[0-9]+]], !range [[RNG0]]
; TUNIT-NEXT: ret i32 [[A]] ; TUNIT-NEXT: ret i32 [[A]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@test0-range-check ; CGSCC-LABEL: define {{[^@]+}}@test0-range-check
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: [[A:%.*]] = tail call i32 @test0(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P]]) #[[ATTR5:[0-9]+]] ; CGSCC-NEXT: [[A:%.*]] = tail call i32 @test0(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P]]) #[[ATTR5:[0-9]+]]
; CGSCC-NEXT: ret i32 [[A]] ; CGSCC-NEXT: ret i32 [[A]]
; ;
%a = tail call i32 @test0(ptr %p) %a = tail call i32 @test0(ptr %p)
ret i32 %a ret i32 %a
} }
▲ Show 20 Lines • Show All 230 Lines • ▼ Show 20 Lines;
%cmp-lte-5 = icmp sle i32 %ret, 0 %cmp-lte-5 = icmp sle i32 %ret, 0
%cmp-lte-6 = icmp sle i32 %ret, -1 %cmp-lte-6 = icmp sle i32 %ret, -1
tail call void @use3(i1 %cmp-lte-1, i1 %cmp-lte-2, i1 %cmp-lte-3) tail call void @use3(i1 %cmp-lte-1, i1 %cmp-lte-2, i1 %cmp-lte-3)
tail call void @use3(i1 %cmp-lte-4, i1 %cmp-lte-5, i1 %cmp-lte-6) tail call void @use3(i1 %cmp-lte-4, i1 %cmp-lte-5, i1 %cmp-lte-6)
ret void ret void
} }
define i32 @test1(ptr %p) { define i32 @test1(ptr %p) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define {{[^@]+}}@test1 ; CHECK-LABEL: define {{[^@]+}}@test1
; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[LOAD_10_100:%.*]] = load i32, ptr [[P]], align 4, !range [[RNG1:![0-9]+]] ; CHECK-NEXT: [[LOAD_10_100:%.*]] = load i32, ptr [[P]], align 4, !range [[RNG1:![0-9]+]]
; CHECK-NEXT: [[ADD_10_THEN_20_110:%.*]] = add i32 [[LOAD_10_100]], 10 ; CHECK-NEXT: [[ADD_10_THEN_20_110:%.*]] = add i32 [[LOAD_10_100]], 10
; CHECK-NEXT: [[MUL_10_THEN_200_1091:%.*]] = mul i32 [[ADD_10_THEN_20_110]], 10 ; CHECK-NEXT: [[MUL_10_THEN_200_1091:%.*]] = mul i32 [[ADD_10_THEN_20_110]], 10
; CHECK-NEXT: ret i32 [[MUL_10_THEN_200_1091]] ; CHECK-NEXT: ret i32 [[MUL_10_THEN_200_1091]]
; ;
%load-10-100 = load i32, ptr %p, !range !1 %load-10-100 = load i32, ptr %p, !range !1
%add-10-then-20-110 = add i32 %load-10-100, 10 %add-10-then-20-110 = add i32 %load-10-100, 10
%mul-10-then-200-1091 = mul i32 %add-10-then-20-110, 10 %mul-10-then-200-1091 = mul i32 %add-10-then-20-110, 10
ret i32 %mul-10-then-200-1091 ret i32 %mul-10-then-200-1091
} }
define i1 @test1-check(ptr %p) { define i1 @test1-check(ptr %p) {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; TUNIT-LABEL: define {{[^@]+}}@test1-check ; TUNIT-LABEL: define {{[^@]+}}@test1-check
; TUNIT-SAME: (ptr nocapture nofree readonly align 4 [[P:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr nocapture nofree readonly align 4 [[P:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[RES:%.*]] = tail call i32 @test1(ptr nocapture nofree readonly align 4 [[P]]) #[[ATTR3]], !range [[RNG2:![0-9]+]] ; TUNIT-NEXT: [[RES:%.*]] = tail call i32 @test1(ptr nocapture nofree readonly align 4 [[P]]) #[[ATTR3]], !range [[RNG2:![0-9]+]]
; TUNIT-NEXT: [[CMP:%.*]] = icmp eq i32 [[RES]], 500 ; TUNIT-NEXT: [[CMP:%.*]] = icmp eq i32 [[RES]], 500
; TUNIT-NEXT: ret i1 [[CMP]] ; TUNIT-NEXT: ret i1 [[CMP]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@test1-check ; CGSCC-LABEL: define {{[^@]+}}@test1-check
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: [[RES:%.*]] = tail call i32 @test1(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P]]) #[[ATTR5]] ; CGSCC-NEXT: [[RES:%.*]] = tail call i32 @test1(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P]]) #[[ATTR5]]
; CGSCC-NEXT: [[CMP:%.*]] = icmp eq i32 [[RES]], 500 ; CGSCC-NEXT: [[CMP:%.*]] = icmp eq i32 [[RES]], 500
; CGSCC-NEXT: ret i1 [[CMP]] ; CGSCC-NEXT: ret i1 [[CMP]]
; ;
%res = tail call i32 @test1(ptr %p) %res = tail call i32 @test1(ptr %p)
%cmp = icmp eq i32 %res, 500 %cmp = icmp eq i32 %res, 500
ret i1 %cmp ret i1 %cmp
} }
; TEST2 ; TEST2
; int test2(int *p) { return *p == 0 ? 4 : 3; } ; int test2(int *p) { return *p == 0 ? 4 : 3; }
; int test2_check(int *p) { ; int test2_check(int *p) {
; int call = test2(p); ; int call = test2(p);
; if (call == 5) { ; if (call == 5) {
; // dead block ; // dead block
; return 2; ; return 2;
; } else { ; } else {
; return 3; ; return 3;
; } ; }
; } ; }
define i32 @test2(ptr %p) { define i32 @test2(ptr %p) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define {{[^@]+}}@test2 ; CHECK-LABEL: define {{[^@]+}}@test2
; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[P]], align 4 ; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[P]], align 4
; CHECK-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[TMP0]], 0 ; CHECK-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[TMP0]], 0
; CHECK-NEXT: [[COND:%.*]] = select i1 [[TOBOOL]], i32 4, i32 3 ; CHECK-NEXT: [[COND:%.*]] = select i1 [[TOBOOL]], i32 4, i32 3
; CHECK-NEXT: ret i32 [[COND]] ; CHECK-NEXT: ret i32 [[COND]]
; ;
entry: entry:
%0 = load i32, ptr %p, align 4 %0 = load i32, ptr %p, align 4
%tobool = icmp eq i32 %0, 0 %tobool = icmp eq i32 %0, 0
%cond = select i1 %tobool, i32 4, i32 3 %cond = select i1 %tobool, i32 4, i32 3
ret i32 %cond ret i32 %cond
} }
define i32 @test2_check(ptr %p) { define i32 @test2_check(ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; TUNIT-LABEL: define {{[^@]+}}@test2_check ; TUNIT-LABEL: define {{[^@]+}}@test2_check
; TUNIT-SAME: (ptr nocapture nofree readonly align 4 [[P:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr nocapture nofree readonly align 4 [[P:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[CALL:%.*]] = tail call i32 @test2(ptr nocapture nofree readonly align 4 [[P]]) #[[ATTR3]] ; TUNIT-NEXT: [[CALL:%.*]] = tail call i32 @test2(ptr nocapture nofree readonly align 4 [[P]]) #[[ATTR3]]
; TUNIT-NEXT: [[CMP:%.*]] = icmp slt i32 [[CALL]], 5 ; TUNIT-NEXT: [[CMP:%.*]] = icmp slt i32 [[CALL]], 5
; TUNIT-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]] ; TUNIT-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; TUNIT: if.then: ; TUNIT: if.then:
; TUNIT-NEXT: br label [[RETURN:%.*]] ; TUNIT-NEXT: br label [[RETURN:%.*]]
; TUNIT: if.end: ; TUNIT: if.end:
; TUNIT-NEXT: br label [[RETURN]] ; TUNIT-NEXT: br label [[RETURN]]
; TUNIT: return: ; TUNIT: return:
; TUNIT-NEXT: [[RETVAL_0:%.*]] = phi i32 [ 2, [[IF_THEN]] ], [ 3, [[IF_END]] ] ; TUNIT-NEXT: [[RETVAL_0:%.*]] = phi i32 [ 2, [[IF_THEN]] ], [ 3, [[IF_END]] ]
; TUNIT-NEXT: ret i32 [[RETVAL_0]] ; TUNIT-NEXT: ret i32 [[RETVAL_0]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@test2_check ; CGSCC-LABEL: define {{[^@]+}}@test2_check
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CALL:%.*]] = tail call i32 @test2(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P]]) #[[ATTR5]] ; CGSCC-NEXT: [[CALL:%.*]] = tail call i32 @test2(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[P]]) #[[ATTR5]]
; CGSCC-NEXT: [[CMP:%.*]] = icmp slt i32 [[CALL]], 5 ; CGSCC-NEXT: [[CMP:%.*]] = icmp slt i32 [[CALL]], 5
; CGSCC-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]] ; CGSCC-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CGSCC: if.then: ; CGSCC: if.then:
; CGSCC-NEXT: br label [[RETURN:%.*]] ; CGSCC-NEXT: br label [[RETURN:%.*]]
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
; }else { ; }else {
; return; ; return;
; } ; }
; } ; }
declare dso_local void @unkown() declare dso_local void @unkown()
define internal i32 @r1(i32) local_unnamed_addr { define internal i32 @r1(i32) local_unnamed_addr {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@r1 ; TUNIT-LABEL: define {{[^@]+}}@r1
; TUNIT-SAME: () local_unnamed_addr #[[ATTR1:[0-9]+]] { ; TUNIT-SAME: () local_unnamed_addr #[[ATTR1:[0-9]+]] {
; TUNIT-NEXT: br label [[TMP4:%.*]] ; TUNIT-NEXT: br label [[TMP4:%.*]]
; TUNIT: 1: ; TUNIT: 1:
; TUNIT-NEXT: [[TMP2:%.*]] = icmp sgt i32 [[TMP7:%.*]], 10000 ; TUNIT-NEXT: [[TMP2:%.*]] = icmp sgt i32 [[TMP7:%.*]], 10000
; TUNIT-NEXT: br i1 [[TMP2]], label [[TMP3:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[TMP2]], label [[TMP3:%.*]], label [[F:%.*]]
; TUNIT: 3: ; TUNIT: 3:
; TUNIT-NEXT: ret i32 20 ; TUNIT-NEXT: ret i32 20
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: ret i32 10 ; TUNIT-NEXT: ret i32 10
; TUNIT: 4: ; TUNIT: 4:
; TUNIT-NEXT: [[TMP5:%.*]] = phi i32 [ 0, [[TMP0:%.*]] ], [ [[TMP8:%.*]], [[TMP4]] ] ; TUNIT-NEXT: [[TMP5:%.*]] = phi i32 [ 0, [[TMP0:%.*]] ], [ [[TMP8:%.*]], [[TMP4]] ]
; TUNIT-NEXT: [[TMP6:%.*]] = phi i32 [ 0, [[TMP0]] ], [ [[TMP7]], [[TMP4]] ] ; TUNIT-NEXT: [[TMP6:%.*]] = phi i32 [ 0, [[TMP0]] ], [ [[TMP7]], [[TMP4]] ]
; TUNIT-NEXT: [[TMP7]] = add nuw nsw i32 [[TMP5]], [[TMP6]] ; TUNIT-NEXT: [[TMP7]] = add nuw nsw i32 [[TMP5]], [[TMP6]]
; TUNIT-NEXT: [[TMP8]] = add nuw nsw i32 [[TMP5]], 1 ; TUNIT-NEXT: [[TMP8]] = add nuw nsw i32 [[TMP5]], 1
; TUNIT-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], 100 ; TUNIT-NEXT: [[TMP9:%.*]] = icmp eq i32 [[TMP8]], 100
; TUNIT-NEXT: br i1 [[TMP9]], label [[TMP1:%.*]], label [[TMP4]] ; TUNIT-NEXT: br i1 [[TMP9]], label [[TMP1:%.*]], label [[TMP4]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@r1 ; CGSCC-LABEL: define {{[^@]+}}@r1
; CGSCC-SAME: () local_unnamed_addr #[[ATTR2:[0-9]+]] { ; CGSCC-SAME: () local_unnamed_addr #[[ATTR2:[0-9]+]] {
; CGSCC-NEXT: br label [[TMP4:%.*]] ; CGSCC-NEXT: br label [[TMP4:%.*]]
; CGSCC: 1: ; CGSCC: 1:
; CGSCC-NEXT: [[TMP2:%.*]] = icmp sgt i32 [[TMP7:%.*]], 10000 ; CGSCC-NEXT: [[TMP2:%.*]] = icmp sgt i32 [[TMP7:%.*]], 10000
; CGSCC-NEXT: br i1 [[TMP2]], label [[TMP3:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[TMP2]], label [[TMP3:%.*]], label [[F:%.*]]
; CGSCC: 3: ; CGSCC: 3:
; CGSCC-NEXT: ret i32 20 ; CGSCC-NEXT: ret i32 20
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines
; int test4-f1(int u){ ; int test4-f1(int u){
; if(u>=0) { ; if(u>=0) {
; return u; ; return u;
; }else{ ; }else{
; return 0; ; return 0;
; } ; }
; } ; }
define dso_local i32 @test4-f1(i32 %u) { define dso_local i32 @test4-f1(i32 %u) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@test4-f1 ; TUNIT-LABEL: define {{[^@]+}}@test4-f1
; TUNIT-SAME: (i32 [[U:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i32 [[U:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[CMP:%.*]] = icmp sgt i32 [[U]], -1 ; TUNIT-NEXT: [[CMP:%.*]] = icmp sgt i32 [[U]], -1
; TUNIT-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[RETURN:%.*]] ; TUNIT-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[RETURN:%.*]]
; TUNIT: if.then: ; TUNIT: if.then:
; TUNIT-NEXT: br label [[RETURN]] ; TUNIT-NEXT: br label [[RETURN]]
; TUNIT: return: ; TUNIT: return:
; TUNIT-NEXT: [[RETVAL_0:%.*]] = phi i32 [ [[U]], [[IF_THEN]] ], [ 0, [[ENTRY:%.*]] ] ; TUNIT-NEXT: [[RETVAL_0:%.*]] = phi i32 [ [[U]], [[IF_THEN]] ], [ 0, [[ENTRY:%.*]] ]
; TUNIT-NEXT: ret i32 [[RETVAL_0]] ; TUNIT-NEXT: ret i32 [[RETVAL_0]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test4-f1 ; CGSCC-LABEL: define {{[^@]+}}@test4-f1
; CGSCC-SAME: (i32 [[U:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i32 [[U:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CMP:%.*]] = icmp sgt i32 [[U]], -1 ; CGSCC-NEXT: [[CMP:%.*]] = icmp sgt i32 [[U]], -1
; CGSCC-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[RETURN:%.*]] ; CGSCC-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[RETURN:%.*]]
; CGSCC: if.then: ; CGSCC: if.then:
; CGSCC-NEXT: br label [[RETURN]] ; CGSCC-NEXT: br label [[RETURN]]
; CGSCC: return: ; CGSCC: return:
Show All 10 Lines
return: ; preds = %entry, %if.then return: ; preds = %entry, %if.then
%retval.0 = phi i32 [ %u, %if.then ], [ 0, %entry ] %retval.0 = phi i32 [ %u, %if.then ], [ 0, %entry ]
ret i32 %retval.0 ret i32 %retval.0
} }
define dso_local i32 @test4-g1(i32 %u) { define dso_local i32 @test4-g1(i32 %u) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@test4-g1 ; TUNIT-LABEL: define {{[^@]+}}@test4-g1
; TUNIT-SAME: (i32 [[U:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i32 [[U:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[CALL:%.*]] = tail call i32 @test4-f1(i32 [[U]]) #[[ATTR3]] ; TUNIT-NEXT: [[CALL:%.*]] = tail call i32 @test4-f1(i32 [[U]]) #[[ATTR3]]
; TUNIT-NEXT: ret i32 [[CALL]] ; TUNIT-NEXT: ret i32 [[CALL]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test4-g1 ; CGSCC-LABEL: define {{[^@]+}}@test4-g1
; CGSCC-SAME: (i32 [[U:%.*]]) #[[ATTR3:[0-9]+]] { ; CGSCC-SAME: (i32 [[U:%.*]]) #[[ATTR3:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CALL:%.*]] = tail call i32 @test4-f1(i32 [[U]]) #[[ATTR5]] ; CGSCC-NEXT: [[CALL:%.*]] = tail call i32 @test4-f1(i32 [[U]]) #[[ATTR5]]
; CGSCC-NEXT: ret i32 [[CALL]] ; CGSCC-NEXT: ret i32 [[CALL]]
; ;
; FIXME: %call should have range [0, inf] ; FIXME: %call should have range [0, inf]
entry: entry:
%call = tail call i32 @test4-f1(i32 %u) %call = tail call i32 @test4-f1(i32 %u)
ret i32 %call ret i32 %call
} }
; f2 ; f2
; int test4-f1(int u){ ; int test4-f1(int u){
; if(u>-1) { ; if(u>-1) {
; return u+1; ; return u+1;
; }else{ ; }else{
; return 1; ; return 1;
; } ; }
; } ; }
define dso_local i32 @test4-f2(i32 %u) { define dso_local i32 @test4-f2(i32 %u) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@test4-f2 ; TUNIT-LABEL: define {{[^@]+}}@test4-f2
; TUNIT-SAME: (i32 [[U:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i32 [[U:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[CMP:%.*]] = icmp sgt i32 [[U]], -1 ; TUNIT-NEXT: [[CMP:%.*]] = icmp sgt i32 [[U]], -1
; TUNIT-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]] ; TUNIT-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; TUNIT: if.then: ; TUNIT: if.then:
; TUNIT-NEXT: [[ADD:%.*]] = add nuw nsw i32 [[U]], 1 ; TUNIT-NEXT: [[ADD:%.*]] = add nuw nsw i32 [[U]], 1
; TUNIT-NEXT: br label [[RETURN:%.*]] ; TUNIT-NEXT: br label [[RETURN:%.*]]
; TUNIT: if.else: ; TUNIT: if.else:
; TUNIT-NEXT: br label [[RETURN]] ; TUNIT-NEXT: br label [[RETURN]]
; TUNIT: return: ; TUNIT: return:
; TUNIT-NEXT: [[RETVAL_0:%.*]] = phi i32 [ [[ADD]], [[IF_THEN]] ], [ 1, [[IF_ELSE]] ] ; TUNIT-NEXT: [[RETVAL_0:%.*]] = phi i32 [ [[ADD]], [[IF_THEN]] ], [ 1, [[IF_ELSE]] ]
; TUNIT-NEXT: ret i32 [[RETVAL_0]] ; TUNIT-NEXT: ret i32 [[RETVAL_0]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test4-f2 ; CGSCC-LABEL: define {{[^@]+}}@test4-f2
; CGSCC-SAME: (i32 [[U:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i32 [[U:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CMP:%.*]] = icmp sgt i32 [[U]], -1 ; CGSCC-NEXT: [[CMP:%.*]] = icmp sgt i32 [[U]], -1
; CGSCC-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]] ; CGSCC-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; CGSCC: if.then: ; CGSCC: if.then:
; CGSCC-NEXT: [[ADD:%.*]] = add nuw nsw i32 [[U]], 1 ; CGSCC-NEXT: [[ADD:%.*]] = add nuw nsw i32 [[U]], 1
; CGSCC-NEXT: br label [[RETURN:%.*]] ; CGSCC-NEXT: br label [[RETURN:%.*]]
Show All 16 Lines
return: ; preds = %if.else, %if.then return: ; preds = %if.else, %if.then
%retval.0 = phi i32 [ %add, %if.then ], [ 1, %if.else ] %retval.0 = phi i32 [ %add, %if.then ], [ 1, %if.else ]
ret i32 %retval.0 ret i32 %retval.0
} }
define dso_local i32 @test4-g2(i32 %u) { define dso_local i32 @test4-g2(i32 %u) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@test4-g2 ; TUNIT-LABEL: define {{[^@]+}}@test4-g2
; TUNIT-SAME: (i32 [[U:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i32 [[U:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[CALL:%.*]] = tail call i32 @test4-f2(i32 [[U]]) #[[ATTR3]], !range [[RNG3:![0-9]+]] ; TUNIT-NEXT: [[CALL:%.*]] = tail call i32 @test4-f2(i32 [[U]]) #[[ATTR3]], !range [[RNG3:![0-9]+]]
; TUNIT-NEXT: ret i32 [[CALL]] ; TUNIT-NEXT: ret i32 [[CALL]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test4-g2 ; CGSCC-LABEL: define {{[^@]+}}@test4-g2
; CGSCC-SAME: (i32 [[U:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i32 [[U:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CALL:%.*]] = tail call i32 @test4-f2(i32 [[U]]) #[[ATTR5]] ; CGSCC-NEXT: [[CALL:%.*]] = tail call i32 @test4-f2(i32 [[U]]) #[[ATTR5]]
; CGSCC-NEXT: ret i32 [[CALL]] ; CGSCC-NEXT: ret i32 [[CALL]]
; ;
entry: entry:
%call = tail call i32 @test4-f2(i32 %u) %call = tail call i32 @test4-f2(i32 %u)
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
; Examples taken from https://llvm.discourse.group/t/impossible-condition-optimization/461/1 ; Examples taken from https://llvm.discourse.group/t/impossible-condition-optimization/461/1
; ;
; The important part is that we return a constant (false) ; The important part is that we return a constant (false)
; ;
; { ; {
; FIXME: All but the return is not needed anymore ; FIXME: All but the return is not needed anymore
define dso_local zeroext i1 @phi(i32 %arg) { define dso_local zeroext i1 @phi(i32 %arg) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@phi ; TUNIT-LABEL: define {{[^@]+}}@phi
; TUNIT-SAME: (i32 [[ARG:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i32 [[ARG:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: bb: ; TUNIT-NEXT: bb:
; TUNIT-NEXT: [[TMP:%.*]] = icmp sgt i32 [[ARG]], 5 ; TUNIT-NEXT: [[TMP:%.*]] = icmp sgt i32 [[ARG]], 5
; TUNIT-NEXT: br i1 [[TMP]], label [[BB1:%.*]], label [[BB2:%.*]] ; TUNIT-NEXT: br i1 [[TMP]], label [[BB1:%.*]], label [[BB2:%.*]]
; TUNIT: bb1: ; TUNIT: bb1:
; TUNIT-NEXT: br label [[BB3:%.*]] ; TUNIT-NEXT: br label [[BB3:%.*]]
; TUNIT: bb2: ; TUNIT: bb2:
Show All 15 Lines
; TUNIT: bb11: ; TUNIT: bb11:
; TUNIT-NEXT: br label [[BB13:%.*]] ; TUNIT-NEXT: br label [[BB13:%.*]]
; TUNIT: bb12: ; TUNIT: bb12:
; TUNIT-NEXT: br label [[BB13]] ; TUNIT-NEXT: br label [[BB13]]
; TUNIT: bb13: ; TUNIT: bb13:
; TUNIT-NEXT: [[DOT0:%.*]] = phi i1 [ true, [[BB11]] ], [ false, [[BB12]] ] ; TUNIT-NEXT: [[DOT0:%.*]] = phi i1 [ true, [[BB11]] ], [ false, [[BB12]] ]
; TUNIT-NEXT: ret i1 [[DOT0]] ; TUNIT-NEXT: ret i1 [[DOT0]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@phi ; CGSCC-LABEL: define {{[^@]+}}@phi
; CGSCC-SAME: (i32 [[ARG:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i32 [[ARG:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: bb: ; CGSCC-NEXT: bb:
; CGSCC-NEXT: [[TMP:%.*]] = icmp sgt i32 [[ARG]], 5 ; CGSCC-NEXT: [[TMP:%.*]] = icmp sgt i32 [[ARG]], 5
; CGSCC-NEXT: br i1 [[TMP]], label [[BB1:%.*]], label [[BB2:%.*]] ; CGSCC-NEXT: br i1 [[TMP]], label [[BB1:%.*]], label [[BB2:%.*]]
; CGSCC: bb1: ; CGSCC: bb1:
; CGSCC-NEXT: br label [[BB3:%.*]] ; CGSCC-NEXT: br label [[BB3:%.*]]
; CGSCC: bb2: ; CGSCC: bb2:
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Linesbb12: ; preds = %bb9
br label %bb13 br label %bb13
bb13: ; preds = %bb12, %bb11 bb13: ; preds = %bb12, %bb11
%.0 = phi i1 [ true, %bb11 ], [ false, %bb12 ] %.0 = phi i1 [ true, %bb11 ], [ false, %bb12 ]
ret i1 %.0 ret i1 %.0
} }
define dso_local i1 @select(i32 %a) local_unnamed_addr #0 { define dso_local i1 @select(i32 %a) local_unnamed_addr #0 {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@select ; TUNIT-LABEL: define {{[^@]+}}@select
; TUNIT-SAME: (i32 [[A:%.*]]) local_unnamed_addr #[[ATTR1]] { ; TUNIT-SAME: (i32 [[A:%.*]]) local_unnamed_addr #[[ATTR1]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[CMP:%.*]] = icmp sgt i32 [[A]], 5 ; TUNIT-NEXT: [[CMP:%.*]] = icmp sgt i32 [[A]], 5
; TUNIT-NEXT: [[DOT:%.*]] = select i1 [[CMP]], i32 1, i32 2 ; TUNIT-NEXT: [[DOT:%.*]] = select i1 [[CMP]], i32 1, i32 2
; TUNIT-NEXT: [[CMP1:%.*]] = icmp sgt i32 [[A]], 10 ; TUNIT-NEXT: [[CMP1:%.*]] = icmp sgt i32 [[A]], 10
; TUNIT-NEXT: [[Y_0_V:%.*]] = select i1 [[CMP1]], i32 1, i32 2 ; TUNIT-NEXT: [[Y_0_V:%.*]] = select i1 [[CMP1]], i32 1, i32 2
; TUNIT-NEXT: [[Y_0:%.*]] = add nuw nsw i32 [[DOT]], [[Y_0_V]] ; TUNIT-NEXT: [[Y_0:%.*]] = add nuw nsw i32 [[DOT]], [[Y_0_V]]
; TUNIT-NEXT: [[CMP6:%.*]] = icmp eq i32 [[Y_0]], 5 ; TUNIT-NEXT: [[CMP6:%.*]] = icmp eq i32 [[Y_0]], 5
; TUNIT-NEXT: ret i1 [[CMP6]] ; TUNIT-NEXT: ret i1 [[CMP6]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@select ; CGSCC-LABEL: define {{[^@]+}}@select
; CGSCC-SAME: (i32 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] { ; CGSCC-SAME: (i32 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CMP:%.*]] = icmp sgt i32 [[A]], 5 ; CGSCC-NEXT: [[CMP:%.*]] = icmp sgt i32 [[A]], 5
; CGSCC-NEXT: [[DOT:%.*]] = select i1 [[CMP]], i32 1, i32 2 ; CGSCC-NEXT: [[DOT:%.*]] = select i1 [[CMP]], i32 1, i32 2
; CGSCC-NEXT: [[CMP1:%.*]] = icmp sgt i32 [[A]], 10 ; CGSCC-NEXT: [[CMP1:%.*]] = icmp sgt i32 [[A]], 10
; CGSCC-NEXT: [[Y_0_V:%.*]] = select i1 [[CMP1]], i32 1, i32 2 ; CGSCC-NEXT: [[Y_0_V:%.*]] = select i1 [[CMP1]], i32 1, i32 2
; CGSCC-NEXT: [[Y_0:%.*]] = add nuw nsw i32 [[DOT]], [[Y_0_V]] ; CGSCC-NEXT: [[Y_0:%.*]] = add nuw nsw i32 [[DOT]], [[Y_0_V]]
; CGSCC-NEXT: [[CMP6:%.*]] = icmp eq i32 [[Y_0]], 5 ; CGSCC-NEXT: [[CMP6:%.*]] = icmp eq i32 [[Y_0]], 5
; CGSCC-NEXT: ret i1 [[CMP6]] ; CGSCC-NEXT: ret i1 [[CMP6]]
; ;
entry: entry:
%cmp = icmp sgt i32 %a, 5 %cmp = icmp sgt i32 %a, 5
%. = select i1 %cmp, i32 1, i32 2 %. = select i1 %cmp, i32 1, i32 2
%cmp1 = icmp sgt i32 %a, 10 %cmp1 = icmp sgt i32 %a, 10
%y.0.v = select i1 %cmp1, i32 1, i32 2 %y.0.v = select i1 %cmp1, i32 1, i32 2
%y.0 = add nuw nsw i32 %., %y.0.v %y.0 = add nuw nsw i32 %., %y.0.v
%cmp6 = icmp eq i32 %y.0, 5 %cmp6 = icmp eq i32 %y.0, 5
ret i1 %cmp6 ret i1 %cmp6
} }
define dso_local i32 @select_zext(i32 %a) local_unnamed_addr #0 { define dso_local i32 @select_zext(i32 %a) local_unnamed_addr #0 {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@select_zext ; TUNIT-LABEL: define {{[^@]+}}@select_zext
; TUNIT-SAME: (i32 [[A:%.*]]) local_unnamed_addr #[[ATTR1]] { ; TUNIT-SAME: (i32 [[A:%.*]]) local_unnamed_addr #[[ATTR1]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[CMP:%.*]] = icmp sgt i32 [[A]], 5 ; TUNIT-NEXT: [[CMP:%.*]] = icmp sgt i32 [[A]], 5
; TUNIT-NEXT: [[DOT:%.*]] = select i1 [[CMP]], i32 1, i32 2 ; TUNIT-NEXT: [[DOT:%.*]] = select i1 [[CMP]], i32 1, i32 2
; TUNIT-NEXT: [[CMP1:%.*]] = icmp sgt i32 [[A]], 10 ; TUNIT-NEXT: [[CMP1:%.*]] = icmp sgt i32 [[A]], 10
; TUNIT-NEXT: [[Y_0_V:%.*]] = select i1 [[CMP1]], i32 1, i32 2 ; TUNIT-NEXT: [[Y_0_V:%.*]] = select i1 [[CMP1]], i32 1, i32 2
; TUNIT-NEXT: [[Y_0:%.*]] = add nuw nsw i32 [[DOT]], [[Y_0_V]] ; TUNIT-NEXT: [[Y_0:%.*]] = add nuw nsw i32 [[DOT]], [[Y_0_V]]
; TUNIT-NEXT: [[CMP6:%.*]] = icmp eq i32 [[Y_0]], 5 ; TUNIT-NEXT: [[CMP6:%.*]] = icmp eq i32 [[Y_0]], 5
; TUNIT-NEXT: [[DOT13:%.*]] = zext i1 [[CMP6]] to i32 ; TUNIT-NEXT: [[DOT13:%.*]] = zext i1 [[CMP6]] to i32
; TUNIT-NEXT: ret i32 [[DOT13]] ; TUNIT-NEXT: ret i32 [[DOT13]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@select_zext ; CGSCC-LABEL: define {{[^@]+}}@select_zext
; CGSCC-SAME: (i32 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] { ; CGSCC-SAME: (i32 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CMP:%.*]] = icmp sgt i32 [[A]], 5 ; CGSCC-NEXT: [[CMP:%.*]] = icmp sgt i32 [[A]], 5
; CGSCC-NEXT: [[DOT:%.*]] = select i1 [[CMP]], i32 1, i32 2 ; CGSCC-NEXT: [[DOT:%.*]] = select i1 [[CMP]], i32 1, i32 2
; CGSCC-NEXT: [[CMP1:%.*]] = icmp sgt i32 [[A]], 10 ; CGSCC-NEXT: [[CMP1:%.*]] = icmp sgt i32 [[A]], 10
; CGSCC-NEXT: [[Y_0_V:%.*]] = select i1 [[CMP1]], i32 1, i32 2 ; CGSCC-NEXT: [[Y_0_V:%.*]] = select i1 [[CMP1]], i32 1, i32 2
; CGSCC-NEXT: [[Y_0:%.*]] = add nuw nsw i32 [[DOT]], [[Y_0_V]] ; CGSCC-NEXT: [[Y_0:%.*]] = add nuw nsw i32 [[DOT]], [[Y_0_V]]
; CGSCC-NEXT: [[CMP6:%.*]] = icmp eq i32 [[Y_0]], 5 ; CGSCC-NEXT: [[CMP6:%.*]] = icmp eq i32 [[Y_0]], 5
; CGSCC-NEXT: [[DOT13:%.*]] = zext i1 [[CMP6]] to i32 ; CGSCC-NEXT: [[DOT13:%.*]] = zext i1 [[CMP6]] to i32
; CGSCC-NEXT: ret i32 [[DOT13]] ; CGSCC-NEXT: ret i32 [[DOT13]]
; ;
entry: entry:
%cmp = icmp sgt i32 %a, 5 %cmp = icmp sgt i32 %a, 5
%. = select i1 %cmp, i32 1, i32 2 %. = select i1 %cmp, i32 1, i32 2
%cmp1 = icmp sgt i32 %a, 10 %cmp1 = icmp sgt i32 %a, 10
%y.0.v = select i1 %cmp1, i32 1, i32 2 %y.0.v = select i1 %cmp1, i32 1, i32 2
%y.0 = add nuw nsw i32 %., %y.0.v %y.0 = add nuw nsw i32 %., %y.0.v
%cmp6 = icmp eq i32 %y.0, 5 %cmp6 = icmp eq i32 %y.0, 5
%.13 = zext i1 %cmp6 to i32 %.13 = zext i1 %cmp6 to i32
ret i32 %.13 ret i32 %.13
} }
define dso_local i64 @select_int2ptr_bitcast_ptr2int(i32 %a) local_unnamed_addr #0 { define dso_local i64 @select_int2ptr_bitcast_ptr2int(i32 %a) local_unnamed_addr #0 {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@select_int2ptr_bitcast_ptr2int ; TUNIT-LABEL: define {{[^@]+}}@select_int2ptr_bitcast_ptr2int
; TUNIT-SAME: (i32 [[A:%.*]]) local_unnamed_addr #[[ATTR1]] { ; TUNIT-SAME: (i32 [[A:%.*]]) local_unnamed_addr #[[ATTR1]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[CMP:%.*]] = icmp sgt i32 [[A]], 5 ; TUNIT-NEXT: [[CMP:%.*]] = icmp sgt i32 [[A]], 5
; TUNIT-NEXT: [[DOT:%.*]] = select i1 [[CMP]], i32 1, i32 2 ; TUNIT-NEXT: [[DOT:%.*]] = select i1 [[CMP]], i32 1, i32 2
; TUNIT-NEXT: [[CMP1:%.*]] = icmp sgt i32 [[A]], 10 ; TUNIT-NEXT: [[CMP1:%.*]] = icmp sgt i32 [[A]], 10
; TUNIT-NEXT: [[Y_0_V:%.*]] = select i1 [[CMP1]], i32 1, i32 2 ; TUNIT-NEXT: [[Y_0_V:%.*]] = select i1 [[CMP1]], i32 1, i32 2
; TUNIT-NEXT: [[Y_0:%.*]] = add nuw nsw i32 [[DOT]], [[Y_0_V]] ; TUNIT-NEXT: [[Y_0:%.*]] = add nuw nsw i32 [[DOT]], [[Y_0_V]]
; TUNIT-NEXT: [[CMP6:%.*]] = icmp eq i32 [[Y_0]], 5 ; TUNIT-NEXT: [[CMP6:%.*]] = icmp eq i32 [[Y_0]], 5
; TUNIT-NEXT: [[I2P:%.*]] = inttoptr i1 [[CMP6]] to ptr ; TUNIT-NEXT: [[I2P:%.*]] = inttoptr i1 [[CMP6]] to ptr
; TUNIT-NEXT: [[P2I:%.*]] = ptrtoint ptr [[I2P]] to i64 ; TUNIT-NEXT: [[P2I:%.*]] = ptrtoint ptr [[I2P]] to i64
; TUNIT-NEXT: ret i64 [[P2I]] ; TUNIT-NEXT: ret i64 [[P2I]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@select_int2ptr_bitcast_ptr2int ; CGSCC-LABEL: define {{[^@]+}}@select_int2ptr_bitcast_ptr2int
; CGSCC-SAME: (i32 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] { ; CGSCC-SAME: (i32 [[A:%.*]]) local_unnamed_addr #[[ATTR2]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CMP:%.*]] = icmp sgt i32 [[A]], 5 ; CGSCC-NEXT: [[CMP:%.*]] = icmp sgt i32 [[A]], 5
; CGSCC-NEXT: [[DOT:%.*]] = select i1 [[CMP]], i32 1, i32 2 ; CGSCC-NEXT: [[DOT:%.*]] = select i1 [[CMP]], i32 1, i32 2
; CGSCC-NEXT: [[CMP1:%.*]] = icmp sgt i32 [[A]], 10 ; CGSCC-NEXT: [[CMP1:%.*]] = icmp sgt i32 [[A]], 10
; CGSCC-NEXT: [[Y_0_V:%.*]] = select i1 [[CMP1]], i32 1, i32 2 ; CGSCC-NEXT: [[Y_0_V:%.*]] = select i1 [[CMP1]], i32 1, i32 2
; CGSCC-NEXT: [[Y_0:%.*]] = add nuw nsw i32 [[DOT]], [[Y_0_V]] ; CGSCC-NEXT: [[Y_0:%.*]] = add nuw nsw i32 [[DOT]], [[Y_0_V]]
Show All 12 Linesentry:
%i2p = inttoptr i1 %cmp6 to ptr %i2p = inttoptr i1 %cmp6 to ptr
%p2i = ptrtoint ptr %i2p to i64 %p2i = ptrtoint ptr %i2p to i64
ret i64 %p2i ret i64 %p2i
} }
; } ; }
define i1 @f_fcmp(float %a, float %b) { define i1 @f_fcmp(float %a, float %b) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@f_fcmp ; TUNIT-LABEL: define {{[^@]+}}@f_fcmp
; TUNIT-SAME: (float [[A:%.*]], float [[B:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (float [[A:%.*]], float [[B:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: [[R:%.*]] = fcmp uge float [[A]], [[B]] ; TUNIT-NEXT: [[R:%.*]] = fcmp uge float [[A]], [[B]]
; TUNIT-NEXT: [[S:%.*]] = select i1 [[R]], i1 [[R]], i1 false ; TUNIT-NEXT: [[S:%.*]] = select i1 [[R]], i1 [[R]], i1 false
; TUNIT-NEXT: ret i1 [[S]] ; TUNIT-NEXT: ret i1 [[S]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@f_fcmp ; CGSCC-LABEL: define {{[^@]+}}@f_fcmp
; CGSCC-SAME: (float [[A:%.*]], float [[B:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (float [[A:%.*]], float [[B:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[R:%.*]] = fcmp uge float [[A]], [[B]] ; CGSCC-NEXT: [[R:%.*]] = fcmp uge float [[A]], [[B]]
; CGSCC-NEXT: [[S:%.*]] = select i1 [[R]], i1 [[R]], i1 false ; CGSCC-NEXT: [[S:%.*]] = select i1 [[R]], i1 [[R]], i1 false
; CGSCC-NEXT: ret i1 [[S]] ; CGSCC-NEXT: ret i1 [[S]]
; ;
%r = fcmp uge float %a, %b %r = fcmp uge float %a, %b
%s = select i1 %r, i1 %r, i1 0 %s = select i1 %r, i1 %r, i1 0
ret i1 %s ret i1 %s
} }
define i1 @d_fcmp(double %a, double %b) { define i1 @d_fcmp(double %a, double %b) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@d_fcmp ; TUNIT-LABEL: define {{[^@]+}}@d_fcmp
; TUNIT-SAME: (double [[A:%.*]], double [[B:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (double [[A:%.*]], double [[B:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: [[R:%.*]] = fcmp oeq double [[A]], [[B]] ; TUNIT-NEXT: [[R:%.*]] = fcmp oeq double [[A]], [[B]]
; TUNIT-NEXT: [[S:%.*]] = select i1 [[R]], i1 [[R]], i1 false ; TUNIT-NEXT: [[S:%.*]] = select i1 [[R]], i1 [[R]], i1 false
; TUNIT-NEXT: ret i1 [[S]] ; TUNIT-NEXT: ret i1 [[S]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@d_fcmp ; CGSCC-LABEL: define {{[^@]+}}@d_fcmp
; CGSCC-SAME: (double [[A:%.*]], double [[B:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (double [[A:%.*]], double [[B:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[R:%.*]] = fcmp oeq double [[A]], [[B]] ; CGSCC-NEXT: [[R:%.*]] = fcmp oeq double [[A]], [[B]]
; CGSCC-NEXT: [[S:%.*]] = select i1 [[R]], i1 [[R]], i1 false ; CGSCC-NEXT: [[S:%.*]] = select i1 [[R]], i1 [[R]], i1 false
; CGSCC-NEXT: ret i1 [[S]] ; CGSCC-NEXT: ret i1 [[S]]
; ;
%r = fcmp oeq double %a, %b %r = fcmp oeq double %a, %b
%s = select i1 %r, i1 %r, i1 0 %s = select i1 %r, i1 %r, i1 0
ret i1 %s ret i1 %s
} }
define i1 @dp_icmp(ptr %a, ptr %b) { define i1 @dp_icmp(ptr %a, ptr %b) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@dp_icmp ; TUNIT-LABEL: define {{[^@]+}}@dp_icmp
; TUNIT-SAME: (ptr nofree readnone [[A:%.*]], ptr nofree readnone [[B:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (ptr nofree readnone [[A:%.*]], ptr nofree readnone [[B:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: [[R:%.*]] = icmp sge ptr [[A]], [[B]] ; TUNIT-NEXT: [[R:%.*]] = icmp sge ptr [[A]], [[B]]
; TUNIT-NEXT: [[S:%.*]] = select i1 [[R]], i1 [[R]], i1 false ; TUNIT-NEXT: [[S:%.*]] = select i1 [[R]], i1 [[R]], i1 false
; TUNIT-NEXT: ret i1 [[S]] ; TUNIT-NEXT: ret i1 [[S]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@dp_icmp ; CGSCC-LABEL: define {{[^@]+}}@dp_icmp
; CGSCC-SAME: (ptr nofree readnone [[A:%.*]], ptr nofree readnone [[B:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (ptr nofree readnone [[A:%.*]], ptr nofree readnone [[B:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[R:%.*]] = icmp sge ptr [[A]], [[B]] ; CGSCC-NEXT: [[R:%.*]] = icmp sge ptr [[A]], [[B]]
; CGSCC-NEXT: [[S:%.*]] = select i1 [[R]], i1 [[R]], i1 false ; CGSCC-NEXT: [[S:%.*]] = select i1 [[R]], i1 [[R]], i1 false
; CGSCC-NEXT: ret i1 [[S]] ; CGSCC-NEXT: ret i1 [[S]]
; ;
%r = icmp sge ptr %a, %b %r = icmp sge ptr %a, %b
%s = select i1 %r, i1 %r, i1 0 %s = select i1 %r, i1 %r, i1 0
ret i1 %s ret i1 %s
} }
define i1 @ip_icmp(ptr %a, ptr %b) { define i1 @ip_icmp(ptr %a, ptr %b) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@ip_icmp ; TUNIT-LABEL: define {{[^@]+}}@ip_icmp
; TUNIT-SAME: (ptr nofree readnone [[A:%.*]], ptr nofree readnone [[B:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (ptr nofree readnone [[A:%.*]], ptr nofree readnone [[B:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: [[R:%.*]] = icmp ult ptr [[A]], [[B]] ; TUNIT-NEXT: [[R:%.*]] = icmp ult ptr [[A]], [[B]]
; TUNIT-NEXT: [[S:%.*]] = select i1 [[R]], i1 [[R]], i1 false ; TUNIT-NEXT: [[S:%.*]] = select i1 [[R]], i1 [[R]], i1 false
; TUNIT-NEXT: ret i1 [[S]] ; TUNIT-NEXT: ret i1 [[S]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@ip_icmp ; CGSCC-LABEL: define {{[^@]+}}@ip_icmp
; CGSCC-SAME: (ptr nofree readnone [[A:%.*]], ptr nofree readnone [[B:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (ptr nofree readnone [[A:%.*]], ptr nofree readnone [[B:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[R:%.*]] = icmp ult ptr [[A]], [[B]] ; CGSCC-NEXT: [[R:%.*]] = icmp ult ptr [[A]], [[B]]
; CGSCC-NEXT: [[S:%.*]] = select i1 [[R]], i1 [[R]], i1 false ; CGSCC-NEXT: [[S:%.*]] = select i1 [[R]], i1 [[R]], i1 false
; CGSCC-NEXT: ret i1 [[S]] ; CGSCC-NEXT: ret i1 [[S]]
; ;
%r = icmp ult ptr %a, %b %r = icmp ult ptr %a, %b
%s = select i1 %r, i1 %r, i1 0 %s = select i1 %r, i1 %r, i1 0
ret i1 %s ret i1 %s
} }
define i1 @fcmp_caller(float %fa, float %fb, double %da, double %db, ptr %dpa, ptr %dpb, ptr %ipa, ptr %ipb) { define i1 @fcmp_caller(float %fa, float %fb, double %da, double %db, ptr %dpa, ptr %dpb, ptr %ipa, ptr %ipb) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@fcmp_caller ; TUNIT-LABEL: define {{[^@]+}}@fcmp_caller
; TUNIT-SAME: (float [[FA:%.*]], float [[FB:%.*]], double [[DA:%.*]], double [[DB:%.*]], ptr nofree readnone [[DPA:%.*]], ptr nofree readnone [[DPB:%.*]], ptr nofree readnone [[IPA:%.*]], ptr nofree readnone [[IPB:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (float [[FA:%.*]], float [[FB:%.*]], double [[DA:%.*]], double [[DB:%.*]], ptr nofree readnone [[DPA:%.*]], ptr nofree readnone [[DPB:%.*]], ptr nofree readnone [[IPA:%.*]], ptr nofree readnone [[IPB:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: [[R1:%.*]] = call i1 @f_fcmp(float [[FA]], float [[FB]]) #[[ATTR3]] ; TUNIT-NEXT: [[R1:%.*]] = call i1 @f_fcmp(float [[FA]], float [[FB]]) #[[ATTR3]]
; TUNIT-NEXT: [[R2:%.*]] = call i1 @d_fcmp(double [[DA]], double [[DB]]) #[[ATTR3]] ; TUNIT-NEXT: [[R2:%.*]] = call i1 @d_fcmp(double [[DA]], double [[DB]]) #[[ATTR3]]
; TUNIT-NEXT: [[R3:%.*]] = call i1 @dp_icmp(ptr noalias nofree readnone [[DPA]], ptr noalias nofree readnone [[DPB]]) #[[ATTR3]] ; TUNIT-NEXT: [[R3:%.*]] = call i1 @dp_icmp(ptr noalias nofree readnone [[DPA]], ptr noalias nofree readnone [[DPB]]) #[[ATTR3]]
; TUNIT-NEXT: [[R4:%.*]] = call i1 @ip_icmp(ptr noalias nofree readnone [[IPA]], ptr noalias nofree readnone [[IPB]]) #[[ATTR3]] ; TUNIT-NEXT: [[R4:%.*]] = call i1 @ip_icmp(ptr noalias nofree readnone [[IPA]], ptr noalias nofree readnone [[IPB]]) #[[ATTR3]]
; TUNIT-NEXT: [[O1:%.*]] = or i1 [[R1]], [[R2]] ; TUNIT-NEXT: [[O1:%.*]] = or i1 [[R1]], [[R2]]
; TUNIT-NEXT: [[O2:%.*]] = or i1 [[R3]], [[R4]] ; TUNIT-NEXT: [[O2:%.*]] = or i1 [[R3]], [[R4]]
; TUNIT-NEXT: [[O3:%.*]] = or i1 [[O1]], [[O2]] ; TUNIT-NEXT: [[O3:%.*]] = or i1 [[O1]], [[O2]]
; TUNIT-NEXT: ret i1 [[O3]] ; TUNIT-NEXT: ret i1 [[O3]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@fcmp_caller ; CGSCC-LABEL: define {{[^@]+}}@fcmp_caller
; CGSCC-SAME: (float [[FA:%.*]], float [[FB:%.*]], double [[DA:%.*]], double [[DB:%.*]], ptr nofree readnone [[DPA:%.*]], ptr nofree readnone [[DPB:%.*]], ptr nofree readnone [[IPA:%.*]], ptr nofree readnone [[IPB:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (float [[FA:%.*]], float [[FB:%.*]], double [[DA:%.*]], double [[DB:%.*]], ptr nofree readnone [[DPA:%.*]], ptr nofree readnone [[DPB:%.*]], ptr nofree readnone [[IPA:%.*]], ptr nofree readnone [[IPB:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[R1:%.*]] = call i1 @f_fcmp(float [[FA]], float [[FB]]) #[[ATTR5]] ; CGSCC-NEXT: [[R1:%.*]] = call i1 @f_fcmp(float [[FA]], float [[FB]]) #[[ATTR5]]
; CGSCC-NEXT: [[R2:%.*]] = call i1 @d_fcmp(double [[DA]], double [[DB]]) #[[ATTR5]] ; CGSCC-NEXT: [[R2:%.*]] = call i1 @d_fcmp(double [[DA]], double [[DB]]) #[[ATTR5]]
; CGSCC-NEXT: [[R3:%.*]] = call i1 @dp_icmp(ptr noalias nofree readnone [[DPA]], ptr noalias nofree readnone [[DPB]]) #[[ATTR5]] ; CGSCC-NEXT: [[R3:%.*]] = call i1 @dp_icmp(ptr noalias nofree readnone [[DPA]], ptr noalias nofree readnone [[DPB]]) #[[ATTR5]]
; CGSCC-NEXT: [[R4:%.*]] = call i1 @ip_icmp(ptr noalias nofree readnone [[IPA]], ptr noalias nofree readnone [[IPB]]) #[[ATTR5]] ; CGSCC-NEXT: [[R4:%.*]] = call i1 @ip_icmp(ptr noalias nofree readnone [[IPA]], ptr noalias nofree readnone [[IPB]]) #[[ATTR5]]
; CGSCC-NEXT: [[O1:%.*]] = or i1 [[R1]], [[R2]] ; CGSCC-NEXT: [[O1:%.*]] = or i1 [[R1]], [[R2]]
; CGSCC-NEXT: [[O2:%.*]] = or i1 [[R3]], [[R4]] ; CGSCC-NEXT: [[O2:%.*]] = or i1 [[R3]], [[R4]]
; CGSCC-NEXT: [[O3:%.*]] = or i1 [[O1]], [[O2]] ; CGSCC-NEXT: [[O3:%.*]] = or i1 [[O1]], [[O2]]
; CGSCC-NEXT: ret i1 [[O3]] ; CGSCC-NEXT: ret i1 [[O3]]
; ;
%r1 = call i1 @f_fcmp(float %fa, float %fb) %r1 = call i1 @f_fcmp(float %fa, float %fb)
%r2 = call i1 @d_fcmp(double %da, double %db) %r2 = call i1 @d_fcmp(double %da, double %db)
%r3 = call i1 @dp_icmp(ptr %dpa, ptr %dpb) %r3 = call i1 @dp_icmp(ptr %dpa, ptr %dpb)
%r4 = call i1 @ip_icmp(ptr %ipa, ptr %ipb) %r4 = call i1 @ip_icmp(ptr %ipa, ptr %ipb)
%o1 = or i1 %r1, %r2 %o1 = or i1 %r1, %r2
%o2 = or i1 %r3, %r4 %o2 = or i1 %r3, %r4
%o3 = or i1 %o1, %o2 %o3 = or i1 %o1, %o2
ret i1 %o3 ret i1 %o3
} }
define i8 @ret_two() { define i8 @ret_two() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@ret_two ; TUNIT-LABEL: define {{[^@]+}}@ret_two
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret i8 2 ; TUNIT-NEXT: ret i8 2
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@ret_two ; CGSCC-LABEL: define {{[^@]+}}@ret_two
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: ret i8 2 ; CGSCC-NEXT: ret i8 2
; ;
ret i8 2 ret i8 2
} }
define i8 @ret_undef() { define i8 @ret_undef() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@ret_undef ; TUNIT-LABEL: define {{[^@]+}}@ret_undef
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret i8 undef ; TUNIT-NEXT: ret i8 undef
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@ret_undef ; CGSCC-LABEL: define {{[^@]+}}@ret_undef
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: ret i8 undef ; CGSCC-NEXT: ret i8 undef
; ;
ret i8 undef ret i8 undef
} }
; Verify we collapse undef to a value and return something non-undef here. ; Verify we collapse undef to a value and return something non-undef here.
define i8 @undef_collapse_1() { define i8 @undef_collapse_1() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@undef_collapse_1 ; TUNIT-LABEL: define {{[^@]+}}@undef_collapse_1
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret i8 0 ; TUNIT-NEXT: ret i8 0
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@undef_collapse_1 ; CGSCC-LABEL: define {{[^@]+}}@undef_collapse_1
; CGSCC-SAME: () #[[ATTR3]] { ; CGSCC-SAME: () #[[ATTR3]] {
; CGSCC-NEXT: [[C:%.*]] = call i8 @ret_undef() #[[ATTR5]] ; CGSCC-NEXT: [[C:%.*]] = call i8 @ret_undef() #[[ATTR5]]
; CGSCC-NEXT: [[S:%.*]] = shl i8 [[C]], 2 ; CGSCC-NEXT: [[S:%.*]] = shl i8 [[C]], 2
; CGSCC-NEXT: ret i8 [[S]] ; CGSCC-NEXT: ret i8 [[S]]
; ;
%c = call i8 @ret_undef() %c = call i8 @ret_undef()
%s = shl i8 %c, 2 %s = shl i8 %c, 2
ret i8 %s ret i8 %s
} }
; Verify we collapse undef to a value and return something non-undef here. ; Verify we collapse undef to a value and return something non-undef here.
define i8 @undef_collapse_2() { define i8 @undef_collapse_2() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@undef_collapse_2 ; TUNIT-LABEL: define {{[^@]+}}@undef_collapse_2
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret i8 0 ; TUNIT-NEXT: ret i8 0
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@undef_collapse_2 ; CGSCC-LABEL: define {{[^@]+}}@undef_collapse_2
; CGSCC-SAME: () #[[ATTR3]] { ; CGSCC-SAME: () #[[ATTR3]] {
; CGSCC-NEXT: [[C:%.*]] = call i8 @ret_two() #[[ATTR5]] ; CGSCC-NEXT: [[C:%.*]] = call i8 @ret_two() #[[ATTR5]]
; CGSCC-NEXT: [[S:%.*]] = shl i8 undef, [[C]] ; CGSCC-NEXT: [[S:%.*]] = shl i8 undef, [[C]]
; CGSCC-NEXT: ret i8 [[S]] ; CGSCC-NEXT: ret i8 [[S]]
; ;
%c = call i8 @ret_two() %c = call i8 @ret_two()
%s = shl i8 undef, %c %s = shl i8 undef, %c
ret i8 %s ret i8 %s
} }
define i8 @undef_collapse_caller() { define i8 @undef_collapse_caller() {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@undef_collapse_caller ; TUNIT-LABEL: define {{[^@]+}}@undef_collapse_caller
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret i8 0 ; TUNIT-NEXT: ret i8 0
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@undef_collapse_caller ; CGSCC-LABEL: define {{[^@]+}}@undef_collapse_caller
; CGSCC-SAME: () #[[ATTR3]] { ; CGSCC-SAME: () #[[ATTR3]] {
; CGSCC-NEXT: [[C1:%.*]] = call i8 @undef_collapse_1() #[[ATTR5]] ; CGSCC-NEXT: [[C1:%.*]] = call i8 @undef_collapse_1() #[[ATTR5]]
; CGSCC-NEXT: [[C2:%.*]] = call i8 @undef_collapse_2() #[[ATTR5]] ; CGSCC-NEXT: [[C2:%.*]] = call i8 @undef_collapse_2() #[[ATTR5]]
; CGSCC-NEXT: [[A:%.*]] = add i8 [[C1]], [[C2]] ; CGSCC-NEXT: [[A:%.*]] = add i8 [[C1]], [[C2]]
; CGSCC-NEXT: ret i8 [[A]] ; CGSCC-NEXT: ret i8 [[A]]
; ;
%c1 = call i8 @undef_collapse_1() %c1 = call i8 @undef_collapse_1()
%c2 = call i8 @undef_collapse_2() %c2 = call i8 @undef_collapse_2()
%a = add i8 %c1, %c2 %a = add i8 %c1, %c2
ret i8 %a ret i8 %a
} }
define i32 @ret1or2(i1 %c) { define i32 @ret1or2(i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@ret1or2 ; TUNIT-LABEL: define {{[^@]+}}@ret1or2
; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: [[S:%.*]] = select i1 [[C]], i32 1, i32 2 ; TUNIT-NEXT: [[S:%.*]] = select i1 [[C]], i32 1, i32 2
; TUNIT-NEXT: ret i32 [[S]] ; TUNIT-NEXT: ret i32 [[S]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@ret1or2 ; CGSCC-LABEL: define {{[^@]+}}@ret1or2
; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[S:%.*]] = select i1 [[C]], i32 1, i32 2 ; CGSCC-NEXT: [[S:%.*]] = select i1 [[C]], i32 1, i32 2
; CGSCC-NEXT: ret i32 [[S]] ; CGSCC-NEXT: ret i32 [[S]]
; ;
%s = select i1 %c, i32 1, i32 2 %s = select i1 %c, i32 1, i32 2
ret i32 %s ret i32 %s
} }
define i1 @callee_range_1(i1 %c1, i1 %c2, i1 %c3) { define i1 @callee_range_1(i1 %c1, i1 %c2, i1 %c3) {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@callee_range_1 ; TUNIT-LABEL: define {{[^@]+}}@callee_range_1
; TUNIT-SAME: (i1 [[C1:%.*]], i1 [[C2:%.*]], i1 [[C3:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i1 [[C1:%.*]], i1 [[C2:%.*]], i1 [[C3:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: [[R1:%.*]] = call i32 @ret1or2(i1 [[C1]]) #[[ATTR3]] ; TUNIT-NEXT: [[R1:%.*]] = call i32 @ret1or2(i1 [[C1]]) #[[ATTR3]]
; TUNIT-NEXT: [[R2:%.*]] = call i32 @ret1or2(i1 [[C2]]) #[[ATTR3]] ; TUNIT-NEXT: [[R2:%.*]] = call i32 @ret1or2(i1 [[C2]]) #[[ATTR3]]
; TUNIT-NEXT: [[INDIRECTION:%.*]] = select i1 [[C3]], i32 [[R1]], i32 [[R2]] ; TUNIT-NEXT: [[INDIRECTION:%.*]] = select i1 [[C3]], i32 [[R1]], i32 [[R2]]
; TUNIT-NEXT: [[A:%.*]] = add i32 [[R1]], [[INDIRECTION]] ; TUNIT-NEXT: [[A:%.*]] = add i32 [[R1]], [[INDIRECTION]]
; TUNIT-NEXT: [[I1:%.*]] = icmp sle i32 [[A]], 4 ; TUNIT-NEXT: [[I1:%.*]] = icmp sle i32 [[A]], 4
; TUNIT-NEXT: [[I2:%.*]] = icmp sge i32 [[A]], 2 ; TUNIT-NEXT: [[I2:%.*]] = icmp sge i32 [[A]], 2
; TUNIT-NEXT: [[F:%.*]] = and i1 [[I1]], [[I2]] ; TUNIT-NEXT: [[F:%.*]] = and i1 [[I1]], [[I2]]
; TUNIT-NEXT: ret i1 [[F]] ; TUNIT-NEXT: ret i1 [[F]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@callee_range_1 ; CGSCC-LABEL: define {{[^@]+}}@callee_range_1
; CGSCC-SAME: (i1 [[C1:%.*]], i1 [[C2:%.*]], i1 [[C3:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i1 [[C1:%.*]], i1 [[C2:%.*]], i1 [[C3:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[R1:%.*]] = call i32 @ret1or2(i1 [[C1]]) #[[ATTR5]] ; CGSCC-NEXT: [[R1:%.*]] = call i32 @ret1or2(i1 [[C1]]) #[[ATTR5]]
; CGSCC-NEXT: [[R2:%.*]] = call i32 @ret1or2(i1 [[C2]]) #[[ATTR5]] ; CGSCC-NEXT: [[R2:%.*]] = call i32 @ret1or2(i1 [[C2]]) #[[ATTR5]]
; CGSCC-NEXT: [[INDIRECTION:%.*]] = select i1 [[C3]], i32 [[R1]], i32 [[R2]] ; CGSCC-NEXT: [[INDIRECTION:%.*]] = select i1 [[C3]], i32 [[R1]], i32 [[R2]]
; CGSCC-NEXT: [[A:%.*]] = add i32 [[R1]], [[INDIRECTION]] ; CGSCC-NEXT: [[A:%.*]] = add i32 [[R1]], [[INDIRECTION]]
; CGSCC-NEXT: [[I1:%.*]] = icmp sle i32 [[A]], 4 ; CGSCC-NEXT: [[I1:%.*]] = icmp sle i32 [[A]], 4
; CGSCC-NEXT: [[I2:%.*]] = icmp sge i32 [[A]], 2 ; CGSCC-NEXT: [[I2:%.*]] = icmp sge i32 [[A]], 2
; CGSCC-NEXT: [[F:%.*]] = and i1 [[I1]], [[I2]] ; CGSCC-NEXT: [[F:%.*]] = and i1 [[I1]], [[I2]]
; CGSCC-NEXT: ret i1 [[F]] ; CGSCC-NEXT: ret i1 [[F]]
; ;
%r1 = call i32 @ret1or2(i1 %c1) %r1 = call i32 @ret1or2(i1 %c1)
%r2 = call i32 @ret1or2(i1 %c2) %r2 = call i32 @ret1or2(i1 %c2)
%indirection = select i1 %c3, i32 %r1, i32 %r2 %indirection = select i1 %c3, i32 %r1, i32 %r2
%a = add i32 %r1, %indirection %a = add i32 %r1, %indirection
%i1 = icmp sle i32 %a, 4 %i1 = icmp sle i32 %a, 4
%i2 = icmp sge i32 %a, 2 %i2 = icmp sge i32 %a, 2
%f = and i1 %i1, %i2 %f = and i1 %i1, %i2
ret i1 %f ret i1 %f
} }
define i1 @callee_range_2(i1 %c1, i1 %c2) { define i1 @callee_range_2(i1 %c1, i1 %c2) {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@callee_range_2 ; TUNIT-LABEL: define {{[^@]+}}@callee_range_2
; TUNIT-SAME: (i1 [[C1:%.*]], i1 [[C2:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i1 [[C1:%.*]], i1 [[C2:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: [[R1:%.*]] = call i32 @ret1or2(i1 [[C1]]) #[[ATTR3]] ; TUNIT-NEXT: [[R1:%.*]] = call i32 @ret1or2(i1 [[C1]]) #[[ATTR3]]
; TUNIT-NEXT: [[R2:%.*]] = call i32 @ret1or2(i1 [[C2]]) #[[ATTR3]] ; TUNIT-NEXT: [[R2:%.*]] = call i32 @ret1or2(i1 [[C2]]) #[[ATTR3]]
; TUNIT-NEXT: [[A:%.*]] = add i32 [[R1]], [[R2]] ; TUNIT-NEXT: [[A:%.*]] = add i32 [[R1]], [[R2]]
; TUNIT-NEXT: [[I1:%.*]] = icmp sle i32 [[A]], 3 ; TUNIT-NEXT: [[I1:%.*]] = icmp sle i32 [[A]], 3
; TUNIT-NEXT: [[I2:%.*]] = icmp sge i32 [[A]], 2 ; TUNIT-NEXT: [[I2:%.*]] = icmp sge i32 [[A]], 2
; TUNIT-NEXT: [[F:%.*]] = and i1 [[I1]], [[I2]] ; TUNIT-NEXT: [[F:%.*]] = and i1 [[I1]], [[I2]]
; TUNIT-NEXT: ret i1 [[F]] ; TUNIT-NEXT: ret i1 [[F]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@callee_range_2 ; CGSCC-LABEL: define {{[^@]+}}@callee_range_2
; CGSCC-SAME: (i1 [[C1:%.*]], i1 [[C2:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i1 [[C1:%.*]], i1 [[C2:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[R1:%.*]] = call i32 @ret1or2(i1 [[C1]]) #[[ATTR5]] ; CGSCC-NEXT: [[R1:%.*]] = call i32 @ret1or2(i1 [[C1]]) #[[ATTR5]]
; CGSCC-NEXT: [[R2:%.*]] = call i32 @ret1or2(i1 [[C2]]) #[[ATTR5]] ; CGSCC-NEXT: [[R2:%.*]] = call i32 @ret1or2(i1 [[C2]]) #[[ATTR5]]
; CGSCC-NEXT: [[A:%.*]] = add i32 [[R1]], [[R2]] ; CGSCC-NEXT: [[A:%.*]] = add i32 [[R1]], [[R2]]
; CGSCC-NEXT: [[I1:%.*]] = icmp sle i32 [[A]], 3 ; CGSCC-NEXT: [[I1:%.*]] = icmp sle i32 [[A]], 3
; CGSCC-NEXT: [[I2:%.*]] = icmp sge i32 [[A]], 2 ; CGSCC-NEXT: [[I2:%.*]] = icmp sge i32 [[A]], 2
; CGSCC-NEXT: [[F:%.*]] = and i1 [[I1]], [[I2]] ; CGSCC-NEXT: [[F:%.*]] = and i1 [[I1]], [[I2]]
; CGSCC-NEXT: ret i1 [[F]] ; CGSCC-NEXT: ret i1 [[F]]
; ;
%r1 = call i32 @ret1or2(i1 %c1) %r1 = call i32 @ret1or2(i1 %c1)
%r2 = call i32 @ret1or2(i1 %c2) %r2 = call i32 @ret1or2(i1 %c2)
%a = add i32 %r1, %r2 %a = add i32 %r1, %r2
%i1 = icmp sle i32 %a, 3 %i1 = icmp sle i32 %a, 3
%i2 = icmp sge i32 %a, 2 %i2 = icmp sge i32 %a, 2
%f = and i1 %i1, %i2 %f = and i1 %i1, %i2
ret i1 %f ret i1 %f
} }
define i32 @ret100() { define i32 @ret100() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@ret100 ; TUNIT-LABEL: define {{[^@]+}}@ret100
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret i32 100 ; TUNIT-NEXT: ret i32 100
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@ret100 ; CGSCC-LABEL: define {{[^@]+}}@ret100
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: ret i32 100 ; CGSCC-NEXT: ret i32 100
; ;
ret i32 100 ret i32 100
} }
define i1 @ctx_adjustment(i32 %V) { define i1 @ctx_adjustment(i32 %V) {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@ctx_adjustment ; TUNIT-LABEL: define {{[^@]+}}@ctx_adjustment
; TUNIT-SAME: (i32 [[V:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i32 [[V:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: [[C1:%.*]] = icmp sge i32 [[V]], 100 ; TUNIT-NEXT: [[C1:%.*]] = icmp sge i32 [[V]], 100
; TUNIT-NEXT: br i1 [[C1]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]] ; TUNIT-NEXT: br i1 [[C1]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]]
; TUNIT: if.true: ; TUNIT: if.true:
; TUNIT-NEXT: br label [[END:%.*]] ; TUNIT-NEXT: br label [[END:%.*]]
; TUNIT: if.false: ; TUNIT: if.false:
; TUNIT-NEXT: br label [[END]] ; TUNIT-NEXT: br label [[END]]
; TUNIT: end: ; TUNIT: end:
; TUNIT-NEXT: [[PHI:%.*]] = phi i32 [ [[V]], [[IF_TRUE]] ], [ 100, [[IF_FALSE]] ] ; TUNIT-NEXT: [[PHI:%.*]] = phi i32 [ [[V]], [[IF_TRUE]] ], [ 100, [[IF_FALSE]] ]
; TUNIT-NEXT: [[C2:%.*]] = icmp sge i32 [[PHI]], 100 ; TUNIT-NEXT: [[C2:%.*]] = icmp sge i32 [[PHI]], 100
; TUNIT-NEXT: ret i1 [[C2]] ; TUNIT-NEXT: ret i1 [[C2]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@ctx_adjustment ; CGSCC-LABEL: define {{[^@]+}}@ctx_adjustment
; CGSCC-SAME: (i32 [[V:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i32 [[V:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[C1:%.*]] = icmp sge i32 [[V]], 100 ; CGSCC-NEXT: [[C1:%.*]] = icmp sge i32 [[V]], 100
; CGSCC-NEXT: br i1 [[C1]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]] ; CGSCC-NEXT: br i1 [[C1]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]]
; CGSCC: if.true: ; CGSCC: if.true:
; CGSCC-NEXT: br label [[END:%.*]] ; CGSCC-NEXT: br label [[END:%.*]]
; CGSCC: if.false: ; CGSCC: if.false:
; CGSCC-NEXT: [[CALL:%.*]] = call i32 @ret100() #[[ATTR5]] ; CGSCC-NEXT: [[CALL:%.*]] = call i32 @ret100() #[[ATTR5]]
Show All 13 Lines
end: end:
%phi = phi i32 [ %V, %if.true ], [ %call, %if.false ] %phi = phi i32 [ %V, %if.true ], [ %call, %if.false ]
%c2 = icmp sge i32 %phi, 100 %c2 = icmp sge i32 %phi, 100
ret i1 %c2 ret i1 %c2
} }
define i32 @func(i1 %c) { define i32 @func(i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@func ; TUNIT-LABEL: define {{[^@]+}}@func
; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: [[RET:%.*]] = select i1 [[C]], i32 0, i32 1 ; TUNIT-NEXT: [[RET:%.*]] = select i1 [[C]], i32 0, i32 1
; TUNIT-NEXT: ret i32 [[RET]] ; TUNIT-NEXT: ret i32 [[RET]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@func ; CGSCC-LABEL: define {{[^@]+}}@func
; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[RET:%.*]] = select i1 [[C]], i32 0, i32 1 ; CGSCC-NEXT: [[RET:%.*]] = select i1 [[C]], i32 0, i32 1
; CGSCC-NEXT: ret i32 [[RET]] ; CGSCC-NEXT: ret i32 [[RET]]
; ;
%ret = select i1 %c, i32 0, i32 1 %ret = select i1 %c, i32 0, i32 1
ret i32 %ret ret i32 %ret
} }
define i32 @simplify_callsite_argument(i1 %d) { define i32 @simplify_callsite_argument(i1 %d) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@simplify_callsite_argument ; TUNIT-LABEL: define {{[^@]+}}@simplify_callsite_argument
; TUNIT-SAME: (i1 [[D:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i1 [[D:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: [[C:%.*]] = select i1 [[D]], i1 true, i1 false ; TUNIT-NEXT: [[C:%.*]] = select i1 [[D]], i1 true, i1 false
; TUNIT-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: [[RET1:%.*]] = call i32 @func(i1 noundef [[C]]) #[[ATTR3]] ; TUNIT-NEXT: [[RET1:%.*]] = call i32 @func(i1 noundef [[C]]) #[[ATTR3]]
; TUNIT-NEXT: ret i32 [[RET1]] ; TUNIT-NEXT: ret i32 [[RET1]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: [[RET2:%.*]] = call i32 @func(i1 noundef false) #[[ATTR3]] ; TUNIT-NEXT: [[RET2:%.*]] = call i32 @func(i1 noundef false) #[[ATTR3]]
; TUNIT-NEXT: ret i32 [[RET2]] ; TUNIT-NEXT: ret i32 [[RET2]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@simplify_callsite_argument ; CGSCC-LABEL: define {{[^@]+}}@simplify_callsite_argument
; CGSCC-SAME: (i1 [[D:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i1 [[D:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[C:%.*]] = select i1 [[D]], i1 true, i1 false ; CGSCC-NEXT: [[C:%.*]] = select i1 [[D]], i1 true, i1 false
; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: [[RET1:%.*]] = call noundef i32 @func(i1 noundef [[C]]) #[[ATTR5]] ; CGSCC-NEXT: [[RET1:%.*]] = call noundef i32 @func(i1 noundef [[C]]) #[[ATTR5]]
; CGSCC-NEXT: ret i32 [[RET1]] ; CGSCC-NEXT: ret i32 [[RET1]]
; CGSCC: f: ; CGSCC: f:
; CGSCC-NEXT: [[RET2:%.*]] = call noundef i32 @func(i1 noundef false) #[[ATTR5]] ; CGSCC-NEXT: [[RET2:%.*]] = call noundef i32 @func(i1 noundef false) #[[ATTR5]]
; CGSCC-NEXT: ret i32 [[RET2]] ; CGSCC-NEXT: ret i32 [[RET2]]
; ;
%c = select i1 %d, i1 true, i1 false %c = select i1 %d, i1 true, i1 false
br i1 %c, label %t, label %f br i1 %c, label %t, label %f
t: t:
%ret1 = call i32 @func(i1 %c) %ret1 = call i32 @func(i1 %c)
ret i32 %ret1 ret i32 %ret1
f: f:
%ret2 = call i32 @func(i1 false) %ret2 = call i32 @func(i1 false)
ret i32 %ret2 ret i32 %ret2
} }
define internal i32 @less_than_65536(i32 %arg) { define internal i32 @less_than_65536(i32 %arg) {
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@less_than_65536 ; CGSCC-LABEL: define {{[^@]+}}@less_than_65536
; CGSCC-SAME: (i32 [[ARG:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i32 [[ARG:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[SHRINKED:%.*]] = udiv i32 [[ARG]], 65536 ; CGSCC-NEXT: [[SHRINKED:%.*]] = udiv i32 [[ARG]], 65536
; CGSCC-NEXT: ret i32 [[SHRINKED]] ; CGSCC-NEXT: ret i32 [[SHRINKED]]
; ;
%shrinked = udiv i32 %arg, 65536 %shrinked = udiv i32 %arg, 65536
ret i32 %shrinked ret i32 %shrinked
} }
define internal i1 @is_less_than_65536(i32 %arg) { define internal i1 @is_less_than_65536(i32 %arg) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@is_less_than_65536 ; CGSCC-LABEL: define {{[^@]+}}@is_less_than_65536
; CGSCC-SAME: (i32 [[ARG:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i32 [[ARG:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[CMP:%.*]] = icmp ult i32 [[ARG]], 65536 ; CGSCC-NEXT: [[CMP:%.*]] = icmp ult i32 [[ARG]], 65536
; CGSCC-NEXT: ret i1 [[CMP]] ; CGSCC-NEXT: ret i1 [[CMP]]
; ;
%cmp = icmp ult i32 %arg, 65536 %cmp = icmp ult i32 %arg, 65536
ret i1 %cmp ret i1 %cmp
} }
define i1 @check_divided_range(i32 %arg) { define i1 @check_divided_range(i32 %arg) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@check_divided_range ; TUNIT-LABEL: define {{[^@]+}}@check_divided_range
; TUNIT-SAME: (i32 [[ARG:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i32 [[ARG:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: ret i1 true ; TUNIT-NEXT: ret i1 true
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@check_divided_range ; CGSCC-LABEL: define {{[^@]+}}@check_divided_range
; CGSCC-SAME: (i32 [[ARG:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i32 [[ARG:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[CSRET1:%.*]] = call i32 @less_than_65536(i32 noundef 0) #[[ATTR5]] ; CGSCC-NEXT: [[CSRET1:%.*]] = call i32 @less_than_65536(i32 noundef 0) #[[ATTR5]]
; CGSCC-NEXT: [[CSRET2:%.*]] = call i32 @less_than_65536(i32 [[ARG]]) #[[ATTR5]] ; CGSCC-NEXT: [[CSRET2:%.*]] = call i32 @less_than_65536(i32 [[ARG]]) #[[ATTR5]]
; CGSCC-NEXT: [[TRUE1:%.*]] = call i1 @is_less_than_65536(i32 [[CSRET1]]) #[[ATTR5]] ; CGSCC-NEXT: [[TRUE1:%.*]] = call i1 @is_less_than_65536(i32 [[CSRET1]]) #[[ATTR5]]
; CGSCC-NEXT: [[TRUE2:%.*]] = call i1 @is_less_than_65536(i32 [[CSRET2]]) #[[ATTR5]] ; CGSCC-NEXT: [[TRUE2:%.*]] = call i1 @is_less_than_65536(i32 [[CSRET2]]) #[[ATTR5]]
; CGSCC-NEXT: [[RET:%.*]] = and i1 [[TRUE1]], [[TRUE2]] ; CGSCC-NEXT: [[RET:%.*]] = and i1 [[TRUE1]], [[TRUE2]]
; CGSCC-NEXT: ret i1 [[RET]] ; CGSCC-NEXT: ret i1 [[RET]]
; ;
%csret1 = call i32 @less_than_65536(i32 0) %csret1 = call i32 @less_than_65536(i32 0)
%csret2 = call i32 @less_than_65536(i32 %arg) %csret2 = call i32 @less_than_65536(i32 %arg)
%true1 = call i1 @is_less_than_65536(i32 %csret1) %true1 = call i1 @is_less_than_65536(i32 %csret1)
%true2 = call i1 @is_less_than_65536(i32 %csret2) %true2 = call i1 @is_less_than_65536(i32 %csret2)
%ret = and i1 %true1, %true2 %ret = and i1 %true1, %true2
ret i1 %ret ret i1 %ret
} }
define internal i32 @cast_and_return(i1 %c) { define internal i32 @cast_and_return(i1 %c) {
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@cast_and_return ; CGSCC-LABEL: define {{[^@]+}}@cast_and_return
; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[RET:%.*]] = zext i1 [[C]] to i32 ; CGSCC-NEXT: [[RET:%.*]] = zext i1 [[C]] to i32
; CGSCC-NEXT: ret i32 [[RET]] ; CGSCC-NEXT: ret i32 [[RET]]
; ;
%ret = zext i1 %c to i32 %ret = zext i1 %c to i32
ret i32 %ret ret i32 %ret
} }
define internal i1 @is_less_than_3(i32 %c) { define internal i1 @is_less_than_3(i32 %c) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@is_less_than_3 ; CGSCC-LABEL: define {{[^@]+}}@is_less_than_3
; CGSCC-SAME: (i32 [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i32 [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[CMP:%.*]] = icmp slt i32 [[C]], 3 ; CGSCC-NEXT: [[CMP:%.*]] = icmp slt i32 [[C]], 3
; CGSCC-NEXT: ret i1 [[CMP]] ; CGSCC-NEXT: ret i1 [[CMP]]
; ;
%cmp = icmp slt i32 %c, 3 %cmp = icmp slt i32 %c, 3
ret i1 %cmp ret i1 %cmp
} }
define i1 @check_casted_range(i1 %c) { define i1 @check_casted_range(i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@check_casted_range ; TUNIT-LABEL: define {{[^@]+}}@check_casted_range
; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: ret i1 true ; TUNIT-NEXT: ret i1 true
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@check_casted_range ; CGSCC-LABEL: define {{[^@]+}}@check_casted_range
; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[CSRET1:%.*]] = call i32 @cast_and_return(i1 noundef true) #[[ATTR5]] ; CGSCC-NEXT: [[CSRET1:%.*]] = call i32 @cast_and_return(i1 noundef true) #[[ATTR5]]
; CGSCC-NEXT: [[CSRET2:%.*]] = call i32 @cast_and_return(i1 [[C]]) #[[ATTR5]] ; CGSCC-NEXT: [[CSRET2:%.*]] = call i32 @cast_and_return(i1 [[C]]) #[[ATTR5]]
; CGSCC-NEXT: [[ADD:%.*]] = add i32 [[CSRET1]], [[CSRET2]] ; CGSCC-NEXT: [[ADD:%.*]] = add i32 [[CSRET1]], [[CSRET2]]
; CGSCC-NEXT: [[RET:%.*]] = call i1 @is_less_than_3(i32 [[ADD]]) #[[ATTR5]] ; CGSCC-NEXT: [[RET:%.*]] = call i1 @is_less_than_3(i32 [[ADD]]) #[[ATTR5]]
; CGSCC-NEXT: ret i1 [[RET]] ; CGSCC-NEXT: ret i1 [[RET]]
; ;
%csret1 = call i32 @cast_and_return(i1 true) %csret1 = call i32 @cast_and_return(i1 true)
%csret2 = call i32 @cast_and_return(i1 %c) %csret2 = call i32 @cast_and_return(i1 %c)
%add = add i32 %csret1, %csret2 %add = add i32 %csret1, %csret2
%ret = call i1 @is_less_than_3(i32 %add) %ret = call i1 @is_less_than_3(i32 %add)
ret i1 %ret ret i1 %ret
} }
define internal i32 @less_than_100_1(i32 %c) { define internal i32 @less_than_100_1(i32 %c) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@less_than_100_1 ; CGSCC-LABEL: define {{[^@]+}}@less_than_100_1
; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: switch i32 [[C]], label [[OTHERWISE:%.*]] [ ; CGSCC-NEXT: switch i32 [[C]], label [[OTHERWISE:%.*]] [
; CGSCC-NEXT: i32 0, label [[ONZERO:%.*]] ; CGSCC-NEXT: i32 0, label [[ONZERO:%.*]]
; CGSCC-NEXT: i32 1, label [[ONONE:%.*]] ; CGSCC-NEXT: i32 1, label [[ONONE:%.*]]
; CGSCC-NEXT: i32 2, label [[ONTWO:%.*]] ; CGSCC-NEXT: i32 2, label [[ONTWO:%.*]]
; CGSCC-NEXT: i32 3, label [[ONTHREE:%.*]] ; CGSCC-NEXT: i32 3, label [[ONTHREE:%.*]]
; CGSCC-NEXT: i32 4, label [[ONFOUR:%.*]] ; CGSCC-NEXT: i32 4, label [[ONFOUR:%.*]]
Show All 38 Linesonfive:
ret i32 5 ret i32 5
onsix: onsix:
ret i32 6 ret i32 6
otherwise: otherwise:
ret i32 99 ret i32 99
} }
define internal i1 @is_less_than_100_1(i32 %c) { define internal i1 @is_less_than_100_1(i32 %c) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@is_less_than_100_1 ; CGSCC-LABEL: define {{[^@]+}}@is_less_than_100_1
; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[CMP:%.*]] = icmp slt i32 [[C]], 100 ; CGSCC-NEXT: [[CMP:%.*]] = icmp slt i32 [[C]], 100
; CGSCC-NEXT: ret i1 [[CMP]] ; CGSCC-NEXT: ret i1 [[CMP]]
; ;
%cmp = icmp slt i32 %c, 100 %cmp = icmp slt i32 %c, 100
ret i1 %cmp ret i1 %cmp
} }
define i1 @propagate_range1(i32 %c){ define i1 @propagate_range1(i32 %c){
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@propagate_range1 ; TUNIT-LABEL: define {{[^@]+}}@propagate_range1
; TUNIT-SAME: (i32 [[C:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i32 [[C:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: ret i1 true ; TUNIT-NEXT: ret i1 true
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@propagate_range1 ; CGSCC-LABEL: define {{[^@]+}}@propagate_range1
; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[CSRET:%.*]] = call i32 @less_than_100_1(i32 noundef [[C]]) #[[ATTR5]] ; CGSCC-NEXT: [[CSRET:%.*]] = call i32 @less_than_100_1(i32 noundef [[C]]) #[[ATTR5]]
; CGSCC-NEXT: [[TRUE:%.*]] = call i1 @is_less_than_100_1(i32 noundef [[CSRET]]) #[[ATTR5]] ; CGSCC-NEXT: [[TRUE:%.*]] = call i1 @is_less_than_100_1(i32 noundef [[CSRET]]) #[[ATTR5]]
; CGSCC-NEXT: ret i1 [[TRUE]] ; CGSCC-NEXT: ret i1 [[TRUE]]
; ;
%csret = call i32 @less_than_100_1(i32 %c) %csret = call i32 @less_than_100_1(i32 %c)
%true = call i1 @is_less_than_100_1(i32 %csret) %true = call i1 @is_less_than_100_1(i32 %csret)
ret i1 %true ret i1 %true
} }
define internal i32 @less_than_100_2(i32 %c) { define internal i32 @less_than_100_2(i32 %c) {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@less_than_100_2 ; TUNIT-LABEL: define {{[^@]+}}@less_than_100_2
; TUNIT-SAME: (i32 noundef [[C:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i32 noundef [[C:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: switch i32 [[C]], label [[OTHERWISE:%.*]] [ ; TUNIT-NEXT: switch i32 [[C]], label [[OTHERWISE:%.*]] [
; TUNIT-NEXT: i32 0, label [[ONZERO:%.*]] ; TUNIT-NEXT: i32 0, label [[ONZERO:%.*]]
; TUNIT-NEXT: i32 1, label [[ONONE:%.*]] ; TUNIT-NEXT: i32 1, label [[ONONE:%.*]]
; TUNIT-NEXT: i32 2, label [[ONTWO:%.*]] ; TUNIT-NEXT: i32 2, label [[ONTWO:%.*]]
; TUNIT-NEXT: i32 3, label [[ONTHREE:%.*]] ; TUNIT-NEXT: i32 3, label [[ONTHREE:%.*]]
; TUNIT-NEXT: i32 4, label [[ONFOUR:%.*]] ; TUNIT-NEXT: i32 4, label [[ONFOUR:%.*]]
Show All 12 Lines
; TUNIT-NEXT: ret i32 4 ; TUNIT-NEXT: ret i32 4
; TUNIT: onfive: ; TUNIT: onfive:
; TUNIT-NEXT: ret i32 5 ; TUNIT-NEXT: ret i32 5
; TUNIT: onsix: ; TUNIT: onsix:
; TUNIT-NEXT: ret i32 6 ; TUNIT-NEXT: ret i32 6
; TUNIT: otherwise: ; TUNIT: otherwise:
; TUNIT-NEXT: ret i32 99 ; TUNIT-NEXT: ret i32 99
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@less_than_100_2 ; CGSCC-LABEL: define {{[^@]+}}@less_than_100_2
; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: switch i32 [[C]], label [[OTHERWISE:%.*]] [ ; CGSCC-NEXT: switch i32 [[C]], label [[OTHERWISE:%.*]] [
; CGSCC-NEXT: i32 0, label [[ONZERO:%.*]] ; CGSCC-NEXT: i32 0, label [[ONZERO:%.*]]
; CGSCC-NEXT: i32 1, label [[ONONE:%.*]] ; CGSCC-NEXT: i32 1, label [[ONONE:%.*]]
; CGSCC-NEXT: i32 2, label [[ONTWO:%.*]] ; CGSCC-NEXT: i32 2, label [[ONTWO:%.*]]
; CGSCC-NEXT: i32 3, label [[ONTHREE:%.*]] ; CGSCC-NEXT: i32 3, label [[ONTHREE:%.*]]
; CGSCC-NEXT: i32 4, label [[ONFOUR:%.*]] ; CGSCC-NEXT: i32 4, label [[ONFOUR:%.*]]
Show All 39 Lines
onsix: onsix:
ret i32 6 ret i32 6
otherwise: otherwise:
ret i32 99 ret i32 99
} }
define internal i1 @is_less_than_100_2(i32 %c) { define internal i1 @is_less_than_100_2(i32 %c) {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@is_less_than_100_2 ; TUNIT-LABEL: define {{[^@]+}}@is_less_than_100_2
; TUNIT-SAME: (i32 noundef [[C:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i32 noundef [[C:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: [[CMP:%.*]] = icmp slt i32 [[C]], 100 ; TUNIT-NEXT: [[CMP:%.*]] = icmp slt i32 [[C]], 100
; TUNIT-NEXT: ret i1 [[CMP]] ; TUNIT-NEXT: ret i1 [[CMP]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@is_less_than_100_2 ; CGSCC-LABEL: define {{[^@]+}}@is_less_than_100_2
; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[CMP:%.*]] = icmp slt i32 [[C]], 100 ; CGSCC-NEXT: [[CMP:%.*]] = icmp slt i32 [[C]], 100
; CGSCC-NEXT: ret i1 [[CMP]] ; CGSCC-NEXT: ret i1 [[CMP]]
; ;
%cmp = icmp slt i32 %c, 100 %cmp = icmp slt i32 %c, 100
ret i1 %cmp ret i1 %cmp
} }
define i1 @propagate_range2(i32 %c) { define i1 @propagate_range2(i32 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@propagate_range2 ; TUNIT-LABEL: define {{[^@]+}}@propagate_range2
; TUNIT-SAME: (i32 [[C:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i32 [[C:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: [[CSRET1:%.*]] = call noundef i32 @less_than_100_2(i32 noundef 0) #[[ATTR3]] ; TUNIT-NEXT: [[CSRET1:%.*]] = call noundef i32 @less_than_100_2(i32 noundef 0) #[[ATTR3]]
; TUNIT-NEXT: [[TRUE1:%.*]] = call i1 @is_less_than_100_2(i32 noundef [[CSRET1]]) #[[ATTR3]] ; TUNIT-NEXT: [[TRUE1:%.*]] = call i1 @is_less_than_100_2(i32 noundef [[CSRET1]]) #[[ATTR3]]
; TUNIT-NEXT: [[CSRET2:%.*]] = call noundef i32 @less_than_100_2(i32 [[C]]) #[[ATTR3]] ; TUNIT-NEXT: [[CSRET2:%.*]] = call noundef i32 @less_than_100_2(i32 [[C]]) #[[ATTR3]]
; TUNIT-NEXT: [[TRUE2:%.*]] = call i1 @is_less_than_100_2(i32 noundef [[CSRET2]]) #[[ATTR3]] ; TUNIT-NEXT: [[TRUE2:%.*]] = call i1 @is_less_than_100_2(i32 noundef [[CSRET2]]) #[[ATTR3]]
; TUNIT-NEXT: [[TRUE:%.*]] = and i1 [[TRUE1]], [[TRUE2]] ; TUNIT-NEXT: [[TRUE:%.*]] = and i1 [[TRUE1]], [[TRUE2]]
; TUNIT-NEXT: ret i1 [[TRUE]] ; TUNIT-NEXT: ret i1 [[TRUE]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@propagate_range2 ; CGSCC-LABEL: define {{[^@]+}}@propagate_range2
; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i32 noundef [[C:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[CSRET1:%.*]] = call i32 @less_than_100_2(i32 noundef 0) #[[ATTR5]] ; CGSCC-NEXT: [[CSRET1:%.*]] = call i32 @less_than_100_2(i32 noundef 0) #[[ATTR5]]
; CGSCC-NEXT: [[TRUE1:%.*]] = call i1 @is_less_than_100_2(i32 noundef [[CSRET1]]) #[[ATTR5]] ; CGSCC-NEXT: [[TRUE1:%.*]] = call i1 @is_less_than_100_2(i32 noundef [[CSRET1]]) #[[ATTR5]]
; CGSCC-NEXT: [[CSRET2:%.*]] = call i32 @less_than_100_2(i32 noundef [[C]]) #[[ATTR5]] ; CGSCC-NEXT: [[CSRET2:%.*]] = call i32 @less_than_100_2(i32 noundef [[C]]) #[[ATTR5]]
; CGSCC-NEXT: [[TRUE2:%.*]] = call i1 @is_less_than_100_2(i32 noundef [[CSRET2]]) #[[ATTR5]] ; CGSCC-NEXT: [[TRUE2:%.*]] = call i1 @is_less_than_100_2(i32 noundef [[CSRET2]]) #[[ATTR5]]
; CGSCC-NEXT: [[TRUE:%.*]] = and i1 [[TRUE1]], [[TRUE2]] ; CGSCC-NEXT: [[TRUE:%.*]] = and i1 [[TRUE1]], [[TRUE2]]
; CGSCC-NEXT: ret i1 [[TRUE]] ; CGSCC-NEXT: ret i1 [[TRUE]]
; ;
%csret1 = call i32 @less_than_100_2(i32 0) %csret1 = call i32 @less_than_100_2(i32 0)
%true1 = call i1 @is_less_than_100_2(i32 %csret1) %true1 = call i1 @is_less_than_100_2(i32 %csret1)
%csret2 = call i32 @less_than_100_2(i32 %c) %csret2 = call i32 @less_than_100_2(i32 %c)
%true2 = call i1 @is_less_than_100_2(i32 %csret2) %true2 = call i1 @is_less_than_100_2(i32 %csret2)
%true = and i1 %true1, %true2 %true = and i1 %true1, %true2
ret i1 %true ret i1 %true
} }
define internal i1 @non_zero(i8 %v) { define internal i1 @non_zero(i8 %v) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@non_zero ; TUNIT-LABEL: define {{[^@]+}}@non_zero
; TUNIT-SAME: (i8 [[V:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i8 [[V:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: [[R:%.*]] = icmp ne i8 [[V]], 0 ; TUNIT-NEXT: [[R:%.*]] = icmp ne i8 [[V]], 0
; TUNIT-NEXT: ret i1 [[R]] ; TUNIT-NEXT: ret i1 [[R]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@non_zero ; CGSCC-LABEL: define {{[^@]+}}@non_zero
; CGSCC-SAME: (i8 [[V:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i8 [[V:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[R:%.*]] = icmp ne i8 [[V]], 0 ; CGSCC-NEXT: [[R:%.*]] = icmp ne i8 [[V]], 0
; CGSCC-NEXT: ret i1 [[R]] ; CGSCC-NEXT: ret i1 [[R]]
; ;
%r = icmp ne i8 %v, 0 %r = icmp ne i8 %v, 0
ret i1 %r ret i1 %r
} }
; Avoid range metadata for %l below ; Avoid range metadata for %l below
define i1 @context(ptr %p) { define i1 @context(ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; TUNIT-LABEL: define {{[^@]+}}@context ; TUNIT-LABEL: define {{[^@]+}}@context
; TUNIT-SAME: (ptr nocapture nofree noundef nonnull readonly dereferenceable(1) [[P:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr nocapture nofree noundef nonnull readonly dereferenceable(1) [[P:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[L:%.*]] = load i8, ptr [[P]], align 1 ; TUNIT-NEXT: [[L:%.*]] = load i8, ptr [[P]], align 1
; TUNIT-NEXT: [[C:%.*]] = icmp slt i8 0, [[L]] ; TUNIT-NEXT: [[C:%.*]] = icmp slt i8 0, [[L]]
; TUNIT-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: [[R:%.*]] = call i1 @non_zero(i8 [[L]]) #[[ATTR3]] ; TUNIT-NEXT: [[R:%.*]] = call i1 @non_zero(i8 [[L]]) #[[ATTR3]]
; TUNIT-NEXT: ret i1 [[R]] ; TUNIT-NEXT: ret i1 [[R]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: ret i1 false ; TUNIT-NEXT: ret i1 false
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@context ; CGSCC-LABEL: define {{[^@]+}}@context
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly dereferenceable(1) [[P:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull readonly dereferenceable(1) [[P:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: [[L:%.*]] = load i8, ptr [[P]], align 1 ; CGSCC-NEXT: [[L:%.*]] = load i8, ptr [[P]], align 1
; CGSCC-NEXT: [[C:%.*]] = icmp slt i8 0, [[L]] ; CGSCC-NEXT: [[C:%.*]] = icmp slt i8 0, [[L]]
; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: [[R:%.*]] = call i1 @non_zero(i8 [[L]]) #[[ATTR5]] ; CGSCC-NEXT: [[R:%.*]] = call i1 @non_zero(i8 [[L]]) #[[ATTR5]]
; CGSCC-NEXT: ret i1 [[R]] ; CGSCC-NEXT: ret i1 [[R]]
▲ Show 20 Lines • Show All 120 Lines • ▼ Show 20 Lines
declare void @ham(i32) declare void @ham(i32)
declare void @barney(i32 signext, i32 signext) declare void @barney(i32 signext, i32 signext)
!0 = !{i32 0, i32 10} !0 = !{i32 0, i32 10}
!1 = !{i32 10, i32 100} !1 = !{i32 10, i32 100}
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind memory(none) } ; TUNIT: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind memory(none) }
; TUNIT: attributes #[[ATTR3]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR3]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR3]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind memory(none) } ; CGSCC: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind memory(none) }
; CGSCC: attributes #[[ATTR5]] = { willreturn } ; CGSCC: attributes #[[ATTR5]] = { willreturn }
;. ;.
; TUNIT: [[RNG0]] = !{i32 0, i32 10} ; TUNIT: [[RNG0]] = !{i32 0, i32 10}
; TUNIT: [[RNG1]] = !{i32 10, i32 100} ; TUNIT: [[RNG1]] = !{i32 10, i32 100}
; TUNIT: [[RNG2]] = !{i32 200, i32 1091} ; TUNIT: [[RNG2]] = !{i32 200, i32 1091}
; TUNIT: [[RNG3]] = !{i32 1, i32 -2147483648} ; TUNIT: [[RNG3]] = !{i32 1, i32 -2147483648}
;. ;.
; CGSCC: [[RNG0]] = !{i32 0, i32 10} ; CGSCC: [[RNG0]] = !{i32 0, i32 10}
; CGSCC: [[RNG1]] = !{i32 10, i32 100} ; CGSCC: [[RNG1]] = !{i32 10, i32 100}
;. ;.

llvm/test/Transforms/Attributor/read_write_returned_arguments_scc.ll

Show First 20 Lines • Show All 219 Lines • ▼ Show 20 Linesif.end: ; preds = %entry
br label %return br label %return
return: ; preds = %if.end, %if.then return: ; preds = %if.end, %if.then
%retval.0 = phi ptr [ %call8, %if.end ], [ %r1, %if.then ] %retval.0 = phi ptr [ %call8, %if.end ], [ %r1, %if.then ]
ret ptr %retval.0 ret ptr %retval.0
} }
define ptr @external_sink_ret2_nrw(ptr %n0, ptr %r0, ptr %w0) { define ptr @external_sink_ret2_nrw(ptr %n0, ptr %r0, ptr %w0) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; CHECK-LABEL: define {{[^@]+}}@external_sink_ret2_nrw ; CHECK-LABEL: define {{[^@]+}}@external_sink_ret2_nrw
; CHECK-SAME: (ptr nofree [[N0:%.*]], ptr nocapture nofree readonly [[R0:%.*]], ptr nofree returned writeonly "no-capture-maybe-returned" [[W0:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (ptr nofree [[N0:%.*]], ptr nocapture nofree readonly [[R0:%.*]], ptr nofree returned writeonly "no-capture-maybe-returned" [[W0:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TOBOOL:%.*]] = icmp ne ptr [[N0]], null ; CHECK-NEXT: [[TOBOOL:%.*]] = icmp ne ptr [[N0]], null
; CHECK-NEXT: br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]] ; CHECK-NEXT: br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
; CHECK: if.then: ; CHECK: if.then:
; CHECK-NEXT: br label [[RETURN:%.*]] ; CHECK-NEXT: br label [[RETURN:%.*]]
; CHECK: if.end: ; CHECK: if.end:
▲ Show 20 Lines • Show All 109 Lines • ▼ Show 20 Linesentry:
%call1 = call ptr @external_ret2_nrw(ptr %n0, ptr %r0, ptr %w0) %call1 = call ptr @external_ret2_nrw(ptr %n0, ptr %r0, ptr %w0)
ret ptr %call1 ret ptr %call1
} }
; Verify that we see only expected attribute sets, the above lines only check ; Verify that we see only expected attribute sets, the above lines only check
; for a subset relation. ; for a subset relation.
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree nosync nounwind memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR0]] = { nofree nosync nounwind memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR3]] = { nofree nosync nounwind } ; TUNIT: attributes #[[ATTR3]] = { nofree nosync nounwind }
; TUNIT: attributes #[[ATTR4]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR4]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree nosync nounwind memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR0]] = { nofree nosync nounwind memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind } ; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind }
; CGSCC: attributes #[[ATTR3]] = { nounwind } ; CGSCC: attributes #[[ATTR3]] = { nounwind }
; CGSCC: attributes #[[ATTR4]] = { nounwind memory(readwrite) } ; CGSCC: attributes #[[ATTR4]] = { nounwind memory(readwrite) }
; CGSCC: attributes #[[ATTR5]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR5]] = { nounwind willreturn }
;. ;.

llvm/test/Transforms/Attributor/readattrs.ll

Show All 20 Lines
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void (ptr, ptr, ...) @test1_1(ptr %x1_2, ptr %y1_2, ptr %z1_2) call void (ptr, ptr, ...) @test1_1(ptr %x1_2, ptr %y1_2, ptr %z1_2)
store i32 0, ptr @x store i32 0, ptr @x
ret void ret void
} }
define ptr @test2(ptr %p) { define ptr @test2(ptr %p) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CHECK-LABEL: define {{[^@]+}}@test2 ; CHECK-LABEL: define {{[^@]+}}@test2
; CHECK-SAME: (ptr nofree readnone returned "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr nofree readnone returned "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: store i32 0, ptr @x, align 4 ; CHECK-NEXT: store i32 0, ptr @x, align 4
; CHECK-NEXT: ret ptr [[P]] ; CHECK-NEXT: ret ptr [[P]]
; ;
store i32 0, ptr @x store i32 0, ptr @x
ret ptr %p ret ptr %p
} }
define i1 @test3(ptr %p, ptr %q) { define i1 @test3(ptr %p, ptr %q) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test3 ; CHECK-LABEL: define {{[^@]+}}@test3
; CHECK-SAME: (ptr nofree readnone [[P:%.*]], ptr nofree readnone [[Q:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (ptr nofree readnone [[P:%.*]], ptr nofree readnone [[Q:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: [[A:%.*]] = icmp ult ptr [[P]], [[Q]] ; CHECK-NEXT: [[A:%.*]] = icmp ult ptr [[P]], [[Q]]
; CHECK-NEXT: ret i1 [[A]] ; CHECK-NEXT: ret i1 [[A]]
; ;
%A = icmp ult ptr %p, %q %A = icmp ult ptr %p, %q
ret i1 %A ret i1 %A
} }
declare void @test4_1(ptr nocapture) readonly declare void @test4_1(ptr nocapture) readonly
define void @test4_2(ptr %p) { define void @test4_2(ptr %p) {
; CHECK: Function Attrs: memory(read) ; CHECK: Function Attrs: memory(read)
; CHECK-LABEL: define {{[^@]+}}@test4_2 ; CHECK-LABEL: define {{[^@]+}}@test4_2
; CHECK-SAME: (ptr nocapture readonly [[P:%.*]]) #[[ATTR2:[0-9]+]] { ; CHECK-SAME: (ptr nocapture readonly [[P:%.*]]) #[[ATTR2:[0-9]+]] {
; CHECK-NEXT: call void @test4_1(ptr nocapture readonly [[P]]) ; CHECK-NEXT: call void @test4_1(ptr nocapture readonly [[P]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @test4_1(ptr %p) call void @test4_1(ptr %p)
ret void ret void
} }
; Missed optz'n: we could make %q readnone, but don't break test6! ; Missed optz'n: we could make %q readnone, but don't break test6!
define void @test5(ptr %p, ptr %q) { define void @test5(ptr %p, ptr %q) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@test5 ; CHECK-LABEL: define {{[^@]+}}@test5
; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[P:%.*]], ptr nofree writeonly [[Q:%.*]]) #[[ATTR3:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[P:%.*]], ptr nofree writeonly [[Q:%.*]]) #[[ATTR3:[0-9]+]] {
; CHECK-NEXT: store ptr [[Q]], ptr [[P]], align 8 ; CHECK-NEXT: store ptr [[Q]], ptr [[P]], align 8
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store ptr %q, ptr %p store ptr %q, ptr %p
ret void ret void
} }
Show All 9 Lines
; ;
store ptr %q, ptr %p store ptr %q, ptr %p
call void @test6_1() call void @test6_1()
ret void ret void
} }
; inalloca parameters are always considered written ; inalloca parameters are always considered written
define void @test7_1(ptr inalloca(i32) %a) { define void @test7_1(ptr inalloca(i32) %a) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test7_1 ; CHECK-LABEL: define {{[^@]+}}@test7_1
; CHECK-SAME: (ptr nocapture nofree nonnull writeonly inalloca(i32) dereferenceable(4) [[A:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ptr nocapture nofree nonnull writeonly inalloca(i32) dereferenceable(4) [[A:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
ret void ret void
} }
define ptr @test8_1(ptr %p) { define ptr @test8_1(ptr %p) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test8_1 ; CHECK-LABEL: define {{[^@]+}}@test8_1
; CHECK-SAME: (ptr nofree readnone returned "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ptr nofree readnone returned "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret ptr [[P]] ; CHECK-NEXT: ret ptr [[P]]
; ;
entry: entry:
ret ptr %p ret ptr %p
} }
define void @test8_2(ptr %p) { define void @test8_2(ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@test8_2 ; TUNIT-LABEL: define {{[^@]+}}@test8_2
; TUNIT-SAME: (ptr nocapture nofree writeonly [[P:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (ptr nocapture nofree writeonly [[P:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: store i32 10, ptr [[P]], align 4 ; TUNIT-NEXT: store i32 10, ptr [[P]], align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@test8_2 ; CGSCC-LABEL: define {{[^@]+}}@test8_2
; CGSCC-SAME: (ptr nofree writeonly [[P:%.*]]) #[[ATTR4:[0-9]+]] { ; CGSCC-SAME: (ptr nofree writeonly [[P:%.*]]) #[[ATTR4:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[CALL:%.*]] = call align 4 ptr @test8_1(ptr noalias nofree readnone [[P]]) #[[ATTR13:[0-9]+]] ; CGSCC-NEXT: [[CALL:%.*]] = call align 4 ptr @test8_1(ptr noalias nofree readnone [[P]]) #[[ATTR13:[0-9]+]]
; CGSCC-NEXT: store i32 10, ptr [[CALL]], align 4 ; CGSCC-NEXT: store i32 10, ptr [[CALL]], align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
entry: entry:
%call = call ptr @test8_1(ptr %p) %call = call ptr @test8_1(ptr %p)
store i32 10, ptr %call, align 4 store i32 10, ptr %call, align 4
ret void ret void
} }
; CHECK: declare void @llvm.masked.scatter ; CHECK: declare void @llvm.masked.scatter
declare void @llvm.masked.scatter.v4i32.v4p0(<4 x i32>%val, <4 x ptr>, i32, <4 x i1>) declare void @llvm.masked.scatter.v4i32.v4p0(<4 x i32>%val, <4 x ptr>, i32, <4 x i1>)
; CHECK-NOT: readnone ; CHECK-NOT: readnone
; CHECK-NOT: readonly ; CHECK-NOT: readonly
define void @test9(<4 x ptr> %ptrs, <4 x i32>%val) { define void @test9(<4 x ptr> %ptrs, <4 x i32>%val) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@test9 ; TUNIT-LABEL: define {{[^@]+}}@test9
; TUNIT-SAME: (<4 x ptr> [[PTRS:%.*]], <4 x i32> [[VAL:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (<4 x ptr> [[PTRS:%.*]], <4 x i32> [[VAL:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: call void @llvm.masked.scatter.v4i32.v4p0(<4 x i32> [[VAL]], <4 x ptr> [[PTRS]], i32 noundef 4, <4 x i1> noundef <i1 true, i1 false, i1 true, i1 false>) #[[ATTR12:[0-9]+]] ; TUNIT-NEXT: call void @llvm.masked.scatter.v4i32.v4p0(<4 x i32> [[VAL]], <4 x ptr> [[PTRS]], i32 noundef 4, <4 x i1> noundef <i1 true, i1 false, i1 true, i1 false>) #[[ATTR12:[0-9]+]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@test9 ; CGSCC-LABEL: define {{[^@]+}}@test9
; CGSCC-SAME: (<4 x ptr> [[PTRS:%.*]], <4 x i32> [[VAL:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (<4 x ptr> [[PTRS:%.*]], <4 x i32> [[VAL:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: call void @llvm.masked.scatter.v4i32.v4p0(<4 x i32> [[VAL]], <4 x ptr> [[PTRS]], i32 noundef 4, <4 x i1> noundef <i1 true, i1 false, i1 true, i1 false>) #[[ATTR13]] ; CGSCC-NEXT: call void @llvm.masked.scatter.v4i32.v4p0(<4 x i32> [[VAL]], <4 x ptr> [[PTRS]], i32 noundef 4, <4 x i1> noundef <i1 true, i1 false, i1 true, i1 false>) #[[ATTR13]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @llvm.masked.scatter.v4i32.v4p0(<4 x i32>%val, <4 x ptr> %ptrs, i32 4, <4 x i1><i1 true, i1 false, i1 true, i1 false>) call void @llvm.masked.scatter.v4i32.v4p0(<4 x i32>%val, <4 x ptr> %ptrs, i32 4, <4 x i1><i1 true, i1 false, i1 true, i1 false>)
ret void ret void
} }
; CHECK: declare <4 x i32> @llvm.masked.gather ; CHECK: declare <4 x i32> @llvm.masked.gather
declare <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr>, i32, <4 x i1>, <4 x i32>) declare <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr>, i32, <4 x i1>, <4 x i32>)
define <4 x i32> @test10(<4 x ptr> %ptrs) { define <4 x i32> @test10(<4 x ptr> %ptrs) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
; TUNIT-LABEL: define {{[^@]+}}@test10 ; TUNIT-LABEL: define {{[^@]+}}@test10
; TUNIT-SAME: (<4 x ptr> [[PTRS:%.*]]) #[[ATTR6:[0-9]+]] { ; TUNIT-SAME: (<4 x ptr> [[PTRS:%.*]]) #[[ATTR6:[0-9]+]] {
; TUNIT-NEXT: [[RES:%.*]] = call <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr> [[PTRS]], i32 noundef 4, <4 x i1> noundef <i1 true, i1 false, i1 true, i1 false>, <4 x i32> undef) #[[ATTR12]] ; TUNIT-NEXT: [[RES:%.*]] = call <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr> [[PTRS]], i32 noundef 4, <4 x i1> noundef <i1 true, i1 false, i1 true, i1 false>, <4 x i32> undef) #[[ATTR12]]
; TUNIT-NEXT: ret <4 x i32> [[RES]] ; TUNIT-NEXT: ret <4 x i32> [[RES]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
; CGSCC-LABEL: define {{[^@]+}}@test10 ; CGSCC-LABEL: define {{[^@]+}}@test10
; CGSCC-SAME: (<4 x ptr> [[PTRS:%.*]]) #[[ATTR7:[0-9]+]] { ; CGSCC-SAME: (<4 x ptr> [[PTRS:%.*]]) #[[ATTR7:[0-9]+]] {
; CGSCC-NEXT: [[RES:%.*]] = call <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr> [[PTRS]], i32 noundef 4, <4 x i1> noundef <i1 true, i1 false, i1 true, i1 false>, <4 x i32> undef) #[[ATTR13]] ; CGSCC-NEXT: [[RES:%.*]] = call <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr> [[PTRS]], i32 noundef 4, <4 x i1> noundef <i1 true, i1 false, i1 true, i1 false>, <4 x i32> undef) #[[ATTR13]]
; CGSCC-NEXT: ret <4 x i32> [[RES]] ; CGSCC-NEXT: ret <4 x i32> [[RES]]
; ;
%res = call <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr> %ptrs, i32 4, <4 x i1><i1 true, i1 false, i1 true, i1 false>, <4 x i32>undef) %res = call <4 x i32> @llvm.masked.gather.v4i32.v4p0(<4 x ptr> %ptrs, i32 4, <4 x i1><i1 true, i1 false, i1 true, i1 false>, <4 x i32>undef)
ret <4 x i32> %res ret <4 x i32> %res
} }
Show All 32 Lines
; CGSCC-NEXT: [[RES:%.*]] = call <4 x i32> @test12_1(<4 x ptr> [[PTRS]]) #[[ATTR14]] ; CGSCC-NEXT: [[RES:%.*]] = call <4 x i32> @test12_1(<4 x ptr> [[PTRS]]) #[[ATTR14]]
; CGSCC-NEXT: ret <4 x i32> [[RES]] ; CGSCC-NEXT: ret <4 x i32> [[RES]]
; ;
%res = call <4 x i32> @test12_1(<4 x ptr> %ptrs) %res = call <4 x i32> @test12_1(<4 x ptr> %ptrs)
ret <4 x i32> %res ret <4 x i32> %res
} }
define i32 @volatile_load(ptr %p) { define i32 @volatile_load(ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@volatile_load ; TUNIT-LABEL: define {{[^@]+}}@volatile_load
; TUNIT-SAME: (ptr nofree noundef align 4 [[P:%.*]]) #[[ATTR9:[0-9]+]] { ; TUNIT-SAME: (ptr nofree noundef align 4 [[P:%.*]]) #[[ATTR9:[0-9]+]] {
; TUNIT-NEXT: [[LOAD:%.*]] = load volatile i32, ptr [[P]], align 4 ; TUNIT-NEXT: [[LOAD:%.*]] = load volatile i32, ptr [[P]], align 4
; TUNIT-NEXT: ret i32 [[LOAD]] ; TUNIT-NEXT: ret i32 [[LOAD]]
; ;
; CGSCC: Function Attrs: nofree norecurse nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@volatile_load ; CGSCC-LABEL: define {{[^@]+}}@volatile_load
; CGSCC-SAME: (ptr nofree noundef align 4 [[P:%.*]]) #[[ATTR10:[0-9]+]] { ; CGSCC-SAME: (ptr nofree noundef align 4 [[P:%.*]]) #[[ATTR10:[0-9]+]] {
; CGSCC-NEXT: [[LOAD:%.*]] = load volatile i32, ptr [[P]], align 4 ; CGSCC-NEXT: [[LOAD:%.*]] = load volatile i32, ptr [[P]], align 4
; CGSCC-NEXT: ret i32 [[LOAD]] ; CGSCC-NEXT: ret i32 [[LOAD]]
; ;
%load = load volatile i32, ptr %p %load = load volatile i32, ptr %p
ret i32 %load ret i32 %load
} }
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
; CHECK-NEXT: call void @escape_i8(ptr nonnull dereferenceable(1) [[WRITTEN]]) ; CHECK-NEXT: call void @escape_i8(ptr nonnull dereferenceable(1) [[WRITTEN]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @escape_i8(ptr %written) call void @escape_i8(ptr %written)
ret void ret void
} }
define void @byval_not_readonly_2(ptr byval(i8) %written) readonly { define void @byval_not_readonly_2(ptr byval(i8) %written) readonly {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@byval_not_readonly_2 ; CHECK-LABEL: define {{[^@]+}}@byval_not_readonly_2
; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly byval(i8) dereferenceable(1) [[WRITTEN:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly byval(i8) dereferenceable(1) [[WRITTEN:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: store i8 0, ptr [[WRITTEN]], align 1 ; CHECK-NEXT: store i8 0, ptr [[WRITTEN]], align 1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store i8 0, ptr %written store i8 0, ptr %written
ret void ret void
} }
Show All 11 Lines
; CGSCC-NEXT: call void @escape_i8(ptr nonnull dereferenceable(1) [[WRITTEN]]) ; CGSCC-NEXT: call void @escape_i8(ptr nonnull dereferenceable(1) [[WRITTEN]])
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @escape_i8(ptr %written) call void @escape_i8(ptr %written)
ret void ret void
} }
define void @byval_not_readnone_2(ptr byval(i8) %written) readnone { define void @byval_not_readnone_2(ptr byval(i8) %written) readnone {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@byval_not_readnone_2 ; CHECK-LABEL: define {{[^@]+}}@byval_not_readnone_2
; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly byval(i8) dereferenceable(1) [[WRITTEN:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly byval(i8) dereferenceable(1) [[WRITTEN:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: store i8 0, ptr [[WRITTEN]], align 1 ; CHECK-NEXT: store i8 0, ptr [[WRITTEN]], align 1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store i8 0, ptr %written store i8 0, ptr %written
ret void ret void
} }
define void @byval_no_fnarg(ptr byval(i8) %written) { define void @byval_no_fnarg(ptr byval(i8) %written) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@byval_no_fnarg ; CHECK-LABEL: define {{[^@]+}}@byval_no_fnarg
; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly byval(i8) dereferenceable(1) [[WRITTEN:%.*]]) #[[ATTR3]] { ; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly byval(i8) dereferenceable(1) [[WRITTEN:%.*]]) #[[ATTR3]] {
; CHECK-NEXT: store i8 0, ptr [[WRITTEN]], align 1 ; CHECK-NEXT: store i8 0, ptr [[WRITTEN]], align 1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store i8 0, ptr %written store i8 0, ptr %written
ret void ret void
} }
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @escape_i8(ptr %ptr) call void @escape_i8(ptr %ptr)
ret void ret void
} }
@constant_mem = external dso_local constant i32, align 4 @constant_mem = external dso_local constant i32, align 4
define i32 @read_only_constant_mem() { define i32 @read_only_constant_mem() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@read_only_constant_mem ; CHECK-LABEL: define {{[^@]+}}@read_only_constant_mem
; CHECK-SAME: () #[[ATTR1]] { ; CHECK-SAME: () #[[ATTR1]] {
; CHECK-NEXT: [[L:%.*]] = load i32, ptr @constant_mem, align 4 ; CHECK-NEXT: [[L:%.*]] = load i32, ptr @constant_mem, align 4
; CHECK-NEXT: ret i32 [[L]] ; CHECK-NEXT: ret i32 [[L]]
; ;
%l = load i32, ptr @constant_mem %l = load i32, ptr @constant_mem
ret i32 %l ret i32 %l
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR2]] = { memory(read) } ; TUNIT: attributes #[[ATTR2]] = { memory(read) }
; TUNIT: attributes #[[ATTR3]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR4:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(write) } ; TUNIT: attributes #[[ATTR4:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(write) }
; TUNIT: attributes #[[ATTR5:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(read) } ; TUNIT: attributes #[[ATTR5:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(read) }
; TUNIT: attributes #[[ATTR6]] = { nofree norecurse nosync nounwind willreturn memory(read) } ; TUNIT: attributes #[[ATTR6]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(read) }
; TUNIT: attributes #[[ATTR7]] = { nounwind memory(argmem: read) } ; TUNIT: attributes #[[ATTR7]] = { nounwind memory(argmem: read) }
; TUNIT: attributes #[[ATTR8]] = { nounwind memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR8]] = { nounwind memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR9]] = { nofree norecurse nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR9]] = { mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR10]] = { memory(none) } ; TUNIT: attributes #[[ATTR10]] = { memory(none) }
; TUNIT: attributes #[[ATTR11]] = { nounwind memory(read) } ; TUNIT: attributes #[[ATTR11]] = { nounwind memory(read) }
; TUNIT: attributes #[[ATTR12]] = { willreturn } ; TUNIT: attributes #[[ATTR12]] = { willreturn }
; TUNIT: attributes #[[ATTR13]] = { nounwind } ; TUNIT: attributes #[[ATTR13]] = { nounwind }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { memory(read) } ; CGSCC: attributes #[[ATTR2]] = { memory(read) }
; CGSCC: attributes #[[ATTR3]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR4]] = { nofree nosync nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR4]] = { mustprogress nofree nosync nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR5:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR5:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR6:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(read) } ; CGSCC: attributes #[[ATTR6:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(read) }
; CGSCC: attributes #[[ATTR7]] = { nofree norecurse nosync nounwind willreturn memory(read) } ; CGSCC: attributes #[[ATTR7]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(read) }
; CGSCC: attributes #[[ATTR8]] = { nounwind memory(argmem: read) } ; CGSCC: attributes #[[ATTR8]] = { nounwind memory(argmem: read) }
; CGSCC: attributes #[[ATTR9]] = { nounwind memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR9]] = { nounwind memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR10]] = { nofree norecurse nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR10]] = { mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR11]] = { memory(none) } ; CGSCC: attributes #[[ATTR11]] = { memory(none) }
; CGSCC: attributes #[[ATTR12]] = { nounwind memory(read) } ; CGSCC: attributes #[[ATTR12]] = { nounwind memory(read) }
; CGSCC: attributes #[[ATTR13]] = { willreturn } ; CGSCC: attributes #[[ATTR13]] = { willreturn }
; CGSCC: attributes #[[ATTR14]] = { nounwind } ; CGSCC: attributes #[[ATTR14]] = { nounwind }
;. ;.

llvm/test/Transforms/Attributor/reduced/assertion_unassigned_range.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
define i1 @_ZNK6openmc4Cell16contains_complexENS_8PositionES1_i() { define i1 @_ZNK6openmc4Cell16contains_complexENS_8PositionES1_i() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@_ZNK6openmc4Cell16contains_complexENS_8PositionES1_i ; CHECK-LABEL: define {{[^@]+}}@_ZNK6openmc4Cell16contains_complexENS_8PositionES1_i
; CHECK-SAME: () #[[ATTR0:[0-9]+]] { ; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TOBOOL71:%.*]] = trunc i8 undef to i1 ; CHECK-NEXT: [[TOBOOL71:%.*]] = trunc i8 undef to i1
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; ;
entry: entry:
%stack = alloca [24 x i8], i32 0, align 1 %stack = alloca [24 x i8], i32 0, align 1
%arrayidx70 = getelementptr [24 x i8], ptr %stack, i64 0, i64 -1 %arrayidx70 = getelementptr [24 x i8], ptr %stack, i64 0, i64 -1
%0 = load i8, ptr %arrayidx70, align 1 %0 = load i8, ptr %arrayidx70, align 1
%tobool71 = trunc i8 %0 to i1 %tobool71 = trunc i8 %0 to i1
ret i1 false ret i1 false
} }
;. ;.
; CHECK: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CHECK: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CGSCC: {{.*}} ; CGSCC: {{.*}}
; TUNIT: {{.*}} ; TUNIT: {{.*}}

llvm/test/Transforms/Attributor/reduced/pred_iterator_crash.ll

Show All 16 Lines
; CHECK-LABEL: define {{[^@]+}}@__omp_offloading_16_19bc70bc_main_l44() { ; CHECK-LABEL: define {{[^@]+}}@__omp_offloading_16_19bc70bc_main_l44() {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call fastcc void @__omp_outlined__() call fastcc void @__omp_outlined__()
ret void ret void
} }
define internal fastcc void @__omp_outlined__() { define internal fastcc void @__omp_outlined__() {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@__omp_outlined__ ; CGSCC-LABEL: define {{[^@]+}}@__omp_outlined__
; CGSCC-SAME: () #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: br label [[TMP2:%.*]] ; CGSCC-NEXT: br label [[TMP2:%.*]]
; CGSCC: 1: ; CGSCC: 1:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: 2: ; CGSCC: 2:
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%1 = load i32, ptr getelementptr inbounds (i8, ptr addrspacecast (ptr addrspace(3) @_ZN4ompx5state9TeamStateE to ptr), i64 4), align 4 %1 = load i32, ptr getelementptr inbounds (i8, ptr addrspacecast (ptr addrspace(3) @_ZN4ompx5state9TeamStateE to ptr), i64 4), align 4
br label %4 br label %4
2: ; No predecessors! 2: ; No predecessors!
%3 = icmp eq i32 %1, 0 %3 = icmp eq i32 %1, 0
call void @llvm.assume(i1 %3) call void @llvm.assume(i1 %3)
br label %4 br label %4
4: ; preds = %2, %0 4: ; preds = %2, %0
ret void ret void
} }
;. ;.
; TUNIT: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; TUNIT: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
;. ;.
; CGSCC: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; CGSCC: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; TUNIT: {{.*}} ; TUNIT: {{.*}}

llvm/test/Transforms/Attributor/returned.ll

Show All 35 Lines
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
;. ;.
; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = external global i8 ; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = external global i8
; CHECK: @[[_ZTI1X:[a-zA-Z0-9_$"\\.-]+]] = external dso_local constant { ptr, ptr }, align 8 ; CHECK: @[[_ZTI1X:[a-zA-Z0-9_$"\\.-]+]] = external dso_local constant { ptr, ptr }, align 8
; CHECK: @[[_ZTI1Y:[a-zA-Z0-9_$"\\.-]+]] = external dso_local constant { ptr, ptr, ptr }, align 8 ; CHECK: @[[_ZTI1Y:[a-zA-Z0-9_$"\\.-]+]] = external dso_local constant { ptr, ptr, ptr }, align 8
;. ;.
define i32 @sink_r0(i32 %r) #0 { define i32 @sink_r0(i32 %r) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@sink_r0 ; CHECK-LABEL: define {{[^@]+}}@sink_r0
; CHECK-SAME: (i32 returned [[R:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (i32 returned [[R:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret i32 [[R]] ; CHECK-NEXT: ret i32 [[R]]
; ;
entry: entry:
ret i32 %r ret i32 %r
} }
▲ Show 20 Lines • Show All 267 Lines • ▼ Show 20 Lines
; __attribute__((noinline)) double* ptr_scc_r2(double* a, double* b, double* r) { ; __attribute__((noinline)) double* ptr_scc_r2(double* a, double* b, double* r) {
; if (a > b) ; if (a > b)
; return ptr_scc_r2(b, a, ptr_sink_r0(r)); ; return ptr_scc_r2(b, a, ptr_sink_r0(r));
; if (a < b) ; if (a < b)
; return ptr_scc_r1(ptr_sink_r0(b), ptr_scc_r2(ptr_scc_r1(a, b, r), ptr_scc_r1(a, ptr_scc_r2(r, r, r), r), ptr_scc_r2(a, b, r)), ptr_scc_r1(a, b, r)); ; return ptr_scc_r1(ptr_sink_r0(b), ptr_scc_r2(ptr_scc_r1(a, b, r), ptr_scc_r1(a, ptr_scc_r2(r, r, r), r), ptr_scc_r2(a, b, r)), ptr_scc_r1(a, b, r));
; return a == b ? r : ptr_scc_r2(a, b, r); ; return a == b ? r : ptr_scc_r2(a, b, r);
; } ; }
define ptr @ptr_sink_r0(ptr %r) #0 { define ptr @ptr_sink_r0(ptr %r) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@ptr_sink_r0 ; CHECK-LABEL: define {{[^@]+}}@ptr_sink_r0
; CHECK-SAME: (ptr nofree readnone returned "no-capture-maybe-returned" [[R:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nofree readnone returned "no-capture-maybe-returned" [[R:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret ptr [[R]] ; CHECK-NEXT: ret ptr [[R]]
; ;
entry: entry:
ret ptr %r ret ptr %r
} }
▲ Show 20 Lines • Show All 166 Lines • ▼ Show 20 Lines
; TEST a no-return singleton SCC ; TEST a no-return singleton SCC
; ;
; int* rt1(int *a) { ; int* rt1(int *a) {
; return *a ? undef : rt1(a); ; return *a ? undef : rt1(a);
; } ; }
; ;
define ptr @rt1(ptr %a) #0 { define ptr @rt1(ptr %a) #0 {
; TUNIT: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
; TUNIT-LABEL: define {{[^@]+}}@rt1 ; TUNIT-LABEL: define {{[^@]+}}@rt1
; TUNIT-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR4:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR4:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: ret ptr undef ; TUNIT-NEXT: ret ptr undef
; ;
; CGSCC: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@rt1 ; CGSCC-LABEL: define {{[^@]+}}@rt1
; CGSCC-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR3:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR3:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: ret ptr undef ; CGSCC-NEXT: ret ptr undef
; ;
entry: entry:
%v = load i32, ptr %a, align 4 %v = load i32, ptr %a, align 4
%tobool = icmp ne i32 %v, 0 %tobool = icmp ne i32 %v, 0
▲ Show 20 Lines • Show All 260 Lines • ▼ Show 20 Lines
; double select_and_phi(double b) { ; double select_and_phi(double b) {
; double x = b; ; double x = b;
; if (b > 0) ; if (b > 0)
; x = b; ; x = b;
; return b == 0? b : x; ; return b == 0? b : x;
; } ; }
; ;
define double @select_and_phi(double %b) #0 { define double @select_and_phi(double %b) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@select_and_phi ; CHECK-LABEL: define {{[^@]+}}@select_and_phi
; CHECK-SAME: (double returned [[B:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (double returned [[B:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt double [[B]], 0.000000e+00 ; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt double [[B]], 0.000000e+00
; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then: ; CHECK: if.then:
; CHECK-NEXT: br label [[IF_END]] ; CHECK-NEXT: br label [[IF_END]]
; CHECK: if.end: ; CHECK: if.end:
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines
; TEST returned argument goes through bitcasts ; TEST returned argument goes through bitcasts
; ;
; double* bitcast(int* b) { ; double* bitcast(int* b) {
; return (double*)b; ; return (double*)b;
; } ; }
; ;
define ptr @bitcast(ptr %b) #0 { define ptr @bitcast(ptr %b) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@bitcast ; CHECK-LABEL: define {{[^@]+}}@bitcast
; CHECK-SAME: (ptr nofree readnone returned "no-capture-maybe-returned" [[B:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nofree readnone returned "no-capture-maybe-returned" [[B:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret ptr [[B]] ; CHECK-NEXT: ret ptr [[B]]
; ;
entry: entry:
ret ptr %b ret ptr %b
} }
; TEST returned argument goes through select and phi interleaved with bitcasts ; TEST returned argument goes through select and phi interleaved with bitcasts
; ;
; double* bitcasts_select_and_phi(int* b) { ; double* bitcasts_select_and_phi(int* b) {
; double* x = b; ; double* x = b;
; if (b == 0) ; if (b == 0)
; x = b; ; x = b;
; return b != 0 ? b : x; ; return b != 0 ? b : x;
; } ; }
; ;
define ptr @bitcasts_select_and_phi(ptr %b) #0 { define ptr @bitcasts_select_and_phi(ptr %b) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@bitcasts_select_and_phi ; CHECK-LABEL: define {{[^@]+}}@bitcasts_select_and_phi
; CHECK-SAME: (ptr nofree readnone returned [[B:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nofree readnone returned [[B:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[B]], null ; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[B]], null
; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then: ; CHECK: if.then:
; CHECK-NEXT: br label [[IF_END]] ; CHECK-NEXT: br label [[IF_END]]
; CHECK: if.end: ; CHECK: if.end:
Show All 21 Lines
; if (b == 0) ; if (b == 0)
; return (double*)b; ; return (double*)b;
; if (b == 0) ; if (b == 0)
; return (double*)b; ; return (double*)b;
; /* return undef */ ; /* return undef */
; } ; }
; ;
define ptr @ret_arg_arg_undef(ptr %b) #0 { define ptr @ret_arg_arg_undef(ptr %b) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@ret_arg_arg_undef ; CHECK-LABEL: define {{[^@]+}}@ret_arg_arg_undef
; CHECK-SAME: (ptr nofree readnone returned [[B:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nofree readnone returned [[B:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[B]], null ; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[B]], null
; CHECK-NEXT: br i1 [[CMP]], label [[RET_ARG0:%.*]], label [[IF_END:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[RET_ARG0:%.*]], label [[IF_END:%.*]]
; CHECK: ret_arg0: ; CHECK: ret_arg0:
; CHECK-NEXT: ret ptr [[B]] ; CHECK-NEXT: ret ptr [[B]]
; CHECK: if.end: ; CHECK: if.end:
Show All 27 Lines
; if (b == 0) ; if (b == 0)
; return (double*)b; ; return (double*)b;
; if (b == 0) ; if (b == 0)
; return (double*)b; ; return (double*)b;
; /* return undef */ ; /* return undef */
; } ; }
; ;
define ptr @ret_undef_arg_arg(ptr %b) #0 { define ptr @ret_undef_arg_arg(ptr %b) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@ret_undef_arg_arg ; CHECK-LABEL: define {{[^@]+}}@ret_undef_arg_arg
; CHECK-SAME: (ptr nofree readnone returned [[B:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nofree readnone returned [[B:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[B]], null ; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[B]], null
; CHECK-NEXT: br i1 [[CMP]], label [[RET_UNDEF:%.*]], label [[IF_END:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[RET_UNDEF:%.*]], label [[IF_END:%.*]]
; CHECK: ret_undef: ; CHECK: ret_undef:
; CHECK-NEXT: ret ptr undef ; CHECK-NEXT: ret ptr undef
; CHECK: if.end: ; CHECK: if.end:
Show All 27 Lines
; if (b == 0) ; if (b == 0)
; /* return undef */ ; /* return undef */
; if (b == 0) ; if (b == 0)
; return (double*)b; ; return (double*)b;
; /* return undef */ ; /* return undef */
; } ; }
; ;
define ptr @ret_undef_arg_undef(ptr %b) #0 { define ptr @ret_undef_arg_undef(ptr %b) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@ret_undef_arg_undef ; CHECK-LABEL: define {{[^@]+}}@ret_undef_arg_undef
; CHECK-SAME: (ptr nofree readnone returned [[B:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nofree readnone returned [[B:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[B]], null ; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[B]], null
; CHECK-NEXT: br i1 [[CMP]], label [[RET_UNDEF0:%.*]], label [[IF_END:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[RET_UNDEF0:%.*]], label [[IF_END:%.*]]
; CHECK: ret_undef0: ; CHECK: ret_undef0:
; CHECK-NEXT: ret ptr undef ; CHECK-NEXT: ret ptr undef
; CHECK: if.end: ; CHECK: if.end:
▲ Show 20 Lines • Show All 114 Lines • ▼ Show 20 Lines
r: r:
%phi = phi ptr [ %b, %ret_arg ], [ %call, %ret_unknown ] %phi = phi ptr [ %b, %ret_arg ], [ %call, %ret_unknown ]
ret ptr %phi ret ptr %phi
} }
; TEST inconsistent IR in dead code. ; TEST inconsistent IR in dead code.
; ;
define i32 @deadblockcall1(i32 %A) #0 { define i32 @deadblockcall1(i32 %A) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@deadblockcall1 ; CHECK-LABEL: define {{[^@]+}}@deadblockcall1
; CHECK-SAME: (i32 returned [[A:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32 returned [[A:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret i32 [[A]] ; CHECK-NEXT: ret i32 [[A]]
; CHECK: unreachableblock: ; CHECK: unreachableblock:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; ;
entry: entry:
ret i32 %A ret i32 %A
unreachableblock: unreachableblock:
%B = call i32 @deadblockcall1(i32 %B) %B = call i32 @deadblockcall1(i32 %B)
ret i32 %B ret i32 %B
} }
declare i32 @deadblockcall_helper(i32 returned %A); declare i32 @deadblockcall_helper(i32 returned %A);
define i32 @deadblockcall2(i32 %A) #0 { define i32 @deadblockcall2(i32 %A) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@deadblockcall2 ; CHECK-LABEL: define {{[^@]+}}@deadblockcall2
; CHECK-SAME: (i32 returned [[A:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32 returned [[A:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: ret i32 [[A]] ; CHECK-NEXT: ret i32 [[A]]
; CHECK: unreachableblock1: ; CHECK: unreachableblock1:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; CHECK: unreachableblock2: ; CHECK: unreachableblock2:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; ;
entry: entry:
ret i32 %A ret i32 %A
unreachableblock1: unreachableblock1:
%B = call i32 @deadblockcall_helper(i32 %B) %B = call i32 @deadblockcall_helper(i32 %B)
ret i32 %B ret i32 %B
unreachableblock2: unreachableblock2:
%C = call i32 @deadblockcall1(i32 %C) %C = call i32 @deadblockcall1(i32 %C)
ret i32 %C ret i32 %C
} }
define i32 @deadblockphi1(i32 %A) #0 { define i32 @deadblockphi1(i32 %A) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@deadblockphi1 ; CHECK-LABEL: define {{[^@]+}}@deadblockphi1
; CHECK-SAME: (i32 returned [[A:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32 returned [[A:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[R:%.*]] ; CHECK-NEXT: br label [[R:%.*]]
; CHECK: unreachableblock1: ; CHECK: unreachableblock1:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; CHECK: unreachableblock2: ; CHECK: unreachableblock2:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
Show All 9 Linesunreachableblock2:
%C = call i32 @deadblockcall1(i32 %C) %C = call i32 @deadblockcall1(i32 %C)
br label %r br label %r
r: r:
%PHI = phi i32 [%A, %entry], [%C, %unreachableblock2] %PHI = phi i32 [%A, %entry], [%C, %unreachableblock2]
ret i32 %PHI ret i32 %PHI
} }
define i32 @deadblockphi2(i32 %A) #0 { define i32 @deadblockphi2(i32 %A) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@deadblockphi2 ; CHECK-LABEL: define {{[^@]+}}@deadblockphi2
; CHECK-SAME: (i32 returned [[A:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32 returned [[A:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[R:%.*]] ; CHECK-NEXT: br label [[R:%.*]]
; CHECK: unreachableblock1: ; CHECK: unreachableblock1:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; CHECK: unreachableblock2: ; CHECK: unreachableblock2:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
▲ Show 20 Lines • Show All 149 Lines • ▼ Show 20 Lines;
%add2 = add i32 %add1, %c2 %add2 = add i32 %add1, %c2
%add3 = add i32 %add2, %c3l %add3 = add i32 %add2, %c3l
%add4 = add i32 %add3, %c4l %add4 = add i32 %add3, %c4l
ret i32 %add4 ret i32 %add4
} }
@G = external global i8 @G = external global i8
define ptr @ret_const() #0 { define ptr @ret_const() #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@ret_const ; CHECK-LABEL: define {{[^@]+}}@ret_const
; CHECK-SAME: () #[[ATTR0]] { ; CHECK-SAME: () #[[ATTR0]] {
; CHECK-NEXT: ret ptr @G ; CHECK-NEXT: ret ptr @G
; ;
ret ptr @G ret ptr @G
} }
define ptr @use_const() #0 { define ptr @use_const() #0 {
; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; TUNIT-LABEL: define {{[^@]+}}@use_const ; TUNIT-LABEL: define {{[^@]+}}@use_const
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: ret ptr @G ; TUNIT-NEXT: ret ptr @G
; ;
; CGSCC: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@use_const ; CGSCC-LABEL: define {{[^@]+}}@use_const
; CGSCC-SAME: () #[[ATTR3]] { ; CGSCC-SAME: () #[[ATTR3]] {
; CGSCC-NEXT: [[C:%.*]] = call noundef nonnull dereferenceable(1) ptr @ret_const() #[[ATTR9:[0-9]+]] ; CGSCC-NEXT: [[C:%.*]] = call noundef nonnull dereferenceable(1) ptr @ret_const() #[[ATTR9:[0-9]+]]
; CGSCC-NEXT: ret ptr [[C]] ; CGSCC-NEXT: ret ptr [[C]]
; ;
%c = call ptr @ret_const() %c = call ptr @ret_const()
ret ptr %c ret ptr %c
} }
define ptr @dont_use_const() #0 { define ptr @dont_use_const() #0 {
; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; TUNIT-LABEL: define {{[^@]+}}@dont_use_const ; TUNIT-LABEL: define {{[^@]+}}@dont_use_const
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: ret ptr @G ; TUNIT-NEXT: ret ptr @G
; ;
; CGSCC: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@dont_use_const ; CGSCC-LABEL: define {{[^@]+}}@dont_use_const
; CGSCC-SAME: () #[[ATTR3]] { ; CGSCC-SAME: () #[[ATTR3]] {
; CGSCC-NEXT: [[C:%.*]] = musttail call noundef nonnull dereferenceable(1) ptr @ret_const() #[[ATTR9]] ; CGSCC-NEXT: [[C:%.*]] = musttail call noundef nonnull dereferenceable(1) ptr @ret_const() #[[ATTR9]]
; CGSCC-NEXT: ret ptr [[C]] ; CGSCC-NEXT: ret ptr [[C]]
; ;
%c = musttail call ptr @ret_const() %c = musttail call ptr @ret_const()
ret ptr %c ret ptr %c
} }
Show All 35 Lines
} }
declare dso_local ptr @__dynamic_cast(ptr, ptr, ptr, i64) declare dso_local ptr @__dynamic_cast(ptr, ptr, ptr, i64)
; UTC_ARGS: --enable ; UTC_ARGS: --enable
attributes #0 = { noinline nounwind uwtable } attributes #0 = { noinline nounwind uwtable }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable }
; TUNIT: attributes #[[ATTR1]] = { nofree noinline nosync nounwind memory(none) uwtable } ; TUNIT: attributes #[[ATTR1]] = { nofree noinline nosync nounwind memory(none) uwtable }
; TUNIT: attributes #[[ATTR2]] = { nofree noinline norecurse nosync nounwind memory(none) uwtable } ; TUNIT: attributes #[[ATTR2]] = { nofree noinline norecurse nosync nounwind memory(none) uwtable }
; TUNIT: attributes #[[ATTR3]] = { nofree noinline nosync nounwind memory(argmem: read) uwtable } ; TUNIT: attributes #[[ATTR3]] = { nofree noinline nosync nounwind memory(argmem: read) uwtable }
; TUNIT: attributes #[[ATTR4]] = { nofree noinline nosync nounwind willreturn memory(none) uwtable } ; TUNIT: attributes #[[ATTR4]] = { mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable }
; TUNIT: attributes #[[ATTR5]] = { noinline nounwind uwtable } ; TUNIT: attributes #[[ATTR5]] = { noinline nounwind uwtable }
; TUNIT: attributes #[[ATTR6]] = { noinline norecurse nounwind uwtable } ; TUNIT: attributes #[[ATTR6]] = { noinline norecurse nounwind uwtable }
; TUNIT: attributes #[[ATTR7]] = { noreturn } ; TUNIT: attributes #[[ATTR7]] = { noreturn }
; TUNIT: attributes #[[ATTR8]] = { norecurse } ; TUNIT: attributes #[[ATTR8]] = { norecurse }
; TUNIT: attributes #[[ATTR9:[0-9]+]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR9:[0-9]+]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR10]] = { nofree nosync nounwind } ; TUNIT: attributes #[[ATTR10]] = { nofree nosync nounwind }
; TUNIT: attributes #[[ATTR11]] = { nounwind } ; TUNIT: attributes #[[ATTR11]] = { nounwind }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable }
; CGSCC: attributes #[[ATTR1]] = { nofree noinline nosync nounwind memory(none) uwtable } ; CGSCC: attributes #[[ATTR1]] = { nofree noinline nosync nounwind memory(none) uwtable }
; CGSCC: attributes #[[ATTR2]] = { nofree noinline nosync nounwind memory(argmem: read) uwtable } ; CGSCC: attributes #[[ATTR2]] = { nofree noinline nosync nounwind memory(argmem: read) uwtable }
; CGSCC: attributes #[[ATTR3]] = { nofree noinline nosync nounwind willreturn memory(none) uwtable } ; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable }
; CGSCC: attributes #[[ATTR4]] = { noinline nounwind uwtable } ; CGSCC: attributes #[[ATTR4]] = { noinline nounwind uwtable }
; CGSCC: attributes #[[ATTR5]] = { noreturn } ; CGSCC: attributes #[[ATTR5]] = { noreturn }
; CGSCC: attributes #[[ATTR6:[0-9]+]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR6:[0-9]+]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR7]] = { nofree nosync nounwind } ; CGSCC: attributes #[[ATTR7]] = { nofree nosync nounwind }
; CGSCC: attributes #[[ATTR8]] = { nounwind } ; CGSCC: attributes #[[ATTR8]] = { nounwind }
; CGSCC: attributes #[[ATTR9]] = { willreturn } ; CGSCC: attributes #[[ATTR9]] = { willreturn }
;. ;.

llvm/test/Transforms/Attributor/undefined_behavior.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=7 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=7 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Test cases specifically designed for the "undefined behavior" abstract function attribute. ; Test cases specifically designed for the "undefined behavior" abstract function attribute.
; We want to verify that whenever undefined behavior is assumed, the code becomes unreachable. ; We want to verify that whenever undefined behavior is assumed, the code becomes unreachable.
; We use FIXME's to indicate problems and missing attributes. ; We use FIXME's to indicate problems and missing attributes.
; -- Load tests -- ; -- Load tests --
define void @load_wholly_unreachable() { define void @load_wholly_unreachable() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@load_wholly_unreachable ; CHECK-LABEL: define {{[^@]+}}@load_wholly_unreachable
; CHECK-SAME: () #[[ATTR0:[0-9]+]] { ; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; ;
%a = load i32, ptr null %a = load i32, ptr null
ret void ret void
} }
define void @loads_wholly_unreachable() { define void @loads_wholly_unreachable() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@loads_wholly_unreachable ; CHECK-LABEL: define {{[^@]+}}@loads_wholly_unreachable
; CHECK-SAME: () #[[ATTR0]] { ; CHECK-SAME: () #[[ATTR0]] {
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; ;
%a = load i32, ptr null %a = load i32, ptr null
%b = load i32, ptr null %b = load i32, ptr null
ret void ret void
} }
define void @load_single_bb_unreachable(i1 %cond) { define void @load_single_bb_unreachable(i1 %cond) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@load_single_bb_unreachable ; CHECK-LABEL: define {{[^@]+}}@load_single_bb_unreachable
; CHECK-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[E:%.*]] ; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[E:%.*]]
; CHECK: t: ; CHECK: t:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; CHECK: e: ; CHECK: e:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
br i1 %cond, label %t, label %e br i1 %cond, label %t, label %e
t: t:
%b = load i32, ptr null %b = load i32, ptr null
br label %e br label %e
e: e:
ret void ret void
} }
; Note that while the load is removed (because it's unused), the block ; Note that while the load is removed (because it's unused), the block
; is not changed to unreachable ; is not changed to unreachable
define void @load_null_pointer_is_defined() null_pointer_is_valid { define void @load_null_pointer_is_defined() null_pointer_is_valid {
; CHECK: Function Attrs: nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@load_null_pointer_is_defined ; CHECK-LABEL: define {{[^@]+}}@load_null_pointer_is_defined
; CHECK-SAME: () #[[ATTR1:[0-9]+]] { ; CHECK-SAME: () #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%a = load i32, ptr null %a = load i32, ptr null
ret void ret void
} }
define internal ptr @ret_null() { define internal ptr @ret_null() {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@ret_null ; CGSCC-LABEL: define {{[^@]+}}@ret_null
; CGSCC-SAME: () #[[ATTR0]] { ; CGSCC-SAME: () #[[ATTR0]] {
; CGSCC-NEXT: ret ptr null ; CGSCC-NEXT: ret ptr null
; ;
ret ptr null ret ptr null
} }
define void @load_null_propagated() { define void @load_null_propagated() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@load_null_propagated ; TUNIT-LABEL: define {{[^@]+}}@load_null_propagated
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@load_null_propagated ; CGSCC-LABEL: define {{[^@]+}}@load_null_propagated
; CGSCC-SAME: () #[[ATTR2:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR2:[0-9]+]] {
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%ptr = call ptr @ret_null() %ptr = call ptr @ret_null()
%a = load i32, ptr %ptr %a = load i32, ptr %ptr
ret void ret void
} }
; -- Store tests -- ; -- Store tests --
define void @store_wholly_unreachable() { define void @store_wholly_unreachable() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@store_wholly_unreachable ; CHECK-LABEL: define {{[^@]+}}@store_wholly_unreachable
; CHECK-SAME: () #[[ATTR0]] { ; CHECK-SAME: () #[[ATTR0]] {
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; ;
store i32 5, ptr null store i32 5, ptr null
ret void ret void
} }
define void @store_wholly_unreachable_volatile() { define void @store_wholly_unreachable_volatile() {
; TUNIT: Function Attrs: nofree norecurse nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@store_wholly_unreachable_volatile ; TUNIT-LABEL: define {{[^@]+}}@store_wholly_unreachable_volatile
; TUNIT-SAME: () #[[ATTR2:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR2:[0-9]+]] {
; TUNIT-NEXT: store volatile i32 5, ptr null, align 4294967296 ; TUNIT-NEXT: store volatile i32 5, ptr null, align 4294967296
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@store_wholly_unreachable_volatile ; CGSCC-LABEL: define {{[^@]+}}@store_wholly_unreachable_volatile
; CGSCC-SAME: () #[[ATTR3:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR3:[0-9]+]] {
; CGSCC-NEXT: store volatile i32 5, ptr null, align 4294967296 ; CGSCC-NEXT: store volatile i32 5, ptr null, align 4294967296
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
store volatile i32 5, ptr null store volatile i32 5, ptr null
ret void ret void
} }
define void @store_single_bb_unreachable(i1 %cond) { define void @store_single_bb_unreachable(i1 %cond) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@store_single_bb_unreachable ; CHECK-LABEL: define {{[^@]+}}@store_single_bb_unreachable
; CHECK-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[E:%.*]] ; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[E:%.*]]
; CHECK: t: ; CHECK: t:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; CHECK: e: ; CHECK: e:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
br i1 %cond, label %t, label %e br i1 %cond, label %t, label %e
t: t:
store i32 5, ptr null store i32 5, ptr null
br label %e br label %e
e: e:
ret void ret void
} }
define void @store_null_pointer_is_defined() null_pointer_is_valid { define void @store_null_pointer_is_defined() null_pointer_is_valid {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@store_null_pointer_is_defined ; TUNIT-LABEL: define {{[^@]+}}@store_null_pointer_is_defined
; TUNIT-SAME: () #[[ATTR3:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR3:[0-9]+]] {
; TUNIT-NEXT: store i32 5, ptr null, align 4294967296 ; TUNIT-NEXT: store i32 5, ptr null, align 4294967296
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@store_null_pointer_is_defined ; CGSCC-LABEL: define {{[^@]+}}@store_null_pointer_is_defined
; CGSCC-SAME: () #[[ATTR4:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR4:[0-9]+]] {
; CGSCC-NEXT: store i32 5, ptr null, align 4294967296 ; CGSCC-NEXT: store i32 5, ptr null, align 4294967296
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
store i32 5, ptr null store i32 5, ptr null
ret void ret void
} }
define void @store_null_propagated() { define void @store_null_propagated() {
; ATTRIBUTOR-LABEL: @store_null_propagated( ; ATTRIBUTOR-LABEL: @store_null_propagated(
; ATTRIBUTOR-NEXT: unreachable ; ATTRIBUTOR-NEXT: unreachable
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@store_null_propagated ; TUNIT-LABEL: define {{[^@]+}}@store_null_propagated
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@store_null_propagated ; CGSCC-LABEL: define {{[^@]+}}@store_null_propagated
; CGSCC-SAME: () #[[ATTR5:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR5:[0-9]+]] {
; CGSCC-NEXT: [[PTR:%.*]] = call noalias align 4294967296 ptr @ret_null() #[[ATTR10:[0-9]+]] ; CGSCC-NEXT: [[PTR:%.*]] = call noalias align 4294967296 ptr @ret_null() #[[ATTR10:[0-9]+]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%ptr = call ptr @ret_null() %ptr = call ptr @ret_null()
store i32 5, ptr %ptr store i32 5, ptr %ptr
ret void ret void
} }
; -- AtomicRMW tests -- ; -- AtomicRMW tests --
define void @atomicrmw_wholly_unreachable() { define void @atomicrmw_wholly_unreachable() {
; TUNIT: Function Attrs: nofree norecurse nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@atomicrmw_wholly_unreachable ; TUNIT-LABEL: define {{[^@]+}}@atomicrmw_wholly_unreachable
; TUNIT-SAME: () #[[ATTR2]] { ; TUNIT-SAME: () #[[ATTR2]] {
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree norecurse nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@atomicrmw_wholly_unreachable ; CGSCC-LABEL: define {{[^@]+}}@atomicrmw_wholly_unreachable
; CGSCC-SAME: () #[[ATTR3]] { ; CGSCC-SAME: () #[[ATTR3]] {
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
%a = atomicrmw add ptr null, i32 1 acquire %a = atomicrmw add ptr null, i32 1 acquire
ret void ret void
} }
define void @atomicrmw_single_bb_unreachable(i1 %cond) { define void @atomicrmw_single_bb_unreachable(i1 %cond) {
; TUNIT: Function Attrs: nofree norecurse nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@atomicrmw_single_bb_unreachable ; TUNIT-LABEL: define {{[^@]+}}@atomicrmw_single_bb_unreachable
; TUNIT-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR2]] { ; TUNIT-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR2]] {
; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[E:%.*]] ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[E:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: e: ; TUNIT: e:
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@atomicrmw_single_bb_unreachable ; CGSCC-LABEL: define {{[^@]+}}@atomicrmw_single_bb_unreachable
; CGSCC-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[E:%.*]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[E:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: e: ; CGSCC: e:
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
br i1 %cond, label %t, label %e br i1 %cond, label %t, label %e
t: t:
%a = atomicrmw add ptr null, i32 1 acquire %a = atomicrmw add ptr null, i32 1 acquire
br label %e br label %e
e: e:
ret void ret void
} }
define void @atomicrmw_null_pointer_is_defined() null_pointer_is_valid { define void @atomicrmw_null_pointer_is_defined() null_pointer_is_valid {
; TUNIT: Function Attrs: nofree norecurse nounwind null_pointer_is_valid willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nounwind null_pointer_is_valid willreturn
; TUNIT-LABEL: define {{[^@]+}}@atomicrmw_null_pointer_is_defined ; TUNIT-LABEL: define {{[^@]+}}@atomicrmw_null_pointer_is_defined
; TUNIT-SAME: () #[[ATTR4:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR4:[0-9]+]] {
; TUNIT-NEXT: [[A:%.*]] = atomicrmw add ptr null, i32 1 acquire, align 4 ; TUNIT-NEXT: [[A:%.*]] = atomicrmw add ptr null, i32 1 acquire, align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nounwind null_pointer_is_valid willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nounwind null_pointer_is_valid willreturn
; CGSCC-LABEL: define {{[^@]+}}@atomicrmw_null_pointer_is_defined ; CGSCC-LABEL: define {{[^@]+}}@atomicrmw_null_pointer_is_defined
; CGSCC-SAME: () #[[ATTR6:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR6:[0-9]+]] {
; CGSCC-NEXT: [[A:%.*]] = atomicrmw add ptr null, i32 1 acquire, align 4 ; CGSCC-NEXT: [[A:%.*]] = atomicrmw add ptr null, i32 1 acquire, align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%a = atomicrmw add ptr null, i32 1 acquire %a = atomicrmw add ptr null, i32 1 acquire
ret void ret void
} }
define void @atomicrmw_null_propagated() { define void @atomicrmw_null_propagated() {
; ATTRIBUTOR-LABEL: @atomicrmw_null_propagated( ; ATTRIBUTOR-LABEL: @atomicrmw_null_propagated(
; ATTRIBUTOR-NEXT: unreachable ; ATTRIBUTOR-NEXT: unreachable
; ;
; TUNIT: Function Attrs: nofree norecurse nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@atomicrmw_null_propagated ; TUNIT-LABEL: define {{[^@]+}}@atomicrmw_null_propagated
; TUNIT-SAME: () #[[ATTR2]] { ; TUNIT-SAME: () #[[ATTR2]] {
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@atomicrmw_null_propagated ; CGSCC-LABEL: define {{[^@]+}}@atomicrmw_null_propagated
; CGSCC-SAME: () #[[ATTR7:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR7:[0-9]+]] {
; CGSCC-NEXT: [[PTR:%.*]] = call noalias ptr @ret_null() #[[ATTR10]] ; CGSCC-NEXT: [[PTR:%.*]] = call noalias ptr @ret_null() #[[ATTR10]]
; CGSCC-NEXT: [[A:%.*]] = atomicrmw add ptr [[PTR]], i32 1 acquire, align 4 ; CGSCC-NEXT: [[A:%.*]] = atomicrmw add ptr [[PTR]], i32 1 acquire, align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%ptr = call ptr @ret_null() %ptr = call ptr @ret_null()
%a = atomicrmw add ptr %ptr, i32 1 acquire %a = atomicrmw add ptr %ptr, i32 1 acquire
ret void ret void
} }
; -- AtomicCmpXchg tests -- ; -- AtomicCmpXchg tests --
define void @atomiccmpxchg_wholly_unreachable() { define void @atomiccmpxchg_wholly_unreachable() {
; TUNIT: Function Attrs: nofree norecurse nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@atomiccmpxchg_wholly_unreachable ; TUNIT-LABEL: define {{[^@]+}}@atomiccmpxchg_wholly_unreachable
; TUNIT-SAME: () #[[ATTR2]] { ; TUNIT-SAME: () #[[ATTR2]] {
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree norecurse nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@atomiccmpxchg_wholly_unreachable ; CGSCC-LABEL: define {{[^@]+}}@atomiccmpxchg_wholly_unreachable
; CGSCC-SAME: () #[[ATTR3]] { ; CGSCC-SAME: () #[[ATTR3]] {
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
%a = cmpxchg ptr null, i32 2, i32 3 acq_rel monotonic %a = cmpxchg ptr null, i32 2, i32 3 acq_rel monotonic
ret void ret void
} }
define void @atomiccmpxchg_single_bb_unreachable(i1 %cond) { define void @atomiccmpxchg_single_bb_unreachable(i1 %cond) {
; TUNIT: Function Attrs: nofree norecurse nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@atomiccmpxchg_single_bb_unreachable ; TUNIT-LABEL: define {{[^@]+}}@atomiccmpxchg_single_bb_unreachable
; TUNIT-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR2]] { ; TUNIT-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR2]] {
; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[E:%.*]] ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[E:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: e: ; TUNIT: e:
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@atomiccmpxchg_single_bb_unreachable ; CGSCC-LABEL: define {{[^@]+}}@atomiccmpxchg_single_bb_unreachable
; CGSCC-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[E:%.*]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[E:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: e: ; CGSCC: e:
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
br i1 %cond, label %t, label %e br i1 %cond, label %t, label %e
t: t:
%a = cmpxchg ptr null, i32 2, i32 3 acq_rel monotonic %a = cmpxchg ptr null, i32 2, i32 3 acq_rel monotonic
br label %e br label %e
e: e:
ret void ret void
} }
define void @atomiccmpxchg_null_pointer_is_defined() null_pointer_is_valid { define void @atomiccmpxchg_null_pointer_is_defined() null_pointer_is_valid {
; TUNIT: Function Attrs: nofree norecurse nounwind null_pointer_is_valid willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nounwind null_pointer_is_valid willreturn
; TUNIT-LABEL: define {{[^@]+}}@atomiccmpxchg_null_pointer_is_defined ; TUNIT-LABEL: define {{[^@]+}}@atomiccmpxchg_null_pointer_is_defined
; TUNIT-SAME: () #[[ATTR4]] { ; TUNIT-SAME: () #[[ATTR4]] {
; TUNIT-NEXT: [[A:%.*]] = cmpxchg ptr null, i32 2, i32 3 acq_rel monotonic, align 4 ; TUNIT-NEXT: [[A:%.*]] = cmpxchg ptr null, i32 2, i32 3 acq_rel monotonic, align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nounwind null_pointer_is_valid willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nounwind null_pointer_is_valid willreturn
; CGSCC-LABEL: define {{[^@]+}}@atomiccmpxchg_null_pointer_is_defined ; CGSCC-LABEL: define {{[^@]+}}@atomiccmpxchg_null_pointer_is_defined
; CGSCC-SAME: () #[[ATTR6]] { ; CGSCC-SAME: () #[[ATTR6]] {
; CGSCC-NEXT: [[A:%.*]] = cmpxchg ptr null, i32 2, i32 3 acq_rel monotonic, align 4 ; CGSCC-NEXT: [[A:%.*]] = cmpxchg ptr null, i32 2, i32 3 acq_rel monotonic, align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%a = cmpxchg ptr null, i32 2, i32 3 acq_rel monotonic %a = cmpxchg ptr null, i32 2, i32 3 acq_rel monotonic
ret void ret void
} }
define void @atomiccmpxchg_null_propagated() { define void @atomiccmpxchg_null_propagated() {
; ATTRIBUTOR-LABEL: @atomiccmpxchg_null_propagated( ; ATTRIBUTOR-LABEL: @atomiccmpxchg_null_propagated(
; ATTRIBUTOR-NEXT: unreachable ; ATTRIBUTOR-NEXT: unreachable
; ;
; TUNIT: Function Attrs: nofree norecurse nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@atomiccmpxchg_null_propagated ; TUNIT-LABEL: define {{[^@]+}}@atomiccmpxchg_null_propagated
; TUNIT-SAME: () #[[ATTR2]] { ; TUNIT-SAME: () #[[ATTR2]] {
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@atomiccmpxchg_null_propagated ; CGSCC-LABEL: define {{[^@]+}}@atomiccmpxchg_null_propagated
; CGSCC-SAME: () #[[ATTR7]] { ; CGSCC-SAME: () #[[ATTR7]] {
; CGSCC-NEXT: [[PTR:%.*]] = call noalias ptr @ret_null() #[[ATTR10]] ; CGSCC-NEXT: [[PTR:%.*]] = call noalias ptr @ret_null() #[[ATTR10]]
; CGSCC-NEXT: [[A:%.*]] = cmpxchg ptr [[PTR]], i32 2, i32 3 acq_rel monotonic, align 4 ; CGSCC-NEXT: [[A:%.*]] = cmpxchg ptr [[PTR]], i32 2, i32 3 acq_rel monotonic, align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%ptr = call ptr @ret_null() %ptr = call ptr @ret_null()
%a = cmpxchg ptr %ptr, i32 2, i32 3 acq_rel monotonic %a = cmpxchg ptr %ptr, i32 2, i32 3 acq_rel monotonic
ret void ret void
} }
; -- Conditional branching tests -- ; -- Conditional branching tests --
; Note: The unreachable on %t and %e is _not_ from AAUndefinedBehavior ; Note: The unreachable on %t and %e is _not_ from AAUndefinedBehavior
define i32 @cond_br_on_undef() { define i32 @cond_br_on_undef() {
; TUNIT: Function Attrs: nofree norecurse noreturn nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@cond_br_on_undef ; TUNIT-LABEL: define {{[^@]+}}@cond_br_on_undef
; TUNIT-SAME: () #[[ATTR5:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR5:[0-9]+]] {
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: e: ; TUNIT: e:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree norecurse noreturn nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@cond_br_on_undef ; CGSCC-LABEL: define {{[^@]+}}@cond_br_on_undef
; CGSCC-SAME: () #[[ATTR8:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR8:[0-9]+]] {
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: e: ; CGSCC: e:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
br i1 undef, label %t, label %e br i1 undef, label %t, label %e
t: t:
ret i32 1 ret i32 1
e: e:
ret i32 2 ret i32 2
} }
; More complicated branching ; More complicated branching
; Valid branch - verify that this is not converted ; Valid branch - verify that this is not converted
; to unreachable. ; to unreachable.
define void @cond_br_on_undef2(i1 %cond) { define void @cond_br_on_undef2(i1 %cond) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@cond_br_on_undef2 ; CHECK-LABEL: define {{[^@]+}}@cond_br_on_undef2
; CHECK-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: br i1 [[COND]], label [[T1:%.*]], label [[E1:%.*]] ; CHECK-NEXT: br i1 [[COND]], label [[T1:%.*]], label [[E1:%.*]]
; CHECK: t1: ; CHECK: t1:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; CHECK: t2: ; CHECK: t2:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; CHECK: e2: ; CHECK: e2:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; CHECK: e1: ; CHECK: e1:
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
br i1 %cond, label %t1, label %e1 br i1 %cond, label %t1, label %e1
t1: t1:
br i1 undef, label %t2, label %e2 br i1 undef, label %t2, label %e2
t2: t2:
ret void ret void
e2: e2:
ret void ret void
e1: e1:
ret void ret void
} }
define i1 @ret_undef() { define i1 @ret_undef() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@ret_undef ; CHECK-LABEL: define {{[^@]+}}@ret_undef
; CHECK-SAME: () #[[ATTR0]] { ; CHECK-SAME: () #[[ATTR0]] {
; CHECK-NEXT: ret i1 undef ; CHECK-NEXT: ret i1 undef
; ;
ret i1 undef ret i1 undef
} }
define void @cond_br_on_undef_interproc() { define void @cond_br_on_undef_interproc() {
; TUNIT: Function Attrs: nofree norecurse noreturn nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@cond_br_on_undef_interproc ; TUNIT-LABEL: define {{[^@]+}}@cond_br_on_undef_interproc
; TUNIT-SAME: () #[[ATTR5]] { ; TUNIT-SAME: () #[[ATTR5]] {
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: e: ; TUNIT: e:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@cond_br_on_undef_interproc ; CGSCC-LABEL: define {{[^@]+}}@cond_br_on_undef_interproc
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: [[COND:%.*]] = call i1 @ret_undef() #[[ATTR10]] ; CGSCC-NEXT: [[COND:%.*]] = call i1 @ret_undef() #[[ATTR10]]
; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[E:%.*]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[E:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; CGSCC: e: ; CGSCC: e:
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%cond = call i1 @ret_undef() %cond = call i1 @ret_undef()
br i1 %cond, label %t, label %e br i1 %cond, label %t, label %e
t: t:
ret void ret void
e: e:
ret void ret void
} }
define i1 @ret_undef2() { define i1 @ret_undef2() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@ret_undef2 ; CHECK-LABEL: define {{[^@]+}}@ret_undef2
; CHECK-SAME: () #[[ATTR0]] { ; CHECK-SAME: () #[[ATTR0]] {
; CHECK-NEXT: br i1 true, label [[T:%.*]], label [[E:%.*]] ; CHECK-NEXT: br i1 true, label [[T:%.*]], label [[E:%.*]]
; CHECK: t: ; CHECK: t:
; CHECK-NEXT: ret i1 undef ; CHECK-NEXT: ret i1 undef
; CHECK: e: ; CHECK: e:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; ;
br i1 true, label %t, label %e br i1 true, label %t, label %e
t: t:
ret i1 undef ret i1 undef
e: e:
ret i1 undef ret i1 undef
} }
; More complicated interproc deduction of undef ; More complicated interproc deduction of undef
define void @cond_br_on_undef_interproc2() { define void @cond_br_on_undef_interproc2() {
; TUNIT: Function Attrs: nofree norecurse noreturn nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@cond_br_on_undef_interproc2 ; TUNIT-LABEL: define {{[^@]+}}@cond_br_on_undef_interproc2
; TUNIT-SAME: () #[[ATTR5]] { ; TUNIT-SAME: () #[[ATTR5]] {
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: e: ; TUNIT: e:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@cond_br_on_undef_interproc2 ; CGSCC-LABEL: define {{[^@]+}}@cond_br_on_undef_interproc2
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: [[COND:%.*]] = call i1 @ret_undef2() #[[ATTR10]] ; CGSCC-NEXT: [[COND:%.*]] = call i1 @ret_undef2() #[[ATTR10]]
; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[E:%.*]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[E:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; CGSCC: e: ; CGSCC: e:
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%cond = call i1 @ret_undef2() %cond = call i1 @ret_undef2()
br i1 %cond, label %t, label %e br i1 %cond, label %t, label %e
t: t:
ret void ret void
e: e:
ret void ret void
} }
; Branch on undef that depends on propagation of ; Branch on undef that depends on propagation of
; undef of a previous instruction. ; undef of a previous instruction.
define i32 @cond_br_on_undef3() { define i32 @cond_br_on_undef3() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@cond_br_on_undef3 ; CHECK-LABEL: define {{[^@]+}}@cond_br_on_undef3
; CHECK-SAME: () #[[ATTR0]] { ; CHECK-SAME: () #[[ATTR0]] {
; CHECK-NEXT: [[COND:%.*]] = icmp ne i32 1, undef ; CHECK-NEXT: [[COND:%.*]] = icmp ne i32 1, undef
; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[E:%.*]] ; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[E:%.*]]
; CHECK: t: ; CHECK: t:
; CHECK-NEXT: ret i32 1 ; CHECK-NEXT: ret i32 1
; CHECK: e: ; CHECK: e:
; CHECK-NEXT: ret i32 2 ; CHECK-NEXT: ret i32 2
; ;
%cond = icmp ne i32 1, undef %cond = icmp ne i32 1, undef
br i1 %cond, label %t, label %e br i1 %cond, label %t, label %e
t: t:
ret i32 1 ret i32 1
e: e:
ret i32 2 ret i32 2
} }
; Branch on undef because of uninitialized value. ; Branch on undef because of uninitialized value.
; FIXME: Currently it doesn't propagate the undef. ; FIXME: Currently it doesn't propagate the undef.
define i32 @cond_br_on_undef_uninit() { define i32 @cond_br_on_undef_uninit() {
; TUNIT: Function Attrs: nofree norecurse noreturn nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@cond_br_on_undef_uninit ; TUNIT-LABEL: define {{[^@]+}}@cond_br_on_undef_uninit
; TUNIT-SAME: () #[[ATTR5]] { ; TUNIT-SAME: () #[[ATTR5]] {
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: e: ; TUNIT: e:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree norecurse noreturn nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@cond_br_on_undef_uninit ; CGSCC-LABEL: define {{[^@]+}}@cond_br_on_undef_uninit
; CGSCC-SAME: () #[[ATTR8]] { ; CGSCC-SAME: () #[[ATTR8]] {
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: e: ; CGSCC: e:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
%alloc = alloca i1 %alloc = alloca i1
%cond = load i1, ptr %alloc %cond = load i1, ptr %alloc
br i1 %cond, label %t, label %e br i1 %cond, label %t, label %e
t: t:
ret i32 1 ret i32 1
e: e:
ret i32 2 ret i32 2
} }
; Note that the `load` has UB (so it will be changed to unreachable) ; Note that the `load` has UB (so it will be changed to unreachable)
; and the branch is a terminator that can be constant-folded. ; and the branch is a terminator that can be constant-folded.
; We want to test that doing both won't cause a segfault. ; We want to test that doing both won't cause a segfault.
; MODULE-NOT: @callee( ; MODULE-NOT: @callee(
define internal i32 @callee(i1 %C, ptr %A) { define internal i32 @callee(i1 %C, ptr %A) {
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@callee ; CGSCC-LABEL: define {{[^@]+}}@callee
; CGSCC-SAME: () #[[ATTR0]] { ; CGSCC-SAME: () #[[ATTR0]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: T: ; CGSCC: T:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; CGSCC: F: ; CGSCC: F:
; CGSCC-NEXT: ret i32 1 ; CGSCC-NEXT: ret i32 1
; ;
entry: entry:
%A.0 = load i32, ptr null %A.0 = load i32, ptr null
br i1 %C, label %T, label %F br i1 %C, label %T, label %F
T: T:
ret i32 %A.0 ret i32 %A.0
F: F:
ret i32 1 ret i32 1
} }
define i32 @foo() { define i32 @foo() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@foo ; TUNIT-LABEL: define {{[^@]+}}@foo
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: ret i32 1 ; TUNIT-NEXT: ret i32 1
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@foo ; CGSCC-LABEL: define {{[^@]+}}@foo
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: [[X:%.*]] = call noundef i32 @callee() #[[ATTR10]] ; CGSCC-NEXT: [[X:%.*]] = call noundef i32 @callee() #[[ATTR10]]
; CGSCC-NEXT: ret i32 [[X]] ; CGSCC-NEXT: ret i32 [[X]]
; ;
%X = call i32 @callee(i1 false, ptr null) %X = call i32 @callee(i1 false, ptr null)
ret i32 %X ret i32 %X
} }
; Tests for nonnull noundef attribute violation. ; Tests for nonnull noundef attribute violation.
; ;
; Tests for argument position ; Tests for argument position
define void @arg_nonnull_1(ptr nonnull %a) { define void @arg_nonnull_1(ptr nonnull %a) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_1 ; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_1
; TUNIT-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR6:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR6:[0-9]+]] {
; TUNIT-NEXT: store i32 0, ptr [[A]], align 4 ; TUNIT-NEXT: store i32 0, ptr [[A]], align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_1 ; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_1
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR9:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR9:[0-9]+]] {
; CGSCC-NEXT: store i32 0, ptr [[A]], align 4 ; CGSCC-NEXT: store i32 0, ptr [[A]], align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
store i32 0, ptr %a store i32 0, ptr %a
ret void ret void
} }
define void @arg_nonnull_1_noundef_1(ptr nonnull noundef %a) { define void @arg_nonnull_1_noundef_1(ptr nonnull noundef %a) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_1_noundef_1 ; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_1_noundef_1
; TUNIT-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR6]] { ; TUNIT-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR6]] {
; TUNIT-NEXT: store i32 0, ptr [[A]], align 4 ; TUNIT-NEXT: store i32 0, ptr [[A]], align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_1_noundef_1 ; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_1_noundef_1
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR9]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR9]] {
; CGSCC-NEXT: store i32 0, ptr [[A]], align 4 ; CGSCC-NEXT: store i32 0, ptr [[A]], align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
store i32 0, ptr %a store i32 0, ptr %a
ret void ret void
} }
define void @arg_nonnull_12(ptr nonnull %a, ptr nonnull %b, ptr %c) { define void @arg_nonnull_12(ptr nonnull %a, ptr nonnull %b, ptr %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_12 ; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_12
; TUNIT-SAME: (ptr nocapture nofree nonnull writeonly [[A:%.*]], ptr nocapture nofree nonnull writeonly [[B:%.*]], ptr nofree writeonly [[C:%.*]]) #[[ATTR6]] { ; TUNIT-SAME: (ptr nocapture nofree nonnull writeonly [[A:%.*]], ptr nocapture nofree nonnull writeonly [[B:%.*]], ptr nofree writeonly [[C:%.*]]) #[[ATTR6]] {
; TUNIT-NEXT: [[D:%.*]] = icmp eq ptr [[C]], null ; TUNIT-NEXT: [[D:%.*]] = icmp eq ptr [[C]], null
; TUNIT-NEXT: br i1 [[D]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[D]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: store i32 0, ptr [[A]], align 4 ; TUNIT-NEXT: store i32 0, ptr [[A]], align 4
; TUNIT-NEXT: br label [[RET:%.*]] ; TUNIT-NEXT: br label [[RET:%.*]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: store i32 1, ptr [[B]], align 4 ; TUNIT-NEXT: store i32 1, ptr [[B]], align 4
; TUNIT-NEXT: br label [[RET]] ; TUNIT-NEXT: br label [[RET]]
; TUNIT: ret: ; TUNIT: ret:
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_12 ; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_12
; CGSCC-SAME: (ptr nocapture nofree nonnull writeonly [[A:%.*]], ptr nocapture nofree nonnull writeonly [[B:%.*]], ptr nofree writeonly [[C:%.*]]) #[[ATTR9]] { ; CGSCC-SAME: (ptr nocapture nofree nonnull writeonly [[A:%.*]], ptr nocapture nofree nonnull writeonly [[B:%.*]], ptr nofree writeonly [[C:%.*]]) #[[ATTR9]] {
; CGSCC-NEXT: [[D:%.*]] = icmp eq ptr [[C]], null ; CGSCC-NEXT: [[D:%.*]] = icmp eq ptr [[C]], null
; CGSCC-NEXT: br i1 [[D]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[D]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: store i32 0, ptr [[A]], align 4 ; CGSCC-NEXT: store i32 0, ptr [[A]], align 4
; CGSCC-NEXT: br label [[RET:%.*]] ; CGSCC-NEXT: br label [[RET:%.*]]
; CGSCC: f: ; CGSCC: f:
Show All 10 Lines
f: f:
store i32 1, ptr %b store i32 1, ptr %b
br label %ret br label %ret
ret: ret:
ret void ret void
} }
define void @arg_nonnull_12_noundef_2(ptr nonnull %a, ptr noundef nonnull %b, ptr %c) { define void @arg_nonnull_12_noundef_2(ptr nonnull %a, ptr noundef nonnull %b, ptr %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_12_noundef_2 ; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_12_noundef_2
; TUNIT-SAME: (ptr nocapture nofree nonnull writeonly [[A:%.*]], ptr nocapture nofree noundef nonnull writeonly [[B:%.*]], ptr nofree writeonly [[C:%.*]]) #[[ATTR6]] { ; TUNIT-SAME: (ptr nocapture nofree nonnull writeonly [[A:%.*]], ptr nocapture nofree noundef nonnull writeonly [[B:%.*]], ptr nofree writeonly [[C:%.*]]) #[[ATTR6]] {
; TUNIT-NEXT: [[D:%.*]] = icmp eq ptr [[C]], null ; TUNIT-NEXT: [[D:%.*]] = icmp eq ptr [[C]], null
; TUNIT-NEXT: br i1 [[D]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[D]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: store i32 0, ptr [[A]], align 4 ; TUNIT-NEXT: store i32 0, ptr [[A]], align 4
; TUNIT-NEXT: br label [[RET:%.*]] ; TUNIT-NEXT: br label [[RET:%.*]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: store i32 1, ptr [[B]], align 4 ; TUNIT-NEXT: store i32 1, ptr [[B]], align 4
; TUNIT-NEXT: br label [[RET]] ; TUNIT-NEXT: br label [[RET]]
; TUNIT: ret: ; TUNIT: ret:
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_12_noundef_2 ; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_12_noundef_2
; CGSCC-SAME: (ptr nocapture nofree nonnull writeonly [[A:%.*]], ptr nocapture nofree noundef nonnull writeonly [[B:%.*]], ptr nofree writeonly [[C:%.*]]) #[[ATTR9]] { ; CGSCC-SAME: (ptr nocapture nofree nonnull writeonly [[A:%.*]], ptr nocapture nofree noundef nonnull writeonly [[B:%.*]], ptr nofree writeonly [[C:%.*]]) #[[ATTR9]] {
; CGSCC-NEXT: [[D:%.*]] = icmp eq ptr [[C]], null ; CGSCC-NEXT: [[D:%.*]] = icmp eq ptr [[C]], null
; CGSCC-NEXT: br i1 [[D]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[D]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: store i32 0, ptr [[A]], align 4 ; CGSCC-NEXT: store i32 0, ptr [[A]], align 4
; CGSCC-NEXT: br label [[RET:%.*]] ; CGSCC-NEXT: br label [[RET:%.*]]
; CGSCC: f: ; CGSCC: f:
Show All 11 Linesf:
store i32 1, ptr %b store i32 1, ptr %b
br label %ret br label %ret
ret: ret:
ret void ret void
} }
; Pass null directly to argument with nonnull attribute ; Pass null directly to argument with nonnull attribute
define void @arg_nonnull_violation1_1() { define void @arg_nonnull_violation1_1() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_violation1_1 ; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_violation1_1
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_violation1_1 ; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_violation1_1
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
call void @arg_nonnull_1(ptr null) call void @arg_nonnull_1(ptr null)
ret void ret void
} }
define void @arg_nonnull_violation1_2() { define void @arg_nonnull_violation1_2() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_violation1_2 ; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_violation1_2
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_violation1_2 ; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_violation1_2
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
call void @arg_nonnull_1_noundef_1(ptr null) call void @arg_nonnull_1_noundef_1(ptr null)
ret void ret void
} }
; A case that depends on value simplification ; A case that depends on value simplification
define void @arg_nonnull_violation2_1(i1 %c) { define void @arg_nonnull_violation2_1(i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_violation2_1 ; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_violation2_1
; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_violation2_1 ; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_violation2_1
; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
%mustnull = select i1 %c, ptr null, ptr null %mustnull = select i1 %c, ptr null, ptr null
call void @arg_nonnull_1(ptr %mustnull) call void @arg_nonnull_1(ptr %mustnull)
ret void ret void
} }
define void @arg_nonnull_violation2_2(i1 %c) { define void @arg_nonnull_violation2_2(i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_violation2_2 ; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_violation2_2
; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_violation2_2 ; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_violation2_2
; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
%mustnull = select i1 %c, ptr null, ptr null %mustnull = select i1 %c, ptr null, ptr null
call void @arg_nonnull_1_noundef_1(ptr %mustnull) call void @arg_nonnull_1_noundef_1(ptr %mustnull)
ret void ret void
} }
; Cases for single and multiple violation at a callsite ; Cases for single and multiple violation at a callsite
define void @arg_nonnull_violation3_1(i1 %c) { define void @arg_nonnull_violation3_1(i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_violation3_1 ; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_violation3_1
; TUNIT-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[PTR:%.*]] = alloca i32, align 4 ; TUNIT-NEXT: [[PTR:%.*]] = alloca i32, align 4
; TUNIT-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: call void @arg_nonnull_12(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]]) #[[ATTR7:[0-9]+]] ; TUNIT-NEXT: call void @arg_nonnull_12(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]]) #[[ATTR7:[0-9]+]]
; TUNIT-NEXT: call void @arg_nonnull_12(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr noalias nocapture nofree noundef writeonly align 4294967296 null) #[[ATTR7]] ; TUNIT-NEXT: call void @arg_nonnull_12(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr noalias nocapture nofree noundef writeonly align 4294967296 null) #[[ATTR7]]
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: ret: ; TUNIT: ret:
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_violation3_1 ; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_violation3_1
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[PTR:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[PTR:%.*]] = alloca i32, align 4
; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: call void @arg_nonnull_12(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]]) #[[ATTR11:[0-9]+]] ; CGSCC-NEXT: call void @arg_nonnull_12(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]]) #[[ATTR11:[0-9]+]]
; CGSCC-NEXT: call void @arg_nonnull_12(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr noalias nocapture nofree noundef writeonly align 4294967296 null) #[[ATTR11]] ; CGSCC-NEXT: call void @arg_nonnull_12(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr noalias nocapture nofree noundef writeonly align 4294967296 null) #[[ATTR11]]
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
Show All 16 Linesf:
call void @arg_nonnull_12(ptr null, ptr null, ptr %ptr) call void @arg_nonnull_12(ptr null, ptr null, ptr %ptr)
call void @arg_nonnull_12(ptr null, ptr null, ptr null) call void @arg_nonnull_12(ptr null, ptr null, ptr null)
br label %ret br label %ret
ret: ret:
ret void ret void
} }
define void @arg_nonnull_violation3_2(i1 %c) { define void @arg_nonnull_violation3_2(i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_violation3_2 ; TUNIT-LABEL: define {{[^@]+}}@arg_nonnull_violation3_2
; TUNIT-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i1 noundef [[C:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[PTR:%.*]] = alloca i32, align 4 ; TUNIT-NEXT: [[PTR:%.*]] = alloca i32, align 4
; TUNIT-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: call void @arg_nonnull_12_noundef_2(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]]) #[[ATTR7]] ; TUNIT-NEXT: call void @arg_nonnull_12_noundef_2(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]]) #[[ATTR7]]
; TUNIT-NEXT: call void @arg_nonnull_12_noundef_2(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr noalias nocapture nofree noundef writeonly align 4294967296 null) #[[ATTR7]] ; TUNIT-NEXT: call void @arg_nonnull_12_noundef_2(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr noalias nocapture nofree noundef writeonly align 4294967296 null) #[[ATTR7]]
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; TUNIT: ret: ; TUNIT: ret:
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_violation3_2 ; CGSCC-LABEL: define {{[^@]+}}@arg_nonnull_violation3_2
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[PTR:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[PTR:%.*]] = alloca i32, align 4
; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: call void @arg_nonnull_12_noundef_2(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]]) #[[ATTR11]] ; CGSCC-NEXT: call void @arg_nonnull_12_noundef_2(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]]) #[[ATTR11]]
; CGSCC-NEXT: call void @arg_nonnull_12_noundef_2(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr noalias nocapture nofree noundef writeonly align 4294967296 null) #[[ATTR11]] ; CGSCC-NEXT: call void @arg_nonnull_12_noundef_2(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[PTR]], ptr noalias nocapture nofree noundef writeonly align 4294967296 null) #[[ATTR11]]
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
Show All 18 Linesf:
br label %ret br label %ret
ret: ret:
ret void ret void
} }
; Tests for returned position ; Tests for returned position
define nonnull ptr @returned_nonnnull(i32 %c) { define nonnull ptr @returned_nonnnull(i32 %c) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@returned_nonnnull ; CHECK-LABEL: define {{[^@]+}}@returned_nonnnull
; CHECK-SAME: (i32 noundef [[C:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32 noundef [[C:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: switch i32 [[C]], label [[ONDEFAULT:%.*]] [ ; CHECK-NEXT: switch i32 [[C]], label [[ONDEFAULT:%.*]] [
; CHECK-NEXT: i32 0, label [[ONZERO:%.*]] ; CHECK-NEXT: i32 0, label [[ONZERO:%.*]]
; CHECK-NEXT: i32 1, label [[ONONE:%.*]] ; CHECK-NEXT: i32 1, label [[ONONE:%.*]]
; CHECK-NEXT: ] ; CHECK-NEXT: ]
; CHECK: onzero: ; CHECK: onzero:
; CHECK-NEXT: [[PTR:%.*]] = alloca i32, align 4 ; CHECK-NEXT: [[PTR:%.*]] = alloca i32, align 4
Show All 10 Linesonzero:
ret ptr %ptr ret ptr %ptr
onone: onone:
ret ptr null ret ptr null
ondefault: ondefault:
ret ptr undef ret ptr undef
} }
define noundef ptr @returned_noundef(i32 %c) { define noundef ptr @returned_noundef(i32 %c) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@returned_noundef ; CHECK-LABEL: define {{[^@]+}}@returned_noundef
; CHECK-SAME: (i32 noundef [[C:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32 noundef [[C:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: switch i32 [[C]], label [[ONDEFAULT:%.*]] [ ; CHECK-NEXT: switch i32 [[C]], label [[ONDEFAULT:%.*]] [
; CHECK-NEXT: i32 0, label [[ONZERO:%.*]] ; CHECK-NEXT: i32 0, label [[ONZERO:%.*]]
; CHECK-NEXT: i32 1, label [[ONONE:%.*]] ; CHECK-NEXT: i32 1, label [[ONONE:%.*]]
; CHECK-NEXT: ] ; CHECK-NEXT: ]
; CHECK: onzero: ; CHECK: onzero:
; CHECK-NEXT: [[PTR:%.*]] = alloca i32, align 4 ; CHECK-NEXT: [[PTR:%.*]] = alloca i32, align 4
Show All 10 Linesonzero:
ret ptr %ptr ret ptr %ptr
onone: onone:
ret ptr null ret ptr null
ondefault: ondefault:
ret ptr undef ret ptr undef
} }
define nonnull noundef ptr @returned_nonnnull_noundef(i32 %c) { define nonnull noundef ptr @returned_nonnnull_noundef(i32 %c) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@returned_nonnnull_noundef ; CHECK-LABEL: define {{[^@]+}}@returned_nonnnull_noundef
; CHECK-SAME: (i32 noundef [[C:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32 noundef [[C:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: switch i32 [[C]], label [[ONDEFAULT:%.*]] [ ; CHECK-NEXT: switch i32 [[C]], label [[ONDEFAULT:%.*]] [
; CHECK-NEXT: i32 0, label [[ONZERO:%.*]] ; CHECK-NEXT: i32 0, label [[ONZERO:%.*]]
; CHECK-NEXT: i32 1, label [[ONONE:%.*]] ; CHECK-NEXT: i32 1, label [[ONONE:%.*]]
; CHECK-NEXT: ] ; CHECK-NEXT: ]
; CHECK: onzero: ; CHECK: onzero:
; CHECK-NEXT: [[PTR:%.*]] = alloca i32, align 4 ; CHECK-NEXT: [[PTR:%.*]] = alloca i32, align 4
Show All 10 Linesonzero:
ret ptr %ptr ret ptr %ptr
onone: onone:
ret ptr null ret ptr null
ondefault: ondefault:
ret ptr undef ret ptr undef
} }
define noundef i32 @returned_nonnnull_noundef_int() { define noundef i32 @returned_nonnnull_noundef_int() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@returned_nonnnull_noundef_int ; CHECK-LABEL: define {{[^@]+}}@returned_nonnnull_noundef_int
; CHECK-SAME: () #[[ATTR0]] { ; CHECK-SAME: () #[[ATTR0]] {
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
ret i32 0 ret i32 0
} }
declare void @callee_int_arg(i32) declare void @callee_int_arg(i32)
Show All 13 Lines
; CHECK-LABEL: define {{[^@]+}}@callsite_noundef_2() { ; CHECK-LABEL: define {{[^@]+}}@callsite_noundef_2() {
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; ;
call void @callee_ptr_arg(ptr noundef undef) call void @callee_ptr_arg(ptr noundef undef)
ret void ret void
} }
define i32 @argument_noundef1(i32 noundef %c) { define i32 @argument_noundef1(i32 noundef %c) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@argument_noundef1 ; CHECK-LABEL: define {{[^@]+}}@argument_noundef1
; CHECK-SAME: (i32 noundef returned [[C:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32 noundef returned [[C:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: ret i32 [[C]] ; CHECK-NEXT: ret i32 [[C]]
; ;
ret i32 %c ret i32 %c
} }
define i32 @violate_noundef_nonpointer() { define i32 @violate_noundef_nonpointer() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@violate_noundef_nonpointer ; TUNIT-LABEL: define {{[^@]+}}@violate_noundef_nonpointer
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: ret i32 undef ; TUNIT-NEXT: ret i32 undef
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@violate_noundef_nonpointer ; CGSCC-LABEL: define {{[^@]+}}@violate_noundef_nonpointer
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
%ret = call i32 @argument_noundef1(i32 undef) %ret = call i32 @argument_noundef1(i32 undef)
ret i32 %ret ret i32 %ret
} }
define ptr @argument_noundef2(ptr noundef %c) { define ptr @argument_noundef2(ptr noundef %c) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@argument_noundef2 ; CHECK-LABEL: define {{[^@]+}}@argument_noundef2
; CHECK-SAME: (ptr nofree noundef readnone returned "no-capture-maybe-returned" [[C:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (ptr nofree noundef readnone returned "no-capture-maybe-returned" [[C:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: ret ptr [[C]] ; CHECK-NEXT: ret ptr [[C]]
; ;
ret ptr %c ret ptr %c
} }
define ptr @violate_noundef_pointer() { define ptr @violate_noundef_pointer() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@violate_noundef_pointer ; TUNIT-LABEL: define {{[^@]+}}@violate_noundef_pointer
; TUNIT-SAME: () #[[ATTR0]] { ; TUNIT-SAME: () #[[ATTR0]] {
; TUNIT-NEXT: ret ptr undef ; TUNIT-NEXT: ret ptr undef
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@violate_noundef_pointer ; CGSCC-LABEL: define {{[^@]+}}@violate_noundef_pointer
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: ret ptr undef ; CGSCC-NEXT: ret ptr undef
; ;
%ret = call ptr @argument_noundef2(ptr undef) %ret = call ptr @argument_noundef2(ptr undef)
ret ptr %ret ret ptr %ret
} }
define internal noundef i32 @assumed_undef_is_ok(i1 %c, i32 %arg) { define internal noundef i32 @assumed_undef_is_ok(i1 %c, i32 %arg) {
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@assumed_undef_is_ok ; CGSCC-LABEL: define {{[^@]+}}@assumed_undef_is_ok
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: br i1 [[C]], label [[REC:%.*]], label [[RET:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[REC:%.*]], label [[RET:%.*]]
; CGSCC: rec: ; CGSCC: rec:
; CGSCC-NEXT: br label [[RET]] ; CGSCC-NEXT: br label [[RET]]
; CGSCC: ret: ; CGSCC: ret:
; CGSCC-NEXT: ret i32 0 ; CGSCC-NEXT: ret i32 0
; ;
%stack = alloca i32 %stack = alloca i32
store i32 %arg, ptr %stack store i32 %arg, ptr %stack
br i1 %c, label %rec, label %ret br i1 %c, label %rec, label %ret
rec: rec:
%call = call i32 @assumed_undef_is_ok(i1 false, i32 0) %call = call i32 @assumed_undef_is_ok(i1 false, i32 0)
store i32 %call, ptr %stack store i32 %call, ptr %stack
br label %ret br label %ret
ret: ret:
%l = load i32, ptr %stack %l = load i32, ptr %stack
ret i32 %l ret i32 %l
} }
define noundef i32 @assumed_undef_is_ok_caller(i1 %c) { define noundef i32 @assumed_undef_is_ok_caller(i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@assumed_undef_is_ok_caller ; TUNIT-LABEL: define {{[^@]+}}@assumed_undef_is_ok_caller
; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: ret i32 0 ; TUNIT-NEXT: ret i32 0
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@assumed_undef_is_ok_caller ; CGSCC-LABEL: define {{[^@]+}}@assumed_undef_is_ok_caller
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[CALL:%.*]] = call i32 @assumed_undef_is_ok(i1 noundef [[C]]) #[[ATTR10]] ; CGSCC-NEXT: [[CALL:%.*]] = call i32 @assumed_undef_is_ok(i1 noundef [[C]]) #[[ATTR10]]
; CGSCC-NEXT: ret i32 [[CALL]] ; CGSCC-NEXT: ret i32 [[CALL]]
; ;
%call = call i32 @assumed_undef_is_ok(i1 %c, i32 undef) %call = call i32 @assumed_undef_is_ok(i1 %c, i32 undef)
ret i32 %call ret i32 %call
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none) }
; TUNIT: attributes #[[ATTR2]] = { nofree norecurse nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR2]] = { mustprogress nofree norecurse nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR3]] = { nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(write) } ; TUNIT: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(write) }
; TUNIT: attributes #[[ATTR4]] = { nofree norecurse nounwind null_pointer_is_valid willreturn } ; TUNIT: attributes #[[ATTR4]] = { mustprogress nofree norecurse nounwind null_pointer_is_valid willreturn }
; TUNIT: attributes #[[ATTR5]] = { nofree norecurse noreturn nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR5]] = { mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR6]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR6]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR7]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR7]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR3]] = { nofree norecurse nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree norecurse nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(write) } ; CGSCC: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind null_pointer_is_valid willreturn memory(write) }
; CGSCC: attributes #[[ATTR5]] = { nofree nosync nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR5]] = { mustprogress nofree nosync nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR6]] = { nofree norecurse nounwind null_pointer_is_valid willreturn } ; CGSCC: attributes #[[ATTR6]] = { mustprogress nofree norecurse nounwind null_pointer_is_valid willreturn }
; CGSCC: attributes #[[ATTR7]] = { nofree nounwind willreturn } ; CGSCC: attributes #[[ATTR7]] = { mustprogress nofree nounwind willreturn }
; CGSCC: attributes #[[ATTR8]] = { nofree norecurse noreturn nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR8]] = { mustprogress nofree norecurse noreturn nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR9]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR9]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR10]] = { willreturn } ; CGSCC: attributes #[[ATTR10]] = { willreturn }
; CGSCC: attributes #[[ATTR11]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR11]] = { nounwind willreturn }
;. ;.

llvm/test/Transforms/Attributor/value-simplify-assume.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=4 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=4 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
@Gstatic_int1 = internal global i32 zeroinitializer, align 4 @Gstatic_int1 = internal global i32 zeroinitializer, align 4
@Gstatic_int2 = internal global i32 zeroinitializer, align 4 @Gstatic_int2 = internal global i32 zeroinitializer, align 4
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
declare void @useI1p(ptr) declare void @useI1p(ptr)
declare void @unknown() declare void @unknown()
;. ;.
; CHECK: @[[GSTATIC_INT1:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 0, align 4 ; CHECK: @[[GSTATIC_INT1:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 0, align 4
; CHECK: @[[GSTATIC_INT2:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 0, align 4 ; CHECK: @[[GSTATIC_INT2:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 0, align 4
;. ;.
define i1 @readI1p(ptr %p) { define i1 @readI1p(ptr %p) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CHECK-LABEL: define {{[^@]+}}@readI1p ; CHECK-LABEL: define {{[^@]+}}@readI1p
; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly dereferenceable(1) [[P:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree noundef nonnull readonly dereferenceable(1) [[P:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: [[L:%.*]] = load i1, ptr [[P]], align 1 ; CHECK-NEXT: [[L:%.*]] = load i1, ptr [[P]], align 1
; CHECK-NEXT: ret i1 [[L]] ; CHECK-NEXT: ret i1 [[L]]
; ;
%l = load i1, ptr %p %l = load i1, ptr %p
ret i1 %l ret i1 %l
} }
Show All 13 Lines;
store i1 true, ptr %stack store i1 true, ptr %stack
call void @useI1p(ptr %stack) call void @useI1p(ptr %stack)
%l = load i1, ptr %stack %l = load i1, ptr %stack
call void @llvm.assume(i1 %l) call void @llvm.assume(i1 %l)
ret i1 %l ret i1 %l
} }
define i1 @drop_assume_1c_nr() norecurse { define i1 @drop_assume_1c_nr() norecurse {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@drop_assume_1c_nr ; TUNIT-LABEL: define {{[^@]+}}@drop_assume_1c_nr
; TUNIT-SAME: () #[[ATTR3:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR3:[0-9]+]] {
; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR6:[0-9]+]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR6:[0-9]+]]
; TUNIT-NEXT: ret i1 true ; TUNIT-NEXT: ret i1 true
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@drop_assume_1c_nr ; CGSCC-LABEL: define {{[^@]+}}@drop_assume_1c_nr
; CGSCC-SAME: () #[[ATTR3:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR3:[0-9]+]] {
; CGSCC-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR7:[0-9]+]] ; CGSCC-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR7:[0-9]+]]
; CGSCC-NEXT: ret i1 true ; CGSCC-NEXT: ret i1 true
; ;
%stack = alloca i1 %stack = alloca i1
store i1 true, ptr %stack store i1 true, ptr %stack
%l = load i1, ptr %stack %l = load i1, ptr %stack
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Lines;
store i1 %arg, ptr %stack store i1 %arg, ptr %stack
call void @useI1p(ptr %stack) call void @useI1p(ptr %stack)
%l = load i1, ptr %stack %l = load i1, ptr %stack
call void @llvm.assume(i1 %l) call void @llvm.assume(i1 %l)
ret i1 %l ret i1 %l
} }
define i1 @drop_assume_1_nr(i1 %arg) norecurse { define i1 @drop_assume_1_nr(i1 %arg) norecurse {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@drop_assume_1_nr ; TUNIT-LABEL: define {{[^@]+}}@drop_assume_1_nr
; TUNIT-SAME: (i1 returned [[ARG:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i1 returned [[ARG:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1
; TUNIT-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR6]]
; TUNIT-NEXT: ret i1 [[ARG]] ; TUNIT-NEXT: ret i1 [[ARG]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@drop_assume_1_nr ; CGSCC-LABEL: define {{[^@]+}}@drop_assume_1_nr
; CGSCC-SAME: (i1 returned [[ARG:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i1 returned [[ARG:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1
; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1
; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR7]] ; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR7]]
; CGSCC-NEXT: ret i1 [[ARG]] ; CGSCC-NEXT: ret i1 [[ARG]]
; ;
%stack = alloca i1 %stack = alloca i1
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines;
store i1 %arg, ptr %stack store i1 %arg, ptr %stack
%l = load i1, ptr %stack %l = load i1, ptr %stack
call void @llvm.assume(i1 %l) call void @llvm.assume(i1 %l)
call void @useI1p(ptr nocapture %stack) call void @useI1p(ptr nocapture %stack)
ret i1 %l ret i1 %l
} }
define i1 @assume_1_nr(i1 %arg, i1 %cond) norecurse { define i1 @assume_1_nr(i1 %arg, i1 %cond) norecurse {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@assume_1_nr ; TUNIT-LABEL: define {{[^@]+}}@assume_1_nr
; TUNIT-SAME: (i1 returned [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i1 returned [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1
; TUNIT-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR6]]
; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: br label [[M:%.*]] ; TUNIT-NEXT: br label [[M:%.*]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: br label [[M]] ; TUNIT-NEXT: br label [[M]]
; TUNIT: m: ; TUNIT: m:
; TUNIT-NEXT: ret i1 [[ARG]] ; TUNIT-NEXT: ret i1 [[ARG]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@assume_1_nr ; CGSCC-LABEL: define {{[^@]+}}@assume_1_nr
; CGSCC-SAME: (i1 returned [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i1 returned [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1
; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1
; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR7]] ; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR7]]
; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: br label [[M:%.*]] ; CGSCC-NEXT: br label [[M:%.*]]
Show All 13 Lines
f: f:
store i1 false, ptr %stack store i1 false, ptr %stack
br label %m br label %m
m: m:
ret i1 %l ret i1 %l
} }
define void @assume_1b_nr(i1 %arg, i1 %cond) norecurse { define void @assume_1b_nr(i1 %arg, i1 %cond) norecurse {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CHECK-LABEL: define {{[^@]+}}@assume_1b_nr ; CHECK-LABEL: define {{[^@]+}}@assume_1b_nr
; CHECK-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3:[0-9]+]] { ; CHECK-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3:[0-9]+]] {
; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; CHECK: t: ; CHECK: t:
; CHECK-NEXT: br label [[M:%.*]] ; CHECK-NEXT: br label [[M:%.*]]
; CHECK: f: ; CHECK: f:
; CHECK-NEXT: br label [[M]] ; CHECK-NEXT: br label [[M]]
; CHECK: m: ; CHECK: m:
Show All 10 Lines
f: f:
store i1 false, ptr %stack store i1 false, ptr %stack
br label %m br label %m
m: m:
ret void ret void
} }
define i1 @assume_2_nr(i1 %arg, i1 %cond) norecurse { define i1 @assume_2_nr(i1 %arg, i1 %cond) norecurse {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@assume_2_nr ; TUNIT-LABEL: define {{[^@]+}}@assume_2_nr
; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1
; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1
; TUNIT-NEXT: br label [[M:%.*]] ; TUNIT-NEXT: br label [[M:%.*]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1
; TUNIT-NEXT: br label [[M]] ; TUNIT-NEXT: br label [[M]]
; TUNIT: m: ; TUNIT: m:
; TUNIT-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]]
; TUNIT-NEXT: ret i1 [[L]] ; TUNIT-NEXT: ret i1 [[L]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@assume_2_nr ; CGSCC-LABEL: define {{[^@]+}}@assume_2_nr
; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1
; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1 ; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1
; CGSCC-NEXT: br label [[M:%.*]] ; CGSCC-NEXT: br label [[M:%.*]]
; CGSCC: f: ; CGSCC: f:
Show All 15 Linesf:
br label %m br label %m
m: m:
%l = load i1, ptr %stack %l = load i1, ptr %stack
call void @llvm.assume(i1 %l) call void @llvm.assume(i1 %l)
ret i1 %l ret i1 %l
} }
define void @assume_2b_nr(i1 %arg, i1 %cond) norecurse { define void @assume_2b_nr(i1 %arg, i1 %cond) norecurse {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CHECK-LABEL: define {{[^@]+}}@assume_2b_nr ; CHECK-LABEL: define {{[^@]+}}@assume_2b_nr
; CHECK-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; CHECK-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; CHECK-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CHECK-NEXT: [[STACK:%.*]] = alloca i1, align 1
; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; CHECK: t: ; CHECK: t:
; CHECK-NEXT: br label [[M:%.*]] ; CHECK-NEXT: br label [[M:%.*]]
; CHECK: f: ; CHECK: f:
; CHECK-NEXT: br label [[M]] ; CHECK-NEXT: br label [[M]]
Show All 12 Linesf:
br label %m br label %m
m: m:
%l = load i1, ptr %stack %l = load i1, ptr %stack
call void @llvm.assume(i1 %l) call void @llvm.assume(i1 %l)
ret void ret void
} }
define i1 @assume_3_nr(i1 %arg, i1 %cond) norecurse { define i1 @assume_3_nr(i1 %arg, i1 %cond) norecurse {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@assume_3_nr ; TUNIT-LABEL: define {{[^@]+}}@assume_3_nr
; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1
; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1
; TUNIT-NEXT: br label [[M:%.*]] ; TUNIT-NEXT: br label [[M:%.*]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1
; TUNIT-NEXT: br label [[M]] ; TUNIT-NEXT: br label [[M]]
; TUNIT: m: ; TUNIT: m:
; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7:[0-9]+]] ; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7:[0-9]+]]
; TUNIT-NEXT: ret i1 [[R]] ; TUNIT-NEXT: ret i1 [[R]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@assume_3_nr ; CGSCC-LABEL: define {{[^@]+}}@assume_3_nr
; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1
; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1
; CGSCC-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1
; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] ; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]]
; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
Show All 18 Linesf:
store i1 false, ptr %stack store i1 false, ptr %stack
br label %m br label %m
m: m:
%r = call i1 @readI1p(ptr %stack) %r = call i1 @readI1p(ptr %stack)
ret i1 %r ret i1 %r
} }
define i1 @assume_4_nr(i1 %arg, i1 %cond) norecurse { define i1 @assume_4_nr(i1 %arg, i1 %cond) norecurse {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@assume_4_nr ; TUNIT-LABEL: define {{[^@]+}}@assume_4_nr
; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1
; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1
; TUNIT-NEXT: br label [[M:%.*]] ; TUNIT-NEXT: br label [[M:%.*]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1
; TUNIT-NEXT: br label [[M]] ; TUNIT-NEXT: br label [[M]]
; TUNIT: m: ; TUNIT: m:
; TUNIT-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]]
; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] ; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]]
; TUNIT-NEXT: ret i1 [[R]] ; TUNIT-NEXT: ret i1 [[R]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@assume_4_nr ; CGSCC-LABEL: define {{[^@]+}}@assume_4_nr
; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1
; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1
; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1 ; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1
; CGSCC-NEXT: br label [[M:%.*]] ; CGSCC-NEXT: br label [[M:%.*]]
Show All 18 Lines
m: m:
%l = load i1, ptr %stack %l = load i1, ptr %stack
call void @llvm.assume(i1 %l) call void @llvm.assume(i1 %l)
%r = call i1 @readI1p(ptr %stack) %r = call i1 @readI1p(ptr %stack)
ret i1 %r ret i1 %r
} }
define i1 @assume_5_nr(i1 %arg, i1 %cond) norecurse { define i1 @assume_5_nr(i1 %arg, i1 %cond) norecurse {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@assume_5_nr ; TUNIT-LABEL: define {{[^@]+}}@assume_5_nr
; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1
; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1
; TUNIT-NEXT: [[L2:%.*]] = load i1, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L2:%.*]] = load i1, ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR6]]
; TUNIT-NEXT: br label [[M:%.*]] ; TUNIT-NEXT: br label [[M:%.*]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1
; TUNIT-NEXT: [[L3:%.*]] = load i1, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L3:%.*]] = load i1, ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR6]]
; TUNIT-NEXT: br label [[M]] ; TUNIT-NEXT: br label [[M]]
; TUNIT: m: ; TUNIT: m:
; TUNIT-NEXT: [[L4:%.*]] = load i1, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L4:%.*]] = load i1, ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR6]]
; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] ; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]]
; TUNIT-NEXT: ret i1 [[R]] ; TUNIT-NEXT: ret i1 [[R]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@assume_5_nr ; CGSCC-LABEL: define {{[^@]+}}@assume_5_nr
; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1
; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1
; CGSCC-NEXT: [[L1:%.*]] = load i1, ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L1:%.*]] = load i1, ptr [[STACK]], align 1
; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L1]]) #[[ATTR7]] ; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L1]]) #[[ATTR7]]
; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
Show All 30 Lines
m: m:
%l4 = load i1, ptr %stack %l4 = load i1, ptr %stack
call void @llvm.assume(i1 %l4) call void @llvm.assume(i1 %l4)
%r = call i1 @readI1p(ptr %stack) %r = call i1 @readI1p(ptr %stack)
ret i1 %r ret i1 %r
} }
define i1 @assume_5c_nr(i1 %cond) norecurse { define i1 @assume_5c_nr(i1 %cond) norecurse {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@assume_5c_nr ; TUNIT-LABEL: define {{[^@]+}}@assume_5c_nr
; TUNIT-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR6]]
; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1
; TUNIT-NEXT: [[L2:%.*]] = load i1, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L2:%.*]] = load i1, ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR6]]
; TUNIT-NEXT: br label [[M:%.*]] ; TUNIT-NEXT: br label [[M:%.*]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1
; TUNIT-NEXT: [[L3:%.*]] = load i1, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L3:%.*]] = load i1, ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR6]]
; TUNIT-NEXT: br label [[M]] ; TUNIT-NEXT: br label [[M]]
; TUNIT: m: ; TUNIT: m:
; TUNIT-NEXT: [[L4:%.*]] = load i1, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L4:%.*]] = load i1, ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR6]]
; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] ; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]]
; TUNIT-NEXT: ret i1 [[R]] ; TUNIT-NEXT: ret i1 [[R]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@assume_5c_nr ; CGSCC-LABEL: define {{[^@]+}}@assume_5c_nr
; CGSCC-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1
; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1 ; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1
; CGSCC-NEXT: [[L1:%.*]] = load i1, ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L1:%.*]] = load i1, ptr [[STACK]], align 1
; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L1]]) #[[ATTR7]] ; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L1]]) #[[ATTR7]]
; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines;
store i1 true, ptr %stack store i1 true, ptr %stack
call void @useI1p(ptr %stack) call void @useI1p(ptr %stack)
%l = load i1, ptr %stack %l = load i1, ptr %stack
call void @llvm.assume(i1 %l) call void @llvm.assume(i1 %l)
ret i1 %l ret i1 %l
} }
define i1 @drop_assume_1c() { define i1 @drop_assume_1c() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@drop_assume_1c ; TUNIT-LABEL: define {{[^@]+}}@drop_assume_1c
; TUNIT-SAME: () #[[ATTR3]] { ; TUNIT-SAME: () #[[ATTR3]] {
; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR6]]
; TUNIT-NEXT: ret i1 true ; TUNIT-NEXT: ret i1 true
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@drop_assume_1c ; CGSCC-LABEL: define {{[^@]+}}@drop_assume_1c
; CGSCC-SAME: () #[[ATTR3]] { ; CGSCC-SAME: () #[[ATTR3]] {
; CGSCC-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR7]] ; CGSCC-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR7]]
; CGSCC-NEXT: ret i1 true ; CGSCC-NEXT: ret i1 true
; ;
%stack = alloca i1 %stack = alloca i1
store i1 true, ptr %stack store i1 true, ptr %stack
%l = load i1, ptr %stack %l = load i1, ptr %stack
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Lines;
store i1 %arg, ptr %stack store i1 %arg, ptr %stack
call void @useI1p(ptr %stack) call void @useI1p(ptr %stack)
%l = load i1, ptr %stack %l = load i1, ptr %stack
call void @llvm.assume(i1 %l) call void @llvm.assume(i1 %l)
ret i1 %l ret i1 %l
} }
define i1 @drop_assume_1(i1 %arg) { define i1 @drop_assume_1(i1 %arg) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@drop_assume_1 ; TUNIT-LABEL: define {{[^@]+}}@drop_assume_1
; TUNIT-SAME: (i1 returned [[ARG:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i1 returned [[ARG:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1
; TUNIT-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR6]]
; TUNIT-NEXT: ret i1 [[ARG]] ; TUNIT-NEXT: ret i1 [[ARG]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@drop_assume_1 ; CGSCC-LABEL: define {{[^@]+}}@drop_assume_1
; CGSCC-SAME: (i1 returned [[ARG:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i1 returned [[ARG:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1
; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1
; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR7]] ; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR7]]
; CGSCC-NEXT: ret i1 [[ARG]] ; CGSCC-NEXT: ret i1 [[ARG]]
; ;
%stack = alloca i1 %stack = alloca i1
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines;
store i1 %arg, ptr %stack store i1 %arg, ptr %stack
%l = load i1, ptr %stack %l = load i1, ptr %stack
call void @llvm.assume(i1 %l) call void @llvm.assume(i1 %l)
call void @useI1p(ptr nocapture %stack) call void @useI1p(ptr nocapture %stack)
ret i1 %l ret i1 %l
} }
define i1 @assume_1(i1 %arg, i1 %cond) { define i1 @assume_1(i1 %arg, i1 %cond) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@assume_1 ; TUNIT-LABEL: define {{[^@]+}}@assume_1
; TUNIT-SAME: (i1 returned [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i1 returned [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1
; TUNIT-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR6]]
; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: br label [[M:%.*]] ; TUNIT-NEXT: br label [[M:%.*]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: br label [[M]] ; TUNIT-NEXT: br label [[M]]
; TUNIT: m: ; TUNIT: m:
; TUNIT-NEXT: ret i1 [[ARG]] ; TUNIT-NEXT: ret i1 [[ARG]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@assume_1 ; CGSCC-LABEL: define {{[^@]+}}@assume_1
; CGSCC-SAME: (i1 returned [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i1 returned [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1
; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1
; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR7]] ; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[ARG]]) #[[ATTR7]]
; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: br label [[M:%.*]] ; CGSCC-NEXT: br label [[M:%.*]]
Show All 13 Lines
f: f:
store i1 false, ptr %stack store i1 false, ptr %stack
br label %m br label %m
m: m:
ret i1 %l ret i1 %l
} }
define void @assume_1b(i1 %arg, i1 %cond) { define void @assume_1b(i1 %arg, i1 %cond) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CHECK-LABEL: define {{[^@]+}}@assume_1b ; CHECK-LABEL: define {{[^@]+}}@assume_1b
; CHECK-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; CHECK-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; CHECK: t: ; CHECK: t:
; CHECK-NEXT: br label [[M:%.*]] ; CHECK-NEXT: br label [[M:%.*]]
; CHECK: f: ; CHECK: f:
; CHECK-NEXT: br label [[M]] ; CHECK-NEXT: br label [[M]]
; CHECK: m: ; CHECK: m:
Show All 10 Lines
f: f:
store i1 false, ptr %stack store i1 false, ptr %stack
br label %m br label %m
m: m:
ret void ret void
} }
define i1 @assume_2(i1 %arg, i1 %cond) { define i1 @assume_2(i1 %arg, i1 %cond) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@assume_2 ; TUNIT-LABEL: define {{[^@]+}}@assume_2
; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1
; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1
; TUNIT-NEXT: br label [[M:%.*]] ; TUNIT-NEXT: br label [[M:%.*]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1
; TUNIT-NEXT: br label [[M]] ; TUNIT-NEXT: br label [[M]]
; TUNIT: m: ; TUNIT: m:
; TUNIT-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]]
; TUNIT-NEXT: ret i1 [[L]] ; TUNIT-NEXT: ret i1 [[L]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@assume_2 ; CGSCC-LABEL: define {{[^@]+}}@assume_2
; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1
; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1 ; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1
; CGSCC-NEXT: br label [[M:%.*]] ; CGSCC-NEXT: br label [[M:%.*]]
; CGSCC: f: ; CGSCC: f:
Show All 15 Linesf:
br label %m br label %m
m: m:
%l = load i1, ptr %stack %l = load i1, ptr %stack
call void @llvm.assume(i1 %l) call void @llvm.assume(i1 %l)
ret i1 %l ret i1 %l
} }
define void @assume_2b(i1 %arg, i1 %cond) { define void @assume_2b(i1 %arg, i1 %cond) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CHECK-LABEL: define {{[^@]+}}@assume_2b ; CHECK-LABEL: define {{[^@]+}}@assume_2b
; CHECK-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; CHECK-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; CHECK-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CHECK-NEXT: [[STACK:%.*]] = alloca i1, align 1
; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; CHECK: t: ; CHECK: t:
; CHECK-NEXT: br label [[M:%.*]] ; CHECK-NEXT: br label [[M:%.*]]
; CHECK: f: ; CHECK: f:
; CHECK-NEXT: br label [[M]] ; CHECK-NEXT: br label [[M]]
Show All 12 Linesf:
br label %m br label %m
m: m:
%l = load i1, ptr %stack %l = load i1, ptr %stack
call void @llvm.assume(i1 %l) call void @llvm.assume(i1 %l)
ret void ret void
} }
define i1 @assume_3(i1 %arg, i1 %cond) { define i1 @assume_3(i1 %arg, i1 %cond) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@assume_3 ; TUNIT-LABEL: define {{[^@]+}}@assume_3
; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1
; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1
; TUNIT-NEXT: br label [[M:%.*]] ; TUNIT-NEXT: br label [[M:%.*]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1
; TUNIT-NEXT: br label [[M]] ; TUNIT-NEXT: br label [[M]]
; TUNIT: m: ; TUNIT: m:
; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] ; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]]
; TUNIT-NEXT: ret i1 [[R]] ; TUNIT-NEXT: ret i1 [[R]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@assume_3 ; CGSCC-LABEL: define {{[^@]+}}@assume_3
; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4:[0-9]+]] { ; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4:[0-9]+]] {
; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1
; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1
; CGSCC-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1
; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]] ; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]]
; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
Show All 18 Linesf:
store i1 false, ptr %stack store i1 false, ptr %stack
br label %m br label %m
m: m:
%r = call i1 @readI1p(ptr %stack) %r = call i1 @readI1p(ptr %stack)
ret i1 %r ret i1 %r
} }
define i1 @assume_4(i1 %arg, i1 %cond) { define i1 @assume_4(i1 %arg, i1 %cond) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@assume_4 ; TUNIT-LABEL: define {{[^@]+}}@assume_4
; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1
; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1
; TUNIT-NEXT: br label [[M:%.*]] ; TUNIT-NEXT: br label [[M:%.*]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1
; TUNIT-NEXT: br label [[M]] ; TUNIT-NEXT: br label [[M]]
; TUNIT: m: ; TUNIT: m:
; TUNIT-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L:%.*]] = load i1, ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]]
; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] ; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]]
; TUNIT-NEXT: ret i1 [[R]] ; TUNIT-NEXT: ret i1 [[R]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@assume_4 ; CGSCC-LABEL: define {{[^@]+}}@assume_4
; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] {
; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1
; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1
; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1 ; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1
; CGSCC-NEXT: br label [[M:%.*]] ; CGSCC-NEXT: br label [[M:%.*]]
Show All 18 Lines
m: m:
%l = load i1, ptr %stack %l = load i1, ptr %stack
call void @llvm.assume(i1 %l) call void @llvm.assume(i1 %l)
%r = call i1 @readI1p(ptr %stack) %r = call i1 @readI1p(ptr %stack)
ret i1 %r ret i1 %r
} }
define i1 @assume_5(i1 %arg, i1 %cond) { define i1 @assume_5(i1 %arg, i1 %cond) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@assume_5 ; TUNIT-LABEL: define {{[^@]+}}@assume_5
; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1
; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1
; TUNIT-NEXT: [[L2:%.*]] = load i1, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L2:%.*]] = load i1, ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR6]]
; TUNIT-NEXT: br label [[M:%.*]] ; TUNIT-NEXT: br label [[M:%.*]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1
; TUNIT-NEXT: [[L3:%.*]] = load i1, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L3:%.*]] = load i1, ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR6]]
; TUNIT-NEXT: br label [[M]] ; TUNIT-NEXT: br label [[M]]
; TUNIT: m: ; TUNIT: m:
; TUNIT-NEXT: [[L4:%.*]] = load i1, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L4:%.*]] = load i1, ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR6]]
; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] ; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]]
; TUNIT-NEXT: ret i1 [[R]] ; TUNIT-NEXT: ret i1 [[R]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@assume_5 ; CGSCC-LABEL: define {{[^@]+}}@assume_5
; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; CGSCC-SAME: (i1 [[ARG:%.*]], i1 noundef [[COND:%.*]]) #[[ATTR4]] {
; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1
; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1 ; CGSCC-NEXT: store i1 [[ARG]], ptr [[STACK]], align 1
; CGSCC-NEXT: [[L1:%.*]] = load i1, ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L1:%.*]] = load i1, ptr [[STACK]], align 1
; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L1]]) #[[ATTR7]] ; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L1]]) #[[ATTR7]]
; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
Show All 30 Lines
m: m:
%l4 = load i1, ptr %stack %l4 = load i1, ptr %stack
call void @llvm.assume(i1 %l4) call void @llvm.assume(i1 %l4)
%r = call i1 @readI1p(ptr %stack) %r = call i1 @readI1p(ptr %stack)
ret i1 %r ret i1 %r
} }
define i1 @assume_5c(i1 %cond) { define i1 @assume_5c(i1 %cond) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@assume_5c ; TUNIT-LABEL: define {{[^@]+}}@assume_5c
; TUNIT-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR6]]
; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 true, ptr [[STACK]], align 1
; TUNIT-NEXT: [[L2:%.*]] = load i1, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L2:%.*]] = load i1, ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L2]]) #[[ATTR6]]
; TUNIT-NEXT: br label [[M:%.*]] ; TUNIT-NEXT: br label [[M:%.*]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1 ; TUNIT-NEXT: store i1 false, ptr [[STACK]], align 1
; TUNIT-NEXT: [[L3:%.*]] = load i1, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L3:%.*]] = load i1, ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L3]]) #[[ATTR6]]
; TUNIT-NEXT: br label [[M]] ; TUNIT-NEXT: br label [[M]]
; TUNIT: m: ; TUNIT: m:
; TUNIT-NEXT: [[L4:%.*]] = load i1, ptr [[STACK]], align 1 ; TUNIT-NEXT: [[L4:%.*]] = load i1, ptr [[STACK]], align 1
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L4]]) #[[ATTR6]]
; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]] ; TUNIT-NEXT: [[R:%.*]] = call i1 @readI1p(ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[STACK]]) #[[ATTR7]]
; TUNIT-NEXT: ret i1 [[R]] ; TUNIT-NEXT: ret i1 [[R]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@assume_5c ; CGSCC-LABEL: define {{[^@]+}}@assume_5c
; CGSCC-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR4]] { ; CGSCC-SAME: (i1 noundef [[COND:%.*]]) #[[ATTR4]] {
; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1 ; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1
; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1 ; CGSCC-NEXT: store i1 true, ptr [[STACK]], align 1
; CGSCC-NEXT: [[L1:%.*]] = load i1, ptr [[STACK]], align 1 ; CGSCC-NEXT: [[L1:%.*]] = load i1, ptr [[STACK]], align 1
; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L1]]) #[[ATTR7]] ; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L1]]) #[[ATTR7]]
; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
Show All 32 Linesm:
call void @llvm.assume(i1 %l4) call void @llvm.assume(i1 %l4)
%r = call i1 @readI1p(ptr %stack) %r = call i1 @readI1p(ptr %stack)
ret i1 %r ret i1 %r
} }
define i32 @assume_read_global_good() { define i32 @assume_read_global_good() {
; ;
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@assume_read_global_good ; TUNIT-LABEL: define {{[^@]+}}@assume_read_global_good
; TUNIT-SAME: () #[[ATTR4:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR4:[0-9]+]] {
; TUNIT-NEXT: [[LGS1:%.*]] = load i32, ptr @Gstatic_int1, align 4 ; TUNIT-NEXT: [[LGS1:%.*]] = load i32, ptr @Gstatic_int1, align 4
; TUNIT-NEXT: [[C:%.*]] = icmp eq i32 [[LGS1]], 42 ; TUNIT-NEXT: [[C:%.*]] = icmp eq i32 [[LGS1]], 42
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[C]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[C]]) #[[ATTR6]]
; TUNIT-NEXT: [[LGS2:%.*]] = load i32, ptr @Gstatic_int1, align 4 ; TUNIT-NEXT: [[LGS2:%.*]] = load i32, ptr @Gstatic_int1, align 4
; TUNIT-NEXT: store i32 17, ptr @Gstatic_int1, align 4 ; TUNIT-NEXT: store i32 17, ptr @Gstatic_int1, align 4
; TUNIT-NEXT: [[LGS3:%.*]] = load i32, ptr @Gstatic_int1, align 4 ; TUNIT-NEXT: [[LGS3:%.*]] = load i32, ptr @Gstatic_int1, align 4
; TUNIT-NEXT: [[ADD:%.*]] = add i32 [[LGS2]], [[LGS3]] ; TUNIT-NEXT: [[ADD:%.*]] = add i32 [[LGS2]], [[LGS3]]
; TUNIT-NEXT: ret i32 [[ADD]] ; TUNIT-NEXT: ret i32 [[ADD]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@assume_read_global_good ; CGSCC-LABEL: define {{[^@]+}}@assume_read_global_good
; CGSCC-SAME: () #[[ATTR5:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR5:[0-9]+]] {
; CGSCC-NEXT: [[LGS1:%.*]] = load i32, ptr @Gstatic_int1, align 4 ; CGSCC-NEXT: [[LGS1:%.*]] = load i32, ptr @Gstatic_int1, align 4
; CGSCC-NEXT: [[C:%.*]] = icmp eq i32 [[LGS1]], 42 ; CGSCC-NEXT: [[C:%.*]] = icmp eq i32 [[LGS1]], 42
; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[C]]) #[[ATTR7]] ; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[C]]) #[[ATTR7]]
; CGSCC-NEXT: [[LGS2:%.*]] = load i32, ptr @Gstatic_int1, align 4 ; CGSCC-NEXT: [[LGS2:%.*]] = load i32, ptr @Gstatic_int1, align 4
; CGSCC-NEXT: store i32 17, ptr @Gstatic_int1, align 4 ; CGSCC-NEXT: store i32 17, ptr @Gstatic_int1, align 4
; CGSCC-NEXT: [[LGS3:%.*]] = load i32, ptr @Gstatic_int1, align 4 ; CGSCC-NEXT: [[LGS3:%.*]] = load i32, ptr @Gstatic_int1, align 4
Show All 9 Lines;
%lgs3 = load i32, ptr @Gstatic_int1 %lgs3 = load i32, ptr @Gstatic_int1
%add = add i32 %lgs2, %lgs3 %add = add i32 %lgs2, %lgs3
ret i32 %add ret i32 %add
} }
; TODO: Technically we could still utilize the assumption if we employ AA. ; TODO: Technically we could still utilize the assumption if we employ AA.
define i32 @assume_read_global_bad(ptr %p) { define i32 @assume_read_global_bad(ptr %p) {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@assume_read_global_bad ; TUNIT-LABEL: define {{[^@]+}}@assume_read_global_bad
; TUNIT-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR4]] { ; TUNIT-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR4]] {
; TUNIT-NEXT: [[LGS1:%.*]] = load i32, ptr @Gstatic_int2, align 4 ; TUNIT-NEXT: [[LGS1:%.*]] = load i32, ptr @Gstatic_int2, align 4
; TUNIT-NEXT: [[C:%.*]] = icmp eq i32 [[LGS1]], 42 ; TUNIT-NEXT: [[C:%.*]] = icmp eq i32 [[LGS1]], 42
; TUNIT-NEXT: store i32 13, ptr [[P]], align 4 ; TUNIT-NEXT: store i32 13, ptr [[P]], align 4
; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[C]]) #[[ATTR6]] ; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[C]]) #[[ATTR6]]
; TUNIT-NEXT: [[LGS2:%.*]] = load i32, ptr @Gstatic_int2, align 4 ; TUNIT-NEXT: [[LGS2:%.*]] = load i32, ptr @Gstatic_int2, align 4
; TUNIT-NEXT: store i32 17, ptr @Gstatic_int2, align 4 ; TUNIT-NEXT: store i32 17, ptr @Gstatic_int2, align 4
; TUNIT-NEXT: ret i32 [[LGS2]] ; TUNIT-NEXT: ret i32 [[LGS2]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@assume_read_global_bad ; CGSCC-LABEL: define {{[^@]+}}@assume_read_global_bad
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR5]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P:%.*]]) #[[ATTR5]] {
; CGSCC-NEXT: [[LGS1:%.*]] = load i32, ptr @Gstatic_int2, align 4 ; CGSCC-NEXT: [[LGS1:%.*]] = load i32, ptr @Gstatic_int2, align 4
; CGSCC-NEXT: [[C:%.*]] = icmp eq i32 [[LGS1]], 42 ; CGSCC-NEXT: [[C:%.*]] = icmp eq i32 [[LGS1]], 42
; CGSCC-NEXT: store i32 13, ptr [[P]], align 4 ; CGSCC-NEXT: store i32 13, ptr [[P]], align 4
; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[C]]) #[[ATTR7]] ; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[C]]) #[[ATTR7]]
; CGSCC-NEXT: [[LGS2:%.*]] = load i32, ptr @Gstatic_int2, align 4 ; CGSCC-NEXT: [[LGS2:%.*]] = load i32, ptr @Gstatic_int2, align 4
; CGSCC-NEXT: store i32 17, ptr @Gstatic_int2, align 4 ; CGSCC-NEXT: store i32 17, ptr @Gstatic_int2, align 4
; CGSCC-NEXT: ret i32 [[LGS2]] ; CGSCC-NEXT: ret i32 [[LGS2]]
; ;
%lgs1 = load i32, ptr @Gstatic_int2 %lgs1 = load i32, ptr @Gstatic_int2
%c = icmp eq i32 %lgs1, 42 %c = icmp eq i32 %lgs1, 42
store i32 13, ptr %p, align 4 store i32 13, ptr %p, align 4
call void @llvm.assume(i1 %c) call void @llvm.assume(i1 %c)
%lgs2 = load i32, ptr @Gstatic_int2 %lgs2 = load i32, ptr @Gstatic_int2
store i32 17, ptr @Gstatic_int2, align 4 store i32 17, ptr @Gstatic_int2, align 4
ret i32 %lgs2 ret i32 %lgs2
} }
define void @assume_write_globals() { define void @assume_write_globals() {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@assume_write_globals ; TUNIT-LABEL: define {{[^@]+}}@assume_write_globals
; TUNIT-SAME: () #[[ATTR5:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR5:[0-9]+]] {
; TUNIT-NEXT: store i32 42, ptr @Gstatic_int1, align 4 ; TUNIT-NEXT: store i32 42, ptr @Gstatic_int1, align 4
; TUNIT-NEXT: store i32 42, ptr @Gstatic_int2, align 4 ; TUNIT-NEXT: store i32 42, ptr @Gstatic_int2, align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@assume_write_globals ; CGSCC-LABEL: define {{[^@]+}}@assume_write_globals
; CGSCC-SAME: () #[[ATTR6:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR6:[0-9]+]] {
; CGSCC-NEXT: store i32 42, ptr @Gstatic_int1, align 4 ; CGSCC-NEXT: store i32 42, ptr @Gstatic_int1, align 4
; CGSCC-NEXT: store i32 42, ptr @Gstatic_int2, align 4 ; CGSCC-NEXT: store i32 42, ptr @Gstatic_int2, align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
store i32 42, ptr @Gstatic_int1, align 4 store i32 42, ptr @Gstatic_int1, align 4
store i32 42, ptr @Gstatic_int2, align 4 store i32 42, ptr @Gstatic_int2, align 4
ret void ret void
} }
;. ;.
; TUNIT: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; TUNIT: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; TUNIT: attributes #[[ATTR2]] = { norecurse } ; TUNIT: attributes #[[ATTR2]] = { norecurse }
; TUNIT: attributes #[[ATTR3]] = { nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; TUNIT: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
; TUNIT: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR5]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; TUNIT: attributes #[[ATTR5]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; TUNIT: attributes #[[ATTR6]] = { willreturn } ; TUNIT: attributes #[[ATTR6]] = { willreturn }
; TUNIT: attributes #[[ATTR7]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR7]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; CGSCC: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR2]] = { norecurse } ; CGSCC: attributes #[[ATTR2]] = { norecurse }
; CGSCC: attributes #[[ATTR3]] = { nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
; CGSCC: attributes #[[ATTR4]] = { nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; CGSCC: attributes #[[ATTR4]] = { mustprogress nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
; CGSCC: attributes #[[ATTR5]] = { nofree norecurse nosync nounwind willreturn } ; CGSCC: attributes #[[ATTR5]] = { mustprogress nofree norecurse nosync nounwind willreturn }
; CGSCC: attributes #[[ATTR6]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR6]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR7]] = { willreturn } ; CGSCC: attributes #[[ATTR7]] = { willreturn }
;. ;.

llvm/test/Transforms/Attributor/value-simplify-gpu.ll

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Linesif.else: ; preds = %entry
br label %if.end br label %if.end
if.end: ; preds = %if.else, %if.then if.end: ; preds = %if.else, %if.then
call void @level2Kernelall_late() call void @level2Kernelall_late()
ret void ret void
} }
define internal void @level2Kernelall_early() { define internal void @level2Kernelall_early() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CHECK-LABEL: define {{[^@]+}}@level2Kernelall_early ; CHECK-LABEL: define {{[^@]+}}@level2Kernelall_early
; CHECK-SAME: () #[[ATTR2:[0-9]+]] { ; CHECK-SAME: () #[[ATTR2:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: store i32 1, ptr @ReachableKernelAS0, align 4 ; CHECK-NEXT: store i32 1, ptr @ReachableKernelAS0, align 4
; CHECK-NEXT: store i32 1, ptr addrspacecast (ptr addrspace(3) @ReachableKernel to ptr), align 4 ; CHECK-NEXT: store i32 1, ptr addrspacecast (ptr addrspace(3) @ReachableKernel to ptr), align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Linesentry:
%0 = load i32, ptr addrspacecast (ptr addrspace(3) @ReachableKernel to ptr), align 4 %0 = load i32, ptr addrspacecast (ptr addrspace(3) @ReachableKernel to ptr), align 4
%1 = load i32, ptr @ReachableKernelAS0, align 4 %1 = load i32, ptr @ReachableKernelAS0, align 4
%2 = load i32, ptr addrspacecast (ptr addrspace(3) @UnreachableKernel to ptr), align 4 %2 = load i32, ptr addrspacecast (ptr addrspace(3) @UnreachableKernel to ptr), align 4
call void @use(i32 %0, i32 %1, i32 %2) call void @use(i32 %0, i32 %1, i32 %2)
ret void ret void
} }
define internal void @level2Kernelall_late() { define internal void @level2Kernelall_late() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CHECK-LABEL: define {{[^@]+}}@level2Kernelall_late ; CHECK-LABEL: define {{[^@]+}}@level2Kernelall_late
; CHECK-SAME: () #[[ATTR2]] { ; CHECK-SAME: () #[[ATTR2]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: store i32 1, ptr addrspacecast (ptr addrspace(3) @UnreachableKernel to ptr), align 4 ; CHECK-NEXT: store i32 1, ptr addrspacecast (ptr addrspace(3) @UnreachableKernel to ptr), align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
store i32 1, ptr addrspacecast (ptr addrspace(3) @UnreachableKernel to ptr), align 4 store i32 1, ptr addrspacecast (ptr addrspace(3) @UnreachableKernel to ptr), align 4
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Linesif.else: ; preds = %entry
br label %if.end br label %if.end
if.end: ; preds = %if.else, %if.then if.end: ; preds = %if.else, %if.then
call void @level2all_late(ptr %local) call void @level2all_late(ptr %local)
ret void ret void
} }
define internal void @level2all_early(ptr %addr) { define internal void @level2all_early(ptr %addr) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@level2all_early ; TUNIT-LABEL: define {{[^@]+}}@level2all_early
; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[ADDR:%.*]]) #[[ATTR2]] { ; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[ADDR:%.*]]) #[[ATTR2]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: store i32 1, ptr addrspacecast (ptr addrspace(3) @ReachableNonKernel to ptr), align 4 ; TUNIT-NEXT: store i32 1, ptr addrspacecast (ptr addrspace(3) @ReachableNonKernel to ptr), align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@level2all_early ; CGSCC-LABEL: define {{[^@]+}}@level2all_early
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[ADDR:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[ADDR:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: store i32 1, ptr addrspacecast (ptr addrspace(3) @ReachableNonKernel to ptr), align 4 ; CGSCC-NEXT: store i32 1, ptr addrspacecast (ptr addrspace(3) @ReachableNonKernel to ptr), align 4
; CGSCC-NEXT: store i32 17, ptr [[ADDR]], align 4 ; CGSCC-NEXT: store i32 17, ptr [[ADDR]], align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
entry: entry:
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Linesentry:
%0 = load i32, ptr addrspacecast (ptr addrspace(3) @ReachableNonKernel to ptr), align 4 %0 = load i32, ptr addrspacecast (ptr addrspace(3) @ReachableNonKernel to ptr), align 4
%1 = load i32, ptr addrspacecast (ptr addrspace(3) @UnreachableNonKernel to ptr), align 4 %1 = load i32, ptr addrspacecast (ptr addrspace(3) @UnreachableNonKernel to ptr), align 4
%2 = load i32, ptr %addr %2 = load i32, ptr %addr
call void @use(i32 %0, i32 %1, i32 %2) call void @use(i32 %0, i32 %1, i32 %2)
ret void ret void
} }
define internal void @level2all_late(ptr %addr) { define internal void @level2all_late(ptr %addr) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@level2all_late ; TUNIT-LABEL: define {{[^@]+}}@level2all_late
; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[ADDR:%.*]]) #[[ATTR2]] { ; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[ADDR:%.*]]) #[[ATTR2]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: store i32 1, ptr addrspacecast (ptr addrspace(3) @UnreachableNonKernel to ptr), align 4 ; TUNIT-NEXT: store i32 1, ptr addrspacecast (ptr addrspace(3) @UnreachableNonKernel to ptr), align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@level2all_late ; CGSCC-LABEL: define {{[^@]+}}@level2all_late
; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[ADDR:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[ADDR:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: store i32 1, ptr addrspacecast (ptr addrspace(3) @UnreachableNonKernel to ptr), align 4 ; CGSCC-NEXT: store i32 1, ptr addrspacecast (ptr addrspace(3) @UnreachableNonKernel to ptr), align 4
; CGSCC-NEXT: store i32 5, ptr [[ADDR]], align 4 ; CGSCC-NEXT: store i32 5, ptr [[ADDR]], align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
entry: entry:
store i32 1, ptr addrspacecast (ptr addrspace(3) @UnreachableNonKernel to ptr), align 4 store i32 1, ptr addrspacecast (ptr addrspace(3) @UnreachableNonKernel to ptr), align 4
store i32 5, ptr %addr, align 4 store i32 5, ptr %addr, align 4
ret void ret void
} }
declare dso_local void @use(i32, i32, i32) nosync norecurse nounwind declare dso_local void @use(i32, i32, i32) nosync norecurse nounwind
;. ;.
; TUNIT: attributes #[[ATTR0]] = { norecurse nosync nounwind "kernel" } ; TUNIT: attributes #[[ATTR0]] = { norecurse nosync nounwind "kernel" }
; TUNIT: attributes #[[ATTR1]] = { norecurse nosync nounwind } ; TUNIT: attributes #[[ATTR1]] = { norecurse nosync nounwind }
; TUNIT: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; TUNIT: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; TUNIT: attributes #[[ATTR3]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR3]] = { nofree nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR4]] = { nosync nounwind } ; TUNIT: attributes #[[ATTR4]] = { nosync nounwind }
; TUNIT: attributes #[[ATTR5]] = { nounwind } ; TUNIT: attributes #[[ATTR5]] = { nounwind }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { norecurse nosync nounwind "kernel" } ; CGSCC: attributes #[[ATTR0]] = { norecurse nosync nounwind "kernel" }
; CGSCC: attributes #[[ATTR1]] = { norecurse nosync nounwind } ; CGSCC: attributes #[[ATTR1]] = { norecurse nosync nounwind }
; CGSCC: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR3]] = { nosync nounwind } ; CGSCC: attributes #[[ATTR3]] = { nosync nounwind }
; CGSCC: attributes #[[ATTR4]] = { nounwind } ; CGSCC: attributes #[[ATTR4]] = { nounwind }
; CGSCC: attributes #[[ATTR5]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR5]] = { nounwind willreturn }
;. ;.

llvm/test/Transforms/Attributor/value-simplify-instances.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=16 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=16 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
declare ptr @geti1Ptr() declare ptr @geti1Ptr()
; Make sure we do *not* return true. ; Make sure we do *not* return true.
;. ;.
; CHECK: @[[G1:[a-zA-Z0-9_$"\\.-]+]] = private global ptr undef ; CHECK: @[[G1:[a-zA-Z0-9_$"\\.-]+]] = private global ptr undef
; CHECK: @[[G2:[a-zA-Z0-9_$"\\.-]+]] = private global ptr undef ; CHECK: @[[G2:[a-zA-Z0-9_$"\\.-]+]] = private global ptr undef
; CHECK: @[[G3:[a-zA-Z0-9_$"\\.-]+]] = private global i1 undef ; CHECK: @[[G3:[a-zA-Z0-9_$"\\.-]+]] = private global i1 undef
;. ;.
define internal i1 @recursive_inst_comparator(ptr %a, ptr %b) { define internal i1 @recursive_inst_comparator(ptr %a, ptr %b) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@recursive_inst_comparator ; CHECK-LABEL: define {{[^@]+}}@recursive_inst_comparator
; CHECK-SAME: (ptr noalias nofree readnone [[A:%.*]], ptr noalias nofree readnone [[B:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr noalias nofree readnone [[A:%.*]], ptr noalias nofree readnone [[B:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[A]], [[B]] ; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[A]], [[B]]
; CHECK-NEXT: ret i1 [[CMP]] ; CHECK-NEXT: ret i1 [[CMP]]
; ;
%cmp = icmp eq ptr %a, %b %cmp = icmp eq ptr %a, %b
ret i1 %cmp ret i1 %cmp
} }
▲ Show 20 Lines • Show All 364 Lines • ▼ Show 20 Lines
; CGSCC-NEXT: [[CALL:%.*]] = call i1 @recursive_inst_compare_global3(i1 noundef [[C]]) #[[ATTR5]] ; CGSCC-NEXT: [[CALL:%.*]] = call i1 @recursive_inst_compare_global3(i1 noundef [[C]]) #[[ATTR5]]
; CGSCC-NEXT: ret i1 [[CALL]] ; CGSCC-NEXT: ret i1 [[CALL]]
; ;
%call = call i1 @recursive_inst_compare_global3(i1 %c) %call = call i1 @recursive_inst_compare_global3(i1 %c)
ret i1 %call ret i1 %call
} }
define i32 @non_unique_phi_ops(ptr %ptr) { define i32 @non_unique_phi_ops(ptr %ptr) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; TUNIT-LABEL: define {{[^@]+}}@non_unique_phi_ops ; TUNIT-LABEL: define {{[^@]+}}@non_unique_phi_ops
; TUNIT-SAME: (ptr nocapture nofree readonly [[PTR:%.*]]) #[[ATTR6:[0-9]+]] { ; TUNIT-SAME: (ptr nocapture nofree readonly [[PTR:%.*]]) #[[ATTR6:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: br label [[HEADER:%.*]] ; TUNIT-NEXT: br label [[HEADER:%.*]]
; TUNIT: header: ; TUNIT: header:
; TUNIT-NEXT: [[I:%.*]] = phi i32 [ [[ADD:%.*]], [[F:%.*]] ], [ 0, [[ENTRY:%.*]] ] ; TUNIT-NEXT: [[I:%.*]] = phi i32 [ [[ADD:%.*]], [[F:%.*]] ], [ 0, [[ENTRY:%.*]] ]
; TUNIT-NEXT: [[P:%.*]] = phi i32 [ [[NON_UNIQUE:%.*]], [[F]] ], [ poison, [[ENTRY]] ] ; TUNIT-NEXT: [[P:%.*]] = phi i32 [ [[NON_UNIQUE:%.*]], [[F]] ], [ poison, [[ENTRY]] ]
; TUNIT-NEXT: [[ADD]] = add i32 [[I]], 1 ; TUNIT-NEXT: [[ADD]] = add i32 [[I]], 1
; TUNIT-NEXT: [[G:%.*]] = getelementptr i32, ptr [[PTR]], i32 [[I]] ; TUNIT-NEXT: [[G:%.*]] = getelementptr i32, ptr [[PTR]], i32 [[I]]
; TUNIT-NEXT: [[NON_UNIQUE_INPUT:%.*]] = load i32, ptr [[G]], align 4 ; TUNIT-NEXT: [[NON_UNIQUE_INPUT:%.*]] = load i32, ptr [[G]], align 4
; TUNIT-NEXT: [[CMP1:%.*]] = icmp eq i32 [[I]], [[NON_UNIQUE_INPUT]] ; TUNIT-NEXT: [[CMP1:%.*]] = icmp eq i32 [[I]], [[NON_UNIQUE_INPUT]]
; TUNIT-NEXT: br i1 [[CMP1]], label [[T:%.*]], label [[F]] ; TUNIT-NEXT: br i1 [[CMP1]], label [[T:%.*]], label [[F]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: br label [[F]] ; TUNIT-NEXT: br label [[F]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: [[NON_UNIQUE]] = phi i32 [ [[NON_UNIQUE_INPUT]], [[T]] ], [ [[P]], [[HEADER]] ] ; TUNIT-NEXT: [[NON_UNIQUE]] = phi i32 [ [[NON_UNIQUE_INPUT]], [[T]] ], [ [[P]], [[HEADER]] ]
; TUNIT-NEXT: [[CMP2:%.*]] = icmp slt i32 [[I]], 42 ; TUNIT-NEXT: [[CMP2:%.*]] = icmp slt i32 [[I]], 42
; TUNIT-NEXT: br i1 [[CMP2]], label [[HEADER]], label [[END:%.*]] ; TUNIT-NEXT: br i1 [[CMP2]], label [[HEADER]], label [[END:%.*]]
; TUNIT: end: ; TUNIT: end:
; TUNIT-NEXT: ret i32 [[P]] ; TUNIT-NEXT: ret i32 [[P]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@non_unique_phi_ops ; CGSCC-LABEL: define {{[^@]+}}@non_unique_phi_ops
; CGSCC-SAME: (ptr nocapture nofree readonly [[PTR:%.*]]) #[[ATTR4:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree readonly [[PTR:%.*]]) #[[ATTR4:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: br label [[HEADER:%.*]] ; CGSCC-NEXT: br label [[HEADER:%.*]]
; CGSCC: header: ; CGSCC: header:
; CGSCC-NEXT: [[I:%.*]] = phi i32 [ [[ADD:%.*]], [[F:%.*]] ], [ 0, [[ENTRY:%.*]] ] ; CGSCC-NEXT: [[I:%.*]] = phi i32 [ [[ADD:%.*]], [[F:%.*]] ], [ 0, [[ENTRY:%.*]] ]
; CGSCC-NEXT: [[P:%.*]] = phi i32 [ [[NON_UNIQUE:%.*]], [[F]] ], [ poison, [[ENTRY]] ] ; CGSCC-NEXT: [[P:%.*]] = phi i32 [ [[NON_UNIQUE:%.*]], [[F]] ], [ poison, [[ENTRY]] ]
; CGSCC-NEXT: [[ADD]] = add i32 [[I]], 1 ; CGSCC-NEXT: [[ADD]] = add i32 [[I]], 1
Show All 28 Linesf:
%cmp2 = icmp slt i32 %i, 42 %cmp2 = icmp slt i32 %i, 42
br i1 %cmp2, label %header, label %end br i1 %cmp2, label %header, label %end
end: end:
ret i32 %p ret i32 %p
} }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind memory(none) } ; TUNIT: attributes #[[ATTR1]] = { nofree nosync nounwind memory(none) }
; TUNIT: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind memory(none) } ; TUNIT: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind memory(none) }
; TUNIT: attributes #[[ATTR3]] = { nofree nosync nounwind memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR3]] = { nofree nosync nounwind memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR4]] = { nofree nosync nounwind } ; TUNIT: attributes #[[ATTR4]] = { nofree nosync nounwind }
; TUNIT: attributes #[[ATTR5]] = { nofree norecurse nosync nounwind } ; TUNIT: attributes #[[ATTR5]] = { nofree norecurse nosync nounwind }
; TUNIT: attributes #[[ATTR6]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; TUNIT: attributes #[[ATTR6]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; TUNIT: attributes #[[ATTR7]] = { nounwind } ; TUNIT: attributes #[[ATTR7]] = { nounwind }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind memory(none) } ; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind memory(none) }
; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR3]] = { nofree nosync nounwind } ; CGSCC: attributes #[[ATTR3]] = { nofree nosync nounwind }
; CGSCC: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR5]] = { nounwind } ; CGSCC: attributes #[[ATTR5]] = { nounwind }
;. ;.

llvm/test/Transforms/Attributor/value-simplify-local-remote.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=7 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=7 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; Most reduced from the OpenMC app running OpenMP offloading code, caused crashes before as we ; Most reduced from the OpenMC app running OpenMP offloading code, caused crashes before as we
; mixed local and remote (=intra and inter procedural) values. ; mixed local and remote (=intra and inter procedural) values.
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
%S = type { ptr } %S = type { ptr }
%S.2 = type { ptr, i64, i64 } %S.2 = type { ptr, i64, i64 }
%struct1 = type { %struct2 } %struct1 = type { %struct2 }
%struct2 = type <{ ptr, i64, i64, i32, [4 x i8] }> %struct2 = type <{ ptr, i64, i64, i32, [4 x i8] }>
define i64 @t1(ptr %first, ptr %first.addr, ptr %0) { define i64 @t1(ptr %first, ptr %first.addr, ptr %0) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@t1 ; TUNIT-LABEL: define {{[^@]+}}@t1
; TUNIT-SAME: (ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[FIRST:%.*]], ptr nocapture nofree readnone [[FIRST_ADDR:%.*]], ptr nocapture nofree readnone [[TMP0:%.*]]) #[[ATTR0:[0-9]+]] { ; TUNIT-SAME: (ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[FIRST:%.*]], ptr nocapture nofree readnone [[FIRST_ADDR:%.*]], ptr nocapture nofree readnone [[TMP0:%.*]]) #[[ATTR0:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[FIRST_ADDR1:%.*]] = alloca ptr, i32 0, align 8 ; TUNIT-NEXT: [[FIRST_ADDR1:%.*]] = alloca ptr, i32 0, align 8
; TUNIT-NEXT: store ptr [[FIRST]], ptr [[FIRST]], align 8 ; TUNIT-NEXT: store ptr [[FIRST]], ptr [[FIRST]], align 8
; TUNIT-NEXT: br label [[IF_END:%.*]] ; TUNIT-NEXT: br label [[IF_END:%.*]]
; TUNIT: if.end: ; TUNIT: if.end:
; TUNIT-NEXT: [[CALL:%.*]] = call ptr @foo.4(ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[FIRST]]) #[[ATTR3:[0-9]+]] ; TUNIT-NEXT: [[CALL:%.*]] = call ptr @foo.4(ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[FIRST]]) #[[ATTR3:[0-9]+]]
; TUNIT-NEXT: ret i64 0 ; TUNIT-NEXT: ret i64 0
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@t1 ; CGSCC-LABEL: define {{[^@]+}}@t1
; CGSCC-SAME: (ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[FIRST:%.*]], ptr nocapture nofree readnone [[FIRST_ADDR:%.*]], ptr nocapture nofree readnone [[TMP0:%.*]]) #[[ATTR0:[0-9]+]] { ; CGSCC-SAME: (ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[FIRST:%.*]], ptr nocapture nofree readnone [[FIRST_ADDR:%.*]], ptr nocapture nofree readnone [[TMP0:%.*]]) #[[ATTR0:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[FIRST_ADDR1:%.*]] = alloca ptr, i32 0, align 8 ; CGSCC-NEXT: [[FIRST_ADDR1:%.*]] = alloca ptr, i32 0, align 8
; CGSCC-NEXT: store ptr [[FIRST]], ptr [[FIRST]], align 8 ; CGSCC-NEXT: store ptr [[FIRST]], ptr [[FIRST]], align 8
; CGSCC-NEXT: br label [[IF_END:%.*]] ; CGSCC-NEXT: br label [[IF_END:%.*]]
; CGSCC: if.end: ; CGSCC: if.end:
; CGSCC-NEXT: [[CALL:%.*]] = call ptr @foo.4(ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[FIRST]]) #[[ATTR6:[0-9]+]] ; CGSCC-NEXT: [[CALL:%.*]] = call ptr @foo.4(ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[FIRST]]) #[[ATTR6:[0-9]+]]
; CGSCC-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds double, ptr [[CALL]], i64 -1 ; CGSCC-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds double, ptr [[CALL]], i64 -1
; CGSCC-NEXT: ret i64 0 ; CGSCC-NEXT: ret i64 0
; ;
entry: entry:
%first.addr1 = alloca ptr, i32 0, align 8 %first.addr1 = alloca ptr, i32 0, align 8
store ptr %first, ptr %first, align 8 store ptr %first, ptr %first, align 8
br label %if.end br label %if.end
if.end: ; preds = %entry if.end: ; preds = %entry
%1 = load ptr, ptr %first, align 8 %1 = load ptr, ptr %first, align 8
%call = call ptr @foo.4(ptr %first) %call = call ptr @foo.4(ptr %first)
%add.ptr = getelementptr inbounds double, ptr %call, i64 -1 %add.ptr = getelementptr inbounds double, ptr %call, i64 -1
ret i64 0 ret i64 0
} }
define internal ptr @foo.4(ptr %__first) { define internal ptr @foo.4(ptr %__first) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@foo.4 ; TUNIT-LABEL: define {{[^@]+}}@foo.4
; TUNIT-SAME: (ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[__FIRST:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[__FIRST:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[__FIRST_ADDR:%.*]] = alloca ptr, i32 0, align 8 ; TUNIT-NEXT: [[__FIRST_ADDR:%.*]] = alloca ptr, i32 0, align 8
; TUNIT-NEXT: store ptr [[__FIRST]], ptr [[__FIRST]], align 8 ; TUNIT-NEXT: store ptr [[__FIRST]], ptr [[__FIRST]], align 8
; TUNIT-NEXT: ret ptr undef ; TUNIT-NEXT: ret ptr undef
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@foo.4 ; CGSCC-LABEL: define {{[^@]+}}@foo.4
; CGSCC-SAME: (ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[__FIRST:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[__FIRST:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[__FIRST_ADDR:%.*]] = alloca ptr, i32 0, align 8 ; CGSCC-NEXT: [[__FIRST_ADDR:%.*]] = alloca ptr, i32 0, align 8
; CGSCC-NEXT: store ptr [[__FIRST]], ptr [[__FIRST]], align 8 ; CGSCC-NEXT: store ptr [[__FIRST]], ptr [[__FIRST]], align 8
; CGSCC-NEXT: [[CALL1:%.*]] = call noalias noundef nonnull align 8 dereferenceable(8) ptr @bar(ptr noalias nofree noundef nonnull readnone align 8 dereferenceable(8) [[__FIRST]]) #[[ATTR7:[0-9]+]] ; CGSCC-NEXT: [[CALL1:%.*]] = call noalias noundef nonnull align 8 dereferenceable(8) ptr @bar(ptr noalias nofree noundef nonnull readnone align 8 dereferenceable(8) [[__FIRST]]) #[[ATTR7:[0-9]+]]
; CGSCC-NEXT: ret ptr [[CALL1]] ; CGSCC-NEXT: ret ptr [[CALL1]]
; ;
entry: entry:
%__first.addr = alloca ptr, i32 0, align 8 %__first.addr = alloca ptr, i32 0, align 8
store ptr %__first, ptr %__first, align 8 store ptr %__first, ptr %__first, align 8
%0 = load ptr, ptr %__first, align 8 %0 = load ptr, ptr %__first, align 8
%call1 = call ptr @bar(ptr %__first) %call1 = call ptr @bar(ptr %__first)
ret ptr %call1 ret ptr %call1
} }
define internal ptr @bar(ptr %QQfirst) { define internal ptr @bar(ptr %QQfirst) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@bar ; CGSCC-LABEL: define {{[^@]+}}@bar
; CGSCC-SAME: (ptr noalias nofree noundef nonnull readnone returned align 8 dereferenceable(8) "no-capture-maybe-returned" [[QQFIRST:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (ptr noalias nofree noundef nonnull readnone returned align 8 dereferenceable(8) "no-capture-maybe-returned" [[QQFIRST:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[QQFIRST_ADDR:%.*]] = alloca ptr, i32 0, align 8 ; CGSCC-NEXT: [[QQFIRST_ADDR:%.*]] = alloca ptr, i32 0, align 8
; CGSCC-NEXT: store ptr [[QQFIRST]], ptr [[QQFIRST_ADDR]], align 8 ; CGSCC-NEXT: store ptr [[QQFIRST]], ptr [[QQFIRST_ADDR]], align 8
; CGSCC-NEXT: br label [[WHILE_COND:%.*]] ; CGSCC-NEXT: br label [[WHILE_COND:%.*]]
; CGSCC: while.cond: ; CGSCC: while.cond:
; CGSCC-NEXT: br label [[WHILE_END:%.*]] ; CGSCC-NEXT: br label [[WHILE_END:%.*]]
Show All 9 Lineswhile.cond: ; preds = %entry
br label %while.end br label %while.end
while.end: ; preds = %while.cond while.end: ; preds = %while.cond
%0 = load ptr, ptr %QQfirst.addr, align 8 %0 = load ptr, ptr %QQfirst.addr, align 8
ret ptr %0 ret ptr %0
} }
define ptr @t2(ptr %this, ptr %this.addr, ptr %this1) { define ptr @t2(ptr %this, ptr %this.addr, ptr %this1) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@t2 ; TUNIT-LABEL: define {{[^@]+}}@t2
; TUNIT-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS:%.*]], ptr nocapture nofree readnone [[THIS_ADDR:%.*]], ptr nocapture nofree readnone [[THIS1:%.*]]) #[[ATTR1:[0-9]+]] { ; TUNIT-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS:%.*]], ptr nocapture nofree readnone [[THIS_ADDR:%.*]], ptr nocapture nofree readnone [[THIS1:%.*]]) #[[ATTR1:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8 ; TUNIT-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8
; TUNIT-NEXT: [[CALL:%.*]] = call [[S:%.*]] @foo.1(ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS]]) #[[ATTR4:[0-9]+]] ; TUNIT-NEXT: [[CALL:%.*]] = call [[S:%.*]] @foo.1(ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS]]) #[[ATTR4:[0-9]+]]
; TUNIT-NEXT: [[TEST_RET:%.*]] = extractvalue [[S]] [[CALL]], 0 ; TUNIT-NEXT: [[TEST_RET:%.*]] = extractvalue [[S]] [[CALL]], 0
; TUNIT-NEXT: ret ptr [[TEST_RET]] ; TUNIT-NEXT: ret ptr [[TEST_RET]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@t2 ; CGSCC-LABEL: define {{[^@]+}}@t2
; CGSCC-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS:%.*]], ptr nocapture nofree readnone [[THIS_ADDR:%.*]], ptr nocapture nofree readnone [[THIS1:%.*]]) #[[ATTR2:[0-9]+]] { ; CGSCC-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS:%.*]], ptr nocapture nofree readnone [[THIS_ADDR:%.*]], ptr nocapture nofree readnone [[THIS1:%.*]]) #[[ATTR2:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8 ; CGSCC-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8
; CGSCC-NEXT: [[CALL:%.*]] = call [[S:%.*]] @foo.1(ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS]]) #[[ATTR6]] ; CGSCC-NEXT: [[CALL:%.*]] = call [[S:%.*]] @foo.1(ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS]]) #[[ATTR6]]
; CGSCC-NEXT: [[TEST_RET:%.*]] = extractvalue [[S]] [[CALL]], 0 ; CGSCC-NEXT: [[TEST_RET:%.*]] = extractvalue [[S]] [[CALL]], 0
; CGSCC-NEXT: ret ptr [[TEST_RET]] ; CGSCC-NEXT: ret ptr [[TEST_RET]]
; ;
entry: entry:
store ptr %this, ptr %this, align 8 store ptr %this, ptr %this, align 8
%this12 = load ptr, ptr %this, align 8 %this12 = load ptr, ptr %this, align 8
%call = call %S @foo.1(ptr %this) %call = call %S @foo.1(ptr %this)
%test.ret = extractvalue %S %call, 0 %test.ret = extractvalue %S %call, 0
ret ptr %test.ret ret ptr %test.ret
} }
define internal %S @foo.1(ptr %foo.this) { define internal %S @foo.1(ptr %foo.this) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@foo.1 ; TUNIT-LABEL: define {{[^@]+}}@foo.1
; TUNIT-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[FOO_THIS:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[FOO_THIS:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[RETVAL:%.*]] = alloca [[S:%.*]], i32 0, align 8 ; TUNIT-NEXT: [[RETVAL:%.*]] = alloca [[S:%.*]], i32 0, align 8
; TUNIT-NEXT: store ptr [[FOO_THIS]], ptr [[FOO_THIS]], align 8 ; TUNIT-NEXT: store ptr [[FOO_THIS]], ptr [[FOO_THIS]], align 8
; TUNIT-NEXT: call void @bar.2(ptr noalias nocapture nofree noundef nonnull writeonly align 8 [[RETVAL]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[FOO_THIS]]) #[[ATTR4]] ; TUNIT-NEXT: call void @bar.2(ptr noalias nocapture nofree noundef nonnull writeonly align 8 [[RETVAL]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[FOO_THIS]]) #[[ATTR4]]
; TUNIT-NEXT: [[FOO_RET:%.*]] = load [[S]], ptr [[RETVAL]], align 8 ; TUNIT-NEXT: [[FOO_RET:%.*]] = load [[S]], ptr [[RETVAL]], align 8
; TUNIT-NEXT: ret [[S]] [[FOO_RET]] ; TUNIT-NEXT: ret [[S]] [[FOO_RET]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@foo.1 ; CGSCC-LABEL: define {{[^@]+}}@foo.1
; CGSCC-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[FOO_THIS:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[FOO_THIS:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[RETVAL:%.*]] = alloca [[S:%.*]], i32 0, align 8 ; CGSCC-NEXT: [[RETVAL:%.*]] = alloca [[S:%.*]], i32 0, align 8
; CGSCC-NEXT: store ptr [[FOO_THIS]], ptr [[FOO_THIS]], align 8 ; CGSCC-NEXT: store ptr [[FOO_THIS]], ptr [[FOO_THIS]], align 8
; CGSCC-NEXT: call void @bar.2(ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[RETVAL]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[FOO_THIS]]) #[[ATTR8:[0-9]+]] ; CGSCC-NEXT: call void @bar.2(ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[RETVAL]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[FOO_THIS]]) #[[ATTR8:[0-9]+]]
; CGSCC-NEXT: [[FOO_RET:%.*]] = load [[S]], ptr [[RETVAL]], align 8 ; CGSCC-NEXT: [[FOO_RET:%.*]] = load [[S]], ptr [[RETVAL]], align 8
; CGSCC-NEXT: ret [[S]] [[FOO_RET]] ; CGSCC-NEXT: ret [[S]] [[FOO_RET]]
; ;
entry: entry:
%retval = alloca %S, i32 0, align 8 %retval = alloca %S, i32 0, align 8
store ptr %foo.this, ptr %foo.this, align 8 store ptr %foo.this, ptr %foo.this, align 8
call void @bar.2(ptr %retval, ptr %foo.this) call void @bar.2(ptr %retval, ptr %foo.this)
%foo.ret = load %S, ptr %retval, align 8 %foo.ret = load %S, ptr %retval, align 8
ret %S %foo.ret ret %S %foo.ret
} }
define internal void @bar.2(ptr %bar.this, ptr %bar.data) { define internal void @bar.2(ptr %bar.this, ptr %bar.data) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@bar.2 ; TUNIT-LABEL: define {{[^@]+}}@bar.2
; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAR_THIS:%.*]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAR_DATA:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAR_THIS:%.*]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAR_DATA:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: store ptr [[BAR_DATA]], ptr [[BAR_THIS]], align 8 ; TUNIT-NEXT: store ptr [[BAR_DATA]], ptr [[BAR_THIS]], align 8
; TUNIT-NEXT: call void @baz(ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAR_THIS]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAR_DATA]]) #[[ATTR4]] ; TUNIT-NEXT: call void @baz(ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAR_THIS]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAR_DATA]]) #[[ATTR4]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@bar.2 ; CGSCC-LABEL: define {{[^@]+}}@bar.2
; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAR_THIS:%.*]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAR_DATA:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAR_THIS:%.*]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAR_DATA:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: store ptr [[BAR_DATA]], ptr [[BAR_THIS]], align 8 ; CGSCC-NEXT: store ptr [[BAR_DATA]], ptr [[BAR_THIS]], align 8
; CGSCC-NEXT: call void @baz(ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAR_THIS]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAR_DATA]]) #[[ATTR8]] ; CGSCC-NEXT: call void @baz(ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAR_THIS]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAR_DATA]]) #[[ATTR8]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
entry: entry:
store ptr %bar.data, ptr %bar.this, align 8 store ptr %bar.data, ptr %bar.this, align 8
call void @baz(ptr %bar.this, ptr %bar.data) call void @baz(ptr %bar.this, ptr %bar.data)
ret void ret void
} }
define internal void @baz(ptr %baz.this, ptr %baz.data) { define internal void @baz(ptr %baz.this, ptr %baz.data) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@baz ; TUNIT-LABEL: define {{[^@]+}}@baz
; TUNIT-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAZ_THIS:%.*]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAZ_DATA:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAZ_THIS:%.*]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAZ_DATA:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: store ptr [[BAZ_DATA]], ptr [[BAZ_THIS]], align 8 ; TUNIT-NEXT: store ptr [[BAZ_DATA]], ptr [[BAZ_THIS]], align 8
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@baz ; CGSCC-LABEL: define {{[^@]+}}@baz
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAZ_THIS:%.*]], ptr nofree writeonly [[BAZ_DATA:%.*]]) #[[ATTR3:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[BAZ_THIS:%.*]], ptr nofree writeonly [[BAZ_DATA:%.*]]) #[[ATTR3:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: store ptr [[BAZ_DATA]], ptr [[BAZ_THIS]], align 8 ; CGSCC-NEXT: store ptr [[BAZ_DATA]], ptr [[BAZ_THIS]], align 8
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
entry: entry:
store ptr %baz.data, ptr %baz.this, align 8 store ptr %baz.data, ptr %baz.this, align 8
ret void ret void
} }
define ptr @foo(ptr %this, ptr %this.addr, ptr %this1) { define ptr @foo(ptr %this, ptr %this.addr, ptr %this1) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@foo ; TUNIT-LABEL: define {{[^@]+}}@foo
; TUNIT-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS:%.*]], ptr nocapture nofree readnone [[THIS_ADDR:%.*]], ptr nocapture nofree readnone [[THIS1:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS:%.*]], ptr nocapture nofree readnone [[THIS_ADDR:%.*]], ptr nocapture nofree readnone [[THIS1:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8 ; TUNIT-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8
; TUNIT-NEXT: [[CALL:%.*]] = call [[S:%.*]] @bar.5(ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS]]) #[[ATTR3]] ; TUNIT-NEXT: [[CALL:%.*]] = call [[S:%.*]] @bar.5(ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS]]) #[[ATTR3]]
; TUNIT-NEXT: [[FOO_RET:%.*]] = extractvalue [[S]] [[CALL]], 0 ; TUNIT-NEXT: [[FOO_RET:%.*]] = extractvalue [[S]] [[CALL]], 0
; TUNIT-NEXT: ret ptr [[FOO_RET]] ; TUNIT-NEXT: ret ptr [[FOO_RET]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@foo ; CGSCC-LABEL: define {{[^@]+}}@foo
; CGSCC-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS:%.*]], ptr nocapture nofree readnone [[THIS_ADDR:%.*]], ptr nocapture nofree readnone [[THIS1:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS:%.*]], ptr nocapture nofree readnone [[THIS_ADDR:%.*]], ptr nocapture nofree readnone [[THIS1:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8 ; CGSCC-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8
; CGSCC-NEXT: [[CALL:%.*]] = call [[S:%.*]] @bar.5(ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS]]) #[[ATTR6]] ; CGSCC-NEXT: [[CALL:%.*]] = call [[S:%.*]] @bar.5(ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS]]) #[[ATTR6]]
; CGSCC-NEXT: [[FOO_RET:%.*]] = extractvalue [[S]] [[CALL]], 0 ; CGSCC-NEXT: [[FOO_RET:%.*]] = extractvalue [[S]] [[CALL]], 0
; CGSCC-NEXT: ret ptr [[FOO_RET]] ; CGSCC-NEXT: ret ptr [[FOO_RET]]
; ;
entry: entry:
store ptr %this, ptr %this, align 8 store ptr %this, ptr %this, align 8
%this12 = load ptr, ptr %this, align 8 %this12 = load ptr, ptr %this, align 8
%call = call %S @bar.5(ptr %this) %call = call %S @bar.5(ptr %this)
%foo.ret = extractvalue %S %call, 0 %foo.ret = extractvalue %S %call, 0
ret ptr %foo.ret ret ptr %foo.ret
} }
define internal %S @bar.5(ptr %this) { define internal %S @bar.5(ptr %this) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@bar.5 ; TUNIT-LABEL: define {{[^@]+}}@bar.5
; TUNIT-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[RETVAL:%.*]] = alloca [[S:%.*]], i32 0, align 8 ; TUNIT-NEXT: [[RETVAL:%.*]] = alloca [[S:%.*]], i32 0, align 8
; TUNIT-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8 ; TUNIT-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8
; TUNIT-NEXT: call void @baz.6(ptr noalias nocapture nofree noundef nonnull writeonly align 8 [[RETVAL]], ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS]]) #[[ATTR3]] ; TUNIT-NEXT: call void @baz.6(ptr noalias nocapture nofree noundef nonnull writeonly align 8 [[RETVAL]], ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS]]) #[[ATTR3]]
; TUNIT-NEXT: [[BAR_RET:%.*]] = load [[S]], ptr [[RETVAL]], align 8 ; TUNIT-NEXT: [[BAR_RET:%.*]] = load [[S]], ptr [[RETVAL]], align 8
; TUNIT-NEXT: ret [[S]] [[BAR_RET]] ; TUNIT-NEXT: ret [[S]] [[BAR_RET]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@bar.5 ; CGSCC-LABEL: define {{[^@]+}}@bar.5
; CGSCC-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[RETVAL:%.*]] = alloca [[S:%.*]], i32 0, align 8 ; CGSCC-NEXT: [[RETVAL:%.*]] = alloca [[S:%.*]], i32 0, align 8
; CGSCC-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8 ; CGSCC-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8
; CGSCC-NEXT: call void @baz.6(ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[RETVAL]], ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS]]) #[[ATTR9:[0-9]+]] ; CGSCC-NEXT: call void @baz.6(ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[RETVAL]], ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS]]) #[[ATTR9:[0-9]+]]
; CGSCC-NEXT: [[BAR_RET:%.*]] = load [[S]], ptr [[RETVAL]], align 8 ; CGSCC-NEXT: [[BAR_RET:%.*]] = load [[S]], ptr [[RETVAL]], align 8
; CGSCC-NEXT: ret [[S]] [[BAR_RET]] ; CGSCC-NEXT: ret [[S]] [[BAR_RET]]
; ;
entry: entry:
%retval = alloca %S, i32 0, align 8 %retval = alloca %S, i32 0, align 8
store ptr %this, ptr %this, align 8 store ptr %this, ptr %this, align 8
%0 = load ptr, ptr %this, align 8 %0 = load ptr, ptr %this, align 8
call void @baz.6(ptr %retval, ptr %this) call void @baz.6(ptr %retval, ptr %this)
%bar.ret = load %S, ptr %retval, align 8 %bar.ret = load %S, ptr %retval, align 8
ret %S %bar.ret ret %S %bar.ret
} }
define internal void @baz.6(ptr %this, ptr %data) { define internal void @baz.6(ptr %this, ptr %data) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@baz.6 ; TUNIT-LABEL: define {{[^@]+}}@baz.6
; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]], ptr nofree noundef nonnull align 8 dereferenceable(8) [[DATA:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]], ptr nofree noundef nonnull align 8 dereferenceable(8) [[DATA:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: store ptr [[DATA]], ptr [[THIS]], align 8 ; TUNIT-NEXT: store ptr [[DATA]], ptr [[THIS]], align 8
; TUNIT-NEXT: call void @boom(ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS]], ptr nofree noundef nonnull align 8 dereferenceable(8) [[DATA]]) #[[ATTR4]] ; TUNIT-NEXT: call void @boom(ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS]], ptr nofree noundef nonnull align 8 dereferenceable(8) [[DATA]]) #[[ATTR4]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@baz.6 ; CGSCC-LABEL: define {{[^@]+}}@baz.6
; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]], ptr nofree noundef nonnull align 8 dereferenceable(8) [[DATA:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]], ptr nofree noundef nonnull align 8 dereferenceable(8) [[DATA:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: store ptr [[DATA]], ptr [[THIS]], align 8 ; CGSCC-NEXT: store ptr [[DATA]], ptr [[THIS]], align 8
; CGSCC-NEXT: call void @boom(ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS]], ptr nofree noundef nonnull align 8 dereferenceable(8) [[DATA]]) #[[ATTR9]] ; CGSCC-NEXT: call void @boom(ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS]], ptr nofree noundef nonnull align 8 dereferenceable(8) [[DATA]]) #[[ATTR9]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
entry: entry:
store ptr %data, ptr %this, align 8 store ptr %data, ptr %this, align 8
call void @boom(ptr %this, ptr %data) call void @boom(ptr %this, ptr %data)
ret void ret void
} }
define internal void @boom(ptr %this, ptr %data) { define internal void @boom(ptr %this, ptr %data) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@boom ; TUNIT-LABEL: define {{[^@]+}}@boom
; TUNIT-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]], ptr nofree noundef nonnull align 8 dereferenceable(8) [[DATA:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]], ptr nofree noundef nonnull align 8 dereferenceable(8) [[DATA:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[DATA_ADDR:%.*]] = alloca ptr, i32 0, align 8 ; TUNIT-NEXT: [[DATA_ADDR:%.*]] = alloca ptr, i32 0, align 8
; TUNIT-NEXT: store ptr [[DATA]], ptr [[DATA_ADDR]], align 8 ; TUNIT-NEXT: store ptr [[DATA]], ptr [[DATA_ADDR]], align 8
; TUNIT-NEXT: [[V:%.*]] = load ptr, ptr [[DATA_ADDR]], align 8 ; TUNIT-NEXT: [[V:%.*]] = load ptr, ptr [[DATA_ADDR]], align 8
; TUNIT-NEXT: store ptr [[V]], ptr [[THIS]], align 8 ; TUNIT-NEXT: store ptr [[V]], ptr [[THIS]], align 8
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@boom ; CGSCC-LABEL: define {{[^@]+}}@boom
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]], ptr nofree [[DATA:%.*]]) #[[ATTR4:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]], ptr nofree [[DATA:%.*]]) #[[ATTR4:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[DATA_ADDR:%.*]] = alloca ptr, i32 0, align 8 ; CGSCC-NEXT: [[DATA_ADDR:%.*]] = alloca ptr, i32 0, align 8
; CGSCC-NEXT: store ptr [[DATA]], ptr [[DATA_ADDR]], align 8 ; CGSCC-NEXT: store ptr [[DATA]], ptr [[DATA_ADDR]], align 8
; CGSCC-NEXT: store ptr [[DATA]], ptr [[THIS]], align 8 ; CGSCC-NEXT: store ptr [[DATA]], ptr [[THIS]], align 8
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines
bb34: ; preds = %bb25 bb34: ; preds = %bb25
br label %bb23 br label %bb23
bb35: ; preds = %bb16 bb35: ; preds = %bb16
unreachable unreachable
} }
define double @t4(ptr %this, ptr %this.addr, ptr %this1) { define double @t4(ptr %this, ptr %this.addr, ptr %this1) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@t4 ; TUNIT-LABEL: define {{[^@]+}}@t4
; TUNIT-SAME: (ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]], ptr nocapture nofree readnone [[THIS_ADDR:%.*]], ptr nocapture nofree readnone [[THIS1:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]], ptr nocapture nofree readnone [[THIS_ADDR:%.*]], ptr nocapture nofree readnone [[THIS1:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[THIS_ADDR1:%.*]] = alloca ptr, i32 0, align 8 ; TUNIT-NEXT: [[THIS_ADDR1:%.*]] = alloca ptr, i32 0, align 8
; TUNIT-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8 ; TUNIT-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8
; TUNIT-NEXT: [[CALL:%.*]] = call [[S:%.*]] @t4a(ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS]]) #[[ATTR3]] ; TUNIT-NEXT: [[CALL:%.*]] = call [[S:%.*]] @t4a(ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS]]) #[[ATTR3]]
; TUNIT-NEXT: ret double 0.000000e+00 ; TUNIT-NEXT: ret double 0.000000e+00
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@t4 ; CGSCC-LABEL: define {{[^@]+}}@t4
; CGSCC-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS:%.*]], ptr nocapture nofree readnone [[THIS_ADDR:%.*]], ptr nocapture nofree readnone [[THIS1:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS:%.*]], ptr nocapture nofree readnone [[THIS_ADDR:%.*]], ptr nocapture nofree readnone [[THIS1:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[THIS_ADDR1:%.*]] = alloca ptr, i32 0, align 8 ; CGSCC-NEXT: [[THIS_ADDR1:%.*]] = alloca ptr, i32 0, align 8
; CGSCC-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8 ; CGSCC-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8
; CGSCC-NEXT: [[CALL:%.*]] = call [[S:%.*]] @t4a(ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS]]) #[[ATTR6]] ; CGSCC-NEXT: [[CALL:%.*]] = call [[S:%.*]] @t4a(ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS]]) #[[ATTR6]]
; CGSCC-NEXT: [[TMP0:%.*]] = extractvalue [[S]] [[CALL]], 0 ; CGSCC-NEXT: [[TMP0:%.*]] = extractvalue [[S]] [[CALL]], 0
; CGSCC-NEXT: ret double 0.000000e+00 ; CGSCC-NEXT: ret double 0.000000e+00
; ;
entry: entry:
%this.addr1 = alloca ptr, i32 0, align 8 %this.addr1 = alloca ptr, i32 0, align 8
store ptr %this, ptr %this, align 8 store ptr %this, ptr %this, align 8
%this12 = load ptr, ptr %this, align 8 %this12 = load ptr, ptr %this, align 8
%call = call %S @t4a(ptr %this) %call = call %S @t4a(ptr %this)
%0 = extractvalue %S %call, 0 %0 = extractvalue %S %call, 0
ret double 0.000000e+00 ret double 0.000000e+00
} }
define internal %S @t4a(ptr %this) { define internal %S @t4a(ptr %this) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@t4a ; TUNIT-LABEL: define {{[^@]+}}@t4a
; TUNIT-SAME: (ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[RETVAL:%.*]] = alloca [[S:%.*]], i32 0, align 8 ; TUNIT-NEXT: [[RETVAL:%.*]] = alloca [[S:%.*]], i32 0, align 8
; TUNIT-NEXT: [[THIS_ADDR:%.*]] = alloca ptr, i32 0, align 8 ; TUNIT-NEXT: [[THIS_ADDR:%.*]] = alloca ptr, i32 0, align 8
; TUNIT-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8 ; TUNIT-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8
; TUNIT-NEXT: call void @t4b(ptr noalias nocapture nofree noundef nonnull writeonly align 8 [[RETVAL]]) #[[ATTR4]] ; TUNIT-NEXT: call void @t4b(ptr noalias nocapture nofree noundef nonnull writeonly align 8 [[RETVAL]]) #[[ATTR4]]
; TUNIT-NEXT: ret [[S]] undef ; TUNIT-NEXT: ret [[S]] undef
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@t4a ; CGSCC-LABEL: define {{[^@]+}}@t4a
; CGSCC-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (ptr nofree noundef nonnull align 8 dereferenceable(8) [[THIS:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[RETVAL:%.*]] = alloca [[S:%.*]], i32 0, align 8 ; CGSCC-NEXT: [[RETVAL:%.*]] = alloca [[S:%.*]], i32 0, align 8
; CGSCC-NEXT: [[THIS_ADDR:%.*]] = alloca ptr, i32 0, align 8 ; CGSCC-NEXT: [[THIS_ADDR:%.*]] = alloca ptr, i32 0, align 8
; CGSCC-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8 ; CGSCC-NEXT: store ptr [[THIS]], ptr [[THIS]], align 8
; CGSCC-NEXT: call void @t4b(ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[RETVAL]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS]]) #[[ATTR8]] ; CGSCC-NEXT: call void @t4b(ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[RETVAL]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS]]) #[[ATTR8]]
; CGSCC-NEXT: [[TMP0:%.*]] = load [[S]], ptr [[RETVAL]], align 8 ; CGSCC-NEXT: [[TMP0:%.*]] = load [[S]], ptr [[RETVAL]], align 8
; CGSCC-NEXT: ret [[S]] [[TMP0]] ; CGSCC-NEXT: ret [[S]] [[TMP0]]
; ;
entry: entry:
%retval = alloca %S, i32 0, align 8 %retval = alloca %S, i32 0, align 8
%this.addr = alloca ptr, i32 0, align 8 %this.addr = alloca ptr, i32 0, align 8
store ptr %this, ptr %this, align 8 store ptr %this, ptr %this, align 8
%this1 = load ptr, ptr %this, align 8 %this1 = load ptr, ptr %this, align 8
%buffer_ = getelementptr inbounds %struct1, ptr %this1, i32 0, i32 0 %buffer_ = getelementptr inbounds %struct1, ptr %this1, i32 0, i32 0
%data_ = getelementptr inbounds %struct2, ptr %buffer_, i32 0, i32 0 %data_ = getelementptr inbounds %struct2, ptr %buffer_, i32 0, i32 0
%0 = load ptr, ptr %this, align 8 %0 = load ptr, ptr %this, align 8
call void @t4b(ptr %retval, ptr %this) call void @t4b(ptr %retval, ptr %this)
%1 = load %S, ptr %retval, align 8 %1 = load %S, ptr %retval, align 8
ret %S %1 ret %S %1
} }
define internal void @t4b(ptr %this, ptr %data) { define internal void @t4b(ptr %this, ptr %data) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@t4b ; TUNIT-LABEL: define {{[^@]+}}@t4b
; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[THIS_ADDR:%.*]] = alloca ptr, i32 0, align 8 ; TUNIT-NEXT: [[THIS_ADDR:%.*]] = alloca ptr, i32 0, align 8
; TUNIT-NEXT: [[DATA_ADDR:%.*]] = alloca ptr, i32 0, align 8 ; TUNIT-NEXT: [[DATA_ADDR:%.*]] = alloca ptr, i32 0, align 8
; TUNIT-NEXT: call void @t4c(ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS]]) #[[ATTR4]] ; TUNIT-NEXT: call void @t4c(ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS]]) #[[ATTR4]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@t4b ; CGSCC-LABEL: define {{[^@]+}}@t4b
; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[DATA:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[DATA:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[THIS_ADDR:%.*]] = alloca ptr, i32 0, align 8 ; CGSCC-NEXT: [[THIS_ADDR:%.*]] = alloca ptr, i32 0, align 8
; CGSCC-NEXT: [[DATA_ADDR:%.*]] = alloca ptr, i32 0, align 8 ; CGSCC-NEXT: [[DATA_ADDR:%.*]] = alloca ptr, i32 0, align 8
; CGSCC-NEXT: store ptr [[DATA]], ptr [[THIS]], align 8 ; CGSCC-NEXT: store ptr [[DATA]], ptr [[THIS]], align 8
; CGSCC-NEXT: call void @t4c(ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[DATA]]) #[[ATTR8]] ; CGSCC-NEXT: call void @t4c(ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS]], ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[DATA]]) #[[ATTR8]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
entry: entry:
%this.addr = alloca ptr, i32 0, align 8 %this.addr = alloca ptr, i32 0, align 8
%data.addr = alloca ptr, i32 0, align 8 %data.addr = alloca ptr, i32 0, align 8
store ptr %this, ptr %this.addr, align 8 store ptr %this, ptr %this.addr, align 8
store ptr %data, ptr %this, align 8 store ptr %data, ptr %this, align 8
%this1 = load ptr, ptr %this, align 8 %this1 = load ptr, ptr %this, align 8
%0 = load ptr, ptr %this, align 8 %0 = load ptr, ptr %this, align 8
call void @t4c(ptr %this, ptr %data) call void @t4c(ptr %this, ptr %data)
ret void ret void
} }
define internal void @t4c(ptr %this, ptr %data) { define internal void @t4c(ptr %this, ptr %data) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@t4c ; TUNIT-LABEL: define {{[^@]+}}@t4c
; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[THIS_ADDR:%.*]] = alloca ptr, i32 0, align 8 ; TUNIT-NEXT: [[THIS_ADDR:%.*]] = alloca ptr, i32 0, align 8
; TUNIT-NEXT: [[DATA_ADDR:%.*]] = alloca ptr, i32 0, align 8 ; TUNIT-NEXT: [[DATA_ADDR:%.*]] = alloca ptr, i32 0, align 8
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@t4c ; CGSCC-LABEL: define {{[^@]+}}@t4c
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]], ptr nofree writeonly [[DATA:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[THIS:%.*]], ptr nofree writeonly [[DATA:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[THIS_ADDR:%.*]] = alloca ptr, i32 0, align 8 ; CGSCC-NEXT: [[THIS_ADDR:%.*]] = alloca ptr, i32 0, align 8
; CGSCC-NEXT: [[DATA_ADDR:%.*]] = alloca ptr, i32 0, align 8 ; CGSCC-NEXT: [[DATA_ADDR:%.*]] = alloca ptr, i32 0, align 8
; CGSCC-NEXT: store ptr [[DATA]], ptr [[THIS]], align 8 ; CGSCC-NEXT: store ptr [[DATA]], ptr [[THIS]], align 8
; CGSCC-NEXT: store ptr [[DATA]], ptr [[THIS]], align 8 ; CGSCC-NEXT: store ptr [[DATA]], ptr [[THIS]], align 8
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
Show All 16 Lines
!1 = !{i32 1, !"wchar_size", i32 4} !1 = !{i32 1, !"wchar_size", i32 4}
!2 = !{i32 7, !"openmp", i32 50} !2 = !{i32 7, !"openmp", i32 50}
!3 = !{i32 7, !"openmp-device", i32 50} !3 = !{i32 7, !"openmp-device", i32 50}
!4 = !{i32 8, !"PIC Level", i32 2} !4 = !{i32 8, !"PIC Level", i32 2}
!5 = !{i32 7, !"frame-pointer", i32 2} !5 = !{i32 7, !"frame-pointer", i32 2}
!6 = !{i32 7, !"Dwarf Version", i32 2} !6 = !{i32 7, !"Dwarf Version", i32 2}
!7 = !{i32 2, !"Debug Info Version", i32 3} !7 = !{i32 2, !"Debug Info Version", i32 3}
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR2]] = { nofree norecurse noreturn nosync nounwind memory(none) } ; TUNIT: attributes #[[ATTR2]] = { nofree norecurse noreturn nosync nounwind memory(none) }
; TUNIT: attributes #[[ATTR3]] = { nofree norecurse nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR3]] = { nofree norecurse nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR4]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR4]] = { nofree nosync nounwind willreturn }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree nosync nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR3]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR5]] = { nofree norecurse noreturn nosync nounwind memory(none) } ; CGSCC: attributes #[[ATTR5]] = { nofree norecurse noreturn nosync nounwind memory(none) }
; CGSCC: attributes #[[ATTR6]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR6]] = { nounwind willreturn }
; CGSCC: attributes #[[ATTR7]] = { willreturn } ; CGSCC: attributes #[[ATTR7]] = { willreturn }
; CGSCC: attributes #[[ATTR8]] = { nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR8]] = { nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR9]] = { nounwind willreturn memory(readwrite) } ; CGSCC: attributes #[[ATTR9]] = { nounwind willreturn memory(readwrite) }
;. ;.
; CHECK: [[META0:![0-9]+]] = !{i32 2, !"SDK Version", [2 x i32] [i32 11, i32 5]} ; CHECK: [[META0:![0-9]+]] = !{i32 2, !"SDK Version", [2 x i32] [i32 11, i32 5]}
; CHECK: [[META1:![0-9]+]] = !{i32 1, !"wchar_size", i32 4} ; CHECK: [[META1:![0-9]+]] = !{i32 1, !"wchar_size", i32 4}
; CHECK: [[META2:![0-9]+]] = !{i32 7, !"openmp", i32 50} ; CHECK: [[META2:![0-9]+]] = !{i32 7, !"openmp", i32 50}
; CHECK: [[META3:![0-9]+]] = !{i32 7, !"openmp-device", i32 50} ; CHECK: [[META3:![0-9]+]] = !{i32 7, !"openmp-device", i32 50}
; CHECK: [[META4:![0-9]+]] = !{i32 8, !"PIC Level", i32 2} ; CHECK: [[META4:![0-9]+]] = !{i32 8, !"PIC Level", i32 2}
; CHECK: [[META5:![0-9]+]] = !{i32 7, !"frame-pointer", i32 2} ; CHECK: [[META5:![0-9]+]] = !{i32 7, !"frame-pointer", i32 2}
; CHECK: [[META6:![0-9]+]] = !{i32 7, !"Dwarf Version", i32 2} ; CHECK: [[META6:![0-9]+]] = !{i32 7, !"Dwarf Version", i32 2}
; CHECK: [[META7:![0-9]+]] = !{i32 2, !"Debug Info Version", i32 3} ; CHECK: [[META7:![0-9]+]] = !{i32 2, !"Debug Info Version", i32 3}
;. ;.

llvm/test/Transforms/Attributor/value-simplify-pointer-info-struct.ll

Show All 28 Lines
@GlobalS = internal constant %struct.S { i32 42, double 3.140000e+00, ptr null, i32 0 }, align 8 @GlobalS = internal constant %struct.S { i32 42, double 3.140000e+00, ptr null, i32 0 }, align 8
declare void @harmless_use(ptr nocapture readonly) nofree norecurse nosync nounwind readnone willreturn nocallback declare void @harmless_use(ptr nocapture readonly) nofree norecurse nosync nounwind readnone willreturn nocallback
;. ;.
; CHECK: @[[GLOBALS:[a-zA-Z0-9_$"\\.-]+]] = internal constant [[STRUCT_S:%.*]] { i32 42, double 3.140000e+00, ptr null, i32 0 }, align 8 ; CHECK: @[[GLOBALS:[a-zA-Z0-9_$"\\.-]+]] = internal constant [[STRUCT_S:%.*]] { i32 42, double 3.140000e+00, ptr null, i32 0 }, align 8
;. ;.
define i32 @testOneFieldGlobalS(i32 %cmpx) { define i32 @testOneFieldGlobalS(i32 %cmpx) {
; CHECK: Function Attrs: nofree norecurse nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@testOneFieldGlobalS ; CHECK-LABEL: define {{[^@]+}}@testOneFieldGlobalS
; CHECK-SAME: (i32 [[CMPX:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (i32 [[CMPX:%.*]]) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[RMW:%.*]] = atomicrmw add ptr getelementptr inbounds ([[STRUCT_S:%.*]], ptr @GlobalS, i32 0, i32 3), i32 1 monotonic, align 4 ; CHECK-NEXT: [[RMW:%.*]] = atomicrmw add ptr getelementptr inbounds ([[STRUCT_S:%.*]], ptr @GlobalS, i32 0, i32 3), i32 1 monotonic, align 4
; CHECK-NEXT: [[CXI:%.*]] = cmpxchg ptr getelementptr inbounds ([[STRUCT_S]], ptr @GlobalS, i32 0, i32 3), i32 [[CMPX]], i32 7 acq_rel monotonic, align 4 ; CHECK-NEXT: [[CXI:%.*]] = cmpxchg ptr getelementptr inbounds ([[STRUCT_S]], ptr @GlobalS, i32 0, i32 3), i32 [[CMPX]], i32 7 acq_rel monotonic, align 4
; CHECK-NEXT: br label [[IF_END:%.*]] ; CHECK-NEXT: br label [[IF_END:%.*]]
; CHECK: if.then: ; CHECK: if.then:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Linesif.then5: ; preds = %if.end4
br label %if.end7 br label %if.end7
if.end7: ; preds = %if.then5, %if.end4 if.end7: ; preds = %if.then5, %if.end4
%r.2 = phi i32 [ %add6, %if.then5 ], [ %r.1, %if.end4 ] %r.2 = phi i32 [ %add6, %if.then5 ], [ %r.1, %if.end4 ]
ret i32 %r.2 ret i32 %r.2
} }
define i32 @testOneFieldGlobalS_type_mismatch() { define i32 @testOneFieldGlobalS_type_mismatch() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@testOneFieldGlobalS_type_mismatch ; CHECK-LABEL: define {{[^@]+}}@testOneFieldGlobalS_type_mismatch
; CHECK-SAME: () #[[ATTR2:[0-9]+]] { ; CHECK-SAME: () #[[ATTR2:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[IF_THEN:%.*]] ; CHECK-NEXT: br label [[IF_THEN:%.*]]
; CHECK: if.then: ; CHECK: if.then:
; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 0, 1 ; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 0, 1
; CHECK-NEXT: br label [[IF_END:%.*]] ; CHECK-NEXT: br label [[IF_END:%.*]]
; CHECK: if.end: ; CHECK: if.end:
Show All 40 Linesif.then5: ; preds = %if.end4
br label %if.end7 br label %if.end7
if.end7: ; preds = %if.then5, %if.end4 if.end7: ; preds = %if.then5, %if.end4
%r.2 = phi i32 [ %add6, %if.then5 ], [ %r.1, %if.end4 ] %r.2 = phi i32 [ %add6, %if.then5 ], [ %r.1, %if.end4 ]
ret i32 %r.2 ret i32 %r.2
} }
define i32 @testOneFieldGlobalS_byte_offset_wrong() { define i32 @testOneFieldGlobalS_byte_offset_wrong() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@testOneFieldGlobalS_byte_offset_wrong ; CHECK-LABEL: define {{[^@]+}}@testOneFieldGlobalS_byte_offset_wrong
; CHECK-SAME: () #[[ATTR2]] { ; CHECK-SAME: () #[[ATTR2]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[IF_THEN:%.*]] ; CHECK-NEXT: br label [[IF_THEN:%.*]]
; CHECK: if.then: ; CHECK: if.then:
; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 0, 1 ; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 0, 1
; CHECK-NEXT: br label [[IF_END:%.*]] ; CHECK-NEXT: br label [[IF_END:%.*]]
; CHECK: if.end: ; CHECK: if.end:
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Linesif.then5: ; preds = %if.end4
br label %if.end7 br label %if.end7
if.end7: ; preds = %if.then5, %if.end4 if.end7: ; preds = %if.then5, %if.end4
%r.2 = phi i32 [ %add6, %if.then5 ], [ %r.1, %if.end4 ] %r.2 = phi i32 [ %add6, %if.then5 ], [ %r.1, %if.end4 ]
ret i32 %r.2 ret i32 %r.2
} }
;. ;.
; CHECK: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree norecurse nosync nounwind willreturn memory(none) } ; CHECK: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree norecurse nosync nounwind willreturn memory(none) }
; CHECK: attributes #[[ATTR1]] = { nofree norecurse nounwind willreturn memory(none) } ; CHECK: attributes #[[ATTR1]] = { mustprogress nofree norecurse nounwind willreturn memory(none) }
; CHECK: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CHECK: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CGSCC: {{.*}} ; CGSCC: {{.*}}
; TUNIT: {{.*}} ; TUNIT: {{.*}}

llvm/test/Transforms/Attributor/value-simplify-pointer-info-vec.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=3 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=3 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
; ;
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define i32 @vec_write_0() { define i32 @vec_write_0() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@vec_write_0 ; CHECK-LABEL: define {{[^@]+}}@vec_write_0
; CHECK-SAME: () #[[ATTR0:[0-9]+]] { ; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
%a = alloca <2 x i32> %a = alloca <2 x i32>
store <2 x i32> <i32 0, i32 0>, ptr %a store <2 x i32> <i32 0, i32 0>, ptr %a
%l1 = load i32, ptr %a %l1 = load i32, ptr %a
%g = getelementptr i32, ptr %a, i64 1 %g = getelementptr i32, ptr %a, i64 1
%l2 = load i32, ptr %g %l2 = load i32, ptr %g
%add = add i32 %l1, %l2 %add = add i32 %l1, %l2
ret i32 %add ret i32 %add
} }
define i32 @vec_write_1() { define i32 @vec_write_1() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@vec_write_1 ; CHECK-LABEL: define {{[^@]+}}@vec_write_1
; CHECK-SAME: () #[[ATTR0]] { ; CHECK-SAME: () #[[ATTR0]] {
; CHECK-NEXT: ret i32 10 ; CHECK-NEXT: ret i32 10
; ;
%a = alloca <2 x i32> %a = alloca <2 x i32>
store <2 x i32> <i32 5, i32 5>, ptr %a store <2 x i32> <i32 5, i32 5>, ptr %a
%l1B = load i32, ptr %a %l1B = load i32, ptr %a
%g = getelementptr i32, ptr %a, i64 1 %g = getelementptr i32, ptr %a, i64 1
%l2B = load i32, ptr %g %l2B = load i32, ptr %g
%add = add i32 %l1B, %l2B %add = add i32 %l1B, %l2B
ret i32 %add ret i32 %add
} }
; TODO: We should support this. ; TODO: We should support this.
define i32 @vec_write_2() { define i32 @vec_write_2() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@vec_write_2 ; CHECK-LABEL: define {{[^@]+}}@vec_write_2
; CHECK-SAME: () #[[ATTR0]] { ; CHECK-SAME: () #[[ATTR0]] {
; CHECK-NEXT: [[A:%.*]] = alloca <2 x i32>, align 8 ; CHECK-NEXT: [[A:%.*]] = alloca <2 x i32>, align 8
; CHECK-NEXT: store <2 x i32> <i32 3, i32 5>, ptr [[A]], align 8 ; CHECK-NEXT: store <2 x i32> <i32 3, i32 5>, ptr [[A]], align 8
; CHECK-NEXT: [[L1:%.*]] = load i32, ptr [[A]], align 8 ; CHECK-NEXT: [[L1:%.*]] = load i32, ptr [[A]], align 8
; CHECK-NEXT: [[G:%.*]] = getelementptr i32, ptr [[A]], i64 1 ; CHECK-NEXT: [[G:%.*]] = getelementptr i32, ptr [[A]], i64 1
; CHECK-NEXT: [[L2:%.*]] = load i32, ptr [[G]], align 4 ; CHECK-NEXT: [[L2:%.*]] = load i32, ptr [[G]], align 4
; CHECK-NEXT: [[ADD:%.*]] = add i32 [[L1]], [[L2]] ; CHECK-NEXT: [[ADD:%.*]] = add i32 [[L1]], [[L2]]
; CHECK-NEXT: ret i32 [[ADD]] ; CHECK-NEXT: ret i32 [[ADD]]
; ;
%a = alloca <2 x i32> %a = alloca <2 x i32>
store <2 x i32> <i32 3, i32 5>, ptr %a store <2 x i32> <i32 3, i32 5>, ptr %a
%l1 = load i32, ptr %a %l1 = load i32, ptr %a
%g = getelementptr i32, ptr %a, i64 1 %g = getelementptr i32, ptr %a, i64 1
%l2 = load i32, ptr %g %l2 = load i32, ptr %g
%add = add i32 %l1, %l2 %add = add i32 %l1, %l2
ret i32 %add ret i32 %add
} }
;. ;.
; CHECK: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CHECK: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
;. ;.
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
; CGSCC: {{.*}} ; CGSCC: {{.*}}
; TUNIT: {{.*}} ; TUNIT: {{.*}}

llvm/test/Transforms/Attributor/value-simplify-pointer-info.ll

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
; CHECK: @[[BYTES1:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 undef ; CHECK: @[[BYTES1:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 undef
; CHECK: @[[BYTES2:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 undef ; CHECK: @[[BYTES2:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 undef
; CHECK: @[[REC_STORAGE:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 undef ; CHECK: @[[REC_STORAGE:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 undef
; CHECK: @[[GLOBAL:[a-zA-Z0-9_$"\\.-]+]] = internal global [[STRUCT_STY:%.*]] zeroinitializer, align 8 ; CHECK: @[[GLOBAL:[a-zA-Z0-9_$"\\.-]+]] = internal global [[STRUCT_STY:%.*]] zeroinitializer, align 8
; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 0, align 4 ; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 0, align 4
; CHECK: @[[GC:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 undef, align 4 ; CHECK: @[[GC:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 undef, align 4
;. ;.
define void @write_arg(ptr %p, i32 %v) { define void @write_arg(ptr %p, i32 %v) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CHECK-LABEL: define {{[^@]+}}@write_arg ; CHECK-LABEL: define {{[^@]+}}@write_arg
; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P:%.*]], i32 [[V:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) [[P:%.*]], i32 [[V:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: store i32 [[V]], ptr [[P]], align 4, !tbaa [[TBAA3:![0-9]+]] ; CHECK-NEXT: store i32 [[V]], ptr [[P]], align 4, !tbaa [[TBAA3:![0-9]+]]
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
store i32 %v, ptr %p, align 4, !tbaa !3 store i32 %v, ptr %p, align 4, !tbaa !3
Show All 29 Lines
; r.f2 = s.f2 * 2; ; r.f2 = s.f2 * 2;
; r.f3 = s.f3 + s.f1; ; r.f3 = s.f3 + s.f1;
; r.i1 = s.i1; ; r.i1 = s.i1;
; r.i2 = s.i2 * 2; ; r.i2 = s.i2 * 2;
; r.i3 = s.i3 + s.i1; ; r.i3 = s.i3 + s.i1;
; return r; ; return r;
; } ; }
define void @local_alloca_simplifiable_1(ptr noalias sret(%struct.S) align 4 %agg.result) { define void @local_alloca_simplifiable_1(ptr noalias sret(%struct.S) align 4 %agg.result) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@local_alloca_simplifiable_1 ; TUNIT-LABEL: define {{[^@]+}}@local_alloca_simplifiable_1
; TUNIT-SAME: (ptr noalias nocapture nofree nonnull writeonly sret([[STRUCT_S:%.*]]) align 4 dereferenceable(24) [[AGG_RESULT:%.*]]) #[[ATTR1:[0-9]+]] { ; TUNIT-SAME: (ptr noalias nocapture nofree nonnull writeonly sret([[STRUCT_S:%.*]]) align 4 dereferenceable(24) [[AGG_RESULT:%.*]]) #[[ATTR1:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[S:%.*]] = alloca [[STRUCT_S]], align 4 ; TUNIT-NEXT: [[S:%.*]] = alloca [[STRUCT_S]], align 4
; TUNIT-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 24, ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(24) [[S]]) #[[ATTR17:[0-9]+]] ; TUNIT-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 24, ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(24) [[S]]) #[[ATTR17:[0-9]+]]
; TUNIT-NEXT: [[F1:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 3 ; TUNIT-NEXT: [[F1:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 3
; TUNIT-NEXT: [[F2:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 4 ; TUNIT-NEXT: [[F2:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 4
; TUNIT-NEXT: [[F3:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 5 ; TUNIT-NEXT: [[F3:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 5
Show All 11 Lines
; TUNIT-NEXT: store i32 1, ptr [[AGG_RESULT]], align 4, !tbaa [[TBAA12:![0-9]+]] ; TUNIT-NEXT: store i32 1, ptr [[AGG_RESULT]], align 4, !tbaa [[TBAA12:![0-9]+]]
; TUNIT-NEXT: [[I212:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[AGG_RESULT]], i64 0, i32 1 ; TUNIT-NEXT: [[I212:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[AGG_RESULT]], i64 0, i32 1
; TUNIT-NEXT: store i32 4, ptr [[I212]], align 4, !tbaa [[TBAA13:![0-9]+]] ; TUNIT-NEXT: store i32 4, ptr [[I212]], align 4, !tbaa [[TBAA13:![0-9]+]]
; TUNIT-NEXT: [[I316:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[AGG_RESULT]], i64 0, i32 2 ; TUNIT-NEXT: [[I316:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[AGG_RESULT]], i64 0, i32 2
; TUNIT-NEXT: store i32 4, ptr [[I316]], align 4, !tbaa [[TBAA14:![0-9]+]] ; TUNIT-NEXT: store i32 4, ptr [[I316]], align 4, !tbaa [[TBAA14:![0-9]+]]
; TUNIT-NEXT: call void @llvm.lifetime.end.p0(i64 noundef 24, ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(24) [[S]]) #[[ATTR17]] ; TUNIT-NEXT: call void @llvm.lifetime.end.p0(i64 noundef 24, ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(24) [[S]]) #[[ATTR17]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@local_alloca_simplifiable_1 ; CGSCC-LABEL: define {{[^@]+}}@local_alloca_simplifiable_1
; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly sret([[STRUCT_S:%.*]]) align 4 dereferenceable(24) [[AGG_RESULT:%.*]]) #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly sret([[STRUCT_S:%.*]]) align 4 dereferenceable(24) [[AGG_RESULT:%.*]]) #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[S:%.*]] = alloca [[STRUCT_S]], align 4 ; CGSCC-NEXT: [[S:%.*]] = alloca [[STRUCT_S]], align 4
; CGSCC-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 24, ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(24) [[S]]) #[[ATTR20:[0-9]+]] ; CGSCC-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 24, ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(24) [[S]]) #[[ATTR20:[0-9]+]]
; CGSCC-NEXT: [[F1:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 3 ; CGSCC-NEXT: [[F1:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 3
; CGSCC-NEXT: store float 0x3FF19999A0000000, ptr [[F1]], align 4, !tbaa [[TBAA7:![0-9]+]] ; CGSCC-NEXT: store float 0x3FF19999A0000000, ptr [[F1]], align 4, !tbaa [[TBAA7:![0-9]+]]
; CGSCC-NEXT: [[F2:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 4 ; CGSCC-NEXT: [[F2:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 4
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines
; Bytes[1023] = 0; ; Bytes[1023] = 0;
; write_arg((int *)&Bytes[500], 0); ; write_arg((int *)&Bytes[500], 0);
; struct S R; ; struct S R;
; for (int i = 0; i < 1024; ++i) ; for (int i = 0; i < 1024; ++i)
; globalBytes[i] = Bytes[i]; ; globalBytes[i] = Bytes[i];
; } ; }
; ;
define void @local_alloca_simplifiable_2() { define void @local_alloca_simplifiable_2() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@local_alloca_simplifiable_2 ; TUNIT-LABEL: define {{[^@]+}}@local_alloca_simplifiable_2
; TUNIT-SAME: () #[[ATTR3:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR3:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; TUNIT-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; TUNIT-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 1024, ptr noalias nocapture nofree noundef nonnull align 16 dereferenceable(1024) [[BYTES]]) #[[ATTR17]] ; TUNIT-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 1024, ptr noalias nocapture nofree noundef nonnull align 16 dereferenceable(1024) [[BYTES]]) #[[ATTR17]]
; TUNIT-NEXT: br label [[FOR_COND:%.*]] ; TUNIT-NEXT: br label [[FOR_COND:%.*]]
; TUNIT: for.cond: ; TUNIT: for.cond:
; TUNIT-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[FOR_INC:%.*]] ], [ 0, [[ENTRY:%.*]] ] ; TUNIT-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[FOR_INC:%.*]] ], [ 0, [[ENTRY:%.*]] ]
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
; TUNIT-NEXT: br label [[FOR_INC36]] ; TUNIT-NEXT: br label [[FOR_INC36]]
; TUNIT: for.inc36: ; TUNIT: for.inc36:
; TUNIT-NEXT: [[INDVARS_IV_NEXT13]] = add nuw nsw i64 [[INDVARS_IV12]], 1 ; TUNIT-NEXT: [[INDVARS_IV_NEXT13]] = add nuw nsw i64 [[INDVARS_IV12]], 1
; TUNIT-NEXT: br label [[FOR_COND28]], !llvm.loop [[LOOP20:![0-9]+]] ; TUNIT-NEXT: br label [[FOR_COND28]], !llvm.loop [[LOOP20:![0-9]+]]
; TUNIT: for.end38: ; TUNIT: for.end38:
; TUNIT-NEXT: call void @llvm.lifetime.end.p0(i64 noundef 1024, ptr noalias nocapture nofree noundef nonnull align 16 dereferenceable(1024) [[BYTES]]) #[[ATTR17]] ; TUNIT-NEXT: call void @llvm.lifetime.end.p0(i64 noundef 1024, ptr noalias nocapture nofree noundef nonnull align 16 dereferenceable(1024) [[BYTES]]) #[[ATTR17]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@local_alloca_simplifiable_2 ; CGSCC-LABEL: define {{[^@]+}}@local_alloca_simplifiable_2
; CGSCC-SAME: () #[[ATTR3:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR3:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; CGSCC-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; CGSCC-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 1024, ptr noalias nocapture nofree noundef nonnull align 16 dereferenceable(1024) [[BYTES]]) #[[ATTR20]] ; CGSCC-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 1024, ptr noalias nocapture nofree noundef nonnull align 16 dereferenceable(1024) [[BYTES]]) #[[ATTR20]]
; CGSCC-NEXT: br label [[FOR_COND:%.*]] ; CGSCC-NEXT: br label [[FOR_COND:%.*]]
; CGSCC: for.cond: ; CGSCC: for.cond:
; CGSCC-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[FOR_INC:%.*]] ], [ 0, [[ENTRY:%.*]] ] ; CGSCC-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[FOR_INC:%.*]] ], [ 0, [[ENTRY:%.*]] ]
▲ Show 20 Lines • Show All 169 Lines • ▼ Show 20 Lines
; int local_alloca_simplifiable_3() { ; int local_alloca_simplifiable_3() {
; int A = 1; ; int A = 1;
; // split ; // split
; A = 2; ; A = 2;
; return A; ; return A;
; } ; }
; ;
define i32 @local_alloca_simplifiable_3() { define i32 @local_alloca_simplifiable_3() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@local_alloca_simplifiable_3 ; CHECK-LABEL: define {{[^@]+}}@local_alloca_simplifiable_3
; CHECK-SAME: () #[[ATTR4:[0-9]+]] { ; CHECK-SAME: () #[[ATTR4:[0-9]+]] {
; CHECK-NEXT: br label [[SPLIT:%.*]] ; CHECK-NEXT: br label [[SPLIT:%.*]]
; CHECK: split: ; CHECK: split:
; CHECK-NEXT: ret i32 2 ; CHECK-NEXT: ret i32 2
; ;
%A = alloca i32, align 4 %A = alloca i32, align 4
store i32 1, ptr %A store i32 1, ptr %A
br label %split br label %split
split: split:
store i32 2, ptr %A store i32 2, ptr %A
%l = load i32, ptr %A, align 4 %l = load i32, ptr %A, align 4
ret i32 %l ret i32 %l
} }
; int local_alloca_simplifiable_4() { ; int local_alloca_simplifiable_4() {
; int A; ; int A;
; return A; ; return A;
; } ; }
; ;
define i32 @local_alloca_simplifiable_4() { define i32 @local_alloca_simplifiable_4() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@local_alloca_simplifiable_4 ; CHECK-LABEL: define {{[^@]+}}@local_alloca_simplifiable_4
; CHECK-SAME: () #[[ATTR4]] { ; CHECK-SAME: () #[[ATTR4]] {
; CHECK-NEXT: ret i32 undef ; CHECK-NEXT: ret i32 undef
; ;
%A = alloca i32, align 4 %A = alloca i32, align 4
%l = load i32, ptr %A, align 4 %l = load i32, ptr %A, align 4
ret i32 %l ret i32 %l
} }
; static int GI1 __attribute__((loader_uninitialized)); ; static int GI1 __attribute__((loader_uninitialized));
; int multi_obj_simplifiable_1(int cnd) { ; int multi_obj_simplifiable_1(int cnd) {
; int L = GI1 = 5; ; int L = GI1 = 5;
; int *p = cnd ? &GI1 : &L; ; int *p = cnd ? &GI1 : &L;
; return *p; ; return *p;
; } ; }
define i32 @multi_obj_simplifiable_1(i32 %cnd) { define i32 @multi_obj_simplifiable_1(i32 %cnd) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@multi_obj_simplifiable_1 ; TUNIT-LABEL: define {{[^@]+}}@multi_obj_simplifiable_1
; TUNIT-SAME: (i32 [[CND:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i32 [[CND:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[L:%.*]] = alloca i32, align 4 ; TUNIT-NEXT: [[L:%.*]] = alloca i32, align 4
; TUNIT-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 4, ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[L]]) #[[ATTR17]] ; TUNIT-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 4, ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[L]]) #[[ATTR17]]
; TUNIT-NEXT: [[TOBOOL_NOT:%.*]] = icmp eq i32 [[CND]], 0 ; TUNIT-NEXT: [[TOBOOL_NOT:%.*]] = icmp eq i32 [[CND]], 0
; TUNIT-NEXT: br i1 [[TOBOOL_NOT]], label [[COND_FALSE:%.*]], label [[COND_TRUE:%.*]] ; TUNIT-NEXT: br i1 [[TOBOOL_NOT]], label [[COND_FALSE:%.*]], label [[COND_TRUE:%.*]]
; TUNIT: cond.true: ; TUNIT: cond.true:
; TUNIT-NEXT: br label [[COND_END:%.*]] ; TUNIT-NEXT: br label [[COND_END:%.*]]
; TUNIT: cond.false: ; TUNIT: cond.false:
; TUNIT-NEXT: br label [[COND_END]] ; TUNIT-NEXT: br label [[COND_END]]
; TUNIT: cond.end: ; TUNIT: cond.end:
; TUNIT-NEXT: call void @llvm.lifetime.end.p0(i64 noundef 4, ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[L]]) #[[ATTR17]] ; TUNIT-NEXT: call void @llvm.lifetime.end.p0(i64 noundef 4, ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[L]]) #[[ATTR17]]
; TUNIT-NEXT: ret i32 5 ; TUNIT-NEXT: ret i32 5
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@multi_obj_simplifiable_1 ; CGSCC-LABEL: define {{[^@]+}}@multi_obj_simplifiable_1
; CGSCC-SAME: (i32 [[CND:%.*]]) #[[ATTR5:[0-9]+]] { ; CGSCC-SAME: (i32 [[CND:%.*]]) #[[ATTR5:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[L:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[L:%.*]] = alloca i32, align 4
; CGSCC-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 4, ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[L]]) #[[ATTR20]] ; CGSCC-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 4, ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[L]]) #[[ATTR20]]
; CGSCC-NEXT: [[TOBOOL_NOT:%.*]] = icmp eq i32 [[CND]], 0 ; CGSCC-NEXT: [[TOBOOL_NOT:%.*]] = icmp eq i32 [[CND]], 0
; CGSCC-NEXT: br i1 [[TOBOOL_NOT]], label [[COND_FALSE:%.*]], label [[COND_TRUE:%.*]] ; CGSCC-NEXT: br i1 [[TOBOOL_NOT]], label [[COND_FALSE:%.*]], label [[COND_TRUE:%.*]]
; CGSCC: cond.true: ; CGSCC: cond.true:
Show All 29 Lines
; int multi_obj_simplifiable_2(int cnd) { ; int multi_obj_simplifiable_2(int cnd) {
; int L; ; int L;
; int *p = cnd ? &GI2 : &L; ; int *p = cnd ? &GI2 : &L;
; *p = 5; ; *p = 5;
; return *p; ; return *p;
; } ; }
; ;
define i32 @multi_obj_simplifiable_2(i32 %cnd) { define i32 @multi_obj_simplifiable_2(i32 %cnd) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@multi_obj_simplifiable_2 ; TUNIT-LABEL: define {{[^@]+}}@multi_obj_simplifiable_2
; TUNIT-SAME: (i32 [[CND:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i32 [[CND:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[L:%.*]] = alloca i32, align 4 ; TUNIT-NEXT: [[L:%.*]] = alloca i32, align 4
; TUNIT-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 4, ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[L]]) #[[ATTR17]] ; TUNIT-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 4, ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[L]]) #[[ATTR17]]
; TUNIT-NEXT: [[TOBOOL_NOT:%.*]] = icmp eq i32 [[CND]], 0 ; TUNIT-NEXT: [[TOBOOL_NOT:%.*]] = icmp eq i32 [[CND]], 0
; TUNIT-NEXT: br i1 [[TOBOOL_NOT]], label [[COND_FALSE:%.*]], label [[COND_TRUE:%.*]] ; TUNIT-NEXT: br i1 [[TOBOOL_NOT]], label [[COND_FALSE:%.*]], label [[COND_TRUE:%.*]]
; TUNIT: cond.true: ; TUNIT: cond.true:
; TUNIT-NEXT: br label [[COND_END:%.*]] ; TUNIT-NEXT: br label [[COND_END:%.*]]
; TUNIT: cond.false: ; TUNIT: cond.false:
; TUNIT-NEXT: br label [[COND_END]] ; TUNIT-NEXT: br label [[COND_END]]
; TUNIT: cond.end: ; TUNIT: cond.end:
; TUNIT-NEXT: call void @llvm.lifetime.end.p0(i64 noundef 4, ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[L]]) #[[ATTR17]] ; TUNIT-NEXT: call void @llvm.lifetime.end.p0(i64 noundef 4, ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[L]]) #[[ATTR17]]
; TUNIT-NEXT: ret i32 5 ; TUNIT-NEXT: ret i32 5
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@multi_obj_simplifiable_2 ; CGSCC-LABEL: define {{[^@]+}}@multi_obj_simplifiable_2
; CGSCC-SAME: (i32 [[CND:%.*]]) #[[ATTR5]] { ; CGSCC-SAME: (i32 [[CND:%.*]]) #[[ATTR5]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[L:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[L:%.*]] = alloca i32, align 4
; CGSCC-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 4, ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[L]]) #[[ATTR20]] ; CGSCC-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 4, ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[L]]) #[[ATTR20]]
; CGSCC-NEXT: [[TOBOOL_NOT:%.*]] = icmp eq i32 [[CND]], 0 ; CGSCC-NEXT: [[TOBOOL_NOT:%.*]] = icmp eq i32 [[CND]], 0
; CGSCC-NEXT: br i1 [[TOBOOL_NOT]], label [[COND_FALSE:%.*]], label [[COND_TRUE:%.*]] ; CGSCC-NEXT: br i1 [[TOBOOL_NOT]], label [[COND_FALSE:%.*]], label [[COND_TRUE:%.*]]
; CGSCC: cond.true: ; CGSCC: cond.true:
Show All 38 Lines
; r.f3 = Gs.f3 + Gs.f1; ; r.f3 = Gs.f3 + Gs.f1;
; r.i1 = Gs.i1; ; r.i1 = Gs.i1;
; r.i2 = Gs.i2 * 2; ; r.i2 = Gs.i2 * 2;
; r.i3 = Gs.i3 + Gs.i1; ; r.i3 = Gs.i3 + Gs.i1;
; return r; ; return r;
; } ; }
; ;
define void @static_global_simplifiable_1(ptr noalias sret(%struct.S) align 4 %agg.result) { define void @static_global_simplifiable_1(ptr noalias sret(%struct.S) align 4 %agg.result) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@static_global_simplifiable_1 ; TUNIT-LABEL: define {{[^@]+}}@static_global_simplifiable_1
; TUNIT-SAME: (ptr noalias nocapture nofree nonnull writeonly sret([[STRUCT_S:%.*]]) align 4 dereferenceable(24) [[AGG_RESULT:%.*]]) #[[ATTR5:[0-9]+]] { ; TUNIT-SAME: (ptr noalias nocapture nofree nonnull writeonly sret([[STRUCT_S:%.*]]) align 4 dereferenceable(24) [[AGG_RESULT:%.*]]) #[[ATTR5:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: call void @write_arg(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(24) @Gs1, i32 noundef 1) #[[ATTR18]] ; TUNIT-NEXT: call void @write_arg(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(24) @Gs1, i32 noundef 1) #[[ATTR18]]
; TUNIT-NEXT: call void @write_arg(ptr nocapture nofree nonnull writeonly align 4 dereferenceable(20) getelementptr inbounds ([[STRUCT_S]], ptr @Gs1, i64 0, i32 1), i32 noundef 2) #[[ATTR18]] ; TUNIT-NEXT: call void @write_arg(ptr nocapture nofree nonnull writeonly align 4 dereferenceable(20) getelementptr inbounds ([[STRUCT_S]], ptr @Gs1, i64 0, i32 1), i32 noundef 2) #[[ATTR18]]
; TUNIT-NEXT: call void @write_arg(ptr nocapture nofree nonnull writeonly align 4 dereferenceable(16) getelementptr inbounds ([[STRUCT_S]], ptr @Gs1, i64 0, i32 2), i32 noundef 3) #[[ATTR18]] ; TUNIT-NEXT: call void @write_arg(ptr nocapture nofree nonnull writeonly align 4 dereferenceable(16) getelementptr inbounds ([[STRUCT_S]], ptr @Gs1, i64 0, i32 2), i32 noundef 3) #[[ATTR18]]
; TUNIT-NEXT: [[F1:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[AGG_RESULT]], i64 0, i32 3 ; TUNIT-NEXT: [[F1:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[AGG_RESULT]], i64 0, i32 3
; TUNIT-NEXT: store float 0x3FF19999A0000000, ptr [[F1]], align 4, !tbaa [[TBAA7]] ; TUNIT-NEXT: store float 0x3FF19999A0000000, ptr [[F1]], align 4, !tbaa [[TBAA7]]
; TUNIT-NEXT: [[F2:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[AGG_RESULT]], i64 0, i32 4 ; TUNIT-NEXT: [[F2:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[AGG_RESULT]], i64 0, i32 4
; TUNIT-NEXT: store float 0x40119999A0000000, ptr [[F2]], align 4, !tbaa [[TBAA10]] ; TUNIT-NEXT: store float 0x40119999A0000000, ptr [[F2]], align 4, !tbaa [[TBAA10]]
; TUNIT-NEXT: [[F3:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[AGG_RESULT]], i64 0, i32 5 ; TUNIT-NEXT: [[F3:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[AGG_RESULT]], i64 0, i32 5
; TUNIT-NEXT: store float 0x40119999A0000000, ptr [[F3]], align 4, !tbaa [[TBAA11]] ; TUNIT-NEXT: store float 0x40119999A0000000, ptr [[F3]], align 4, !tbaa [[TBAA11]]
; TUNIT-NEXT: store i32 1, ptr [[AGG_RESULT]], align 4, !tbaa [[TBAA12]] ; TUNIT-NEXT: store i32 1, ptr [[AGG_RESULT]], align 4, !tbaa [[TBAA12]]
; TUNIT-NEXT: [[I2:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[AGG_RESULT]], i64 0, i32 1 ; TUNIT-NEXT: [[I2:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[AGG_RESULT]], i64 0, i32 1
; TUNIT-NEXT: store i32 4, ptr [[I2]], align 4, !tbaa [[TBAA13]] ; TUNIT-NEXT: store i32 4, ptr [[I2]], align 4, !tbaa [[TBAA13]]
; TUNIT-NEXT: [[I3:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[AGG_RESULT]], i64 0, i32 2 ; TUNIT-NEXT: [[I3:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[AGG_RESULT]], i64 0, i32 2
; TUNIT-NEXT: store i32 4, ptr [[I3]], align 4, !tbaa [[TBAA14]] ; TUNIT-NEXT: store i32 4, ptr [[I3]], align 4, !tbaa [[TBAA14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@static_global_simplifiable_1 ; CGSCC-LABEL: define {{[^@]+}}@static_global_simplifiable_1
; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly sret([[STRUCT_S:%.*]]) align 4 dereferenceable(24) [[AGG_RESULT:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly sret([[STRUCT_S:%.*]]) align 4 dereferenceable(24) [[AGG_RESULT:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: store float 0x3FF19999A0000000, ptr getelementptr inbounds ([[STRUCT_S]], ptr @Gs1, i64 0, i32 3), align 4, !tbaa [[TBAA7]] ; CGSCC-NEXT: store float 0x3FF19999A0000000, ptr getelementptr inbounds ([[STRUCT_S]], ptr @Gs1, i64 0, i32 3), align 4, !tbaa [[TBAA7]]
; CGSCC-NEXT: store float 0x40019999A0000000, ptr getelementptr inbounds ([[STRUCT_S]], ptr @Gs1, i64 0, i32 4), align 4, !tbaa [[TBAA10]] ; CGSCC-NEXT: store float 0x40019999A0000000, ptr getelementptr inbounds ([[STRUCT_S]], ptr @Gs1, i64 0, i32 4), align 4, !tbaa [[TBAA10]]
; CGSCC-NEXT: store float 0x400A666660000000, ptr getelementptr inbounds ([[STRUCT_S]], ptr @Gs1, i64 0, i32 5), align 4, !tbaa [[TBAA11]] ; CGSCC-NEXT: store float 0x400A666660000000, ptr getelementptr inbounds ([[STRUCT_S]], ptr @Gs1, i64 0, i32 5), align 4, !tbaa [[TBAA11]]
; CGSCC-NEXT: call void @write_arg(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(24) @Gs1, i32 noundef 1) #[[ATTR21]] ; CGSCC-NEXT: call void @write_arg(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(24) @Gs1, i32 noundef 1) #[[ATTR21]]
; CGSCC-NEXT: call void @write_arg(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(20) getelementptr inbounds ([[STRUCT_S]], ptr @Gs1, i64 0, i32 1), i32 noundef 2) #[[ATTR21]] ; CGSCC-NEXT: call void @write_arg(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(20) getelementptr inbounds ([[STRUCT_S]], ptr @Gs1, i64 0, i32 1), i32 noundef 2) #[[ATTR21]]
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
; GBytes[1023] = 0; ; GBytes[1023] = 0;
; write_arg((int *)&GBytes[500], 0); ; write_arg((int *)&GBytes[500], 0);
; struct S R; ; struct S R;
; for (int i = 0; i < 1024; ++i) ; for (int i = 0; i < 1024; ++i)
; globalBytes[i] = GBytes[i]; ; globalBytes[i] = GBytes[i];
; } ; }
; ;
define void @static_global_simplifiable_2() { define void @static_global_simplifiable_2() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@static_global_simplifiable_2 ; TUNIT-LABEL: define {{[^@]+}}@static_global_simplifiable_2
; TUNIT-SAME: () #[[ATTR5]] { ; TUNIT-SAME: () #[[ATTR5]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: br label [[FOR_COND:%.*]] ; TUNIT-NEXT: br label [[FOR_COND:%.*]]
; TUNIT: for.cond: ; TUNIT: for.cond:
; TUNIT-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[FOR_INC:%.*]] ], [ 0, [[ENTRY:%.*]] ] ; TUNIT-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[FOR_INC:%.*]] ], [ 0, [[ENTRY:%.*]] ]
; TUNIT-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV]], 100 ; TUNIT-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV]], 100
; TUNIT-NEXT: br i1 [[EXITCOND]], label [[FOR_BODY:%.*]], label [[FOR_COND_CLEANUP:%.*]] ; TUNIT-NEXT: br i1 [[EXITCOND]], label [[FOR_BODY:%.*]], label [[FOR_COND_CLEANUP:%.*]]
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
; TUNIT-NEXT: store i8 0, ptr [[ARRAYIDX32]], align 1, !tbaa [[TBAA19]] ; TUNIT-NEXT: store i8 0, ptr [[ARRAYIDX32]], align 1, !tbaa [[TBAA19]]
; TUNIT-NEXT: br label [[FOR_INC33]] ; TUNIT-NEXT: br label [[FOR_INC33]]
; TUNIT: for.inc33: ; TUNIT: for.inc33:
; TUNIT-NEXT: [[INDVARS_IV_NEXT13]] = add nuw nsw i64 [[INDVARS_IV12]], 1 ; TUNIT-NEXT: [[INDVARS_IV_NEXT13]] = add nuw nsw i64 [[INDVARS_IV12]], 1
; TUNIT-NEXT: br label [[FOR_COND25]], !llvm.loop [[LOOP24:![0-9]+]] ; TUNIT-NEXT: br label [[FOR_COND25]], !llvm.loop [[LOOP24:![0-9]+]]
; TUNIT: for.end35: ; TUNIT: for.end35:
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@static_global_simplifiable_2 ; CGSCC-LABEL: define {{[^@]+}}@static_global_simplifiable_2
; CGSCC-SAME: () #[[ATTR3]] { ; CGSCC-SAME: () #[[ATTR3]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: br label [[FOR_COND:%.*]] ; CGSCC-NEXT: br label [[FOR_COND:%.*]]
; CGSCC: for.cond: ; CGSCC: for.cond:
; CGSCC-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[FOR_INC:%.*]] ], [ 0, [[ENTRY:%.*]] ] ; CGSCC-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[FOR_INC:%.*]] ], [ 0, [[ENTRY:%.*]] ]
; CGSCC-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV]], 100 ; CGSCC-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV]], 100
; CGSCC-NEXT: br i1 [[EXITCOND]], label [[FOR_BODY:%.*]], label [[FOR_COND_CLEANUP:%.*]] ; CGSCC-NEXT: br i1 [[EXITCOND]], label [[FOR_BODY:%.*]], label [[FOR_COND_CLEANUP:%.*]]
▲ Show 20 Lines • Show All 157 Lines • ▼ Show 20 Lines
} }
; static int Flag3; ; static int Flag3;
; int static_global_simplifiable_3() { ; int static_global_simplifiable_3() {
; Flag3 = 1; ; Flag3 = 1;
; return Flag3; ; return Flag3;
; } ; }
define i32 @static_global_simplifiable_3() { define i32 @static_global_simplifiable_3() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@static_global_simplifiable_3 ; TUNIT-LABEL: define {{[^@]+}}@static_global_simplifiable_3
; TUNIT-SAME: () #[[ATTR5]] { ; TUNIT-SAME: () #[[ATTR5]] {
; TUNIT-NEXT: store i32 1, ptr @Flag3, align 4, !tbaa [[TBAA3]] ; TUNIT-NEXT: store i32 1, ptr @Flag3, align 4, !tbaa [[TBAA3]]
; TUNIT-NEXT: ret i32 1 ; TUNIT-NEXT: ret i32 1
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@static_global_simplifiable_3 ; CGSCC-LABEL: define {{[^@]+}}@static_global_simplifiable_3
; CGSCC-SAME: () #[[ATTR6:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR6:[0-9]+]] {
; CGSCC-NEXT: store i32 1, ptr @Flag3, align 4, !tbaa [[TBAA3]] ; CGSCC-NEXT: store i32 1, ptr @Flag3, align 4, !tbaa [[TBAA3]]
; CGSCC-NEXT: ret i32 1 ; CGSCC-NEXT: ret i32 1
; ;
store i32 1, ptr @Flag3, align 4, !tbaa !3 store i32 1, ptr @Flag3, align 4, !tbaa !3
%i = load i32, ptr @Flag3, align 4, !tbaa !3 %i = load i32, ptr @Flag3, align 4, !tbaa !3
ret i32 %i ret i32 %i
Show All 12 Lines
; r.f3 = s.f3 + s.f1; ; r.f3 = s.f3 + s.f1;
; r.i1 = s.i1; ; r.i1 = s.i1;
; r.i2 = s.i2 * 2; ; r.i2 = s.i2 * 2;
; r.i3 = s.i3 + s.i1; ; r.i3 = s.i3 + s.i1;
; return r; ; return r;
; } ; }
; ;
define void @noalias_arg_simplifiable_1(ptr noalias sret(%struct.S) align 4 %agg.result, ptr byval(%struct.S) align 8 %s) { define void @noalias_arg_simplifiable_1(ptr noalias sret(%struct.S) align 4 %agg.result, ptr byval(%struct.S) align 8 %s) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@noalias_arg_simplifiable_1 ; TUNIT-LABEL: define {{[^@]+}}@noalias_arg_simplifiable_1
; TUNIT-SAME: (ptr noalias nocapture nofree nonnull writeonly sret([[STRUCT_S:%.*]]) align 4 dereferenceable(24) [[AGG_RESULT:%.*]], ptr noalias nocapture nofree nonnull byval([[STRUCT_S]]) align 8 dereferenceable(24) [[S:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (ptr noalias nocapture nofree nonnull writeonly sret([[STRUCT_S:%.*]]) align 4 dereferenceable(24) [[AGG_RESULT:%.*]], ptr noalias nocapture nofree nonnull byval([[STRUCT_S]]) align 8 dereferenceable(24) [[S:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[F1:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 3 ; TUNIT-NEXT: [[F1:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 3
; TUNIT-NEXT: store float 0x3FF19999A0000000, ptr [[F1]], align 4, !tbaa [[TBAA7]] ; TUNIT-NEXT: store float 0x3FF19999A0000000, ptr [[F1]], align 4, !tbaa [[TBAA7]]
; TUNIT-NEXT: [[F2:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 4 ; TUNIT-NEXT: [[F2:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 4
; TUNIT-NEXT: store float 0x40019999A0000000, ptr [[F2]], align 8, !tbaa [[TBAA10]] ; TUNIT-NEXT: store float 0x40019999A0000000, ptr [[F2]], align 8, !tbaa [[TBAA10]]
; TUNIT-NEXT: [[F3:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 5 ; TUNIT-NEXT: [[F3:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 5
Show All 29 Lines
; TUNIT-NEXT: [[I313:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 2 ; TUNIT-NEXT: [[I313:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 2
; TUNIT-NEXT: [[I9:%.*]] = load i32, ptr [[I313]], align 8, !tbaa [[TBAA14]] ; TUNIT-NEXT: [[I9:%.*]] = load i32, ptr [[I313]], align 8, !tbaa [[TBAA14]]
; TUNIT-NEXT: [[I10:%.*]] = load i32, ptr [[S]], align 8, !tbaa [[TBAA12]] ; TUNIT-NEXT: [[I10:%.*]] = load i32, ptr [[S]], align 8, !tbaa [[TBAA12]]
; TUNIT-NEXT: [[ADD15:%.*]] = add nsw i32 [[I9]], [[I10]] ; TUNIT-NEXT: [[ADD15:%.*]] = add nsw i32 [[I9]], [[I10]]
; TUNIT-NEXT: [[I316:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[AGG_RESULT]], i64 0, i32 2 ; TUNIT-NEXT: [[I316:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[AGG_RESULT]], i64 0, i32 2
; TUNIT-NEXT: store i32 [[ADD15]], ptr [[I316]], align 4, !tbaa [[TBAA14]] ; TUNIT-NEXT: store i32 [[ADD15]], ptr [[I316]], align 4, !tbaa [[TBAA14]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@noalias_arg_simplifiable_1 ; CGSCC-LABEL: define {{[^@]+}}@noalias_arg_simplifiable_1
; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly sret([[STRUCT_S:%.*]]) align 4 dereferenceable(24) [[AGG_RESULT:%.*]], ptr noalias nocapture nofree noundef nonnull byval([[STRUCT_S]]) align 8 dereferenceable(24) [[S:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (ptr noalias nocapture nofree noundef nonnull writeonly sret([[STRUCT_S:%.*]]) align 4 dereferenceable(24) [[AGG_RESULT:%.*]], ptr noalias nocapture nofree noundef nonnull byval([[STRUCT_S]]) align 8 dereferenceable(24) [[S:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[F1:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 3 ; CGSCC-NEXT: [[F1:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 3
; CGSCC-NEXT: store float 0x3FF19999A0000000, ptr [[F1]], align 4, !tbaa [[TBAA7]] ; CGSCC-NEXT: store float 0x3FF19999A0000000, ptr [[F1]], align 4, !tbaa [[TBAA7]]
; CGSCC-NEXT: [[F2:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 4 ; CGSCC-NEXT: [[F2:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 4
; CGSCC-NEXT: store float 0x40019999A0000000, ptr [[F2]], align 8, !tbaa [[TBAA10]] ; CGSCC-NEXT: store float 0x40019999A0000000, ptr [[F2]], align 8, !tbaa [[TBAA10]]
; CGSCC-NEXT: [[F3:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 5 ; CGSCC-NEXT: [[F3:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 5
▲ Show 20 Lines • Show All 88 Lines • ▼ Show 20 Lines
; Bytes[1023] = 0; ; Bytes[1023] = 0;
; write_arg((int *)&Bytes[500], 0); ; write_arg((int *)&Bytes[500], 0);
; struct S R; ; struct S R;
; for (int i = 0; i < 1024; ++i) ; for (int i = 0; i < 1024; ++i)
; globalBytes[i] = Bytes[i]; ; globalBytes[i] = Bytes[i];
; } ; }
; ;
define void @noalias_arg_simplifiable_2(ptr %Bytes) { define void @noalias_arg_simplifiable_2(ptr %Bytes) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@noalias_arg_simplifiable_2 ; TUNIT-LABEL: define {{[^@]+}}@noalias_arg_simplifiable_2
; TUNIT-SAME: (ptr nocapture nofree [[BYTES:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (ptr nocapture nofree [[BYTES:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: br label [[FOR_COND:%.*]] ; TUNIT-NEXT: br label [[FOR_COND:%.*]]
; TUNIT: for.cond: ; TUNIT: for.cond:
; TUNIT-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[FOR_INC:%.*]] ], [ 0, [[ENTRY:%.*]] ] ; TUNIT-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[FOR_INC:%.*]] ], [ 0, [[ENTRY:%.*]] ]
; TUNIT-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV]], 100 ; TUNIT-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV]], 100
; TUNIT-NEXT: br i1 [[EXITCOND]], label [[FOR_BODY:%.*]], label [[FOR_COND_CLEANUP:%.*]] ; TUNIT-NEXT: br i1 [[EXITCOND]], label [[FOR_BODY:%.*]], label [[FOR_COND_CLEANUP:%.*]]
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
; TUNIT-NEXT: store i8 [[I22]], ptr [[ARRAYIDX34]], align 1, !tbaa [[TBAA19]] ; TUNIT-NEXT: store i8 [[I22]], ptr [[ARRAYIDX34]], align 1, !tbaa [[TBAA19]]
; TUNIT-NEXT: br label [[FOR_INC35]] ; TUNIT-NEXT: br label [[FOR_INC35]]
; TUNIT: for.inc35: ; TUNIT: for.inc35:
; TUNIT-NEXT: [[INDVARS_IV_NEXT13]] = add nuw nsw i64 [[INDVARS_IV12]], 1 ; TUNIT-NEXT: [[INDVARS_IV_NEXT13]] = add nuw nsw i64 [[INDVARS_IV12]], 1
; TUNIT-NEXT: br label [[FOR_COND27]], !llvm.loop [[LOOP31:![0-9]+]] ; TUNIT-NEXT: br label [[FOR_COND27]], !llvm.loop [[LOOP31:![0-9]+]]
; TUNIT: for.end37: ; TUNIT: for.end37:
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@noalias_arg_simplifiable_2 ; CGSCC-LABEL: define {{[^@]+}}@noalias_arg_simplifiable_2
; CGSCC-SAME: (ptr nocapture nofree [[BYTES:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (ptr nocapture nofree [[BYTES:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: br label [[FOR_COND:%.*]] ; CGSCC-NEXT: br label [[FOR_COND:%.*]]
; CGSCC: for.cond: ; CGSCC: for.cond:
; CGSCC-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[FOR_INC:%.*]] ], [ 0, [[ENTRY:%.*]] ] ; CGSCC-NEXT: [[INDVARS_IV:%.*]] = phi i64 [ [[INDVARS_IV_NEXT:%.*]], [[FOR_INC:%.*]] ], [ 0, [[ENTRY:%.*]] ]
; CGSCC-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV]], 100 ; CGSCC-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDVARS_IV]], 100
; CGSCC-NEXT: br i1 [[EXITCOND]], label [[FOR_BODY:%.*]], label [[FOR_COND_CLEANUP:%.*]] ; CGSCC-NEXT: br i1 [[EXITCOND]], label [[FOR_BODY:%.*]], label [[FOR_COND_CLEANUP:%.*]]
▲ Show 20 Lines • Show All 226 Lines • ▼ Show 20 Linesentry:
%add = add nsw i32 %i3, %i4 %add = add nsw i32 %i3, %i4
%add1 = add nsw i32 %add, %cond %add1 = add nsw i32 %add, %cond
call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %Y) call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %Y)
call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %X) call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %X)
ret i32 %add1 ret i32 %add1
} }
define i8 @local_alloca_not_simplifiable_2(i64 %index1, i64 %index2, i1 %cnd) { define i8 @local_alloca_not_simplifiable_2(i64 %index1, i64 %index2, i1 %cnd) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@local_alloca_not_simplifiable_2 ; TUNIT-LABEL: define {{[^@]+}}@local_alloca_not_simplifiable_2
; TUNIT-SAME: (i64 [[INDEX1:%.*]], i64 [[INDEX2:%.*]], i1 noundef [[CND:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i64 [[INDEX1:%.*]], i64 [[INDEX2:%.*]], i1 noundef [[CND:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; TUNIT-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; TUNIT-NEXT: store i8 7, ptr [[BYTES]], align 16 ; TUNIT-NEXT: store i8 7, ptr [[BYTES]], align 16
; TUNIT-NEXT: br i1 [[CND]], label [[LEFT:%.*]], label [[RIGHT:%.*]] ; TUNIT-NEXT: br i1 [[CND]], label [[LEFT:%.*]], label [[RIGHT:%.*]]
; TUNIT: left: ; TUNIT: left:
; TUNIT-NEXT: [[GEP1:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 [[INDEX1]] ; TUNIT-NEXT: [[GEP1:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 [[INDEX1]]
; TUNIT-NEXT: br label [[JOIN:%.*]] ; TUNIT-NEXT: br label [[JOIN:%.*]]
; TUNIT: right: ; TUNIT: right:
; TUNIT-NEXT: [[GEP2:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 [[INDEX2]] ; TUNIT-NEXT: [[GEP2:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 [[INDEX2]]
; TUNIT-NEXT: br label [[JOIN]] ; TUNIT-NEXT: br label [[JOIN]]
; TUNIT: join: ; TUNIT: join:
; TUNIT-NEXT: [[GEP_JOIN:%.*]] = phi ptr [ [[GEP1]], [[LEFT]] ], [ [[GEP2]], [[RIGHT]] ] ; TUNIT-NEXT: [[GEP_JOIN:%.*]] = phi ptr [ [[GEP1]], [[LEFT]] ], [ [[GEP2]], [[RIGHT]] ]
; TUNIT-NEXT: store i8 9, ptr [[GEP_JOIN]], align 4 ; TUNIT-NEXT: store i8 9, ptr [[GEP_JOIN]], align 4
; TUNIT-NEXT: [[I:%.*]] = load i8, ptr [[BYTES]], align 16 ; TUNIT-NEXT: [[I:%.*]] = load i8, ptr [[BYTES]], align 16
; TUNIT-NEXT: ret i8 [[I]] ; TUNIT-NEXT: ret i8 [[I]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@local_alloca_not_simplifiable_2 ; CGSCC-LABEL: define {{[^@]+}}@local_alloca_not_simplifiable_2
; CGSCC-SAME: (i64 [[INDEX1:%.*]], i64 [[INDEX2:%.*]], i1 noundef [[CND:%.*]]) #[[ATTR5]] { ; CGSCC-SAME: (i64 [[INDEX1:%.*]], i64 [[INDEX2:%.*]], i1 noundef [[CND:%.*]]) #[[ATTR5]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; CGSCC-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; CGSCC-NEXT: store i8 7, ptr [[BYTES]], align 16 ; CGSCC-NEXT: store i8 7, ptr [[BYTES]], align 16
; CGSCC-NEXT: br i1 [[CND]], label [[LEFT:%.*]], label [[RIGHT:%.*]] ; CGSCC-NEXT: br i1 [[CND]], label [[LEFT:%.*]], label [[RIGHT:%.*]]
; CGSCC: left: ; CGSCC: left:
; CGSCC-NEXT: [[GEP1:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 [[INDEX1]] ; CGSCC-NEXT: [[GEP1:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 [[INDEX1]]
Show All 27 Linesjoin: ; preds = %right, %left
; This load cannot be replaced by the value 7 from %entry, since the previous ; This load cannot be replaced by the value 7 from %entry, since the previous
; store interferes due to its unknown offset. ; store interferes due to its unknown offset.
%i = load i8, ptr %Bytes, align 4 %i = load i8, ptr %Bytes, align 4
ret i8 %i ret i8 %i
} }
; We could simplify these if we separate accessed bins wrt. alignment (here mod 4). ; We could simplify these if we separate accessed bins wrt. alignment (here mod 4).
define i32 @unknown_access_mixed_simplifiable(i32 %arg1, i32 %arg2) { define i32 @unknown_access_mixed_simplifiable(i32 %arg1, i32 %arg2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@unknown_access_mixed_simplifiable ; CHECK-LABEL: define {{[^@]+}}@unknown_access_mixed_simplifiable
; CHECK-SAME: (i32 [[ARG1:%.*]], i32 [[ARG2:%.*]]) #[[ATTR4]] { ; CHECK-SAME: (i32 [[ARG1:%.*]], i32 [[ARG2:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[S:%.*]] = alloca [[STRUCT_S:%.*]], align 4 ; CHECK-NEXT: [[S:%.*]] = alloca [[STRUCT_S:%.*]], align 4
; CHECK-NEXT: [[GEP1:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 2 ; CHECK-NEXT: [[GEP1:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 2
; CHECK-NEXT: [[GEP2:%.*]] = getelementptr inbounds i32, ptr [[S]], i32 [[ARG1]] ; CHECK-NEXT: [[GEP2:%.*]] = getelementptr inbounds i32, ptr [[S]], i32 [[ARG1]]
; CHECK-NEXT: [[GEP3:%.*]] = getelementptr inbounds i32, ptr [[S]], i32 [[ARG2]] ; CHECK-NEXT: [[GEP3:%.*]] = getelementptr inbounds i32, ptr [[S]], i32 [[ARG2]]
; CHECK-NEXT: store i32 7, ptr [[GEP1]], align 4 ; CHECK-NEXT: store i32 7, ptr [[GEP1]], align 4
Show All 19 Linesentry:
%l3 = load i32, ptr %gep3 %l3 = load i32, ptr %gep3
%add1 = add i32 %l1, %l2 %add1 = add i32 %l1, %l2
%add2 = add i32 %add1, %l3 %add2 = add i32 %add1, %l3
ret i32 %add2 ret i32 %add2
} }
; The access to bc4b could go anywhere, nothing is simplifiable. ; The access to bc4b could go anywhere, nothing is simplifiable.
define i32 @unknown_access_mixed_not_simplifiable(i32 %arg1, i32 %arg2, i32 %arg3) { define i32 @unknown_access_mixed_not_simplifiable(i32 %arg1, i32 %arg2, i32 %arg3) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@unknown_access_mixed_not_simplifiable ; CHECK-LABEL: define {{[^@]+}}@unknown_access_mixed_not_simplifiable
; CHECK-SAME: (i32 [[ARG1:%.*]], i32 [[ARG2:%.*]], i32 [[ARG3:%.*]]) #[[ATTR4]] { ; CHECK-SAME: (i32 [[ARG1:%.*]], i32 [[ARG2:%.*]], i32 [[ARG3:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[S:%.*]] = alloca [[STRUCT_S:%.*]], align 4 ; CHECK-NEXT: [[S:%.*]] = alloca [[STRUCT_S:%.*]], align 4
; CHECK-NEXT: [[GEP1:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 2 ; CHECK-NEXT: [[GEP1:%.*]] = getelementptr inbounds [[STRUCT_S]], ptr [[S]], i64 0, i32 2
; CHECK-NEXT: [[GEP2:%.*]] = getelementptr inbounds i32, ptr [[S]], i32 [[ARG1]] ; CHECK-NEXT: [[GEP2:%.*]] = getelementptr inbounds i32, ptr [[S]], i32 [[ARG1]]
; CHECK-NEXT: [[GEP3:%.*]] = getelementptr inbounds i32, ptr [[S]], i32 [[ARG2]] ; CHECK-NEXT: [[GEP3:%.*]] = getelementptr inbounds i32, ptr [[S]], i32 [[ARG2]]
; CHECK-NEXT: [[GEP4:%.*]] = getelementptr inbounds i8, ptr [[S]], i32 [[ARG3]] ; CHECK-NEXT: [[GEP4:%.*]] = getelementptr inbounds i8, ptr [[S]], i32 [[ARG3]]
Show All 33 Lines
declare void @escape(ptr) declare void @escape(ptr)
; int Flag0 = 0; ; int Flag0 = 0;
; int global_not_simplifiable_1(int cnd) { ; int global_not_simplifiable_1(int cnd) {
; return Flag0; ; return Flag0;
; } ; }
; ;
define i32 @global_not_simplifiable_1(i32 %cnd) { define i32 @global_not_simplifiable_1(i32 %cnd) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
; TUNIT-LABEL: define {{[^@]+}}@global_not_simplifiable_1 ; TUNIT-LABEL: define {{[^@]+}}@global_not_simplifiable_1
; TUNIT-SAME: (i32 [[CND:%.*]]) #[[ATTR6:[0-9]+]] { ; TUNIT-SAME: (i32 [[CND:%.*]]) #[[ATTR6:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[I:%.*]] = load i32, ptr @Flag0, align 4, !tbaa [[TBAA3]] ; TUNIT-NEXT: [[I:%.*]] = load i32, ptr @Flag0, align 4, !tbaa [[TBAA3]]
; TUNIT-NEXT: ret i32 [[I]] ; TUNIT-NEXT: ret i32 [[I]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
; CGSCC-LABEL: define {{[^@]+}}@global_not_simplifiable_1 ; CGSCC-LABEL: define {{[^@]+}}@global_not_simplifiable_1
; CGSCC-SAME: (i32 [[CND:%.*]]) #[[ATTR7:[0-9]+]] { ; CGSCC-SAME: (i32 [[CND:%.*]]) #[[ATTR7:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[I:%.*]] = load i32, ptr @Flag0, align 4, !tbaa [[TBAA3]] ; CGSCC-NEXT: [[I:%.*]] = load i32, ptr @Flag0, align 4, !tbaa [[TBAA3]]
; CGSCC-NEXT: ret i32 [[I]] ; CGSCC-NEXT: ret i32 [[I]]
; ;
entry: entry:
%i = load i32, ptr @Flag0, align 4, !tbaa !3 %i = load i32, ptr @Flag0, align 4, !tbaa !3
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines
entry: entry:
store i32 1, ptr @Flag4, align 4, !tbaa !3 store i32 1, ptr @Flag4, align 4, !tbaa !3
call void @sync() nocallback call void @sync() nocallback
%i = load i32, ptr @Flag4, align 4, !tbaa !3 %i = load i32, ptr @Flag4, align 4, !tbaa !3
store i32 2, ptr @Flag4, align 4, !tbaa !3 store i32 2, ptr @Flag4, align 4, !tbaa !3
ret i32 %i ret i32 %i
} }
define void @static_global_not_simplifiable_2_helper() { define void @static_global_not_simplifiable_2_helper() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@static_global_not_simplifiable_2_helper ; TUNIT-LABEL: define {{[^@]+}}@static_global_not_simplifiable_2_helper
; TUNIT-SAME: () #[[ATTR5]] { ; TUNIT-SAME: () #[[ATTR5]] {
; TUNIT-NEXT: store i32 2, ptr @Flag4, align 4, !tbaa [[TBAA3]] ; TUNIT-NEXT: store i32 2, ptr @Flag4, align 4, !tbaa [[TBAA3]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@static_global_not_simplifiable_2_helper ; CGSCC-LABEL: define {{[^@]+}}@static_global_not_simplifiable_2_helper
; CGSCC-SAME: () #[[ATTR6]] { ; CGSCC-SAME: () #[[ATTR6]] {
; CGSCC-NEXT: store i32 2, ptr @Flag4, align 4, !tbaa [[TBAA3]] ; CGSCC-NEXT: store i32 2, ptr @Flag4, align 4, !tbaa [[TBAA3]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
store i32 2, ptr @Flag4, align 4, !tbaa !3 store i32 2, ptr @Flag4, align 4, !tbaa !3
ret void ret void
} }
; Similiar to static_global_simplifiable_3 but with a may-store. ; Similiar to static_global_simplifiable_3 but with a may-store.
define i32 @static_global_not_simplifiable_3(i1 %c, ptr %p) { define i32 @static_global_not_simplifiable_3(i1 %c, ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@static_global_not_simplifiable_3 ; TUNIT-LABEL: define {{[^@]+}}@static_global_not_simplifiable_3
; TUNIT-SAME: (i1 [[C:%.*]], ptr nocapture nofree writeonly [[P:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (i1 [[C:%.*]], ptr nocapture nofree writeonly [[P:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: [[SEL:%.*]] = select i1 [[C]], ptr @Flag3, ptr [[P]] ; TUNIT-NEXT: [[SEL:%.*]] = select i1 [[C]], ptr @Flag3, ptr [[P]]
; TUNIT-NEXT: store i32 1, ptr [[SEL]], align 4, !tbaa [[TBAA3]] ; TUNIT-NEXT: store i32 1, ptr [[SEL]], align 4, !tbaa [[TBAA3]]
; TUNIT-NEXT: [[I:%.*]] = load i32, ptr @Flag3, align 4, !tbaa [[TBAA3]] ; TUNIT-NEXT: [[I:%.*]] = load i32, ptr @Flag3, align 4, !tbaa [[TBAA3]]
; TUNIT-NEXT: ret i32 [[I]] ; TUNIT-NEXT: ret i32 [[I]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@static_global_not_simplifiable_3 ; CGSCC-LABEL: define {{[^@]+}}@static_global_not_simplifiable_3
; CGSCC-SAME: (i1 [[C:%.*]], ptr nocapture nofree writeonly [[P:%.*]]) #[[ATTR5]] { ; CGSCC-SAME: (i1 [[C:%.*]], ptr nocapture nofree writeonly [[P:%.*]]) #[[ATTR5]] {
; CGSCC-NEXT: [[SEL:%.*]] = select i1 [[C]], ptr @Flag3, ptr [[P]] ; CGSCC-NEXT: [[SEL:%.*]] = select i1 [[C]], ptr @Flag3, ptr [[P]]
; CGSCC-NEXT: store i32 1, ptr [[SEL]], align 4, !tbaa [[TBAA3]] ; CGSCC-NEXT: store i32 1, ptr [[SEL]], align 4, !tbaa [[TBAA3]]
; CGSCC-NEXT: [[I:%.*]] = load i32, ptr @Flag3, align 4, !tbaa [[TBAA3]] ; CGSCC-NEXT: [[I:%.*]] = load i32, ptr @Flag3, align 4, !tbaa [[TBAA3]]
; CGSCC-NEXT: ret i32 [[I]] ; CGSCC-NEXT: ret i32 [[I]]
; ;
%sel = select i1 %c, ptr @Flag3, ptr %p %sel = select i1 %c, ptr @Flag3, ptr %p
Show All 11 Lines
; Gint{,static,_static_undef}2 = 7; ; Gint{,static,_static_undef}2 = 7;
; } ; }
; int read{,_static,_static_undef}_global(void) { ; int read{,_static,_static_undef}_global(void) {
; return Gint{,static,_static_undef}2; ; return Gint{,static,_static_undef}2;
; } ; }
; ;
; FIXME: We could replace these loads. ; FIXME: We could replace these loads.
define i32 @write_read_global() { define i32 @write_read_global() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@write_read_global ; TUNIT-LABEL: define {{[^@]+}}@write_read_global
; TUNIT-SAME: () #[[ATTR3]] { ; TUNIT-SAME: () #[[ATTR3]] {
; TUNIT-NEXT: store i32 7, ptr @Gint1, align 4 ; TUNIT-NEXT: store i32 7, ptr @Gint1, align 4
; TUNIT-NEXT: [[L:%.*]] = load i32, ptr @Gint1, align 4 ; TUNIT-NEXT: [[L:%.*]] = load i32, ptr @Gint1, align 4
; TUNIT-NEXT: ret i32 [[L]] ; TUNIT-NEXT: ret i32 [[L]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@write_read_global ; CGSCC-LABEL: define {{[^@]+}}@write_read_global
; CGSCC-SAME: () #[[ATTR5]] { ; CGSCC-SAME: () #[[ATTR5]] {
; CGSCC-NEXT: store i32 7, ptr @Gint1, align 4 ; CGSCC-NEXT: store i32 7, ptr @Gint1, align 4
; CGSCC-NEXT: [[L:%.*]] = load i32, ptr @Gint1, align 4 ; CGSCC-NEXT: [[L:%.*]] = load i32, ptr @Gint1, align 4
; CGSCC-NEXT: ret i32 [[L]] ; CGSCC-NEXT: ret i32 [[L]]
; ;
store i32 7, ptr @Gint1 store i32 7, ptr @Gint1
%l = load i32, ptr @Gint1 %l = load i32, ptr @Gint1
ret i32 %l ret i32 %l
} }
define void @write_global() { define void @write_global() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@write_global ; TUNIT-LABEL: define {{[^@]+}}@write_global
; TUNIT-SAME: () #[[ATTR5]] { ; TUNIT-SAME: () #[[ATTR5]] {
; TUNIT-NEXT: store i32 7, ptr @Gint2, align 4 ; TUNIT-NEXT: store i32 7, ptr @Gint2, align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@write_global ; CGSCC-LABEL: define {{[^@]+}}@write_global
; CGSCC-SAME: () #[[ATTR6]] { ; CGSCC-SAME: () #[[ATTR6]] {
; CGSCC-NEXT: store i32 7, ptr @Gint2, align 4 ; CGSCC-NEXT: store i32 7, ptr @Gint2, align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
store i32 7, ptr @Gint2 store i32 7, ptr @Gint2
ret void ret void
} }
define i32 @read_global() { define i32 @read_global() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
; TUNIT-LABEL: define {{[^@]+}}@read_global ; TUNIT-LABEL: define {{[^@]+}}@read_global
; TUNIT-SAME: () #[[ATTR6]] { ; TUNIT-SAME: () #[[ATTR6]] {
; TUNIT-NEXT: [[L:%.*]] = load i32, ptr @Gint2, align 4 ; TUNIT-NEXT: [[L:%.*]] = load i32, ptr @Gint2, align 4
; TUNIT-NEXT: ret i32 [[L]] ; TUNIT-NEXT: ret i32 [[L]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
; CGSCC-LABEL: define {{[^@]+}}@read_global ; CGSCC-LABEL: define {{[^@]+}}@read_global
; CGSCC-SAME: () #[[ATTR7]] { ; CGSCC-SAME: () #[[ATTR7]] {
; CGSCC-NEXT: [[L:%.*]] = load i32, ptr @Gint2, align 4 ; CGSCC-NEXT: [[L:%.*]] = load i32, ptr @Gint2, align 4
; CGSCC-NEXT: ret i32 [[L]] ; CGSCC-NEXT: ret i32 [[L]]
; ;
%l = load i32, ptr @Gint2 %l = load i32, ptr @Gint2
ret i32 %l ret i32 %l
} }
define i32 @write_read_static_global() { define i32 @write_read_static_global() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@write_read_static_global ; TUNIT-LABEL: define {{[^@]+}}@write_read_static_global
; TUNIT-SAME: () #[[ATTR5]] { ; TUNIT-SAME: () #[[ATTR5]] {
; TUNIT-NEXT: ret i32 7 ; TUNIT-NEXT: ret i32 7
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@write_read_static_global ; CGSCC-LABEL: define {{[^@]+}}@write_read_static_global
; CGSCC-SAME: () #[[ATTR6]] { ; CGSCC-SAME: () #[[ATTR6]] {
; CGSCC-NEXT: ret i32 7 ; CGSCC-NEXT: ret i32 7
; ;
store i32 7, ptr @Gstatic_int1 store i32 7, ptr @Gstatic_int1
%l = load i32, ptr @Gstatic_int1 %l = load i32, ptr @Gstatic_int1
ret i32 %l ret i32 %l
} }
define void @write_static_global() { define void @write_static_global() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@write_static_global ; TUNIT-LABEL: define {{[^@]+}}@write_static_global
; TUNIT-SAME: () #[[ATTR5]] { ; TUNIT-SAME: () #[[ATTR5]] {
; TUNIT-NEXT: store i32 7, ptr @Gstatic_int2, align 4 ; TUNIT-NEXT: store i32 7, ptr @Gstatic_int2, align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@write_static_global ; CGSCC-LABEL: define {{[^@]+}}@write_static_global
; CGSCC-SAME: () #[[ATTR6]] { ; CGSCC-SAME: () #[[ATTR6]] {
; CGSCC-NEXT: store i32 7, ptr @Gstatic_int2, align 4 ; CGSCC-NEXT: store i32 7, ptr @Gstatic_int2, align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
store i32 7, ptr @Gstatic_int2 store i32 7, ptr @Gstatic_int2
ret void ret void
} }
define i32 @read_static_global() { define i32 @read_static_global() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
; TUNIT-LABEL: define {{[^@]+}}@read_static_global ; TUNIT-LABEL: define {{[^@]+}}@read_static_global
; TUNIT-SAME: () #[[ATTR6]] { ; TUNIT-SAME: () #[[ATTR6]] {
; TUNIT-NEXT: [[L:%.*]] = load i32, ptr @Gstatic_int2, align 4 ; TUNIT-NEXT: [[L:%.*]] = load i32, ptr @Gstatic_int2, align 4
; TUNIT-NEXT: ret i32 [[L]] ; TUNIT-NEXT: ret i32 [[L]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(read)
; CGSCC-LABEL: define {{[^@]+}}@read_static_global ; CGSCC-LABEL: define {{[^@]+}}@read_static_global
; CGSCC-SAME: () #[[ATTR7]] { ; CGSCC-SAME: () #[[ATTR7]] {
; CGSCC-NEXT: [[L:%.*]] = load i32, ptr @Gstatic_int2, align 4 ; CGSCC-NEXT: [[L:%.*]] = load i32, ptr @Gstatic_int2, align 4
; CGSCC-NEXT: ret i32 [[L]] ; CGSCC-NEXT: ret i32 [[L]]
; ;
%l = load i32, ptr @Gstatic_int2 %l = load i32, ptr @Gstatic_int2
ret i32 %l ret i32 %l
} }
define i32 @write_read_static_undef_global() { define i32 @write_read_static_undef_global() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@write_read_static_undef_global ; TUNIT-LABEL: define {{[^@]+}}@write_read_static_undef_global
; TUNIT-SAME: () #[[ATTR5]] { ; TUNIT-SAME: () #[[ATTR5]] {
; TUNIT-NEXT: ret i32 7 ; TUNIT-NEXT: ret i32 7
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@write_read_static_undef_global ; CGSCC-LABEL: define {{[^@]+}}@write_read_static_undef_global
; CGSCC-SAME: () #[[ATTR6]] { ; CGSCC-SAME: () #[[ATTR6]] {
; CGSCC-NEXT: ret i32 7 ; CGSCC-NEXT: ret i32 7
; ;
store i32 7, ptr @Gstatic_undef_int1 store i32 7, ptr @Gstatic_undef_int1
%l = load i32, ptr @Gstatic_undef_int1 %l = load i32, ptr @Gstatic_undef_int1
ret i32 %l ret i32 %l
} }
define void @write_static_undef_global() { define void @write_static_undef_global() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@write_static_undef_global ; TUNIT-LABEL: define {{[^@]+}}@write_static_undef_global
; TUNIT-SAME: () #[[ATTR5]] { ; TUNIT-SAME: () #[[ATTR5]] {
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@write_static_undef_global ; CGSCC-LABEL: define {{[^@]+}}@write_static_undef_global
; CGSCC-SAME: () #[[ATTR6]] { ; CGSCC-SAME: () #[[ATTR6]] {
; CGSCC-NEXT: store i32 7, ptr @Gstatic_undef_int2, align 4 ; CGSCC-NEXT: store i32 7, ptr @Gstatic_undef_int2, align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
store i32 7, ptr @Gstatic_undef_int2 store i32 7, ptr @Gstatic_undef_int2
ret void ret void
} }
define i32 @read_static_undef_global() { define i32 @read_static_undef_global() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@read_static_undef_global ; CHECK-LABEL: define {{[^@]+}}@read_static_undef_global
; CHECK-SAME: () #[[ATTR4]] { ; CHECK-SAME: () #[[ATTR4]] {
; CHECK-NEXT: ret i32 7 ; CHECK-NEXT: ret i32 7
; ;
%l = load i32, ptr @Gstatic_undef_int2 %l = load i32, ptr @Gstatic_undef_int2
ret i32 %l ret i32 %l
} }
define i32 @single_read_of_static_global() { define i32 @single_read_of_static_global() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@single_read_of_static_global ; CHECK-LABEL: define {{[^@]+}}@single_read_of_static_global
; CHECK-SAME: () #[[ATTR4]] { ; CHECK-SAME: () #[[ATTR4]] {
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
%l = load i32, ptr @Gstatic_int3 %l = load i32, ptr @Gstatic_int3
ret i32 %l ret i32 %l
} }
define i8 @phi_store() { define i8 @phi_store() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@phi_store ; CHECK-LABEL: define {{[^@]+}}@phi_store
; CHECK-SAME: () #[[ATTR4]] { ; CHECK-SAME: () #[[ATTR4]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i16, align 2 ; CHECK-NEXT: [[A:%.*]] = alloca i16, align 2
; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop: ; CHECK: loop:
; CHECK-NEXT: [[P:%.*]] = phi ptr [ [[A]], [[ENTRY:%.*]] ], [ [[G:%.*]], [[LOOP]] ] ; CHECK-NEXT: [[P:%.*]] = phi ptr [ [[A]], [[ENTRY:%.*]] ], [ [[G:%.*]], [[LOOP]] ]
; CHECK-NEXT: [[I:%.*]] = phi i8 [ 0, [[ENTRY]] ], [ [[O:%.*]], [[LOOP]] ] ; CHECK-NEXT: [[I:%.*]] = phi i8 [ 0, [[ENTRY]] ], [ [[O:%.*]], [[LOOP]] ]
Show All 22 Linesend:
%s = getelementptr i8, ptr %a, i64 1 %s = getelementptr i8, ptr %a, i64 1
%l = load i8, ptr %s %l = load i8, ptr %s
ret i8 %l ret i8 %l
} }
; FIXME: This function returns 1. ; FIXME: This function returns 1.
define i8 @phi_no_store_1() { define i8 @phi_no_store_1() {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@phi_no_store_1 ; TUNIT-LABEL: define {{[^@]+}}@phi_no_store_1
; TUNIT-SAME: () #[[ATTR3]] { ; TUNIT-SAME: () #[[ATTR3]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: br label [[LOOP:%.*]] ; TUNIT-NEXT: br label [[LOOP:%.*]]
; TUNIT: loop: ; TUNIT: loop:
; TUNIT-NEXT: [[P:%.*]] = phi ptr [ @a1, [[ENTRY:%.*]] ], [ [[G:%.*]], [[LOOP]] ] ; TUNIT-NEXT: [[P:%.*]] = phi ptr [ @a1, [[ENTRY:%.*]] ], [ [[G:%.*]], [[LOOP]] ]
; TUNIT-NEXT: [[I:%.*]] = phi i8 [ 0, [[ENTRY]] ], [ [[O:%.*]], [[LOOP]] ] ; TUNIT-NEXT: [[I:%.*]] = phi i8 [ 0, [[ENTRY]] ], [ [[O:%.*]], [[LOOP]] ]
; TUNIT-NEXT: store i8 1, ptr [[P]], align 1 ; TUNIT-NEXT: store i8 1, ptr [[P]], align 1
; TUNIT-NEXT: [[G]] = getelementptr i8, ptr [[P]], i64 1 ; TUNIT-NEXT: [[G]] = getelementptr i8, ptr [[P]], i64 1
; TUNIT-NEXT: [[O]] = add nsw i8 [[I]], 1 ; TUNIT-NEXT: [[O]] = add nsw i8 [[I]], 1
; TUNIT-NEXT: [[C:%.*]] = icmp eq i8 [[O]], 3 ; TUNIT-NEXT: [[C:%.*]] = icmp eq i8 [[O]], 3
; TUNIT-NEXT: br i1 [[C]], label [[END:%.*]], label [[LOOP]] ; TUNIT-NEXT: br i1 [[C]], label [[END:%.*]], label [[LOOP]]
; TUNIT: end: ; TUNIT: end:
; TUNIT-NEXT: [[S11:%.*]] = getelementptr i8, ptr @a1, i64 2 ; TUNIT-NEXT: [[S11:%.*]] = getelementptr i8, ptr @a1, i64 2
; TUNIT-NEXT: [[L11:%.*]] = load i8, ptr [[S11]], align 2 ; TUNIT-NEXT: [[L11:%.*]] = load i8, ptr [[S11]], align 2
; TUNIT-NEXT: [[S12:%.*]] = getelementptr i8, ptr @a1, i64 3 ; TUNIT-NEXT: [[S12:%.*]] = getelementptr i8, ptr @a1, i64 3
; TUNIT-NEXT: [[L12:%.*]] = load i8, ptr [[S12]], align 1 ; TUNIT-NEXT: [[L12:%.*]] = load i8, ptr [[S12]], align 1
; TUNIT-NEXT: [[ADD:%.*]] = add i8 [[L11]], [[L12]] ; TUNIT-NEXT: [[ADD:%.*]] = add i8 [[L11]], [[L12]]
; TUNIT-NEXT: ret i8 [[ADD]] ; TUNIT-NEXT: ret i8 [[ADD]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@phi_no_store_1 ; CGSCC-LABEL: define {{[^@]+}}@phi_no_store_1
; CGSCC-SAME: () #[[ATTR5]] { ; CGSCC-SAME: () #[[ATTR5]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: br label [[LOOP:%.*]] ; CGSCC-NEXT: br label [[LOOP:%.*]]
; CGSCC: loop: ; CGSCC: loop:
; CGSCC-NEXT: [[P:%.*]] = phi ptr [ @a1, [[ENTRY:%.*]] ], [ [[G:%.*]], [[LOOP]] ] ; CGSCC-NEXT: [[P:%.*]] = phi ptr [ @a1, [[ENTRY:%.*]] ], [ [[G:%.*]], [[LOOP]] ]
; CGSCC-NEXT: [[I:%.*]] = phi i8 [ 0, [[ENTRY]] ], [ [[O:%.*]], [[LOOP]] ] ; CGSCC-NEXT: [[I:%.*]] = phi i8 [ 0, [[ENTRY]] ], [ [[O:%.*]], [[LOOP]] ]
; CGSCC-NEXT: store i8 1, ptr [[P]], align 1 ; CGSCC-NEXT: store i8 1, ptr [[P]], align 1
Show All 26 Linesend:
%l12 = load i8, ptr %s12 %l12 = load i8, ptr %s12
%add = add i8 %l11, %l12 %add = add i8 %l11, %l12
ret i8 %add ret i8 %add
} }
; FIXME: This function returns 1. ; FIXME: This function returns 1.
define i8 @phi_no_store_2() { define i8 @phi_no_store_2() {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@phi_no_store_2 ; TUNIT-LABEL: define {{[^@]+}}@phi_no_store_2
; TUNIT-SAME: () #[[ATTR3]] { ; TUNIT-SAME: () #[[ATTR3]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: br label [[LOOP:%.*]] ; TUNIT-NEXT: br label [[LOOP:%.*]]
; TUNIT: loop: ; TUNIT: loop:
; TUNIT-NEXT: [[P:%.*]] = phi ptr [ @a2, [[ENTRY:%.*]] ], [ [[G:%.*]], [[LOOP]] ] ; TUNIT-NEXT: [[P:%.*]] = phi ptr [ @a2, [[ENTRY:%.*]] ], [ [[G:%.*]], [[LOOP]] ]
; TUNIT-NEXT: [[I:%.*]] = phi i8 [ 0, [[ENTRY]] ], [ [[O:%.*]], [[LOOP]] ] ; TUNIT-NEXT: [[I:%.*]] = phi i8 [ 0, [[ENTRY]] ], [ [[O:%.*]], [[LOOP]] ]
; TUNIT-NEXT: store i8 1, ptr [[P]], align 1 ; TUNIT-NEXT: store i8 1, ptr [[P]], align 1
; TUNIT-NEXT: [[G]] = getelementptr i8, ptr @a2, i64 2 ; TUNIT-NEXT: [[G]] = getelementptr i8, ptr @a2, i64 2
; TUNIT-NEXT: [[O]] = add nsw i8 [[I]], 1 ; TUNIT-NEXT: [[O]] = add nsw i8 [[I]], 1
; TUNIT-NEXT: [[C:%.*]] = icmp eq i8 [[O]], 7 ; TUNIT-NEXT: [[C:%.*]] = icmp eq i8 [[O]], 7
; TUNIT-NEXT: br i1 [[C]], label [[END:%.*]], label [[LOOP]] ; TUNIT-NEXT: br i1 [[C]], label [[END:%.*]], label [[LOOP]]
; TUNIT: end: ; TUNIT: end:
; TUNIT-NEXT: [[S21:%.*]] = getelementptr i8, ptr @a2, i64 2 ; TUNIT-NEXT: [[S21:%.*]] = getelementptr i8, ptr @a2, i64 2
; TUNIT-NEXT: [[L21:%.*]] = load i8, ptr [[S21]], align 2 ; TUNIT-NEXT: [[L21:%.*]] = load i8, ptr [[S21]], align 2
; TUNIT-NEXT: [[S22:%.*]] = getelementptr i8, ptr @a2, i64 3 ; TUNIT-NEXT: [[S22:%.*]] = getelementptr i8, ptr @a2, i64 3
; TUNIT-NEXT: [[L22:%.*]] = load i8, ptr [[S22]], align 1 ; TUNIT-NEXT: [[L22:%.*]] = load i8, ptr [[S22]], align 1
; TUNIT-NEXT: [[ADD:%.*]] = add i8 [[L21]], [[L22]] ; TUNIT-NEXT: [[ADD:%.*]] = add i8 [[L21]], [[L22]]
; TUNIT-NEXT: ret i8 [[ADD]] ; TUNIT-NEXT: ret i8 [[ADD]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@phi_no_store_2 ; CGSCC-LABEL: define {{[^@]+}}@phi_no_store_2
; CGSCC-SAME: () #[[ATTR5]] { ; CGSCC-SAME: () #[[ATTR5]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: br label [[LOOP:%.*]] ; CGSCC-NEXT: br label [[LOOP:%.*]]
; CGSCC: loop: ; CGSCC: loop:
; CGSCC-NEXT: [[P:%.*]] = phi ptr [ @a2, [[ENTRY:%.*]] ], [ [[G:%.*]], [[LOOP]] ] ; CGSCC-NEXT: [[P:%.*]] = phi ptr [ @a2, [[ENTRY:%.*]] ], [ [[G:%.*]], [[LOOP]] ]
; CGSCC-NEXT: [[I:%.*]] = phi i8 [ 0, [[ENTRY]] ], [ [[O:%.*]], [[LOOP]] ] ; CGSCC-NEXT: [[I:%.*]] = phi i8 [ 0, [[ENTRY]] ], [ [[O:%.*]], [[LOOP]] ]
; CGSCC-NEXT: store i8 1, ptr [[P]], align 1 ; CGSCC-NEXT: store i8 1, ptr [[P]], align 1
Show All 24 Linesend:
%l21 = load i8, ptr %s21 %l21 = load i8, ptr %s21
%s22 = getelementptr i8, ptr @a2, i64 3 %s22 = getelementptr i8, ptr @a2, i64 3
%l22 = load i8, ptr %s22 %l22 = load i8, ptr %s22
%add = add i8 %l21, %l22 %add = add i8 %l21, %l22
ret i8 %add ret i8 %add
} }
define i8 @phi_no_store_3() { define i8 @phi_no_store_3() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@phi_no_store_3 ; TUNIT-LABEL: define {{[^@]+}}@phi_no_store_3
; TUNIT-SAME: () #[[ATTR3]] { ; TUNIT-SAME: () #[[ATTR3]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[S30:%.*]] = getelementptr i8, ptr @a3, i64 3 ; TUNIT-NEXT: [[S30:%.*]] = getelementptr i8, ptr @a3, i64 3
; TUNIT-NEXT: store i8 0, ptr [[S30]], align 1 ; TUNIT-NEXT: store i8 0, ptr [[S30]], align 1
; TUNIT-NEXT: br label [[LOOP:%.*]] ; TUNIT-NEXT: br label [[LOOP:%.*]]
; TUNIT: loop: ; TUNIT: loop:
; TUNIT-NEXT: [[P:%.*]] = phi ptr [ @a3, [[ENTRY:%.*]] ], [ [[G:%.*]], [[LOOP]] ] ; TUNIT-NEXT: [[P:%.*]] = phi ptr [ @a3, [[ENTRY:%.*]] ], [ [[G:%.*]], [[LOOP]] ]
Show All 9 Lines
; TUNIT-NEXT: [[S32:%.*]] = getelementptr i8, ptr @a3, i64 3 ; TUNIT-NEXT: [[S32:%.*]] = getelementptr i8, ptr @a3, i64 3
; TUNIT-NEXT: [[L32:%.*]] = load i8, ptr [[S32]], align 1 ; TUNIT-NEXT: [[L32:%.*]] = load i8, ptr [[S32]], align 1
; TUNIT-NEXT: [[ADD:%.*]] = add i8 [[L31]], [[L32]] ; TUNIT-NEXT: [[ADD:%.*]] = add i8 [[L31]], [[L32]]
; TUNIT-NEXT: [[S34:%.*]] = getelementptr i8, ptr @a3, i64 4 ; TUNIT-NEXT: [[S34:%.*]] = getelementptr i8, ptr @a3, i64 4
; TUNIT-NEXT: [[L34:%.*]] = load i8, ptr [[S34]], align 4 ; TUNIT-NEXT: [[L34:%.*]] = load i8, ptr [[S34]], align 4
; TUNIT-NEXT: [[ADD2:%.*]] = add i8 [[ADD]], [[L34]] ; TUNIT-NEXT: [[ADD2:%.*]] = add i8 [[ADD]], [[L34]]
; TUNIT-NEXT: ret i8 [[ADD2]] ; TUNIT-NEXT: ret i8 [[ADD2]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@phi_no_store_3 ; CGSCC-LABEL: define {{[^@]+}}@phi_no_store_3
; CGSCC-SAME: () #[[ATTR5]] { ; CGSCC-SAME: () #[[ATTR5]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[S30:%.*]] = getelementptr i8, ptr @a3, i64 3 ; CGSCC-NEXT: [[S30:%.*]] = getelementptr i8, ptr @a3, i64 3
; CGSCC-NEXT: store i8 0, ptr [[S30]], align 1 ; CGSCC-NEXT: store i8 0, ptr [[S30]], align 1
; CGSCC-NEXT: br label [[LOOP:%.*]] ; CGSCC-NEXT: br label [[LOOP:%.*]]
; CGSCC: loop: ; CGSCC: loop:
; CGSCC-NEXT: [[P:%.*]] = phi ptr [ @a3, [[ENTRY:%.*]] ], [ [[G:%.*]], [[LOOP]] ] ; CGSCC-NEXT: [[P:%.*]] = phi ptr [ @a3, [[ENTRY:%.*]] ], [ [[G:%.*]], [[LOOP]] ]
Show All 34 Linesend:
%add = add i8 %l31, %l32 %add = add i8 %l31, %l32
%s34 = getelementptr i8, ptr @a3, i64 4 %s34 = getelementptr i8, ptr @a3, i64 4
%l34 = load i8, ptr %s34 %l34 = load i8, ptr %s34
%add2 = add i8 %add, %l34 %add2 = add i8 %add, %l34
ret i8 %add2 ret i8 %add2
} }
define i8 @cast_and_load_1() { define i8 @cast_and_load_1() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@cast_and_load_1 ; TUNIT-LABEL: define {{[^@]+}}@cast_and_load_1
; TUNIT-SAME: () #[[ATTR3]] { ; TUNIT-SAME: () #[[ATTR3]] {
; TUNIT-NEXT: store i32 42, ptr @bytes1, align 4 ; TUNIT-NEXT: store i32 42, ptr @bytes1, align 4
; TUNIT-NEXT: [[L:%.*]] = load i8, ptr @bytes1, align 4 ; TUNIT-NEXT: [[L:%.*]] = load i8, ptr @bytes1, align 4
; TUNIT-NEXT: ret i8 [[L]] ; TUNIT-NEXT: ret i8 [[L]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@cast_and_load_1 ; CGSCC-LABEL: define {{[^@]+}}@cast_and_load_1
; CGSCC-SAME: () #[[ATTR5]] { ; CGSCC-SAME: () #[[ATTR5]] {
; CGSCC-NEXT: store i32 42, ptr @bytes1, align 4 ; CGSCC-NEXT: store i32 42, ptr @bytes1, align 4
; CGSCC-NEXT: [[L:%.*]] = load i8, ptr @bytes1, align 4 ; CGSCC-NEXT: [[L:%.*]] = load i8, ptr @bytes1, align 4
; CGSCC-NEXT: ret i8 [[L]] ; CGSCC-NEXT: ret i8 [[L]]
; ;
store i32 42, ptr @bytes1 store i32 42, ptr @bytes1
%l = load i8, ptr @bytes1 %l = load i8, ptr @bytes1
ret i8 %l ret i8 %l
} }
define i64 @cast_and_load_2() { define i64 @cast_and_load_2() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@cast_and_load_2 ; TUNIT-LABEL: define {{[^@]+}}@cast_and_load_2
; TUNIT-SAME: () #[[ATTR3]] { ; TUNIT-SAME: () #[[ATTR3]] {
; TUNIT-NEXT: store i32 42, ptr @bytes2, align 4 ; TUNIT-NEXT: store i32 42, ptr @bytes2, align 4
; TUNIT-NEXT: [[L:%.*]] = load i64, ptr @bytes2, align 4 ; TUNIT-NEXT: [[L:%.*]] = load i64, ptr @bytes2, align 4
; TUNIT-NEXT: ret i64 [[L]] ; TUNIT-NEXT: ret i64 [[L]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@cast_and_load_2 ; CGSCC-LABEL: define {{[^@]+}}@cast_and_load_2
; CGSCC-SAME: () #[[ATTR5]] { ; CGSCC-SAME: () #[[ATTR5]] {
; CGSCC-NEXT: store i32 42, ptr @bytes2, align 4 ; CGSCC-NEXT: store i32 42, ptr @bytes2, align 4
; CGSCC-NEXT: [[L:%.*]] = load i64, ptr @bytes2, align 4 ; CGSCC-NEXT: [[L:%.*]] = load i64, ptr @bytes2, align 4
; CGSCC-NEXT: ret i64 [[L]] ; CGSCC-NEXT: ret i64 [[L]]
; ;
store i32 42, ptr @bytes2 store i32 42, ptr @bytes2
%l = load i64, ptr @bytes2 %l = load i64, ptr @bytes2
▲ Show 20 Lines • Show All 369 Lines • ▼ Show 20 Linesentry:
%src2 = getelementptr inbounds i8, ptr %call, i64 8 %src2 = getelementptr inbounds i8, ptr %call, i64 8
store ptr %src, ptr %src2, align 8 store ptr %src, ptr %src2, align 8
store ptr %call, ptr getelementptr inbounds (%struct.STy, ptr @global, i64 0, i32 2), align 8 store ptr %call, ptr getelementptr inbounds (%struct.STy, ptr @global, i64 0, i32 2), align 8
call fastcc void @nested_memory_callee(ptr nonnull %local) call fastcc void @nested_memory_callee(ptr nonnull %local)
ret void ret void
} }
define internal fastcc void @nested_memory_callee(ptr nocapture readonly %S) nofree norecurse nounwind uwtable { define internal fastcc void @nested_memory_callee(ptr nocapture readonly %S) nofree norecurse nounwind uwtable {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn uwtable ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn uwtable
; TUNIT-LABEL: define {{[^@]+}}@nested_memory_callee ; TUNIT-LABEL: define {{[^@]+}}@nested_memory_callee
; TUNIT-SAME: (ptr [[TMP0:%.*]], ptr [[TMP1:%.*]], ptr [[TMP2:%.*]]) #[[ATTR11:[0-9]+]] { ; TUNIT-SAME: (ptr [[TMP0:%.*]], ptr [[TMP1:%.*]], ptr [[TMP2:%.*]]) #[[ATTR11:[0-9]+]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[S_PRIV:%.*]] = alloca [[STRUCT_STY:%.*]], align 8 ; TUNIT-NEXT: [[S_PRIV:%.*]] = alloca [[STRUCT_STY:%.*]], align 8
; TUNIT-NEXT: store ptr [[TMP0]], ptr [[S_PRIV]], align 8 ; TUNIT-NEXT: store ptr [[TMP0]], ptr [[S_PRIV]], align 8
; TUNIT-NEXT: [[S_PRIV_0_1:%.*]] = getelementptr [[STRUCT_STY]], ptr [[S_PRIV]], i64 0, i32 1 ; TUNIT-NEXT: [[S_PRIV_0_1:%.*]] = getelementptr [[STRUCT_STY]], ptr [[S_PRIV]], i64 0, i32 1
; TUNIT-NEXT: store ptr [[TMP1]], ptr [[S_PRIV_0_1]], align 8 ; TUNIT-NEXT: store ptr [[TMP1]], ptr [[S_PRIV_0_1]], align 8
; TUNIT-NEXT: [[S_PRIV_0_2:%.*]] = getelementptr [[STRUCT_STY]], ptr [[S_PRIV]], i64 0, i32 2 ; TUNIT-NEXT: [[S_PRIV_0_2:%.*]] = getelementptr [[STRUCT_STY]], ptr [[S_PRIV]], i64 0, i32 2
; TUNIT-NEXT: store ptr [[TMP2]], ptr [[S_PRIV_0_2]], align 8 ; TUNIT-NEXT: store ptr [[TMP2]], ptr [[S_PRIV_0_2]], align 8
; TUNIT-NEXT: [[INNER:%.*]] = getelementptr inbounds [[STRUCT_STY]], ptr [[S_PRIV]], i64 0, i32 2 ; TUNIT-NEXT: [[INNER:%.*]] = getelementptr inbounds [[STRUCT_STY]], ptr [[S_PRIV]], i64 0, i32 2
; TUNIT-NEXT: [[TMP3:%.*]] = load ptr, ptr [[INNER]], align 8 ; TUNIT-NEXT: [[TMP3:%.*]] = load ptr, ptr [[INNER]], align 8
; TUNIT-NEXT: [[INNER1:%.*]] = getelementptr inbounds [[STRUCT_STY]], ptr [[TMP3]], i64 0, i32 2 ; TUNIT-NEXT: [[INNER1:%.*]] = getelementptr inbounds [[STRUCT_STY]], ptr [[TMP3]], i64 0, i32 2
; TUNIT-NEXT: [[TMP4:%.*]] = load ptr, ptr [[INNER1]], align 8 ; TUNIT-NEXT: [[TMP4:%.*]] = load ptr, ptr [[INNER1]], align 8
; TUNIT-NEXT: [[SRC:%.*]] = getelementptr inbounds [[STRUCT_STY]], ptr [[TMP4]], i64 0, i32 1 ; TUNIT-NEXT: [[SRC:%.*]] = getelementptr inbounds [[STRUCT_STY]], ptr [[TMP4]], i64 0, i32 1
; TUNIT-NEXT: [[TMP5:%.*]] = load ptr, ptr [[SRC]], align 8 ; TUNIT-NEXT: [[TMP5:%.*]] = load ptr, ptr [[SRC]], align 8
; TUNIT-NEXT: [[TMP6:%.*]] = load double, ptr [[TMP5]], align 8 ; TUNIT-NEXT: [[TMP6:%.*]] = load double, ptr [[TMP5]], align 8
; TUNIT-NEXT: [[CONV:%.*]] = fptrunc double [[TMP6]] to float ; TUNIT-NEXT: [[CONV:%.*]] = fptrunc double [[TMP6]] to float
; TUNIT-NEXT: [[TMP7:%.*]] = load ptr, ptr [[TMP4]], align 8 ; TUNIT-NEXT: [[TMP7:%.*]] = load ptr, ptr [[TMP4]], align 8
; TUNIT-NEXT: store float [[CONV]], ptr [[TMP7]], align 4 ; TUNIT-NEXT: store float [[CONV]], ptr [[TMP7]], align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn uwtable ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn uwtable
; CGSCC-LABEL: define {{[^@]+}}@nested_memory_callee ; CGSCC-LABEL: define {{[^@]+}}@nested_memory_callee
; CGSCC-SAME: (ptr [[TMP0:%.*]], ptr [[TMP1:%.*]], ptr [[TMP2:%.*]]) #[[ATTR12:[0-9]+]] { ; CGSCC-SAME: (ptr [[TMP0:%.*]], ptr [[TMP1:%.*]], ptr [[TMP2:%.*]]) #[[ATTR12:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[S_PRIV:%.*]] = alloca [[STRUCT_STY:%.*]], align 8 ; CGSCC-NEXT: [[S_PRIV:%.*]] = alloca [[STRUCT_STY:%.*]], align 8
; CGSCC-NEXT: store ptr [[TMP0]], ptr [[S_PRIV]], align 8 ; CGSCC-NEXT: store ptr [[TMP0]], ptr [[S_PRIV]], align 8
; CGSCC-NEXT: [[S_PRIV_0_1:%.*]] = getelementptr [[STRUCT_STY]], ptr [[S_PRIV]], i64 0, i32 1 ; CGSCC-NEXT: [[S_PRIV_0_1:%.*]] = getelementptr [[STRUCT_STY]], ptr [[S_PRIV]], i64 0, i32 1
; CGSCC-NEXT: store ptr [[TMP1]], ptr [[S_PRIV_0_1]], align 8 ; CGSCC-NEXT: store ptr [[TMP1]], ptr [[S_PRIV_0_1]], align 8
; CGSCC-NEXT: [[S_PRIV_0_2:%.*]] = getelementptr [[STRUCT_STY]], ptr [[S_PRIV]], i64 0, i32 2 ; CGSCC-NEXT: [[S_PRIV_0_2:%.*]] = getelementptr [[STRUCT_STY]], ptr [[S_PRIV]], i64 0, i32 2
Show All 22 Linesentry:
%4 = load ptr, ptr %1, align 8 %4 = load ptr, ptr %1, align 8
store float %conv, ptr %4, align 4 store float %conv, ptr %4, align 4
ret void ret void
} }
; Make sure the access %1 is not forwarded to the loads %2 and %3 as the indices are ; Make sure the access %1 is not forwarded to the loads %2 and %3 as the indices are
; varying and the accesses thus not "exact". This used to simplify %cmp12 to true. ; varying and the accesses thus not "exact". This used to simplify %cmp12 to true.
define hidden void @no_propagation_of_unknown_index_access(ptr %in, ptr %out, i32 %idx) #0 { define hidden void @no_propagation_of_unknown_index_access(ptr %in, ptr %out, i32 %idx) #0 {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@no_propagation_of_unknown_index_access ; TUNIT-LABEL: define {{[^@]+}}@no_propagation_of_unknown_index_access
; TUNIT-SAME: (ptr nocapture nofree readonly [[IN:%.*]], ptr nocapture nofree writeonly [[OUT:%.*]], i32 [[IDX:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (ptr nocapture nofree readonly [[IN:%.*]], ptr nocapture nofree writeonly [[OUT:%.*]], i32 [[IDX:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[BUF:%.*]] = alloca [128 x i32], align 16 ; TUNIT-NEXT: [[BUF:%.*]] = alloca [128 x i32], align 16
; TUNIT-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 512, ptr noalias nocapture nofree noundef nonnull align 16 dereferenceable(512) [[BUF]]) #[[ATTR17]] ; TUNIT-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 512, ptr noalias nocapture nofree noundef nonnull align 16 dereferenceable(512) [[BUF]]) #[[ATTR17]]
; TUNIT-NEXT: br label [[FOR_COND:%.*]] ; TUNIT-NEXT: br label [[FOR_COND:%.*]]
; TUNIT: for.cond: ; TUNIT: for.cond:
; TUNIT-NEXT: [[I_0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FOR_BODY:%.*]] ] ; TUNIT-NEXT: [[I_0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FOR_BODY:%.*]] ]
Show All 25 Lines
; TUNIT-NEXT: [[TMP2:%.*]] = load i32, ptr [[ARRAYIDX11]], align 4 ; TUNIT-NEXT: [[TMP2:%.*]] = load i32, ptr [[ARRAYIDX11]], align 4
; TUNIT-NEXT: [[CMP12:%.*]] = icmp sle i32 [[TMP1]], [[TMP2]] ; TUNIT-NEXT: [[CMP12:%.*]] = icmp sle i32 [[TMP1]], [[TMP2]]
; TUNIT-NEXT: [[CONV:%.*]] = zext i1 [[CMP12]] to i32 ; TUNIT-NEXT: [[CONV:%.*]] = zext i1 [[CMP12]] to i32
; TUNIT-NEXT: [[ARRAYIDX14:%.*]] = getelementptr inbounds i32, ptr [[OUT]], i64 [[IDXPROM8]] ; TUNIT-NEXT: [[ARRAYIDX14:%.*]] = getelementptr inbounds i32, ptr [[OUT]], i64 [[IDXPROM8]]
; TUNIT-NEXT: store i32 [[CONV]], ptr [[ARRAYIDX14]], align 4 ; TUNIT-NEXT: store i32 [[CONV]], ptr [[ARRAYIDX14]], align 4
; TUNIT-NEXT: [[INC16]] = add nsw i32 [[I3_0]], 1 ; TUNIT-NEXT: [[INC16]] = add nsw i32 [[I3_0]], 1
; TUNIT-NEXT: br label [[FOR_COND4]], !llvm.loop [[TBAA12]] ; TUNIT-NEXT: br label [[FOR_COND4]], !llvm.loop [[TBAA12]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@no_propagation_of_unknown_index_access ; CGSCC-LABEL: define {{[^@]+}}@no_propagation_of_unknown_index_access
; CGSCC-SAME: (ptr nocapture nofree readonly [[IN:%.*]], ptr nocapture nofree writeonly [[OUT:%.*]], i32 [[IDX:%.*]]) #[[ATTR13:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree readonly [[IN:%.*]], ptr nocapture nofree writeonly [[OUT:%.*]], i32 [[IDX:%.*]]) #[[ATTR13:[0-9]+]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: [[BUF:%.*]] = alloca [128 x i32], align 16 ; CGSCC-NEXT: [[BUF:%.*]] = alloca [128 x i32], align 16
; CGSCC-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 512, ptr noalias nocapture nofree noundef nonnull align 16 dereferenceable(512) [[BUF]]) #[[ATTR20]] ; CGSCC-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 512, ptr noalias nocapture nofree noundef nonnull align 16 dereferenceable(512) [[BUF]]) #[[ATTR20]]
; CGSCC-NEXT: br label [[FOR_COND:%.*]] ; CGSCC-NEXT: br label [[FOR_COND:%.*]]
; CGSCC: for.cond: ; CGSCC: for.cond:
; CGSCC-NEXT: [[I_0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FOR_BODY:%.*]] ] ; CGSCC-NEXT: [[I_0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FOR_BODY:%.*]] ]
▲ Show 20 Lines • Show All 133 Lines • ▼ Show 20 Lines
; CGSCC-NEXT: ret i1 [[R]] ; CGSCC-NEXT: ret i1 [[R]]
; ;
%r = call i1 @alloca_non_unique(ptr undef, i32 %in, i1 %c) %r = call i1 @alloca_non_unique(ptr undef, i32 %in, i1 %c)
ret i1 %r ret i1 %r
} }
; Ensure we do not return %bad or %l, but %sel ; Ensure we do not return %bad or %l, but %sel
define i32 @scope_value_traversal(i32 %bad, i1 %c, i1 %c2) { define i32 @scope_value_traversal(i32 %bad, i1 %c, i1 %c2) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@scope_value_traversal ; TUNIT-LABEL: define {{[^@]+}}@scope_value_traversal
; TUNIT-SAME: (i32 [[BAD:%.*]], i1 [[C:%.*]], i1 [[C2:%.*]]) #[[ATTR4]] { ; TUNIT-SAME: (i32 [[BAD:%.*]], i1 [[C:%.*]], i1 [[C2:%.*]]) #[[ATTR4]] {
; TUNIT-NEXT: [[A:%.*]] = alloca i32, align 4 ; TUNIT-NEXT: [[A:%.*]] = alloca i32, align 4
; TUNIT-NEXT: store i32 [[BAD]], ptr [[A]], align 4 ; TUNIT-NEXT: store i32 [[BAD]], ptr [[A]], align 4
; TUNIT-NEXT: call void @scope_value_traversal_helper(ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[A]], i1 [[C2]]) #[[ATTR18]] ; TUNIT-NEXT: call void @scope_value_traversal_helper(ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[A]], i1 [[C2]]) #[[ATTR18]]
; TUNIT-NEXT: [[L:%.*]] = load i32, ptr [[A]], align 4 ; TUNIT-NEXT: [[L:%.*]] = load i32, ptr [[A]], align 4
; TUNIT-NEXT: [[SEL:%.*]] = select i1 [[C]], i32 [[BAD]], i32 [[L]] ; TUNIT-NEXT: [[SEL:%.*]] = select i1 [[C]], i32 [[BAD]], i32 [[L]]
; TUNIT-NEXT: ret i32 [[SEL]] ; TUNIT-NEXT: ret i32 [[SEL]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@scope_value_traversal ; CGSCC-LABEL: define {{[^@]+}}@scope_value_traversal
; CGSCC-SAME: (i32 [[BAD:%.*]], i1 [[C:%.*]], i1 [[C2:%.*]]) #[[ATTR16:[0-9]+]] { ; CGSCC-SAME: (i32 [[BAD:%.*]], i1 [[C:%.*]], i1 [[C2:%.*]]) #[[ATTR16:[0-9]+]] {
; CGSCC-NEXT: [[A:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[A:%.*]] = alloca i32, align 4
; CGSCC-NEXT: store i32 [[BAD]], ptr [[A]], align 4 ; CGSCC-NEXT: store i32 [[BAD]], ptr [[A]], align 4
; CGSCC-NEXT: call void @scope_value_traversal_helper(ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[A]], i1 [[C2]]) #[[ATTR21]] ; CGSCC-NEXT: call void @scope_value_traversal_helper(ptr noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[A]], i1 [[C2]]) #[[ATTR21]]
; CGSCC-NEXT: [[L:%.*]] = load i32, ptr [[A]], align 4 ; CGSCC-NEXT: [[L:%.*]] = load i32, ptr [[A]], align 4
; CGSCC-NEXT: [[SEL:%.*]] = select i1 [[C]], i32 [[BAD]], i32 [[L]] ; CGSCC-NEXT: [[SEL:%.*]] = select i1 [[C]], i32 [[BAD]], i32 [[L]]
; CGSCC-NEXT: ret i32 [[SEL]] ; CGSCC-NEXT: ret i32 [[SEL]]
; ;
%a = alloca i32 %a = alloca i32
store i32 %bad, ptr %a store i32 %bad, ptr %a
call void @scope_value_traversal_helper(ptr %a, i1 %c2) call void @scope_value_traversal_helper(ptr %a, i1 %c2)
%l = load i32, ptr %a %l = load i32, ptr %a
%sel = select i1 %c, i32 %bad, i32 %l %sel = select i1 %c, i32 %bad, i32 %l
ret i32 %sel ret i32 %sel
} }
define void @scope_value_traversal_helper(ptr %a, i1 %c) { define void @scope_value_traversal_helper(ptr %a, i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; TUNIT-LABEL: define {{[^@]+}}@scope_value_traversal_helper ; TUNIT-LABEL: define {{[^@]+}}@scope_value_traversal_helper
; TUNIT-SAME: (ptr nocapture nofree noundef nonnull align 4 dereferenceable(4) [[A:%.*]], i1 [[C:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (ptr nocapture nofree noundef nonnull align 4 dereferenceable(4) [[A:%.*]], i1 [[C:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: [[L:%.*]] = load i32, ptr [[A]], align 4 ; TUNIT-NEXT: [[L:%.*]] = load i32, ptr [[A]], align 4
; TUNIT-NEXT: [[SEL:%.*]] = select i1 [[C]], i32 [[L]], i32 42 ; TUNIT-NEXT: [[SEL:%.*]] = select i1 [[C]], i32 [[L]], i32 42
; TUNIT-NEXT: store i32 [[SEL]], ptr [[A]], align 4 ; TUNIT-NEXT: store i32 [[SEL]], ptr [[A]], align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
; CGSCC-LABEL: define {{[^@]+}}@scope_value_traversal_helper ; CGSCC-LABEL: define {{[^@]+}}@scope_value_traversal_helper
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull align 4 dereferenceable(4) [[A:%.*]], i1 [[C:%.*]]) #[[ATTR13]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull align 4 dereferenceable(4) [[A:%.*]], i1 [[C:%.*]]) #[[ATTR13]] {
; CGSCC-NEXT: [[L:%.*]] = load i32, ptr [[A]], align 4 ; CGSCC-NEXT: [[L:%.*]] = load i32, ptr [[A]], align 4
; CGSCC-NEXT: [[SEL:%.*]] = select i1 [[C]], i32 [[L]], i32 42 ; CGSCC-NEXT: [[SEL:%.*]] = select i1 [[C]], i32 [[L]], i32 42
; CGSCC-NEXT: store i32 [[SEL]], ptr [[A]], align 4 ; CGSCC-NEXT: store i32 [[SEL]], ptr [[A]], align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%l = load i32, ptr %a %l = load i32, ptr %a
%sel = select i1 %c, i32 %l, i32 42 %sel = select i1 %c, i32 %l, i32 42
store i32 %sel, ptr %a store i32 %sel, ptr %a
ret void ret void
} }
define i8 @gep_index_from_binary_operator(i1 %cnd1, i1 %cnd2) { define i8 @gep_index_from_binary_operator(i1 %cnd1, i1 %cnd2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@gep_index_from_binary_operator ; CHECK-LABEL: define {{[^@]+}}@gep_index_from_binary_operator
; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR4]] { ; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; CHECK-NEXT: [[GEP_FIXED:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 12 ; CHECK-NEXT: [[GEP_FIXED:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 12
; CHECK-NEXT: ret i8 100 ; CHECK-NEXT: ret i8 100
; ;
entry: entry:
%Bytes = alloca [1024 x i8], align 16 %Bytes = alloca [1024 x i8], align 16
%offset = add i64 5, 7 %offset = add i64 5, 7
%gep.fixed = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 12 %gep.fixed = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 12
%gep.sum = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 %offset %gep.sum = getelementptr inbounds [1024 x i8], ptr %Bytes, i64 0, i64 %offset
store i8 100, ptr %gep.fixed, align 4 store i8 100, ptr %gep.fixed, align 4
%i = load i8, ptr %gep.sum, align 4 %i = load i8, ptr %gep.sum, align 4
ret i8 %i ret i8 %i
} }
define i8 @gep_index_from_memory(i1 %cnd1, i1 %cnd2) { define i8 @gep_index_from_memory(i1 %cnd1, i1 %cnd2) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@gep_index_from_memory ; CHECK-LABEL: define {{[^@]+}}@gep_index_from_memory
; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR4]] { ; CHECK-SAME: (i1 [[CND1:%.*]], i1 [[CND2:%.*]]) #[[ATTR4]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16 ; CHECK-NEXT: [[BYTES:%.*]] = alloca [1024 x i8], align 16
; CHECK-NEXT: [[GEP_LOADED:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 12 ; CHECK-NEXT: [[GEP_LOADED:%.*]] = getelementptr inbounds [1024 x i8], ptr [[BYTES]], i64 0, i64 12
; CHECK-NEXT: ret i8 100 ; CHECK-NEXT: ret i8 100
; ;
entry: entry:
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
f: f:
%r = load i32, ptr @G %r = load i32, ptr @G
store i32 5, ptr @G store i32 5, ptr @G
ret i32 %r ret i32 %r
} }
@GC = internal global i32 undef, align 4 @GC = internal global i32 undef, align 4
define void @atomicrmw(ptr %p, i32 %i, i1 %cnd) { define void @atomicrmw(ptr %p, i32 %i, i1 %cnd) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@atomicrmw ; TUNIT-LABEL: define {{[^@]+}}@atomicrmw
; TUNIT-SAME: (ptr nofree [[P:%.*]], i32 [[I:%.*]], i1 noundef [[CND:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (ptr nofree [[P:%.*]], i32 [[I:%.*]], i1 noundef [[CND:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: br i1 [[CND]], label [[T:%.*]], label [[M:%.*]] ; TUNIT-NEXT: br i1 [[CND]], label [[T:%.*]], label [[M:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: br label [[M]] ; TUNIT-NEXT: br label [[M]]
; TUNIT: m: ; TUNIT: m:
; TUNIT-NEXT: [[ARMW:%.*]] = atomicrmw add ptr @GC, i32 [[I]] monotonic, align 4 ; TUNIT-NEXT: [[ARMW:%.*]] = atomicrmw add ptr @GC, i32 [[I]] monotonic, align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@atomicrmw ; CGSCC-LABEL: define {{[^@]+}}@atomicrmw
; CGSCC-SAME: (ptr nofree [[P:%.*]], i32 [[I:%.*]], i1 noundef [[CND:%.*]]) #[[ATTR5]] { ; CGSCC-SAME: (ptr nofree [[P:%.*]], i32 [[I:%.*]], i1 noundef [[CND:%.*]]) #[[ATTR5]] {
; CGSCC-NEXT: br i1 [[CND]], label [[T:%.*]], label [[M:%.*]] ; CGSCC-NEXT: br i1 [[CND]], label [[T:%.*]], label [[M:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: br label [[M]] ; CGSCC-NEXT: br label [[M]]
; CGSCC: m: ; CGSCC: m:
; CGSCC-NEXT: [[ARMW:%.*]] = atomicrmw add ptr @GC, i32 [[I]] monotonic, align 4 ; CGSCC-NEXT: [[ARMW:%.*]] = atomicrmw add ptr @GC, i32 [[I]] monotonic, align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
!25 = distinct !{!25, !17} !25 = distinct !{!25, !17}
!26 = distinct !{!26, !17} !26 = distinct !{!26, !17}
!27 = distinct !{!27, !17} !27 = distinct !{!27, !17}
!28 = distinct !{!28, !17} !28 = distinct !{!28, !17}
!29 = distinct !{!29, !17} !29 = distinct !{!29, !17}
!30 = distinct !{!30, !17} !30 = distinct !{!30, !17}
!31 = distinct !{!31, !17} !31 = distinct !{!31, !17}
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR2:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR2:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR3]] = { nofree norecurse nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR5]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; TUNIT: attributes #[[ATTR5]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; TUNIT: attributes #[[ATTR6]] = { nofree norecurse nosync nounwind willreturn memory(read) } ; TUNIT: attributes #[[ATTR6]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(read) }
; TUNIT: attributes #[[ATTR7]] = { nofree norecurse nosync nounwind memory(write) } ; TUNIT: attributes #[[ATTR7]] = { nofree norecurse nosync nounwind memory(write) }
; TUNIT: attributes #[[ATTR8:[0-9]+]] = { allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" } ; TUNIT: attributes #[[ATTR8:[0-9]+]] = { allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
; TUNIT: attributes #[[ATTR9:[0-9]+]] = { allockind("free") "alloc-family"="malloc" } ; TUNIT: attributes #[[ATTR9:[0-9]+]] = { allockind("free") "alloc-family"="malloc" }
; TUNIT: attributes #[[ATTR10:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc" } ; TUNIT: attributes #[[ATTR10:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc" }
; TUNIT: attributes #[[ATTR11]] = { nofree norecurse nosync nounwind willreturn uwtable } ; TUNIT: attributes #[[ATTR11]] = { mustprogress nofree norecurse nosync nounwind willreturn uwtable }
; TUNIT: attributes #[[ATTR12]] = { nofree nosync nounwind memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR12]] = { nofree nosync nounwind memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR13]] = { nofree norecurse nosync nounwind memory(none) } ; TUNIT: attributes #[[ATTR13]] = { nofree norecurse nosync nounwind memory(none) }
; TUNIT: attributes #[[ATTR14]] = { nofree nosync nounwind } ; TUNIT: attributes #[[ATTR14]] = { nofree nosync nounwind }
; TUNIT: attributes #[[ATTR15:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; TUNIT: attributes #[[ATTR15:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
; TUNIT: attributes #[[ATTR16:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR16:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR17]] = { willreturn } ; TUNIT: attributes #[[ATTR17]] = { willreturn }
; TUNIT: attributes #[[ATTR18]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR18]] = { nofree nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR19]] = { nocallback } ; TUNIT: attributes #[[ATTR19]] = { nocallback }
; TUNIT: attributes #[[ATTR20]] = { norecurse } ; TUNIT: attributes #[[ATTR20]] = { norecurse }
; TUNIT: attributes #[[ATTR21]] = { nounwind } ; TUNIT: attributes #[[ATTR21]] = { nounwind }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR1]] = { nofree nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR2:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR2:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR3]] = { nofree nosync nounwind willreturn } ; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree nosync nounwind willreturn }
; CGSCC: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR5]] = { nofree norecurse nosync nounwind willreturn } ; CGSCC: attributes #[[ATTR5]] = { mustprogress nofree norecurse nosync nounwind willreturn }
; CGSCC: attributes #[[ATTR6]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR6]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR7]] = { nofree norecurse nosync nounwind willreturn memory(read) } ; CGSCC: attributes #[[ATTR7]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(read) }
; CGSCC: attributes #[[ATTR8]] = { nofree norecurse nosync nounwind memory(write) } ; CGSCC: attributes #[[ATTR8]] = { nofree norecurse nosync nounwind memory(write) }
; CGSCC: attributes #[[ATTR9:[0-9]+]] = { allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" } ; CGSCC: attributes #[[ATTR9:[0-9]+]] = { allockind("alloc,uninitialized") allocsize(0) "alloc-family"="malloc" }
; CGSCC: attributes #[[ATTR10:[0-9]+]] = { allockind("free") "alloc-family"="malloc" } ; CGSCC: attributes #[[ATTR10:[0-9]+]] = { allockind("free") "alloc-family"="malloc" }
; CGSCC: attributes #[[ATTR11:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc" } ; CGSCC: attributes #[[ATTR11:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc" }
; CGSCC: attributes #[[ATTR12]] = { nofree norecurse nosync nounwind willreturn uwtable } ; CGSCC: attributes #[[ATTR12]] = { mustprogress nofree norecurse nosync nounwind willreturn uwtable }
; CGSCC: attributes #[[ATTR13]] = { nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR13]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR14]] = { nofree nosync nounwind memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR14]] = { nofree nosync nounwind memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR15]] = { nofree nosync nounwind memory(none) } ; CGSCC: attributes #[[ATTR15]] = { nofree nosync nounwind memory(none) }
; CGSCC: attributes #[[ATTR16]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR16]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR17]] = { nofree nosync nounwind } ; CGSCC: attributes #[[ATTR17]] = { nofree nosync nounwind }
; CGSCC: attributes #[[ATTR18:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; CGSCC: attributes #[[ATTR18:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
; CGSCC: attributes #[[ATTR19:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR19:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR20]] = { willreturn } ; CGSCC: attributes #[[ATTR20]] = { willreturn }
; CGSCC: attributes #[[ATTR21]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR21]] = { nounwind willreturn }
; CGSCC: attributes #[[ATTR22]] = { nocallback } ; CGSCC: attributes #[[ATTR22]] = { nocallback }
; CGSCC: attributes #[[ATTR23]] = { norecurse } ; CGSCC: attributes #[[ATTR23]] = { norecurse }
; CGSCC: attributes #[[ATTR24]] = { nounwind } ; CGSCC: attributes #[[ATTR24]] = { nounwind }
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/value-simplify-reachability.ll

Show All 15 Lines
;. ;.
; CHECK: @[[GINT1:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 undef, align 4 ; CHECK: @[[GINT1:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 undef, align 4
; CHECK: @[[GINT2:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 0, align 4 ; CHECK: @[[GINT2:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 0, align 4
; CHECK: @[[GINT3:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 undef, align 4 ; CHECK: @[[GINT3:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 undef, align 4
; CHECK: @[[GINT4:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 0, align 4 ; CHECK: @[[GINT4:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 0, align 4
; CHECK: @[[GINT5:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 undef, align 4 ; CHECK: @[[GINT5:[a-zA-Z0-9_$"\\.-]+]] = internal global i32 undef, align 4
;. ;.
define internal void @write1ToGInt1() { define internal void @write1ToGInt1() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CHECK-LABEL: define {{[^@]+}}@write1ToGInt1 ; CHECK-LABEL: define {{[^@]+}}@write1ToGInt1
; CHECK-SAME: () #[[ATTR4:[0-9]+]] { ; CHECK-SAME: () #[[ATTR4:[0-9]+]] {
; CHECK-NEXT: store i32 1, ptr @GInt1, align 4 ; CHECK-NEXT: store i32 1, ptr @GInt1, align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store i32 1, ptr @GInt1 store i32 1, ptr @GInt1
ret void ret void
} }
define internal void @write1ToGInt2() { define internal void @write1ToGInt2() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CHECK-LABEL: define {{[^@]+}}@write1ToGInt2 ; CHECK-LABEL: define {{[^@]+}}@write1ToGInt2
; CHECK-SAME: () #[[ATTR4]] { ; CHECK-SAME: () #[[ATTR4]] {
; CHECK-NEXT: store i32 1, ptr @GInt2, align 4 ; CHECK-NEXT: store i32 1, ptr @GInt2, align 4
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
store i32 1, ptr @GInt2 store i32 1, ptr @GInt2
ret void ret void
} }
▲ Show 20 Lines • Show All 746 Lines • ▼ Show 20 Lines;
ret i32 %final ret i32 %final
} }
;. ;.
; TUNIT: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; TUNIT: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
; TUNIT: attributes #[[ATTR1:[0-9]+]] = { nocallback nosync } ; TUNIT: attributes #[[ATTR1:[0-9]+]] = { nocallback nosync }
; TUNIT: attributes #[[ATTR2:[0-9]+]] = { allockind("free") "alloc-family"="malloc" } ; TUNIT: attributes #[[ATTR2:[0-9]+]] = { allockind("free") "alloc-family"="malloc" }
; TUNIT: attributes #[[ATTR3:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc" } ; TUNIT: attributes #[[ATTR3:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc" }
; TUNIT: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; TUNIT: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; TUNIT: attributes #[[ATTR5]] = { norecurse nosync } ; TUNIT: attributes #[[ATTR5]] = { norecurse nosync }
; TUNIT: attributes #[[ATTR6]] = { nocallback } ; TUNIT: attributes #[[ATTR6]] = { nocallback }
; TUNIT: attributes #[[ATTR7]] = { norecurse } ; TUNIT: attributes #[[ATTR7]] = { norecurse }
; TUNIT: attributes #[[ATTR8]] = { nosync } ; TUNIT: attributes #[[ATTR8]] = { nosync }
; TUNIT: attributes #[[ATTR9:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR9:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR10]] = { nosync nounwind } ; TUNIT: attributes #[[ATTR10]] = { nosync nounwind }
;. ;.
; CGSCC: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } ; CGSCC: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
; CGSCC: attributes #[[ATTR1:[0-9]+]] = { nocallback nosync } ; CGSCC: attributes #[[ATTR1:[0-9]+]] = { nocallback nosync }
; CGSCC: attributes #[[ATTR2:[0-9]+]] = { allockind("free") "alloc-family"="malloc" } ; CGSCC: attributes #[[ATTR2:[0-9]+]] = { allockind("free") "alloc-family"="malloc" }
; CGSCC: attributes #[[ATTR3:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc" } ; CGSCC: attributes #[[ATTR3:[0-9]+]] = { allockind("alloc,zeroed") allocsize(0,1) "alloc-family"="malloc" }
; CGSCC: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR5]] = { nosync } ; CGSCC: attributes #[[ATTR5]] = { nosync }
; CGSCC: attributes #[[ATTR6]] = { norecurse nosync } ; CGSCC: attributes #[[ATTR6]] = { norecurse nosync }
; CGSCC: attributes #[[ATTR7]] = { nocallback } ; CGSCC: attributes #[[ATTR7]] = { nocallback }
; CGSCC: attributes #[[ATTR8]] = { norecurse } ; CGSCC: attributes #[[ATTR8]] = { norecurse }
; CGSCC: attributes #[[ATTR9:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR9:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR10]] = { nounwind } ; CGSCC: attributes #[[ATTR10]] = { nounwind }
;. ;.

llvm/test/Transforms/Attributor/value-simplify.ll

Show All 12 Lines
;. ;.
; CHECK: @[[STR:[a-zA-Z0-9_$"\\.-]+]] = private unnamed_addr addrspace(4) constant [1 x i8] zeroinitializer, align 1 ; CHECK: @[[STR:[a-zA-Z0-9_$"\\.-]+]] = private unnamed_addr addrspace(4) constant [1 x i8] zeroinitializer, align 1
; CHECK: @[[CONSTAS3PTR:[a-zA-Z0-9_$"\\.-]+]] = addrspace(3) global i32 0, align 4 ; CHECK: @[[CONSTAS3PTR:[a-zA-Z0-9_$"\\.-]+]] = addrspace(3) global i32 0, align 4
; CHECK: @[[S:[a-zA-Z0-9_$"\\.-]+]] = external global [[STRUCT_X:%.*]] ; CHECK: @[[S:[a-zA-Z0-9_$"\\.-]+]] = external global [[STRUCT_X:%.*]]
; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = internal constant { [2 x ptr] } { [2 x ptr] [ptr @f1, ptr @f2] } ; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = internal constant { [2 x ptr] } { [2 x ptr] [ptr @f1, ptr @f2] }
; CHECK: @[[X:[a-zA-Z0-9_$"\\.-]+]] = external global i32 ; CHECK: @[[X:[a-zA-Z0-9_$"\\.-]+]] = external global i32
;. ;.
define internal ptr addrspace(3) @const_ptr_return_as3() { define internal ptr addrspace(3) @const_ptr_return_as3() {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@const_ptr_return_as3 ; CGSCC-LABEL: define {{[^@]+}}@const_ptr_return_as3
; CGSCC-SAME: () #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: ret ptr addrspace(3) @ConstAS3Ptr ; CGSCC-NEXT: ret ptr addrspace(3) @ConstAS3Ptr
; ;
ret ptr addrspace(3) @ConstAS3Ptr ret ptr addrspace(3) @ConstAS3Ptr
} }
define internal ptr @const_ptr_return() { define internal ptr @const_ptr_return() {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@const_ptr_return ; CGSCC-LABEL: define {{[^@]+}}@const_ptr_return
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: ret ptr addrspacecast (ptr addrspace(3) @ConstAS3Ptr to ptr) ; CGSCC-NEXT: ret ptr addrspacecast (ptr addrspace(3) @ConstAS3Ptr to ptr)
; ;
ret ptr addrspacecast (ptr addrspace(3) @ConstAS3Ptr to ptr) ret ptr addrspacecast (ptr addrspace(3) @ConstAS3Ptr to ptr)
} }
; Test1: Replace argument with constant ; Test1: Replace argument with constant
Show All 12 Lines
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
tail call void @test1(i32 1) tail call void @test1(i32 1)
ret void ret void
} }
; TEST 2 : Simplify return value ; TEST 2 : Simplify return value
define i32 @return0() { define i32 @return0() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@return0 ; CHECK-LABEL: define {{[^@]+}}@return0
; CHECK-SAME: () #[[ATTR1:[0-9]+]] { ; CHECK-SAME: () #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
ret i32 0 ret i32 0
} }
define i32 @return1() { define i32 @return1() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@return1 ; CHECK-LABEL: define {{[^@]+}}@return1
; CHECK-SAME: () #[[ATTR1]] { ; CHECK-SAME: () #[[ATTR1]] {
; CHECK-NEXT: ret i32 1 ; CHECK-NEXT: ret i32 1
; ;
ret i32 1 ret i32 1
} }
define i32 @test2_1(i1 %c) { define i32 @test2_1(i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@test2_1 ; TUNIT-LABEL: define {{[^@]+}}@test2_1
; TUNIT-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: br i1 [[C]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]] ; TUNIT-NEXT: br i1 [[C]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]]
; TUNIT: if.true: ; TUNIT: if.true:
; TUNIT-NEXT: [[RET0:%.*]] = add i32 0, 1 ; TUNIT-NEXT: [[RET0:%.*]] = add i32 0, 1
; TUNIT-NEXT: br label [[END:%.*]] ; TUNIT-NEXT: br label [[END:%.*]]
; TUNIT: if.false: ; TUNIT: if.false:
; TUNIT-NEXT: br label [[END]] ; TUNIT-NEXT: br label [[END]]
; TUNIT: end: ; TUNIT: end:
; TUNIT-NEXT: [[RET:%.*]] = phi i32 [ [[RET0]], [[IF_TRUE]] ], [ 1, [[IF_FALSE]] ] ; TUNIT-NEXT: [[RET:%.*]] = phi i32 [ [[RET0]], [[IF_TRUE]] ], [ 1, [[IF_FALSE]] ]
; TUNIT-NEXT: ret i32 1 ; TUNIT-NEXT: ret i32 1
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test2_1 ; CGSCC-LABEL: define {{[^@]+}}@test2_1
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2:[0-9]+]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2:[0-9]+]] {
; CGSCC-NEXT: br i1 [[C]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]]
; CGSCC: if.true: ; CGSCC: if.true:
; CGSCC-NEXT: [[CALL:%.*]] = tail call i32 @return0() #[[ATTR13:[0-9]+]] ; CGSCC-NEXT: [[CALL:%.*]] = tail call i32 @return0() #[[ATTR13:[0-9]+]]
; CGSCC-NEXT: [[RET0:%.*]] = add i32 [[CALL]], 1 ; CGSCC-NEXT: [[RET0:%.*]] = add i32 [[CALL]], 1
; CGSCC-NEXT: br label [[END:%.*]] ; CGSCC-NEXT: br label [[END:%.*]]
; CGSCC: if.false: ; CGSCC: if.false:
Show All 16 Linesend:
%ret = phi i32 [ %ret0, %if.true ], [ %ret1, %if.false ] %ret = phi i32 [ %ret0, %if.true ], [ %ret1, %if.false ]
ret i32 1 ret i32 1
} }
define i32 @test2_2(i1 %c) { define i32 @test2_2(i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@test2_2 ; TUNIT-LABEL: define {{[^@]+}}@test2_2
; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: ret i32 1 ; TUNIT-NEXT: ret i32 1
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test2_2 ; CGSCC-LABEL: define {{[^@]+}}@test2_2
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[RET:%.*]] = tail call noundef i32 @test2_1(i1 noundef [[C]]) #[[ATTR13]] ; CGSCC-NEXT: [[RET:%.*]] = tail call noundef i32 @test2_1(i1 noundef [[C]]) #[[ATTR13]]
; CGSCC-NEXT: ret i32 [[RET]] ; CGSCC-NEXT: ret i32 [[RET]]
; ;
%ret = tail call i32 @test2_1(i1 %c) %ret = tail call i32 @test2_1(i1 %c)
ret i32 %ret ret i32 %ret
} }
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Linesend:
tail call void @use(i32 %select-not-same-undef) tail call void @use(i32 %select-not-same-undef)
ret void ret void
} }
define i32 @ipccp1(i32 %a) { define i32 @ipccp1(i32 %a) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@ipccp1 ; CHECK-LABEL: define {{[^@]+}}@ipccp1
; CHECK-SAME: (i32 returned [[A:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (i32 returned [[A:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: br i1 true, label [[T:%.*]], label [[F:%.*]] ; CHECK-NEXT: br i1 true, label [[T:%.*]], label [[F:%.*]]
; CHECK: t: ; CHECK: t:
; CHECK-NEXT: ret i32 [[A]] ; CHECK-NEXT: ret i32 [[A]]
; CHECK: f: ; CHECK: f:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; ;
br i1 true, label %t, label %f br i1 true, label %t, label %f
t: t:
ret i32 %a ret i32 %a
f: f:
%r = call i32 @ipccp1(i32 5) %r = call i32 @ipccp1(i32 5)
ret i32 %r ret i32 %r
} }
define internal i1 @ipccp2i(i1 %a) { define internal i1 @ipccp2i(i1 %a) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@ipccp2i ; CGSCC-LABEL: define {{[^@]+}}@ipccp2i
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: br label [[T:%.*]] ; CGSCC-NEXT: br label [[T:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: ret i1 true ; CGSCC-NEXT: ret i1 true
; CGSCC: f: ; CGSCC: f:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
br i1 %a, label %t, label %f br i1 %a, label %t, label %f
t: t:
ret i1 %a ret i1 %a
f: f:
%r = call i1 @ipccp2i(i1 false) %r = call i1 @ipccp2i(i1 false)
ret i1 %r ret i1 %r
} }
define i1 @ipccp2() { define i1 @ipccp2() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@ipccp2 ; TUNIT-LABEL: define {{[^@]+}}@ipccp2
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret i1 true ; TUNIT-NEXT: ret i1 true
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@ipccp2 ; CGSCC-LABEL: define {{[^@]+}}@ipccp2
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: [[R:%.*]] = call noundef i1 @ipccp2i() #[[ATTR13]] ; CGSCC-NEXT: [[R:%.*]] = call noundef i1 @ipccp2i() #[[ATTR13]]
; CGSCC-NEXT: ret i1 [[R]] ; CGSCC-NEXT: ret i1 [[R]]
; ;
%r = call i1 @ipccp2i(i1 true) %r = call i1 @ipccp2i(i1 true)
ret i1 %r ret i1 %r
} }
define internal i1 @ipccp2ib(i1 %a) { define internal i1 @ipccp2ib(i1 %a) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@ipccp2ib ; CGSCC-LABEL: define {{[^@]+}}@ipccp2ib
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: br label [[T:%.*]] ; CGSCC-NEXT: br label [[T:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: ret i1 true ; CGSCC-NEXT: ret i1 true
; CGSCC: f: ; CGSCC: f:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
br i1 %a, label %t, label %f br i1 %a, label %t, label %f
t: t:
ret i1 true ret i1 true
f: f:
%r = call i1 @ipccp2ib(i1 false) %r = call i1 @ipccp2ib(i1 false)
ret i1 %r ret i1 %r
} }
define i1 @ipccp2b() { define i1 @ipccp2b() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@ipccp2b ; TUNIT-LABEL: define {{[^@]+}}@ipccp2b
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret i1 true ; TUNIT-NEXT: ret i1 true
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@ipccp2b ; CGSCC-LABEL: define {{[^@]+}}@ipccp2b
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: [[R:%.*]] = call noundef i1 @ipccp2ib() #[[ATTR13]] ; CGSCC-NEXT: [[R:%.*]] = call noundef i1 @ipccp2ib() #[[ATTR13]]
; CGSCC-NEXT: ret i1 [[R]] ; CGSCC-NEXT: ret i1 [[R]]
; ;
%r = call i1 @ipccp2ib(i1 true) %r = call i1 @ipccp2ib(i1 true)
ret i1 %r ret i1 %r
} }
define internal i32 @ipccp3i(i32 %a) { define internal i32 @ipccp3i(i32 %a) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@ipccp3i ; CGSCC-LABEL: define {{[^@]+}}@ipccp3i
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: br label [[T:%.*]] ; CGSCC-NEXT: br label [[T:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: ret i32 7 ; CGSCC-NEXT: ret i32 7
; CGSCC: f: ; CGSCC: f:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
%c = icmp eq i32 %a, 7 %c = icmp eq i32 %a, 7
br i1 %c, label %t, label %f br i1 %c, label %t, label %f
t: t:
ret i32 %a ret i32 %a
f: f:
%r = call i32 @ipccp3i(i32 5) %r = call i32 @ipccp3i(i32 5)
ret i32 %r ret i32 %r
} }
define i32 @ipccp3() { define i32 @ipccp3() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@ipccp3 ; TUNIT-LABEL: define {{[^@]+}}@ipccp3
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret i32 7 ; TUNIT-NEXT: ret i32 7
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@ipccp3 ; CGSCC-LABEL: define {{[^@]+}}@ipccp3
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: [[R:%.*]] = call noundef i32 @ipccp3i() #[[ATTR13]] ; CGSCC-NEXT: [[R:%.*]] = call noundef i32 @ipccp3i() #[[ATTR13]]
; CGSCC-NEXT: ret i32 [[R]] ; CGSCC-NEXT: ret i32 [[R]]
; ;
%r = call i32 @ipccp3i(i32 7) %r = call i32 @ipccp3i(i32 7)
ret i32 %r ret i32 %r
} }
define internal i32 @ipccp4ia(i1 %c) { define internal i32 @ipccp4ia(i1 %c) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@ipccp4ia ; CGSCC-LABEL: define {{[^@]+}}@ipccp4ia
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: ret i32 0 ; CGSCC-NEXT: ret i32 0
; CGSCC: f: ; CGSCC: f:
; CGSCC-NEXT: ret i32 1 ; CGSCC-NEXT: ret i32 1
; ;
br i1 %c, label %t, label %f br i1 %c, label %t, label %f
t: t:
ret i32 0 ret i32 0
f: f:
ret i32 1 ret i32 1
} }
define internal i32 @ipccp4ib(i32 %a) { define internal i32 @ipccp4ib(i32 %a) {
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@ipccp4ib ; CGSCC-LABEL: define {{[^@]+}}@ipccp4ib
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: br label [[T:%.*]] ; CGSCC-NEXT: br label [[T:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: [[R:%.*]] = call noundef i32 @ipccp4ia(i1 noundef true) #[[ATTR13]] ; CGSCC-NEXT: [[R:%.*]] = call noundef i32 @ipccp4ia(i1 noundef true) #[[ATTR13]]
; CGSCC-NEXT: ret i32 [[R]] ; CGSCC-NEXT: ret i32 [[R]]
; CGSCC: f: ; CGSCC: f:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
%c = icmp eq i32 %a, 7 %c = icmp eq i32 %a, 7
br i1 %c, label %t, label %f br i1 %c, label %t, label %f
t: t:
%r = call i32 @ipccp4ia(i1 %c) %r = call i32 @ipccp4ia(i1 %c)
ret i32 %r ret i32 %r
f: f:
ret i32 1 ret i32 1
} }
define i32 @ipccp4(i1 %c) { define i32 @ipccp4(i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@ipccp4 ; TUNIT-LABEL: define {{[^@]+}}@ipccp4
; TUNIT-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: br label [[F]] ; TUNIT-NEXT: br label [[F]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: ret i32 0 ; TUNIT-NEXT: ret i32 0
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@ipccp4 ; CGSCC-LABEL: define {{[^@]+}}@ipccp4
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: br label [[F]] ; CGSCC-NEXT: br label [[F]]
; CGSCC: f: ; CGSCC: f:
; CGSCC-NEXT: [[R:%.*]] = call noundef i32 @ipccp4ib() #[[ATTR13]] ; CGSCC-NEXT: [[R:%.*]] = call noundef i32 @ipccp4ib() #[[ATTR13]]
; CGSCC-NEXT: ret i32 [[R]] ; CGSCC-NEXT: ret i32 [[R]]
; ;
br i1 %c, label %t, label %f br i1 %c, label %t, label %f
t: t:
%q = call i32 @ipccp4ia(i1 undef) %q = call i32 @ipccp4ia(i1 undef)
br label %f br label %f
f: f:
%r = call i32 @ipccp4ib(i32 7) %r = call i32 @ipccp4ib(i32 7)
ret i32 %r ret i32 %r
} }
; Do not touch complicated arguments (for now) ; Do not touch complicated arguments (for now)
%struct.X = type { ptr } %struct.X = type { ptr }
define internal ptr @test_inalloca(ptr inalloca(i32) %a) { define internal ptr @test_inalloca(ptr inalloca(i32) %a) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test_inalloca ; CHECK-LABEL: define {{[^@]+}}@test_inalloca
; CHECK-SAME: (ptr noalias nofree nonnull returned writeonly inalloca(i32) dereferenceable(4) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ptr noalias nofree nonnull returned writeonly inalloca(i32) dereferenceable(4) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: ret ptr [[A]] ; CHECK-NEXT: ret ptr [[A]]
; ;
ret ptr %a ret ptr %a
} }
define ptr @complicated_args_inalloca(ptr %arg) { define ptr @complicated_args_inalloca(ptr %arg) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@complicated_args_inalloca ; TUNIT-LABEL: define {{[^@]+}}@complicated_args_inalloca
; TUNIT-SAME: (ptr nofree readnone "no-capture-maybe-returned" [[ARG:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (ptr nofree readnone "no-capture-maybe-returned" [[ARG:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: [[CALL:%.*]] = call nonnull dereferenceable(4) ptr @test_inalloca(ptr noalias nofree writeonly inalloca(i32) "no-capture-maybe-returned" [[ARG]]) #[[ATTR9:[0-9]+]] ; TUNIT-NEXT: [[CALL:%.*]] = call nonnull dereferenceable(4) ptr @test_inalloca(ptr noalias nofree writeonly inalloca(i32) "no-capture-maybe-returned" [[ARG]]) #[[ATTR9:[0-9]+]]
; TUNIT-NEXT: ret ptr [[CALL]] ; TUNIT-NEXT: ret ptr [[CALL]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@complicated_args_inalloca ; CGSCC-LABEL: define {{[^@]+}}@complicated_args_inalloca
; CGSCC-SAME: (ptr nofree noundef nonnull readnone dereferenceable(4) [[ARG:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (ptr nofree noundef nonnull readnone dereferenceable(4) [[ARG:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[CALL:%.*]] = call noalias nonnull dereferenceable(4) ptr @test_inalloca(ptr noalias nofree noundef nonnull writeonly inalloca(i32) dereferenceable(4) [[ARG]]) #[[ATTR13]] ; CGSCC-NEXT: [[CALL:%.*]] = call noalias nonnull dereferenceable(4) ptr @test_inalloca(ptr noalias nofree noundef nonnull writeonly inalloca(i32) dereferenceable(4) [[ARG]]) #[[ATTR13]]
; CGSCC-NEXT: ret ptr [[CALL]] ; CGSCC-NEXT: ret ptr [[CALL]]
; ;
%call = call ptr @test_inalloca(ptr inalloca(i32) %arg) %call = call ptr @test_inalloca(ptr inalloca(i32) %arg)
ret ptr %call ret ptr %call
} }
define internal ptr @test_preallocated(ptr preallocated(i32) %a) { define internal ptr @test_preallocated(ptr preallocated(i32) %a) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@test_preallocated ; CHECK-LABEL: define {{[^@]+}}@test_preallocated
; CHECK-SAME: (ptr noalias nofree noundef nonnull returned writeonly preallocated(i32) align 4294967296 dereferenceable(4) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (ptr noalias nofree noundef nonnull returned writeonly preallocated(i32) align 4294967296 dereferenceable(4) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: ret ptr [[A]] ; CHECK-NEXT: ret ptr [[A]]
; ;
ret ptr %a ret ptr %a
} }
define ptr @complicated_args_preallocated() { define ptr @complicated_args_preallocated() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@complicated_args_preallocated ; TUNIT-LABEL: define {{[^@]+}}@complicated_args_preallocated
; TUNIT-SAME: () #[[ATTR2:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR2:[0-9]+]] {
; TUNIT-NEXT: [[C:%.*]] = call token @llvm.call.preallocated.setup(i32 noundef 1) #[[ATTR10:[0-9]+]] ; TUNIT-NEXT: [[C:%.*]] = call token @llvm.call.preallocated.setup(i32 noundef 1) #[[ATTR10:[0-9]+]]
; TUNIT-NEXT: [[CALL:%.*]] = call noundef nonnull align 4294967296 dereferenceable(4) ptr @test_preallocated(ptr noalias nocapture nofree noundef writeonly preallocated(i32) align 4294967296 null) #[[ATTR9]] [ "preallocated"(token [[C]]) ] ; TUNIT-NEXT: [[CALL:%.*]] = call noundef nonnull align 4294967296 dereferenceable(4) ptr @test_preallocated(ptr noalias nocapture nofree noundef writeonly preallocated(i32) align 4294967296 null) #[[ATTR9]] [ "preallocated"(token [[C]]) ]
; TUNIT-NEXT: ret ptr [[CALL]] ; TUNIT-NEXT: ret ptr [[CALL]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@complicated_args_preallocated ; CGSCC-LABEL: define {{[^@]+}}@complicated_args_preallocated
; CGSCC-SAME: () #[[ATTR3:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR3:[0-9]+]] {
; CGSCC-NEXT: [[C:%.*]] = call token @llvm.call.preallocated.setup(i32 noundef 1) #[[ATTR13]] ; CGSCC-NEXT: [[C:%.*]] = call token @llvm.call.preallocated.setup(i32 noundef 1) #[[ATTR13]]
; CGSCC-NEXT: [[CALL:%.*]] = call ptr @test_preallocated(ptr noalias nocapture nofree noundef writeonly preallocated(i32) align 4294967296 null) #[[ATTR14:[0-9]+]] [ "preallocated"(token [[C]]) ] ; CGSCC-NEXT: [[CALL:%.*]] = call ptr @test_preallocated(ptr noalias nocapture nofree noundef writeonly preallocated(i32) align 4294967296 null) #[[ATTR14:[0-9]+]] [ "preallocated"(token [[C]]) ]
; CGSCC-NEXT: ret ptr null ; CGSCC-NEXT: ret ptr null
; ;
%c = call token @llvm.call.preallocated.setup(i32 1) %c = call token @llvm.call.preallocated.setup(i32 1)
%call = call ptr @test_preallocated(ptr preallocated(i32) null) ["preallocated"(token %c)] %call = call ptr @test_preallocated(ptr preallocated(i32) null) ["preallocated"(token %c)]
ret ptr %call ret ptr %call
} }
define internal void @test_sret(ptr sret(%struct.X) %a, ptr %b) { define internal void @test_sret(ptr sret(%struct.X) %a, ptr %b) {
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@test_sret ; TUNIT-LABEL: define {{[^@]+}}@test_sret
; TUNIT-SAME: (ptr noalias nofree noundef nonnull writeonly sret([[STRUCT_X:%.*]]) align 4294967296 dereferenceable(8) [[A:%.*]], ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[B:%.*]]) #[[ATTR3:[0-9]+]] { ; TUNIT-SAME: (ptr noalias nofree noundef nonnull writeonly sret([[STRUCT_X:%.*]]) align 4294967296 dereferenceable(8) [[A:%.*]], ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[B:%.*]]) #[[ATTR3:[0-9]+]] {
; TUNIT-NEXT: store ptr [[A]], ptr [[B]], align 8 ; TUNIT-NEXT: store ptr [[A]], ptr [[B]], align 8
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@test_sret ; CGSCC-LABEL: define {{[^@]+}}@test_sret
; CGSCC-SAME: (ptr noalias nofree noundef nonnull writeonly sret([[STRUCT_X:%.*]]) align 4294967296 dereferenceable(8) [[A:%.*]], ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[B:%.*]]) #[[ATTR4:[0-9]+]] { ; CGSCC-SAME: (ptr noalias nofree noundef nonnull writeonly sret([[STRUCT_X:%.*]]) align 4294967296 dereferenceable(8) [[A:%.*]], ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[B:%.*]]) #[[ATTR4:[0-9]+]] {
; CGSCC-NEXT: store ptr [[A]], ptr [[B]], align 8 ; CGSCC-NEXT: store ptr [[A]], ptr [[B]], align 8
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
store ptr %a, ptr %b store ptr %a, ptr %b
ret void ret void
} }
; FIXME: Alignment and dereferenceability are not propagated to the argument ; FIXME: Alignment and dereferenceability are not propagated to the argument
define void @complicated_args_sret(ptr %b) { define void @complicated_args_sret(ptr %b) {
; ;
; ;
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@complicated_args_sret ; TUNIT-LABEL: define {{[^@]+}}@complicated_args_sret
; TUNIT-SAME: (ptr nocapture nofree writeonly [[B:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (ptr nocapture nofree writeonly [[B:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: call void @test_sret(ptr noalias nocapture nofree noundef writeonly sret([[STRUCT_X:%.*]]) align 4294967296 null, ptr nocapture nofree writeonly align 8 [[B]]) #[[ATTR9]] ; TUNIT-NEXT: call void @test_sret(ptr noalias nocapture nofree noundef writeonly sret([[STRUCT_X:%.*]]) align 4294967296 null, ptr nocapture nofree writeonly align 8 [[B]]) #[[ATTR9]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@complicated_args_sret ; CGSCC-LABEL: define {{[^@]+}}@complicated_args_sret
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[B:%.*]]) #[[ATTR5:[0-9]+]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[B:%.*]]) #[[ATTR5:[0-9]+]] {
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
call void @test_sret(ptr sret(%struct.X) null, ptr %b) call void @test_sret(ptr sret(%struct.X) null, ptr %b)
ret void ret void
} }
define internal ptr @test_nest(ptr nest %a) { define internal ptr @test_nest(ptr nest %a) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test_nest ; CGSCC-LABEL: define {{[^@]+}}@test_nest
; CGSCC-SAME: (ptr nest noalias nocapture nofree readnone align 4294967296 [[A:%.*]]) #[[ATTR1]] { ; CGSCC-SAME: (ptr nest noalias nocapture nofree readnone align 4294967296 [[A:%.*]]) #[[ATTR1]] {
; CGSCC-NEXT: ret ptr null ; CGSCC-NEXT: ret ptr null
; ;
ret ptr %a ret ptr %a
} }
define ptr @complicated_args_nest() { define ptr @complicated_args_nest() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@complicated_args_nest ; TUNIT-LABEL: define {{[^@]+}}@complicated_args_nest
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret ptr null ; TUNIT-NEXT: ret ptr null
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@complicated_args_nest ; CGSCC-LABEL: define {{[^@]+}}@complicated_args_nest
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: [[CALL:%.*]] = call noalias noundef align 4294967296 ptr @test_nest(ptr noalias nocapture nofree noundef readnone align 4294967296 null) #[[ATTR13]] ; CGSCC-NEXT: [[CALL:%.*]] = call noalias noundef align 4294967296 ptr @test_nest(ptr noalias nocapture nofree noundef readnone align 4294967296 null) #[[ATTR13]]
; CGSCC-NEXT: ret ptr [[CALL]] ; CGSCC-NEXT: ret ptr [[CALL]]
; ;
%call = call ptr @test_nest(ptr null) %call = call ptr @test_nest(ptr null)
ret ptr %call ret ptr %call
} }
@S = external global %struct.X @S = external global %struct.X
define internal void @test_byval(ptr byval(%struct.X) %a) { define internal void @test_byval(ptr byval(%struct.X) %a) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@test_byval ; TUNIT-LABEL: define {{[^@]+}}@test_byval
; TUNIT-SAME: (ptr [[TMP0:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (ptr [[TMP0:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: [[A_PRIV:%.*]] = alloca [[STRUCT_X:%.*]], align 8 ; TUNIT-NEXT: [[A_PRIV:%.*]] = alloca [[STRUCT_X:%.*]], align 8
; TUNIT-NEXT: store ptr [[TMP0]], ptr [[A_PRIV]], align 8 ; TUNIT-NEXT: store ptr [[TMP0]], ptr [[A_PRIV]], align 8
; TUNIT-NEXT: store ptr null, ptr [[A_PRIV]], align 8 ; TUNIT-NEXT: store ptr null, ptr [[A_PRIV]], align 8
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@test_byval ; CGSCC-LABEL: define {{[^@]+}}@test_byval
; CGSCC-SAME: (ptr [[TMP0:%.*]]) #[[ATTR4]] { ; CGSCC-SAME: (ptr [[TMP0:%.*]]) #[[ATTR4]] {
; CGSCC-NEXT: [[A_PRIV:%.*]] = alloca [[STRUCT_X:%.*]], align 8 ; CGSCC-NEXT: [[A_PRIV:%.*]] = alloca [[STRUCT_X:%.*]], align 8
; CGSCC-NEXT: store ptr [[TMP0]], ptr [[A_PRIV]], align 8 ; CGSCC-NEXT: store ptr [[TMP0]], ptr [[A_PRIV]], align 8
; CGSCC-NEXT: store ptr null, ptr [[A_PRIV]], align 8 ; CGSCC-NEXT: store ptr null, ptr [[A_PRIV]], align 8
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
store ptr null, ptr %a store ptr null, ptr %a
ret void ret void
} }
define void @complicated_args_byval() { define void @complicated_args_byval() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@complicated_args_byval ; TUNIT-LABEL: define {{[^@]+}}@complicated_args_byval
; TUNIT-SAME: () #[[ATTR4:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR4:[0-9]+]] {
; TUNIT-NEXT: [[TMP1:%.*]] = load ptr, ptr @S, align 8 ; TUNIT-NEXT: [[TMP1:%.*]] = load ptr, ptr @S, align 8
; TUNIT-NEXT: call void @test_byval(ptr [[TMP1]]) #[[ATTR9]] ; TUNIT-NEXT: call void @test_byval(ptr [[TMP1]]) #[[ATTR9]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@complicated_args_byval ; CGSCC-LABEL: define {{[^@]+}}@complicated_args_byval
; CGSCC-SAME: () #[[ATTR3]] { ; CGSCC-SAME: () #[[ATTR3]] {
; CGSCC-NEXT: [[TMP1:%.*]] = load ptr, ptr @S, align 8 ; CGSCC-NEXT: [[TMP1:%.*]] = load ptr, ptr @S, align 8
; CGSCC-NEXT: call void @test_byval(ptr nofree writeonly [[TMP1]]) #[[ATTR14]] ; CGSCC-NEXT: call void @test_byval(ptr nofree writeonly [[TMP1]]) #[[ATTR14]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @test_byval(ptr byval(%struct.X) @S) call void @test_byval(ptr byval(%struct.X) @S)
ret void ret void
Show All 21 Lines
; CHECK-NEXT: [[C:%.*]] = call ptr @test_byval2(ptr [[TMP1]]) ; CHECK-NEXT: [[C:%.*]] = call ptr @test_byval2(ptr [[TMP1]])
; CHECK-NEXT: ret ptr [[C]] ; CHECK-NEXT: ret ptr [[C]]
; ;
%c = call ptr @test_byval2(ptr byval(%struct.X) @S) %c = call ptr @test_byval2(ptr byval(%struct.X) @S)
ret ptr %c ret ptr %c
} }
define void @fixpoint_changed(ptr %p) { define void @fixpoint_changed(ptr %p) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@fixpoint_changed ; TUNIT-LABEL: define {{[^@]+}}@fixpoint_changed
; TUNIT-SAME: (ptr nocapture nofree writeonly [[P:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (ptr nocapture nofree writeonly [[P:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: br label [[FOR_COND:%.*]] ; TUNIT-NEXT: br label [[FOR_COND:%.*]]
; TUNIT: for.cond: ; TUNIT: for.cond:
; TUNIT-NEXT: [[J_0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[SW_EPILOG:%.*]] ] ; TUNIT-NEXT: [[J_0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[SW_EPILOG:%.*]] ]
; TUNIT-NEXT: [[CMP:%.*]] = icmp slt i32 [[J_0]], 30 ; TUNIT-NEXT: [[CMP:%.*]] = icmp slt i32 [[J_0]], 30
; TUNIT-NEXT: br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]] ; TUNIT-NEXT: br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
; TUNIT: for.body: ; TUNIT: for.body:
; TUNIT-NEXT: switch i32 [[J_0]], label [[SW_EPILOG]] [ ; TUNIT-NEXT: switch i32 [[J_0]], label [[SW_EPILOG]] [
; TUNIT-NEXT: i32 1, label [[SW_BB:%.*]] ; TUNIT-NEXT: i32 1, label [[SW_BB:%.*]]
; TUNIT-NEXT: ] ; TUNIT-NEXT: ]
; TUNIT: sw.bb: ; TUNIT: sw.bb:
; TUNIT-NEXT: br label [[SW_EPILOG]] ; TUNIT-NEXT: br label [[SW_EPILOG]]
; TUNIT: sw.epilog: ; TUNIT: sw.epilog:
; TUNIT-NEXT: [[X_0:%.*]] = phi i32 [ 255, [[FOR_BODY]] ], [ 253, [[SW_BB]] ] ; TUNIT-NEXT: [[X_0:%.*]] = phi i32 [ 255, [[FOR_BODY]] ], [ 253, [[SW_BB]] ]
; TUNIT-NEXT: store i32 [[X_0]], ptr [[P]], align 4 ; TUNIT-NEXT: store i32 [[X_0]], ptr [[P]], align 4
; TUNIT-NEXT: [[INC]] = add nsw i32 [[J_0]], 1 ; TUNIT-NEXT: [[INC]] = add nsw i32 [[J_0]], 1
; TUNIT-NEXT: br label [[FOR_COND]] ; TUNIT-NEXT: br label [[FOR_COND]]
; TUNIT: for.end: ; TUNIT: for.end:
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@fixpoint_changed ; CGSCC-LABEL: define {{[^@]+}}@fixpoint_changed
; CGSCC-SAME: (ptr nocapture nofree writeonly [[P:%.*]]) #[[ATTR4]] { ; CGSCC-SAME: (ptr nocapture nofree writeonly [[P:%.*]]) #[[ATTR4]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: br label [[FOR_COND:%.*]] ; CGSCC-NEXT: br label [[FOR_COND:%.*]]
; CGSCC: for.cond: ; CGSCC: for.cond:
; CGSCC-NEXT: [[J_0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[SW_EPILOG:%.*]] ] ; CGSCC-NEXT: [[J_0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[SW_EPILOG:%.*]] ]
; CGSCC-NEXT: [[CMP:%.*]] = icmp slt i32 [[J_0]], 30 ; CGSCC-NEXT: [[CMP:%.*]] = icmp slt i32 [[J_0]], 30
; CGSCC-NEXT: br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]] ; CGSCC-NEXT: br i1 [[CMP]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
Show All 34 Linessw.epilog:
br label %for.cond br label %for.cond
for.end: for.end:
ret void ret void
} }
; Check we merge undef and a constant properly. ; Check we merge undef and a constant properly.
define i8 @caller0() { define i8 @caller0() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@caller0 ; TUNIT-LABEL: define {{[^@]+}}@caller0
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret i8 49 ; TUNIT-NEXT: ret i8 49
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@caller0 ; CGSCC-LABEL: define {{[^@]+}}@caller0
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: [[C:%.*]] = call noundef i8 @callee() #[[ATTR13]] ; CGSCC-NEXT: [[C:%.*]] = call noundef i8 @callee() #[[ATTR13]]
; CGSCC-NEXT: ret i8 [[C]] ; CGSCC-NEXT: ret i8 [[C]]
; ;
%c = call i8 @callee(i8 undef) %c = call i8 @callee(i8 undef)
ret i8 %c ret i8 %c
} }
define i8 @caller1() { define i8 @caller1() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@caller1 ; TUNIT-LABEL: define {{[^@]+}}@caller1
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret i8 49 ; TUNIT-NEXT: ret i8 49
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@caller1 ; CGSCC-LABEL: define {{[^@]+}}@caller1
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: [[C:%.*]] = call noundef i8 @callee() #[[ATTR13]] ; CGSCC-NEXT: [[C:%.*]] = call noundef i8 @callee() #[[ATTR13]]
; CGSCC-NEXT: ret i8 [[C]] ; CGSCC-NEXT: ret i8 [[C]]
; ;
%c = call i8 @callee(i8 undef) %c = call i8 @callee(i8 undef)
ret i8 %c ret i8 %c
} }
define i8 @caller2() { define i8 @caller2() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@caller2 ; TUNIT-LABEL: define {{[^@]+}}@caller2
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret i8 49 ; TUNIT-NEXT: ret i8 49
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@caller2 ; CGSCC-LABEL: define {{[^@]+}}@caller2
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: [[C:%.*]] = call noundef i8 @callee() #[[ATTR13]] ; CGSCC-NEXT: [[C:%.*]] = call noundef i8 @callee() #[[ATTR13]]
; CGSCC-NEXT: ret i8 [[C]] ; CGSCC-NEXT: ret i8 [[C]]
; ;
%c = call i8 @callee(i8 undef) %c = call i8 @callee(i8 undef)
ret i8 %c ret i8 %c
} }
define i8 @caller_middle() { define i8 @caller_middle() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@caller_middle ; TUNIT-LABEL: define {{[^@]+}}@caller_middle
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret i8 49 ; TUNIT-NEXT: ret i8 49
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@caller_middle ; CGSCC-LABEL: define {{[^@]+}}@caller_middle
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: [[C:%.*]] = call noundef i8 @callee() #[[ATTR13]] ; CGSCC-NEXT: [[C:%.*]] = call noundef i8 @callee() #[[ATTR13]]
; CGSCC-NEXT: ret i8 [[C]] ; CGSCC-NEXT: ret i8 [[C]]
; ;
%c = call i8 @callee(i8 42) %c = call i8 @callee(i8 42)
ret i8 %c ret i8 %c
} }
define i8 @caller3() { define i8 @caller3() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@caller3 ; TUNIT-LABEL: define {{[^@]+}}@caller3
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret i8 49 ; TUNIT-NEXT: ret i8 49
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@caller3 ; CGSCC-LABEL: define {{[^@]+}}@caller3
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: [[C:%.*]] = call noundef i8 @callee() #[[ATTR13]] ; CGSCC-NEXT: [[C:%.*]] = call noundef i8 @callee() #[[ATTR13]]
; CGSCC-NEXT: ret i8 [[C]] ; CGSCC-NEXT: ret i8 [[C]]
; ;
%c = call i8 @callee(i8 undef) %c = call i8 @callee(i8 undef)
ret i8 %c ret i8 %c
} }
define i8 @caller4() { define i8 @caller4() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@caller4 ; TUNIT-LABEL: define {{[^@]+}}@caller4
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret i8 49 ; TUNIT-NEXT: ret i8 49
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@caller4 ; CGSCC-LABEL: define {{[^@]+}}@caller4
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: [[C:%.*]] = call noundef i8 @callee() #[[ATTR13]] ; CGSCC-NEXT: [[C:%.*]] = call noundef i8 @callee() #[[ATTR13]]
; CGSCC-NEXT: ret i8 [[C]] ; CGSCC-NEXT: ret i8 [[C]]
; ;
%c = call i8 @callee(i8 undef) %c = call i8 @callee(i8 undef)
ret i8 %c ret i8 %c
} }
define internal i8 @callee(i8 %a) { define internal i8 @callee(i8 %a) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@callee ; CGSCC-LABEL: define {{[^@]+}}@callee
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: ret i8 49 ; CGSCC-NEXT: ret i8 49
; ;
%c = add i8 %a, 7 %c = add i8 %a, 7
ret i8 %c ret i8 %c
} }
define void @user_as3() { define void @user_as3() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@user_as3 ; TUNIT-LABEL: define {{[^@]+}}@user_as3
; TUNIT-SAME: () #[[ATTR4]] { ; TUNIT-SAME: () #[[ATTR4]] {
; TUNIT-NEXT: store i32 0, ptr addrspace(3) @ConstAS3Ptr, align 4 ; TUNIT-NEXT: store i32 0, ptr addrspace(3) @ConstAS3Ptr, align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@user_as3 ; CGSCC-LABEL: define {{[^@]+}}@user_as3
; CGSCC-SAME: () #[[ATTR6:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR6:[0-9]+]] {
; CGSCC-NEXT: [[CALL:%.*]] = call fastcc align 4 ptr addrspace(3) @const_ptr_return_as3() #[[ATTR13]] ; CGSCC-NEXT: [[CALL:%.*]] = call fastcc align 4 ptr addrspace(3) @const_ptr_return_as3() #[[ATTR13]]
; CGSCC-NEXT: store i32 0, ptr addrspace(3) [[CALL]], align 4 ; CGSCC-NEXT: store i32 0, ptr addrspace(3) [[CALL]], align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%call = call fastcc ptr addrspace(3) @const_ptr_return_as3() %call = call fastcc ptr addrspace(3) @const_ptr_return_as3()
store i32 0, ptr addrspace(3) %call store i32 0, ptr addrspace(3) %call
ret void ret void
} }
define void @user() { define void @user() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@user ; TUNIT-LABEL: define {{[^@]+}}@user
; TUNIT-SAME: () #[[ATTR4]] { ; TUNIT-SAME: () #[[ATTR4]] {
; TUNIT-NEXT: store i32 0, ptr addrspacecast (ptr addrspace(3) @ConstAS3Ptr to ptr), align 4 ; TUNIT-NEXT: store i32 0, ptr addrspacecast (ptr addrspace(3) @ConstAS3Ptr to ptr), align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@user ; CGSCC-LABEL: define {{[^@]+}}@user
; CGSCC-SAME: () #[[ATTR6]] { ; CGSCC-SAME: () #[[ATTR6]] {
; CGSCC-NEXT: [[CALL:%.*]] = call fastcc align 4 ptr @const_ptr_return() #[[ATTR13]] ; CGSCC-NEXT: [[CALL:%.*]] = call fastcc align 4 ptr @const_ptr_return() #[[ATTR13]]
; CGSCC-NEXT: store i32 0, ptr [[CALL]], align 4 ; CGSCC-NEXT: store i32 0, ptr [[CALL]], align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
%call = call fastcc ptr @const_ptr_return() %call = call fastcc ptr @const_ptr_return()
store i32 0, ptr %call store i32 0, ptr %call
ret void ret void
} }
define i1 @test_merge_with_undef_values_ptr(i1 %c) { define i1 @test_merge_with_undef_values_ptr(i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@test_merge_with_undef_values_ptr ; TUNIT-LABEL: define {{[^@]+}}@test_merge_with_undef_values_ptr
; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: ret i1 false ; TUNIT-NEXT: ret i1 false
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test_merge_with_undef_values_ptr ; CGSCC-LABEL: define {{[^@]+}}@test_merge_with_undef_values_ptr
; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[R1:%.*]] = call noundef i1 @undef_then_null(i1 [[C]]) #[[ATTR13]] ; CGSCC-NEXT: [[R1:%.*]] = call noundef i1 @undef_then_null(i1 [[C]]) #[[ATTR13]]
; CGSCC-NEXT: ret i1 [[R1]] ; CGSCC-NEXT: ret i1 [[R1]]
; ;
%r1 = call i1 @undef_then_null(i1 %c, ptr undef, ptr undef) %r1 = call i1 @undef_then_null(i1 %c, ptr undef, ptr undef)
ret i1 %r1 ret i1 %r1
} }
define internal i1 @undef_then_null(i1 %c, ptr %i32Aptr, ptr %i32Bptr) { define internal i1 @undef_then_null(i1 %c, ptr %i32Aptr, ptr %i32Bptr) {
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@undef_then_null ; CGSCC-LABEL: define {{[^@]+}}@undef_then_null
; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: br i1 [[C]], label [[A:%.*]], label [[B:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[A:%.*]], label [[B:%.*]]
; CGSCC: a: ; CGSCC: a:
; CGSCC-NEXT: ret i1 false ; CGSCC-NEXT: ret i1 false
; CGSCC: b: ; CGSCC: b:
; CGSCC-NEXT: ret i1 false ; CGSCC-NEXT: ret i1 false
; ;
%cmp1 = icmp eq ptr %i32Aptr, %i32Bptr %cmp1 = icmp eq ptr %i32Aptr, %i32Bptr
%cmp2 = icmp eq i1 %cmp1, false %cmp2 = icmp eq i1 %cmp1, false
%or = or i1 %cmp2, %c %or = or i1 %cmp2, %c
br i1 %or, label %a, label %b br i1 %or, label %a, label %b
a: a:
%r2 = call i1 @undef_then_null(i1 false, ptr null, ptr null) %r2 = call i1 @undef_then_null(i1 false, ptr null, ptr null)
ret i1 %r2 ret i1 %r2
b: b:
ret i1 %cmp2 ret i1 %cmp2
} }
define i1 @test_merge_with_undef_values(i1 %c) { define i1 @test_merge_with_undef_values(i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@test_merge_with_undef_values ; TUNIT-LABEL: define {{[^@]+}}@test_merge_with_undef_values
; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: ret i1 false ; TUNIT-NEXT: ret i1 false
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test_merge_with_undef_values ; CGSCC-LABEL: define {{[^@]+}}@test_merge_with_undef_values
; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[R1:%.*]] = call noundef i1 @undef_then_1(i1 [[C]]) #[[ATTR13]] ; CGSCC-NEXT: [[R1:%.*]] = call noundef i1 @undef_then_1(i1 [[C]]) #[[ATTR13]]
; CGSCC-NEXT: ret i1 [[R1]] ; CGSCC-NEXT: ret i1 [[R1]]
; ;
%r1 = call i1 @undef_then_1(i1 %c, i32 undef, i32 undef) %r1 = call i1 @undef_then_1(i1 %c, i32 undef, i32 undef)
ret i1 %r1 ret i1 %r1
} }
define internal i1 @undef_then_1(i1 %c, i32 %i32A, i32 %i32B) { define internal i1 @undef_then_1(i1 %c, i32 %i32A, i32 %i32B) {
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@undef_then_1 ; CGSCC-LABEL: define {{[^@]+}}@undef_then_1
; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: br i1 [[C]], label [[A:%.*]], label [[B:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[A:%.*]], label [[B:%.*]]
; CGSCC: a: ; CGSCC: a:
; CGSCC-NEXT: ret i1 false ; CGSCC-NEXT: ret i1 false
; CGSCC: b: ; CGSCC: b:
; CGSCC-NEXT: ret i1 false ; CGSCC-NEXT: ret i1 false
; ;
%cmp1 = icmp eq i32 %i32A, %i32B %cmp1 = icmp eq i32 %i32A, %i32B
%cmp2 = icmp eq i1 %cmp1, false %cmp2 = icmp eq i1 %cmp1, false
%or = or i1 %cmp2, %c %or = or i1 %cmp2, %c
br i1 %or, label %a, label %b br i1 %or, label %a, label %b
a: a:
%r2 = call i1 @undef_then_1(i1 false, i32 1, i32 1) %r2 = call i1 @undef_then_1(i1 false, i32 1, i32 1)
ret i1 %r2 ret i1 %r2
b: b:
ret i1 %cmp2 ret i1 %cmp2
} }
define i32 @test_select(i32 %c) { define i32 @test_select(i32 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@test_select ; TUNIT-LABEL: define {{[^@]+}}@test_select
; TUNIT-SAME: (i32 [[C:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i32 [[C:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: ret i32 42 ; TUNIT-NEXT: ret i32 42
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test_select ; CGSCC-LABEL: define {{[^@]+}}@test_select
; CGSCC-SAME: (i32 [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i32 [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: [[CALL:%.*]] = call noundef i32 @select() #[[ATTR13]] ; CGSCC-NEXT: [[CALL:%.*]] = call noundef i32 @select() #[[ATTR13]]
; CGSCC-NEXT: ret i32 [[CALL]] ; CGSCC-NEXT: ret i32 [[CALL]]
; ;
%call = call i32 @select(i1 1, i32 42, i32 %c) %call = call i32 @select(i1 1, i32 42, i32 %c)
ret i32 %call ret i32 %call
} }
define internal i32 @select(i1 %a, i32 %b, i32 %c) { define internal i32 @select(i1 %a, i32 %b, i32 %c) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@select ; CGSCC-LABEL: define {{[^@]+}}@select
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: ret i32 42 ; CGSCC-NEXT: ret i32 42
; ;
%s = select i1 %a, i32 %b, i32 %c %s = select i1 %a, i32 %b, i32 %c
ret i32 %s ret i32 %s
} }
define i1 @icmp() { define i1 @icmp() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@icmp ; CHECK-LABEL: define {{[^@]+}}@icmp
; CHECK-SAME: () #[[ATTR1]] { ; CHECK-SAME: () #[[ATTR1]] {
; CHECK-NEXT: ret i1 true ; CHECK-NEXT: ret i1 true
; ;
%c = icmp eq ptr null, null %c = icmp eq ptr null, null
ret i1 %c ret i1 %c
} }
Show All 35 Lines
} }
; Taken from 50683 ; Taken from 50683
; {{{ ; {{{
@g = internal constant { [2 x ptr] } { [2 x ptr] [ptr @f1, ptr @f2] } @g = internal constant { [2 x ptr] } { [2 x ptr] [ptr @f1, ptr @f2] }
define internal void @f1(ptr %a) { define internal void @f1(ptr %a) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; TUNIT-LABEL: define {{[^@]+}}@f1 ; TUNIT-LABEL: define {{[^@]+}}@f1
; TUNIT-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[A:%.*]]) #[[ATTR3]] { ; TUNIT-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[A:%.*]]) #[[ATTR3]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: store ptr @g, ptr [[A]], align 8 ; TUNIT-NEXT: store ptr @g, ptr [[A]], align 8
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
; CGSCC-LABEL: define {{[^@]+}}@f1 ; CGSCC-LABEL: define {{[^@]+}}@f1
; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[A:%.*]]) #[[ATTR4]] { ; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[A:%.*]]) #[[ATTR4]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: store ptr @g, ptr [[A]], align 8 ; CGSCC-NEXT: store ptr @g, ptr [[A]], align 8
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
entry: entry:
store ptr @g , ptr %a, align 8 store ptr @g , ptr %a, align 8
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
entry: entry:
ret i1 false ret i1 false
} }
; }}} ; }}}
define i1 @test_cmp_null_after_cast() { define i1 @test_cmp_null_after_cast() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@test_cmp_null_after_cast ; TUNIT-LABEL: define {{[^@]+}}@test_cmp_null_after_cast
; TUNIT-SAME: () #[[ATTR1]] { ; TUNIT-SAME: () #[[ATTR1]] {
; TUNIT-NEXT: ret i1 true ; TUNIT-NEXT: ret i1 true
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test_cmp_null_after_cast ; CGSCC-LABEL: define {{[^@]+}}@test_cmp_null_after_cast
; CGSCC-SAME: () #[[ATTR2]] { ; CGSCC-SAME: () #[[ATTR2]] {
; CGSCC-NEXT: [[C:%.*]] = call noundef i1 @cmp_null_after_cast() #[[ATTR13]] ; CGSCC-NEXT: [[C:%.*]] = call noundef i1 @cmp_null_after_cast() #[[ATTR13]]
; CGSCC-NEXT: ret i1 [[C]] ; CGSCC-NEXT: ret i1 [[C]]
; ;
%c = call i1 @cmp_null_after_cast(i32 0, i8 0) %c = call i1 @cmp_null_after_cast(i32 0, i8 0)
ret i1 %c ret i1 %c
} }
define internal i1 @cmp_null_after_cast(i32 %a, i8 %b) { define internal i1 @cmp_null_after_cast(i32 %a, i8 %b) {
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@cmp_null_after_cast ; CGSCC-LABEL: define {{[^@]+}}@cmp_null_after_cast
; CGSCC-SAME: () #[[ATTR1]] { ; CGSCC-SAME: () #[[ATTR1]] {
; CGSCC-NEXT: ret i1 true ; CGSCC-NEXT: ret i1 true
; ;
%t = trunc i32 %a to i8 %t = trunc i32 %a to i8
%c = icmp eq i8 %t, %b %c = icmp eq i8 %t, %b
ret i1 %c ret i1 %c
} }
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Linesjoin:
%phi = phi i32 [ %i, %then ], [ undef, %entry ] %phi = phi i32 [ %i, %then ], [ undef, %entry ]
%ret = lshr i32 %phi, 1 %ret = lshr i32 %phi, 1
ret i32 %ret ret i32 %ret
uselistorder label %join, { 1, 0 } uselistorder label %join, { 1, 0 }
} }
define i1 @test_liveness(i1 %c) { define i1 @test_liveness(i1 %c) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; TUNIT-LABEL: define {{[^@]+}}@test_liveness ; TUNIT-LABEL: define {{[^@]+}}@test_liveness
; TUNIT-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] { ; TUNIT-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; TUNIT-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; TUNIT: t: ; TUNIT: t:
; TUNIT-NEXT: br label [[F]] ; TUNIT-NEXT: br label [[F]]
; TUNIT: f: ; TUNIT: f:
; TUNIT-NEXT: [[P:%.*]] = phi i1 [ true, [[ENTRY:%.*]] ], [ false, [[T]] ] ; TUNIT-NEXT: [[P:%.*]] = phi i1 [ true, [[ENTRY:%.*]] ], [ false, [[T]] ]
; TUNIT-NEXT: [[RC1:%.*]] = call i1 @ret(i1 noundef [[P]]) #[[ATTR9]] ; TUNIT-NEXT: [[RC1:%.*]] = call i1 @ret(i1 noundef [[P]]) #[[ATTR9]]
; TUNIT-NEXT: ret i1 [[RC1]] ; TUNIT-NEXT: ret i1 [[RC1]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none) ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
; CGSCC-LABEL: define {{[^@]+}}@test_liveness ; CGSCC-LABEL: define {{[^@]+}}@test_liveness
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR2]] {
; CGSCC-NEXT: entry: ; CGSCC-NEXT: entry:
; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; CGSCC: t: ; CGSCC: t:
; CGSCC-NEXT: br label [[F]] ; CGSCC-NEXT: br label [[F]]
; CGSCC: f: ; CGSCC: f:
; CGSCC-NEXT: [[P:%.*]] = phi i1 [ true, [[ENTRY:%.*]] ], [ false, [[T]] ] ; CGSCC-NEXT: [[P:%.*]] = phi i1 [ true, [[ENTRY:%.*]] ], [ false, [[T]] ]
; CGSCC-NEXT: [[RC1:%.*]] = call noundef i1 @ret(i1 noundef [[P]]) #[[ATTR13]] ; CGSCC-NEXT: [[RC1:%.*]] = call noundef i1 @ret(i1 noundef [[P]]) #[[ATTR13]]
; CGSCC-NEXT: ret i1 [[RC1]] ; CGSCC-NEXT: ret i1 [[RC1]]
; ;
entry: entry:
br i1 %c, label %t, label %f br i1 %c, label %t, label %f
t: t:
br label %f br label %f
f: f:
%p = phi i1 [true, %entry], [false, %t] %p = phi i1 [true, %entry], [false, %t]
%rc1 = call i1 @ret(i1 %p) %rc1 = call i1 @ret(i1 %p)
ret i1 %rc1 ret i1 %rc1
} }
define internal i1 @ret(i1 %c) { define internal i1 @ret(i1 %c) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@ret ; CHECK-LABEL: define {{[^@]+}}@ret
; CHECK-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (i1 noundef [[C:%.*]]) #[[ATTR1]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]] ; CHECK-NEXT: br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
; CHECK: t: ; CHECK: t:
; CHECK-NEXT: br label [[F]] ; CHECK-NEXT: br label [[F]]
; CHECK: f: ; CHECK: f:
; CHECK-NEXT: [[P:%.*]] = phi i1 [ [[C]], [[ENTRY:%.*]] ], [ false, [[T]] ] ; CHECK-NEXT: [[P:%.*]] = phi i1 [ [[C]], [[ENTRY:%.*]] ], [ false, [[T]] ]
Show All 25 Lines
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%r = call i8 @dead_ret() %r = call i8 @dead_ret()
ret void ret void
} }
declare void @llvm.memcpy(ptr %dest, ptr %src, i32 %len, i1 %isvolatile) declare void @llvm.memcpy(ptr %dest, ptr %src, i32 %len, i1 %isvolatile)
define internal i8 @memcpy_uses_store(i8 %arg) { define internal i8 @memcpy_uses_store(i8 %arg) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@memcpy_uses_store ; TUNIT-LABEL: define {{[^@]+}}@memcpy_uses_store
; TUNIT-SAME: (i8 [[ARG:%.*]]) #[[ATTR2]] { ; TUNIT-SAME: (i8 [[ARG:%.*]]) #[[ATTR2]] {
; TUNIT-NEXT: [[SRC:%.*]] = alloca i8, align 1 ; TUNIT-NEXT: [[SRC:%.*]] = alloca i8, align 1
; TUNIT-NEXT: [[DST:%.*]] = alloca i8, align 1 ; TUNIT-NEXT: [[DST:%.*]] = alloca i8, align 1
; TUNIT-NEXT: store i8 [[ARG]], ptr [[SRC]], align 1 ; TUNIT-NEXT: store i8 [[ARG]], ptr [[SRC]], align 1
; TUNIT-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr noalias nocapture nofree noundef nonnull writeonly dereferenceable(1) [[DST]], ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[SRC]], i32 noundef 1, i1 noundef false) #[[ATTR11:[0-9]+]] ; TUNIT-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr noalias nocapture nofree noundef nonnull writeonly dereferenceable(1) [[DST]], ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[SRC]], i32 noundef 1, i1 noundef false) #[[ATTR11:[0-9]+]]
; TUNIT-NEXT: [[L:%.*]] = load i8, ptr [[DST]], align 1 ; TUNIT-NEXT: [[L:%.*]] = load i8, ptr [[DST]], align 1
; TUNIT-NEXT: ret i8 [[L]] ; TUNIT-NEXT: ret i8 [[L]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@memcpy_uses_store ; CGSCC-LABEL: define {{[^@]+}}@memcpy_uses_store
; CGSCC-SAME: (i8 [[ARG:%.*]]) #[[ATTR7:[0-9]+]] { ; CGSCC-SAME: (i8 [[ARG:%.*]]) #[[ATTR7:[0-9]+]] {
; CGSCC-NEXT: [[SRC:%.*]] = alloca i8, align 1 ; CGSCC-NEXT: [[SRC:%.*]] = alloca i8, align 1
; CGSCC-NEXT: [[DST:%.*]] = alloca i8, align 1 ; CGSCC-NEXT: [[DST:%.*]] = alloca i8, align 1
; CGSCC-NEXT: store i8 [[ARG]], ptr [[SRC]], align 1 ; CGSCC-NEXT: store i8 [[ARG]], ptr [[SRC]], align 1
; CGSCC-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr noalias nocapture nofree noundef nonnull writeonly dereferenceable(1) [[DST]], ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[SRC]], i32 noundef 1, i1 noundef false) #[[ATTR15:[0-9]+]] ; CGSCC-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr noalias nocapture nofree noundef nonnull writeonly dereferenceable(1) [[DST]], ptr noalias nocapture nofree noundef nonnull readonly dereferenceable(1) [[SRC]], i32 noundef 1, i1 noundef false) #[[ATTR15:[0-9]+]]
; CGSCC-NEXT: [[L:%.*]] = load i8, ptr [[DST]], align 1 ; CGSCC-NEXT: [[L:%.*]] = load i8, ptr [[DST]], align 1
; CGSCC-NEXT: ret i8 [[L]] ; CGSCC-NEXT: ret i8 [[L]]
; ;
%src = alloca i8 %src = alloca i8
%dst = alloca i8 %dst = alloca i8
store i8 %arg, ptr %src store i8 %arg, ptr %src
call void @llvm.memcpy(ptr %dst, ptr %src, i32 1, i1 false) call void @llvm.memcpy(ptr %dst, ptr %src, i32 1, i1 false)
%l = load i8, ptr %dst %l = load i8, ptr %dst
ret i8 %l ret i8 %l
} }
define i8 @memcpy_uses_store_caller(i8 %arg) { define i8 @memcpy_uses_store_caller(i8 %arg) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@memcpy_uses_store_caller ; TUNIT-LABEL: define {{[^@]+}}@memcpy_uses_store_caller
; TUNIT-SAME: (i8 [[ARG:%.*]]) #[[ATTR2]] { ; TUNIT-SAME: (i8 [[ARG:%.*]]) #[[ATTR2]] {
; TUNIT-NEXT: [[R:%.*]] = call i8 @memcpy_uses_store(i8 [[ARG]]) #[[ATTR9]] ; TUNIT-NEXT: [[R:%.*]] = call i8 @memcpy_uses_store(i8 [[ARG]]) #[[ATTR9]]
; TUNIT-NEXT: ret i8 [[R]] ; TUNIT-NEXT: ret i8 [[R]]
; ;
; CGSCC: Function Attrs: nofree nosync nounwind willreturn ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@memcpy_uses_store_caller ; CGSCC-LABEL: define {{[^@]+}}@memcpy_uses_store_caller
; CGSCC-SAME: (i8 [[ARG:%.*]]) #[[ATTR3]] { ; CGSCC-SAME: (i8 [[ARG:%.*]]) #[[ATTR3]] {
; CGSCC-NEXT: [[R:%.*]] = call i8 @memcpy_uses_store(i8 [[ARG]]) #[[ATTR14]] ; CGSCC-NEXT: [[R:%.*]] = call i8 @memcpy_uses_store(i8 [[ARG]]) #[[ATTR14]]
; CGSCC-NEXT: ret i8 [[R]] ; CGSCC-NEXT: ret i8 [[R]]
; ;
%r = call i8 @memcpy_uses_store(i8 %arg) %r = call i8 @memcpy_uses_store(i8 %arg)
ret i8 %r ret i8 %r
} }
Show All 27 Lines;
%spec_result = call i32 @speculatable() %spec_result = call i32 @speculatable()
%plus1 = add i32 %spec_result, 1 %plus1 = add i32 %spec_result, 1
store i32 %plus1, ptr %stack store i32 %plus1, ptr %stack
%rspec = call i32 @ret_speculatable_expr(ptr %stack, i32 13) %rspec = call i32 @ret_speculatable_expr(ptr %stack, i32 13)
ret i32 %rspec ret i32 %rspec
} }
define internal i32 @ret_speculatable_expr(ptr %mem, i32 %a2) { define internal i32 @ret_speculatable_expr(ptr %mem, i32 %a2) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; TUNIT-LABEL: define {{[^@]+}}@ret_speculatable_expr ; TUNIT-LABEL: define {{[^@]+}}@ret_speculatable_expr
; TUNIT-SAME: (i32 [[TMP0:%.*]]) #[[ATTR7:[0-9]+]] { ; TUNIT-SAME: (i32 [[TMP0:%.*]]) #[[ATTR7:[0-9]+]] {
; TUNIT-NEXT: [[MEM_PRIV:%.*]] = alloca i32, align 4 ; TUNIT-NEXT: [[MEM_PRIV:%.*]] = alloca i32, align 4
; TUNIT-NEXT: store i32 [[TMP0]], ptr [[MEM_PRIV]], align 4 ; TUNIT-NEXT: store i32 [[TMP0]], ptr [[MEM_PRIV]], align 4
; TUNIT-NEXT: [[L:%.*]] = load i32, ptr [[MEM_PRIV]], align 4 ; TUNIT-NEXT: [[L:%.*]] = load i32, ptr [[MEM_PRIV]], align 4
; TUNIT-NEXT: [[MUL:%.*]] = mul i32 [[L]], 13 ; TUNIT-NEXT: [[MUL:%.*]] = mul i32 [[L]], 13
; TUNIT-NEXT: [[ADD:%.*]] = add i32 [[MUL]], 7 ; TUNIT-NEXT: [[ADD:%.*]] = add i32 [[MUL]], 7
; TUNIT-NEXT: ret i32 [[ADD]] ; TUNIT-NEXT: ret i32 [[ADD]]
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(argmem: read) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)
; CGSCC-LABEL: define {{[^@]+}}@ret_speculatable_expr ; CGSCC-LABEL: define {{[^@]+}}@ret_speculatable_expr
; CGSCC-SAME: (i32 [[TMP0:%.*]]) #[[ATTR10:[0-9]+]] { ; CGSCC-SAME: (i32 [[TMP0:%.*]]) #[[ATTR10:[0-9]+]] {
; CGSCC-NEXT: [[MEM_PRIV:%.*]] = alloca i32, align 4 ; CGSCC-NEXT: [[MEM_PRIV:%.*]] = alloca i32, align 4
; CGSCC-NEXT: store i32 [[TMP0]], ptr [[MEM_PRIV]], align 4 ; CGSCC-NEXT: store i32 [[TMP0]], ptr [[MEM_PRIV]], align 4
; CGSCC-NEXT: [[L:%.*]] = load i32, ptr [[MEM_PRIV]], align 4 ; CGSCC-NEXT: [[L:%.*]] = load i32, ptr [[MEM_PRIV]], align 4
; CGSCC-NEXT: [[MUL:%.*]] = mul i32 [[L]], 13 ; CGSCC-NEXT: [[MUL:%.*]] = mul i32 [[L]], 13
; CGSCC-NEXT: [[ADD:%.*]] = add i32 [[MUL]], 7 ; CGSCC-NEXT: [[ADD:%.*]] = add i32 [[MUL]], 7
; CGSCC-NEXT: ret i32 [[ADD]] ; CGSCC-NEXT: ret i32 [[ADD]]
; ;
%l = load i32, ptr %mem %l = load i32, ptr %mem
%mul = mul i32 %l, %a2 %mul = mul i32 %l, %a2
%add = add i32 %mul, 7 %add = add i32 %mul, 7
ret i32 %add ret i32 %add
} }
define internal void @not_called1() { define internal void @not_called1() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@not_called1 ; CHECK-LABEL: define {{[^@]+}}@not_called1
; CHECK-SAME: () #[[ATTR1]] { ; CHECK-SAME: () #[[ATTR1]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
ret void ret void
} }
define internal void @not_called2() { define internal void @not_called2() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@not_called2 ; CHECK-LABEL: define {{[^@]+}}@not_called2
; CHECK-SAME: () #[[ATTR1]] { ; CHECK-SAME: () #[[ATTR1]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
ret void ret void
} }
define internal void @not_called3() { define internal void @not_called3() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@not_called3 ; CHECK-LABEL: define {{[^@]+}}@not_called3
; CHECK-SAME: () #[[ATTR1]] { ; CHECK-SAME: () #[[ATTR1]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
ret void ret void
} }
declare void @useFnDecl(ptr addrspace(42)); declare void @useFnDecl(ptr addrspace(42));
define void @useFnDef(ptr addrspace(42) %arg) { define void @useFnDef(ptr addrspace(42) %arg) {
Show All 15 Lines;
call void @useFnDecl(ptr addrspace(42) addrspacecast (ptr @not_called1 to ptr addrspace(42))) call void @useFnDecl(ptr addrspace(42) addrspacecast (ptr @not_called1 to ptr addrspace(42)))
call void @useFnDef(ptr addrspace(42) addrspacecast (ptr @not_called2 to ptr addrspace(42))) call void @useFnDef(ptr addrspace(42) addrspacecast (ptr @not_called2 to ptr addrspace(42)))
%cmp = icmp eq ptr addrspace(42) addrspacecast (ptr @not_called3 to ptr addrspace(42)), null %cmp = icmp eq ptr addrspace(42) addrspacecast (ptr @not_called3 to ptr addrspace(42)), null
ret i1 %cmp ret i1 %cmp
} }
@x = external global i32 @x = external global i32
define internal void @indirect() { define internal void @indirect() {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; TUNIT-LABEL: define {{[^@]+}}@indirect ; TUNIT-LABEL: define {{[^@]+}}@indirect
; TUNIT-SAME: () #[[ATTR4]] { ; TUNIT-SAME: () #[[ATTR4]] {
; TUNIT-NEXT: store i32 0, ptr @x, align 4 ; TUNIT-NEXT: store i32 0, ptr @x, align 4
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write) ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(write)
; CGSCC-LABEL: define {{[^@]+}}@indirect ; CGSCC-LABEL: define {{[^@]+}}@indirect
; CGSCC-SAME: () #[[ATTR11:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR11:[0-9]+]] {
; CGSCC-NEXT: store i32 0, ptr @x, align 4 ; CGSCC-NEXT: store i32 0, ptr @x, align 4
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
store i32 0, i32* @x store i32 0, i32* @x
ret void ret void
} }
Show All 18 Lines
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
call void @broker(void ()* @indirect) call void @broker(void ()* @indirect)
ret void ret void
} }
define i1 @constexpr_icmp1() { define i1 @constexpr_icmp1() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@constexpr_icmp1 ; CHECK-LABEL: define {{[^@]+}}@constexpr_icmp1
; CHECK-SAME: () #[[ATTR1]] { ; CHECK-SAME: () #[[ATTR1]] {
; CHECK-NEXT: ret i1 true ; CHECK-NEXT: ret i1 true
; ;
ret i1 icmp ne (ptr addrspacecast (ptr addrspace(4) @str to ptr), ptr null) ret i1 icmp ne (ptr addrspacecast (ptr addrspace(4) @str to ptr), ptr null)
} }
define i1 @constexpr_icmp2() { define i1 @constexpr_icmp2() {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@constexpr_icmp2 ; CHECK-LABEL: define {{[^@]+}}@constexpr_icmp2
; CHECK-SAME: () #[[ATTR1]] { ; CHECK-SAME: () #[[ATTR1]] {
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; ;
ret i1 icmp eq (ptr addrspacecast (ptr addrspace(4) @str to ptr), ptr null) ret i1 icmp eq (ptr addrspacecast (ptr addrspace(4) @str to ptr), ptr null)
} }
;. ;.
; TUNIT: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR3]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; TUNIT: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; TUNIT: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; TUNIT: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; TUNIT: attributes #[[ATTR5:[0-9]+]] = { speculatable memory(none) } ; TUNIT: attributes #[[ATTR5:[0-9]+]] = { speculatable memory(none) }
; TUNIT: attributes #[[ATTR6]] = { norecurse nosync memory(none) } ; TUNIT: attributes #[[ATTR6]] = { norecurse nosync memory(none) }
; TUNIT: attributes #[[ATTR7]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; TUNIT: attributes #[[ATTR7]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; TUNIT: attributes #[[ATTR8:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } ; TUNIT: attributes #[[ATTR8:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
; TUNIT: attributes #[[ATTR9]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR9]] = { nofree nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR10]] = { willreturn } ; TUNIT: attributes #[[ATTR10]] = { willreturn }
; TUNIT: attributes #[[ATTR11]] = { willreturn memory(readwrite) } ; TUNIT: attributes #[[ATTR11]] = { willreturn memory(readwrite) }
; TUNIT: attributes #[[ATTR12]] = { nosync nounwind } ; TUNIT: attributes #[[ATTR12]] = { nosync nounwind }
;. ;.
; CGSCC: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn } ; CGSCC: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn }
; CGSCC: attributes #[[ATTR1]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR3]] = { nofree nosync nounwind willreturn } ; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree nosync nounwind willreturn }
; CGSCC: attributes #[[ATTR4]] = { nofree norecurse nosync nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR4]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR5]] = { nofree nosync nounwind willreturn memory(argmem: write) } ; CGSCC: attributes #[[ATTR5]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: write) }
; CGSCC: attributes #[[ATTR6]] = { nofree nosync nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR6]] = { mustprogress nofree nosync nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR7]] = { nofree norecurse nosync nounwind willreturn } ; CGSCC: attributes #[[ATTR7]] = { mustprogress nofree norecurse nosync nounwind willreturn }
; CGSCC: attributes #[[ATTR8:[0-9]+]] = { speculatable memory(none) } ; CGSCC: attributes #[[ATTR8:[0-9]+]] = { speculatable memory(none) }
; CGSCC: attributes #[[ATTR9]] = { norecurse nosync memory(none) } ; CGSCC: attributes #[[ATTR9]] = { norecurse nosync memory(none) }
; CGSCC: attributes #[[ATTR10]] = { nofree norecurse nosync nounwind willreturn memory(argmem: read) } ; CGSCC: attributes #[[ATTR10]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read) }
; CGSCC: attributes #[[ATTR11]] = { nofree norecurse nosync nounwind willreturn memory(write) } ; CGSCC: attributes #[[ATTR11]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(write) }
; CGSCC: attributes #[[ATTR12:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } ; CGSCC: attributes #[[ATTR12:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
; CGSCC: attributes #[[ATTR13]] = { willreturn } ; CGSCC: attributes #[[ATTR13]] = { willreturn }
; CGSCC: attributes #[[ATTR14]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR14]] = { nounwind willreturn }
; CGSCC: attributes #[[ATTR15]] = { willreturn memory(readwrite) } ; CGSCC: attributes #[[ATTR15]] = { willreturn memory(readwrite) }
;. ;.

llvm/test/Transforms/Attributor/willreturn.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=7 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=7 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC ; RUN: opt -opaque-pointers=0 -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
target datalayout = "e-m:e-i54:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i54:64-f80:128-n8:16:32:64-S128"
; Test cases specifically designed for the "willreturn" function attribute. ; Test cases specifically designed for the "willreturn" function attribute.
; We use FIXME's to indicate problems and missing attributes. ; We use FIXME's to indicate problems and missing attributes.
; TEST 1 (positive case) ; TEST 1 (positive case)
define void @only_return() #0 { define void @only_return() #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@only_return ; CHECK-LABEL: define {{[^@]+}}@only_return
; CHECK-SAME: () #[[ATTR0:[0-9]+]] { ; CHECK-SAME: () #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
ret void ret void
} }
; TEST 2 (positive & negative case) ; TEST 2 (positive & negative case)
; 2.1 (positive case) ; 2.1 (positive case)
; recursive function which will halt ; recursive function which will halt
; int fib(int n){ ; int fib(int n){
; return n<=1? n : fib(n-1) + fib(n-2); ; return n<=1? n : fib(n-1) + fib(n-2);
; } ; }
; FIXME: missing willreturn ; FIXME: missing willreturn
define i32 @fib(i32 %0) local_unnamed_addr #0 { define i32 @fib(i32 %0) local_unnamed_addr #0 {
; TUNIT: Function Attrs: nofree noinline nosync nounwind memory(none) uwtable ; TUNIT: Function Attrs: nofree noinline nosync nounwind memory(none) uwtable
; TUNIT-LABEL: define {{[^@]+}}@fib ; TUNIT-LABEL: define {{[^@]+}}@fib
; TUNIT-SAME: (i32 [[TMP0:%.*]]) local_unnamed_addr #[[ATTR1:[0-9]+]] { ; TUNIT-SAME: (i32 [[TMP0:%.*]]) local_unnamed_addr #[[ATTR1:[0-9]+]] {
; TUNIT-NEXT: [[TMP2:%.*]] = icmp slt i32 [[TMP0]], 2 ; TUNIT-NEXT: [[TMP2:%.*]] = icmp slt i32 [[TMP0]], 2
; TUNIT-NEXT: br i1 [[TMP2]], label [[TMP9:%.*]], label [[TMP3:%.*]] ; TUNIT-NEXT: br i1 [[TMP2]], label [[TMP9:%.*]], label [[TMP3:%.*]]
; TUNIT: 3: ; TUNIT: 3:
; TUNIT-NEXT: [[TMP4:%.*]] = add nsw i32 [[TMP0]], -1 ; TUNIT-NEXT: [[TMP4:%.*]] = add nsw i32 [[TMP0]], -1
; TUNIT-NEXT: [[TMP5:%.*]] = tail call i32 @fib(i32 [[TMP4]]) #[[ATTR26:[0-9]+]] ; TUNIT-NEXT: [[TMP5:%.*]] = tail call i32 @fib(i32 [[TMP4]]) #[[ATTR25:[0-9]+]]
; TUNIT-NEXT: [[TMP6:%.*]] = add nsw i32 [[TMP0]], -2 ; TUNIT-NEXT: [[TMP6:%.*]] = add nsw i32 [[TMP0]], -2
; TUNIT-NEXT: [[TMP7:%.*]] = tail call i32 @fib(i32 [[TMP6]]) #[[ATTR26]] ; TUNIT-NEXT: [[TMP7:%.*]] = tail call i32 @fib(i32 [[TMP6]]) #[[ATTR25]]
; TUNIT-NEXT: [[TMP8:%.*]] = add nsw i32 [[TMP7]], [[TMP5]] ; TUNIT-NEXT: [[TMP8:%.*]] = add nsw i32 [[TMP7]], [[TMP5]]
; TUNIT-NEXT: ret i32 [[TMP8]] ; TUNIT-NEXT: ret i32 [[TMP8]]
; TUNIT: 9: ; TUNIT: 9:
; TUNIT-NEXT: ret i32 [[TMP0]] ; TUNIT-NEXT: ret i32 [[TMP0]]
; ;
; CGSCC: Function Attrs: nofree noinline nosync nounwind memory(none) uwtable ; CGSCC: Function Attrs: nofree noinline nosync nounwind memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@fib ; CGSCC-LABEL: define {{[^@]+}}@fib
; CGSCC-SAME: (i32 [[TMP0:%.*]]) local_unnamed_addr #[[ATTR1:[0-9]+]] { ; CGSCC-SAME: (i32 [[TMP0:%.*]]) local_unnamed_addr #[[ATTR1:[0-9]+]] {
; CGSCC-NEXT: [[TMP2:%.*]] = icmp slt i32 [[TMP0]], 2 ; CGSCC-NEXT: [[TMP2:%.*]] = icmp slt i32 [[TMP0]], 2
; CGSCC-NEXT: br i1 [[TMP2]], label [[TMP9:%.*]], label [[TMP3:%.*]] ; CGSCC-NEXT: br i1 [[TMP2]], label [[TMP9:%.*]], label [[TMP3:%.*]]
; CGSCC: 3: ; CGSCC: 3:
; CGSCC-NEXT: [[TMP4:%.*]] = add nsw i32 [[TMP0]], -1 ; CGSCC-NEXT: [[TMP4:%.*]] = add nsw i32 [[TMP0]], -1
; CGSCC-NEXT: [[TMP5:%.*]] = tail call i32 @fib(i32 [[TMP4]]) #[[ATTR27:[0-9]+]] ; CGSCC-NEXT: [[TMP5:%.*]] = tail call i32 @fib(i32 [[TMP4]]) #[[ATTR26:[0-9]+]]
; CGSCC-NEXT: [[TMP6:%.*]] = add nsw i32 [[TMP0]], -2 ; CGSCC-NEXT: [[TMP6:%.*]] = add nsw i32 [[TMP0]], -2
; CGSCC-NEXT: [[TMP7:%.*]] = tail call i32 @fib(i32 [[TMP6]]) #[[ATTR27]] ; CGSCC-NEXT: [[TMP7:%.*]] = tail call i32 @fib(i32 [[TMP6]]) #[[ATTR26]]
; CGSCC-NEXT: [[TMP8:%.*]] = add nsw i32 [[TMP7]], [[TMP5]] ; CGSCC-NEXT: [[TMP8:%.*]] = add nsw i32 [[TMP7]], [[TMP5]]
; CGSCC-NEXT: ret i32 [[TMP8]] ; CGSCC-NEXT: ret i32 [[TMP8]]
; CGSCC: 9: ; CGSCC: 9:
; CGSCC-NEXT: ret i32 [[TMP0]] ; CGSCC-NEXT: ret i32 [[TMP0]]
; ;
%2 = icmp slt i32 %0, 2 %2 = icmp slt i32 %0, 2
br i1 %2, label %9, label %3 br i1 %2, label %9, label %3
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
; int ans = 1; ; int ans = 1;
; for(int i = 1;i<=n;i++){ ; for(int i = 1;i<=n;i++){
; ans *= i; ; ans *= i;
; } ; }
; return ans; ; return ans;
; } ; }
define i32 @fact_loop(i32 %0) local_unnamed_addr #0 { define i32 @fact_loop(i32 %0) local_unnamed_addr #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@fact_loop ; CHECK-LABEL: define {{[^@]+}}@fact_loop
; CHECK-SAME: (i32 [[TMP0:%.*]]) local_unnamed_addr #[[ATTR0]] { ; CHECK-SAME: (i32 [[TMP0:%.*]]) local_unnamed_addr #[[ATTR0]] {
; CHECK-NEXT: [[TMP2:%.*]] = icmp slt i32 [[TMP0]], 1 ; CHECK-NEXT: [[TMP2:%.*]] = icmp slt i32 [[TMP0]], 1
; CHECK-NEXT: br i1 [[TMP2]], label [[TMP3:%.*]], label [[TMP5:%.*]] ; CHECK-NEXT: br i1 [[TMP2]], label [[TMP3:%.*]], label [[TMP5:%.*]]
; CHECK: 3: ; CHECK: 3:
; CHECK-NEXT: [[TMP4:%.*]] = phi i32 [ 1, [[TMP1:%.*]] ], [ [[TMP8:%.*]], [[TMP5]] ] ; CHECK-NEXT: [[TMP4:%.*]] = phi i32 [ 1, [[TMP1:%.*]] ], [ [[TMP8:%.*]], [[TMP5]] ]
; CHECK-NEXT: ret i32 [[TMP4]] ; CHECK-NEXT: ret i32 [[TMP4]]
; CHECK: 5: ; CHECK: 5:
Show All 32 Lines
declare void @sink() nounwind willreturn nosync nofree declare void @sink() nounwind willreturn nosync nofree
define void @mutual_recursion1(i1 %c) #0 { define void @mutual_recursion1(i1 %c) #0 {
; TUNIT: Function Attrs: nofree noinline nosync nounwind uwtable ; TUNIT: Function Attrs: nofree noinline nosync nounwind uwtable
; TUNIT-LABEL: define {{[^@]+}}@mutual_recursion1 ; TUNIT-LABEL: define {{[^@]+}}@mutual_recursion1
; TUNIT-SAME: (i1 noundef [[C:%.*]]) #[[ATTR4:[0-9]+]] { ; TUNIT-SAME: (i1 noundef [[C:%.*]]) #[[ATTR4:[0-9]+]] {
; TUNIT-NEXT: br i1 [[C]], label [[REC:%.*]], label [[END:%.*]] ; TUNIT-NEXT: br i1 [[C]], label [[REC:%.*]], label [[END:%.*]]
; TUNIT: rec: ; TUNIT: rec:
; TUNIT-NEXT: call void @sink() #[[ATTR12:[0-9]+]] ; TUNIT-NEXT: call void @sink() #[[ATTR26:[0-9]+]]
; TUNIT-NEXT: call void @mutual_recursion2(i1 noundef [[C]]) #[[ATTR26]] ; TUNIT-NEXT: call void @mutual_recursion2(i1 noundef [[C]]) #[[ATTR25]]
; TUNIT-NEXT: br label [[END]] ; TUNIT-NEXT: br label [[END]]
; TUNIT: end: ; TUNIT: end:
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree noinline nosync nounwind uwtable ; CGSCC: Function Attrs: nofree noinline nosync nounwind uwtable
; CGSCC-LABEL: define {{[^@]+}}@mutual_recursion1 ; CGSCC-LABEL: define {{[^@]+}}@mutual_recursion1
; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR4:[0-9]+]] { ; CGSCC-SAME: (i1 noundef [[C:%.*]]) #[[ATTR4:[0-9]+]] {
; CGSCC-NEXT: br i1 [[C]], label [[REC:%.*]], label [[END:%.*]] ; CGSCC-NEXT: br i1 [[C]], label [[REC:%.*]], label [[END:%.*]]
; CGSCC: rec: ; CGSCC: rec:
; CGSCC-NEXT: call void @sink() #[[ATTR12:[0-9]+]] ; CGSCC-NEXT: call void @sink() #[[ATTR27:[0-9]+]]
; CGSCC-NEXT: call void @mutual_recursion2(i1 noundef [[C]]) #[[ATTR27]] ; CGSCC-NEXT: call void @mutual_recursion2(i1 noundef [[C]]) #[[ATTR26]]
; CGSCC-NEXT: br label [[END]] ; CGSCC-NEXT: br label [[END]]
; CGSCC: end: ; CGSCC: end:
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
br i1 %c, label %rec, label %end br i1 %c, label %rec, label %end
rec: rec:
call void @sink() call void @sink()
call void @mutual_recursion2(i1 %c) call void @mutual_recursion2(i1 %c)
br label %end br label %end
end: end:
ret void ret void
} }
define void @mutual_recursion2(i1 %c) #0 { define void @mutual_recursion2(i1 %c) #0 {
; TUNIT: Function Attrs: nofree noinline nosync nounwind uwtable ; TUNIT: Function Attrs: nofree noinline nosync nounwind uwtable
; TUNIT-LABEL: define {{[^@]+}}@mutual_recursion2 ; TUNIT-LABEL: define {{[^@]+}}@mutual_recursion2
; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR4]] { ; TUNIT-SAME: (i1 [[C:%.*]]) #[[ATTR4]] {
; TUNIT-NEXT: call void @mutual_recursion1(i1 [[C]]) #[[ATTR26]] ; TUNIT-NEXT: call void @mutual_recursion1(i1 [[C]]) #[[ATTR25]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nofree noinline nosync nounwind uwtable ; CGSCC: Function Attrs: nofree noinline nosync nounwind uwtable
; CGSCC-LABEL: define {{[^@]+}}@mutual_recursion2 ; CGSCC-LABEL: define {{[^@]+}}@mutual_recursion2
; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR4]] { ; CGSCC-SAME: (i1 [[C:%.*]]) #[[ATTR4]] {
; CGSCC-NEXT: call void @mutual_recursion1(i1 [[C]]) #[[ATTR27]] ; CGSCC-NEXT: call void @mutual_recursion1(i1 [[C]]) #[[ATTR26]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @mutual_recursion1(i1 %c) call void @mutual_recursion1(i1 %c)
ret void ret void
} }
; TEST 5 (negative case) ; TEST 5 (negative case)
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines
; TEST 6 (positive case) ; TEST 6 (positive case)
; Call intrinsic function ; Call intrinsic function
; CHECK: Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) ; CHECK: Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
; CHECK-NEXT: declare float @llvm.floor.f32(float) ; CHECK-NEXT: declare float @llvm.floor.f32(float)
declare float @llvm.floor.f32(float) declare float @llvm.floor.f32(float)
define void @call_floor(float %a) #0 { define void @call_floor(float %a) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@call_floor ; CHECK-LABEL: define {{[^@]+}}@call_floor
; CHECK-SAME: (float [[A:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (float [[A:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
tail call float @llvm.floor.f32(float %a) tail call float @llvm.floor.f32(float %a)
ret void ret void
} }
define float @call_floor2(float %a) #0 { define float @call_floor2(float %a) #0 {
; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; TUNIT-LABEL: define {{[^@]+}}@call_floor2 ; TUNIT-LABEL: define {{[^@]+}}@call_floor2
; TUNIT-SAME: (float [[A:%.*]]) #[[ATTR0]] { ; TUNIT-SAME: (float [[A:%.*]]) #[[ATTR0]] {
; TUNIT-NEXT: [[C:%.*]] = tail call nofpclass(sub) float @llvm.floor.f32(float [[A]]) #[[ATTR27:[0-9]+]] ; TUNIT-NEXT: [[C:%.*]] = tail call nofpclass(sub) float @llvm.floor.f32(float [[A]]) #[[ATTR27:[0-9]+]]
; TUNIT-NEXT: ret float [[C]] ; TUNIT-NEXT: ret float [[C]]
; ;
; CGSCC: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CGSCC: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CGSCC-LABEL: define {{[^@]+}}@call_floor2 ; CGSCC-LABEL: define {{[^@]+}}@call_floor2
; CGSCC-SAME: (float [[A:%.*]]) #[[ATTR0]] { ; CGSCC-SAME: (float [[A:%.*]]) #[[ATTR0]] {
; CGSCC-NEXT: [[C:%.*]] = tail call nofpclass(sub) float @llvm.floor.f32(float [[A]]) #[[ATTR28:[0-9]+]] ; CGSCC-NEXT: [[C:%.*]] = tail call nofpclass(sub) float @llvm.floor.f32(float [[A]]) #[[ATTR28:[0-9]+]]
; CGSCC-NEXT: ret float [[C]] ; CGSCC-NEXT: ret float [[C]]
; ;
%c = tail call float @llvm.floor.f32(float %a) %c = tail call float @llvm.floor.f32(float %a)
ret float %c ret float %c
} }
Show All 28 Lines
; TEST 8 (positive case) ; TEST 8 (positive case)
; Check propagation. ; Check propagation.
; CHECK: Function Attrs: norecurse willreturn ; CHECK: Function Attrs: norecurse willreturn
; CHECK-NEXT: declare void @will_return() ; CHECK-NEXT: declare void @will_return()
declare void @will_return() willreturn norecurse declare void @will_return() willreturn norecurse
define void @f1() #0 { define void @f1() #0 {
; TUNIT: Function Attrs: noinline nounwind willreturn uwtable ; TUNIT: Function Attrs: mustprogress noinline nounwind willreturn uwtable
; TUNIT-LABEL: define {{[^@]+}}@f1 ; TUNIT-LABEL: define {{[^@]+}}@f1
; TUNIT-SAME: () #[[ATTR10:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR10:[0-9]+]] {
; TUNIT-NEXT: tail call void @will_return() #[[ATTR27]] ; TUNIT-NEXT: tail call void @will_return() #[[ATTR27]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: noinline nounwind willreturn uwtable ; CGSCC: Function Attrs: mustprogress noinline nounwind willreturn uwtable
; CGSCC-LABEL: define {{[^@]+}}@f1 ; CGSCC-LABEL: define {{[^@]+}}@f1
; CGSCC-SAME: () #[[ATTR10:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR10:[0-9]+]] {
; CGSCC-NEXT: tail call void @will_return() #[[ATTR28]] ; CGSCC-NEXT: tail call void @will_return() #[[ATTR28]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
tail call void @will_return() tail call void @will_return()
ret void ret void
} }
define void @f2() #0 { define void @f2() #0 {
; CHECK: Function Attrs: noinline nounwind willreturn uwtable ; TUNIT: Function Attrs: mustprogress noinline nounwind willreturn uwtable
; CHECK-LABEL: define {{[^@]+}}@f2 ; TUNIT-LABEL: define {{[^@]+}}@f2
; CHECK-SAME: () #[[ATTR10:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR10]] {
; CHECK-NEXT: tail call void @f1() #[[ATTR12:[0-9]+]] ; TUNIT-NEXT: tail call void @f1() #[[ATTR26]]
; CHECK-NEXT: ret void ; TUNIT-NEXT: ret void
;
; CGSCC: Function Attrs: mustprogress noinline nounwind willreturn uwtable
; CGSCC-LABEL: define {{[^@]+}}@f2
; CGSCC-SAME: () #[[ATTR10]] {
; CGSCC-NEXT: tail call void @f1() #[[ATTR27]]
; CGSCC-NEXT: ret void
; ;
tail call void @f1() tail call void @f1()
ret void ret void
} }
; TEST 9 (negative case) ; TEST 9 (negative case)
; call willreturn function in endless loop. ; call willreturn function in endless loop.
Show All 21 Lines
; TEST 10 (positive case) ; TEST 10 (positive case)
; invoke a function with willreturn ; invoke a function with willreturn
; CHECK: Function Attrs: noinline willreturn uwtable ; CHECK: Function Attrs: noinline willreturn uwtable
; CHECK-NEXT: declare i1 @maybe_raise_exception() ; CHECK-NEXT: declare i1 @maybe_raise_exception()
declare i1 @maybe_raise_exception() #1 willreturn declare i1 @maybe_raise_exception() #1 willreturn
define void @invoke_test() personality i32 (...)* @__gxx_personality_v0 { define void @invoke_test() personality i32 (...)* @__gxx_personality_v0 {
; TUNIT: Function Attrs: nounwind willreturn ; TUNIT: Function Attrs: mustprogress nounwind willreturn
; TUNIT-LABEL: define {{[^@]+}}@invoke_test ; TUNIT-LABEL: define {{[^@]+}}@invoke_test
; TUNIT-SAME: () #[[ATTR12]] personality i32 (...)* @__gxx_personality_v0 { ; TUNIT-SAME: () #[[ATTR12:[0-9]+]] personality i32 (...)* @__gxx_personality_v0 {
; TUNIT-NEXT: [[TMP1:%.*]] = invoke i1 @maybe_raise_exception() #[[ATTR27]] ; TUNIT-NEXT: [[TMP1:%.*]] = invoke i1 @maybe_raise_exception() #[[ATTR27]]
; TUNIT-NEXT: to label [[N:%.*]] unwind label [[F:%.*]] ; TUNIT-NEXT: to label [[N:%.*]] unwind label [[F:%.*]]
; TUNIT: N: ; TUNIT: N:
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; TUNIT: F: ; TUNIT: F:
; TUNIT-NEXT: [[VAL:%.*]] = landingpad { i8*, i32 } ; TUNIT-NEXT: [[VAL:%.*]] = landingpad { i8*, i32 }
; TUNIT-NEXT: catch i8* null ; TUNIT-NEXT: catch i8* null
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: nounwind willreturn ; CGSCC: Function Attrs: mustprogress nounwind willreturn
; CGSCC-LABEL: define {{[^@]+}}@invoke_test ; CGSCC-LABEL: define {{[^@]+}}@invoke_test
; CGSCC-SAME: () #[[ATTR12]] personality i32 (...)* @__gxx_personality_v0 { ; CGSCC-SAME: () #[[ATTR12:[0-9]+]] personality i32 (...)* @__gxx_personality_v0 {
; CGSCC-NEXT: [[TMP1:%.*]] = invoke i1 @maybe_raise_exception() #[[ATTR28]] ; CGSCC-NEXT: [[TMP1:%.*]] = invoke i1 @maybe_raise_exception() #[[ATTR28]]
; CGSCC-NEXT: to label [[N:%.*]] unwind label [[F:%.*]] ; CGSCC-NEXT: to label [[N:%.*]] unwind label [[F:%.*]]
; CGSCC: N: ; CGSCC: N:
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; CGSCC: F: ; CGSCC: F:
; CGSCC-NEXT: [[VAL:%.*]] = landingpad { i8*, i32 } ; CGSCC-NEXT: [[VAL:%.*]] = landingpad { i8*, i32 }
; CGSCC-NEXT: catch i8* null ; CGSCC-NEXT: catch i8* null
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
Show All 17 Lines
; int ans = 0; ; int ans = 0;
; for(int i = 0;i<10;i++){ ; for(int i = 0;i<10;i++){
; ans += p[i]; ; ans += p[i];
; } ; }
; return ans; ; return ans;
; } ; }
define i32 @loop_constant_trip_count(i32* nocapture readonly %0) #0 { define i32 @loop_constant_trip_count(i32* nocapture readonly %0) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable
; CHECK-LABEL: define {{[^@]+}}@loop_constant_trip_count ; CHECK-LABEL: define {{[^@]+}}@loop_constant_trip_count
; CHECK-SAME: (i32* nocapture nofree nonnull readonly dereferenceable(4) [[TMP0:%.*]]) #[[ATTR13:[0-9]+]] { ; CHECK-SAME: (i32* nocapture nofree nonnull readonly dereferenceable(4) [[TMP0:%.*]]) #[[ATTR13:[0-9]+]] {
; CHECK-NEXT: br label [[TMP3:%.*]] ; CHECK-NEXT: br label [[TMP3:%.*]]
; CHECK: 2: ; CHECK: 2:
; CHECK-NEXT: ret i32 [[TMP8:%.*]] ; CHECK-NEXT: ret i32 [[TMP8:%.*]]
; CHECK: 3: ; CHECK: 3:
; CHECK-NEXT: [[TMP4:%.*]] = phi i64 [ 0, [[TMP1:%.*]] ], [ [[TMP9:%.*]], [[TMP3]] ] ; CHECK-NEXT: [[TMP4:%.*]] = phi i64 [ 0, [[TMP1:%.*]] ], [ [[TMP9:%.*]], [[TMP3]] ]
; CHECK-NEXT: [[TMP5:%.*]] = phi i32 [ 0, [[TMP1]] ], [ [[TMP8]], [[TMP3]] ] ; CHECK-NEXT: [[TMP5:%.*]] = phi i32 [ 0, [[TMP1]] ], [ [[TMP8]], [[TMP3]] ]
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines
; for(;n >= 0;n--){ ; for(;n >= 0;n--){
; ans += p[n]; ; ans += p[n];
; } ; }
; return ans; ; return ans;
; } ; }
define i32 @loop_trip_dec(i32 %0, i32* nocapture readonly %1) local_unnamed_addr #0 { define i32 @loop_trip_dec(i32 %0, i32* nocapture readonly %1) local_unnamed_addr #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable
; CHECK-LABEL: define {{[^@]+}}@loop_trip_dec ; CHECK-LABEL: define {{[^@]+}}@loop_trip_dec
; CHECK-SAME: (i32 [[TMP0:%.*]], i32* nocapture nofree readonly [[TMP1:%.*]]) local_unnamed_addr #[[ATTR13]] { ; CHECK-SAME: (i32 [[TMP0:%.*]], i32* nocapture nofree readonly [[TMP1:%.*]]) local_unnamed_addr #[[ATTR13]] {
; CHECK-NEXT: [[TMP3:%.*]] = icmp sgt i32 [[TMP0]], -1 ; CHECK-NEXT: [[TMP3:%.*]] = icmp sgt i32 [[TMP0]], -1
; CHECK-NEXT: br i1 [[TMP3]], label [[TMP4:%.*]], label [[TMP14:%.*]] ; CHECK-NEXT: br i1 [[TMP3]], label [[TMP4:%.*]], label [[TMP14:%.*]]
; CHECK: 4: ; CHECK: 4:
; CHECK-NEXT: [[TMP5:%.*]] = sext i32 [[TMP0]] to i64 ; CHECK-NEXT: [[TMP5:%.*]] = sext i32 [[TMP0]] to i64
; CHECK-NEXT: br label [[TMP6:%.*]] ; CHECK-NEXT: br label [[TMP6:%.*]]
; CHECK: 6: ; CHECK: 6:
Show All 30 Lines; <label>:14: ; preds = %6, %2
%15 = phi i32 [ 0, %2 ], [ %11, %6 ] %15 = phi i32 [ 0, %2 ], [ %11, %6 ]
ret i32 %15 ret i32 %15
} }
; TEST 14 (positive case) ; TEST 14 (positive case)
; multiple return ; multiple return
define i32 @multiple_return(i32 %a) #0 { define i32 @multiple_return(i32 %a) #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@multiple_return ; CHECK-LABEL: define {{[^@]+}}@multiple_return
; CHECK-SAME: (i32 [[A:%.*]]) #[[ATTR0]] { ; CHECK-SAME: (i32 [[A:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[B:%.*]] = icmp eq i32 [[A]], 0 ; CHECK-NEXT: [[B:%.*]] = icmp eq i32 [[A]], 0
; CHECK-NEXT: br i1 [[B]], label [[T:%.*]], label [[F:%.*]] ; CHECK-NEXT: br i1 [[B]], label [[T:%.*]], label [[F:%.*]]
; CHECK: t: ; CHECK: t:
; CHECK-NEXT: ret i32 1 ; CHECK-NEXT: ret i32 1
; CHECK: f: ; CHECK: f:
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
%b = icmp eq i32 %a, 0 %b = icmp eq i32 %a, 0
br i1 %b, label %t, label %f br i1 %b, label %t, label %f
t: t:
ret i32 1 ret i32 1
f: f:
ret i32 0 ret i32 0
} }
; TEST 15 (positive & negative case) ; TEST 15 (positive & negative case)
; unreachable exit ; unreachable exit
; 15.1 (positive case) ; 15.1 (positive case)
define void @unreachable_exit_positive1() #0 { define void @unreachable_exit_positive1() #0 {
; TUNIT: Function Attrs: noinline nounwind willreturn uwtable ; TUNIT: Function Attrs: mustprogress noinline nounwind willreturn uwtable
; TUNIT-LABEL: define {{[^@]+}}@unreachable_exit_positive1 ; TUNIT-LABEL: define {{[^@]+}}@unreachable_exit_positive1
; TUNIT-SAME: () #[[ATTR10]] { ; TUNIT-SAME: () #[[ATTR10]] {
; TUNIT-NEXT: tail call void @will_return() #[[ATTR27]] ; TUNIT-NEXT: tail call void @will_return() #[[ATTR27]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; TUNIT: unreachable_label: ; TUNIT: unreachable_label:
; TUNIT-NEXT: unreachable ; TUNIT-NEXT: unreachable
; ;
; CGSCC: Function Attrs: noinline nounwind willreturn uwtable ; CGSCC: Function Attrs: mustprogress noinline nounwind willreturn uwtable
; CGSCC-LABEL: define {{[^@]+}}@unreachable_exit_positive1 ; CGSCC-LABEL: define {{[^@]+}}@unreachable_exit_positive1
; CGSCC-SAME: () #[[ATTR10]] { ; CGSCC-SAME: () #[[ATTR10]] {
; CGSCC-NEXT: tail call void @will_return() #[[ATTR28]] ; CGSCC-NEXT: tail call void @will_return() #[[ATTR28]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; CGSCC: unreachable_label: ; CGSCC: unreachable_label:
; CGSCC-NEXT: unreachable ; CGSCC-NEXT: unreachable
; ;
tail call void @will_return() tail call void @will_return()
ret void ret void
unreachable_label: unreachable_label:
tail call void @exit(i32 0) tail call void @exit(i32 0)
unreachable unreachable
} }
define i32 @unreachable_exit_positive2(i32) local_unnamed_addr #0 { define i32 @unreachable_exit_positive2(i32) local_unnamed_addr #0 {
; CHECK: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
; CHECK-LABEL: define {{[^@]+}}@unreachable_exit_positive2 ; CHECK-LABEL: define {{[^@]+}}@unreachable_exit_positive2
; CHECK-SAME: (i32 [[TMP0:%.*]]) local_unnamed_addr #[[ATTR0]] { ; CHECK-SAME: (i32 [[TMP0:%.*]]) local_unnamed_addr #[[ATTR0]] {
; CHECK-NEXT: [[TMP2:%.*]] = icmp slt i32 [[TMP0]], 1 ; CHECK-NEXT: [[TMP2:%.*]] = icmp slt i32 [[TMP0]], 1
; CHECK-NEXT: br i1 [[TMP2]], label [[TMP3:%.*]], label [[TMP5:%.*]] ; CHECK-NEXT: br i1 [[TMP2]], label [[TMP3:%.*]], label [[TMP5:%.*]]
; CHECK: 3: ; CHECK: 3:
; CHECK-NEXT: [[TMP4:%.*]] = phi i32 [ 1, [[TMP1:%.*]] ], [ [[TMP8:%.*]], [[TMP5]] ] ; CHECK-NEXT: [[TMP4:%.*]] = phi i32 [ 1, [[TMP1:%.*]] ], [ [[TMP8:%.*]], [[TMP5]] ]
; CHECK-NEXT: ret i32 [[TMP4]] ; CHECK-NEXT: ret i32 [[TMP4]]
; CHECK: 5: ; CHECK: 5:
▲ Show 20 Lines • Show All 152 Lines • ▼ Show 20 Lines
; while (n--) { ; while (n--) {
; ans++; ; ans++;
; } ; }
; } ; }
; return ans; ; return ans;
; } ; }
define i32 @bounded_nested_loops(i32 %n) { define i32 @bounded_nested_loops(i32 %n) {
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK-LABEL: define {{[^@]+}}@bounded_nested_loops ; CHECK-LABEL: define {{[^@]+}}@bounded_nested_loops
; CHECK-SAME: (i32 [[N:%.*]]) #[[ATTR18:[0-9]+]] { ; CHECK-SAME: (i32 [[N:%.*]]) #[[ATTR18:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FOR_COND:%.*]] ; CHECK-NEXT: br label [[FOR_COND:%.*]]
; CHECK: for.cond: ; CHECK: for.cond:
; CHECK-NEXT: [[I_0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC1:%.*]], [[FOR_INC:%.*]] ] ; CHECK-NEXT: [[I_0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC1:%.*]], [[FOR_INC:%.*]] ]
; CHECK-NEXT: [[ANS_0:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[TMP:%.*]], [[FOR_INC]] ] ; CHECK-NEXT: [[ANS_0:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[TMP:%.*]], [[FOR_INC]] ]
; CHECK-NEXT: [[N_ADDR_0:%.*]] = phi i32 [ [[N]], [[ENTRY]] ], [ -1, [[FOR_INC]] ] ; CHECK-NEXT: [[N_ADDR_0:%.*]] = phi i32 [ [[N]], [[ENTRY]] ], [ -1, [[FOR_INC]] ]
▲ Show 20 Lines • Show All 238 Lines • ▼ Show 20 Lines
; return; ; return;
; } ; }
define void @non_loop_cycle(i32 %n) { define void @non_loop_cycle(i32 %n) {
; TUNIT: Function Attrs: nofree norecurse nosync nounwind memory(none) ; TUNIT: Function Attrs: nofree norecurse nosync nounwind memory(none)
; TUNIT-LABEL: define {{[^@]+}}@non_loop_cycle ; TUNIT-LABEL: define {{[^@]+}}@non_loop_cycle
; TUNIT-SAME: (i32 [[N:%.*]]) #[[ATTR17]] { ; TUNIT-SAME: (i32 [[N:%.*]]) #[[ATTR17]] {
; TUNIT-NEXT: entry: ; TUNIT-NEXT: entry:
; TUNIT-NEXT: [[CALL:%.*]] = call i32 @fact_loop(i32 [[N]]) #[[ATTR26]] ; TUNIT-NEXT: [[CALL:%.*]] = call i32 @fact_loop(i32 [[N]]) #[[ATTR25]]
; TUNIT-NEXT: [[CMP:%.*]] = icmp sgt i32 [[CALL]], 5 ; TUNIT-NEXT: [[CMP:%.*]] = icmp sgt i32 [[CALL]], 5
; TUNIT-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]] ; TUNIT-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
; TUNIT: if.then: ; TUNIT: if.then:
; TUNIT-NEXT: br label [[ENTRY1:%.*]] ; TUNIT-NEXT: br label [[ENTRY1:%.*]]
; TUNIT: if.else: ; TUNIT: if.else:
; TUNIT-NEXT: br label [[ENTRY2:%.*]] ; TUNIT-NEXT: br label [[ENTRY2:%.*]]
; TUNIT: entry1: ; TUNIT: entry1:
; TUNIT-NEXT: [[CALL1:%.*]] = call i32 @fact_loop(i32 [[N]]) #[[ATTR26]] ; TUNIT-NEXT: [[CALL1:%.*]] = call i32 @fact_loop(i32 [[N]]) #[[ATTR25]]
; TUNIT-NEXT: [[CMP2:%.*]] = icmp sgt i32 [[CALL1]], 5 ; TUNIT-NEXT: [[CMP2:%.*]] = icmp sgt i32 [[CALL1]], 5
; TUNIT-NEXT: br i1 [[CMP2]], label [[IF_THEN3:%.*]], label [[IF_ELSE4:%.*]] ; TUNIT-NEXT: br i1 [[CMP2]], label [[IF_THEN3:%.*]], label [[IF_ELSE4:%.*]]
; TUNIT: if.then3: ; TUNIT: if.then3:
; TUNIT-NEXT: br label [[EXIT:%.*]] ; TUNIT-NEXT: br label [[EXIT:%.*]]
; TUNIT: if.else4: ; TUNIT: if.else4:
; TUNIT-NEXT: br label [[ENTRY2]] ; TUNIT-NEXT: br label [[ENTRY2]]
; TUNIT: entry2: ; TUNIT: entry2:
; TUNIT-NEXT: [[CALL5:%.*]] = call i32 @fact_loop(i32 [[N]]) #[[ATTR26]] ; TUNIT-NEXT: [[CALL5:%.*]] = call i32 @fact_loop(i32 [[N]]) #[[ATTR25]]
; TUNIT-NEXT: [[CMP6:%.*]] = icmp sgt i32 [[CALL5]], 5 ; TUNIT-NEXT: [[CMP6:%.*]] = icmp sgt i32 [[CALL5]], 5
; TUNIT-NEXT: br i1 [[CMP6]], label [[IF_THEN7:%.*]], label [[IF_ELSE8:%.*]] ; TUNIT-NEXT: br i1 [[CMP6]], label [[IF_THEN7:%.*]], label [[IF_ELSE8:%.*]]
; TUNIT: if.then7: ; TUNIT: if.then7:
; TUNIT-NEXT: br label [[EXIT]] ; TUNIT-NEXT: br label [[EXIT]]
; TUNIT: if.else8: ; TUNIT: if.else8:
; TUNIT-NEXT: br label [[ENTRY1]] ; TUNIT-NEXT: br label [[ENTRY1]]
; TUNIT: exit: ; TUNIT: exit:
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
▲ Show 20 Lines • Show All 123 Lines • ▼ Show 20 Lines
; CHECK-LABEL: define {{[^@]+}}@willreturn_mustprogress_callee_1() { ; CHECK-LABEL: define {{[^@]+}}@willreturn_mustprogress_callee_1() {
; CHECK-NEXT: call void @unknown_mustprogress() ; CHECK-NEXT: call void @unknown_mustprogress()
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @unknown_mustprogress() call void @unknown_mustprogress()
ret void ret void
} }
define void @willreturn_mustprogress_callee_2() { define void @willreturn_mustprogress_callee_2() {
; TUNIT: Function Attrs: willreturn memory(read) ; TUNIT: Function Attrs: mustprogress willreturn memory(read)
; TUNIT-LABEL: define {{[^@]+}}@willreturn_mustprogress_callee_2 ; TUNIT-LABEL: define {{[^@]+}}@willreturn_mustprogress_callee_2
; TUNIT-SAME: () #[[ATTR25:[0-9]+]] { ; TUNIT-SAME: () #[[ATTR23]] {
; TUNIT-NEXT: call void @readonly_mustprogress() #[[ATTR27]] ; TUNIT-NEXT: call void @readonly_mustprogress() #[[ATTR27]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: willreturn memory(read) ; CGSCC: Function Attrs: mustprogress willreturn memory(read)
; CGSCC-LABEL: define {{[^@]+}}@willreturn_mustprogress_callee_2 ; CGSCC-LABEL: define {{[^@]+}}@willreturn_mustprogress_callee_2
; CGSCC-SAME: () #[[ATTR26:[0-9]+]] { ; CGSCC-SAME: () #[[ATTR24]] {
; CGSCC-NEXT: call void @readonly_mustprogress() #[[ATTR28]] ; CGSCC-NEXT: call void @readonly_mustprogress() #[[ATTR28]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @readonly_mustprogress() call void @readonly_mustprogress()
ret void ret void
} }
define void @willreturn_mustprogress_callee_3() { define void @willreturn_mustprogress_callee_3() {
; CHECK-LABEL: define {{[^@]+}}@willreturn_mustprogress_callee_3() { ; CHECK-LABEL: define {{[^@]+}}@willreturn_mustprogress_callee_3() {
; CHECK-NEXT: call void @willreturn_mustprogress_callee_1() ; CHECK-NEXT: call void @willreturn_mustprogress_callee_1()
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @willreturn_mustprogress_callee_1() call void @willreturn_mustprogress_callee_1()
ret void ret void
} }
define void @willreturn_mustprogress_callee_4() { define void @willreturn_mustprogress_callee_4() {
; TUNIT: Function Attrs: willreturn memory(read) ; TUNIT: Function Attrs: mustprogress willreturn memory(read)
; TUNIT-LABEL: define {{[^@]+}}@willreturn_mustprogress_callee_4 ; TUNIT-LABEL: define {{[^@]+}}@willreturn_mustprogress_callee_4
; TUNIT-SAME: () #[[ATTR25]] { ; TUNIT-SAME: () #[[ATTR23]] {
; TUNIT-NEXT: call void @willreturn_mustprogress_callee_2() #[[ATTR27]] ; TUNIT-NEXT: call void @willreturn_mustprogress_callee_2() #[[ATTR27]]
; TUNIT-NEXT: ret void ; TUNIT-NEXT: ret void
; ;
; CGSCC: Function Attrs: willreturn memory(read) ; CGSCC: Function Attrs: mustprogress willreturn memory(read)
; CGSCC-LABEL: define {{[^@]+}}@willreturn_mustprogress_callee_4 ; CGSCC-LABEL: define {{[^@]+}}@willreturn_mustprogress_callee_4
; CGSCC-SAME: () #[[ATTR26]] { ; CGSCC-SAME: () #[[ATTR24]] {
; CGSCC-NEXT: call void @willreturn_mustprogress_callee_2() #[[ATTR28]] ; CGSCC-NEXT: call void @willreturn_mustprogress_callee_2() #[[ATTR28]]
; CGSCC-NEXT: ret void ; CGSCC-NEXT: ret void
; ;
call void @willreturn_mustprogress_callee_2() call void @willreturn_mustprogress_callee_2()
ret void ret void
} }
attributes #0 = { nounwind uwtable noinline } attributes #0 = { nounwind uwtable noinline }
attributes #1 = { uwtable noinline } attributes #1 = { uwtable noinline }
;. ;.
; TUNIT: attributes #[[ATTR0]] = { nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable } ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable }
; TUNIT: attributes #[[ATTR1]] = { nofree noinline nosync nounwind memory(none) uwtable } ; TUNIT: attributes #[[ATTR1]] = { nofree noinline nosync nounwind memory(none) uwtable }
; TUNIT: attributes #[[ATTR2]] = { nofree noinline norecurse nosync nounwind memory(none) uwtable } ; TUNIT: attributes #[[ATTR2]] = { nofree noinline norecurse nosync nounwind memory(none) uwtable }
; TUNIT: attributes #[[ATTR3:[0-9]+]] = { nofree nosync nounwind willreturn } ; TUNIT: attributes #[[ATTR3:[0-9]+]] = { nofree nosync nounwind willreturn }
; TUNIT: attributes #[[ATTR4]] = { nofree noinline nosync nounwind uwtable } ; TUNIT: attributes #[[ATTR4]] = { nofree noinline nosync nounwind uwtable }
; TUNIT: attributes #[[ATTR5]] = { noreturn } ; TUNIT: attributes #[[ATTR5]] = { noreturn }
; TUNIT: attributes #[[ATTR6]] = { noinline noreturn nounwind uwtable } ; TUNIT: attributes #[[ATTR6]] = { noinline noreturn nounwind uwtable }
; TUNIT: attributes #[[ATTR7]] = { noinline nounwind uwtable } ; TUNIT: attributes #[[ATTR7]] = { noinline nounwind uwtable }
; TUNIT: attributes #[[ATTR8:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } ; TUNIT: attributes #[[ATTR8:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
; TUNIT: attributes #[[ATTR9:[0-9]+]] = { norecurse willreturn } ; TUNIT: attributes #[[ATTR9:[0-9]+]] = { norecurse willreturn }
; TUNIT: attributes #[[ATTR10]] = { noinline nounwind willreturn uwtable } ; TUNIT: attributes #[[ATTR10]] = { mustprogress noinline nounwind willreturn uwtable }
; TUNIT: attributes #[[ATTR11:[0-9]+]] = { noinline willreturn uwtable } ; TUNIT: attributes #[[ATTR11:[0-9]+]] = { noinline willreturn uwtable }
; TUNIT: attributes #[[ATTR12]] = { nounwind willreturn } ; TUNIT: attributes #[[ATTR12]] = { mustprogress nounwind willreturn }
; TUNIT: attributes #[[ATTR13]] = { nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable } ; TUNIT: attributes #[[ATTR13]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable }
; TUNIT: attributes #[[ATTR14]] = { nofree noinline norecurse nosync nounwind memory(argmem: read) uwtable } ; TUNIT: attributes #[[ATTR14]] = { nofree noinline norecurse nosync nounwind memory(argmem: read) uwtable }
; TUNIT: attributes #[[ATTR15]] = { nofree noinline norecurse noreturn nosync nounwind memory(none) uwtable } ; TUNIT: attributes #[[ATTR15]] = { nofree noinline norecurse noreturn nosync nounwind memory(none) uwtable }
; TUNIT: attributes #[[ATTR16:[0-9]+]] = { noreturn nounwind } ; TUNIT: attributes #[[ATTR16:[0-9]+]] = { noreturn nounwind }
; TUNIT: attributes #[[ATTR17]] = { nofree norecurse nosync nounwind memory(none) } ; TUNIT: attributes #[[ATTR17]] = { nofree norecurse nosync nounwind memory(none) }
; TUNIT: attributes #[[ATTR18]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; TUNIT: attributes #[[ATTR18]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; TUNIT: attributes #[[ATTR19:[0-9]+]] = { memory(read) } ; TUNIT: attributes #[[ATTR19:[0-9]+]] = { memory(read) }
; TUNIT: attributes #[[ATTR20:[0-9]+]] = { memory(none) } ; TUNIT: attributes #[[ATTR20:[0-9]+]] = { memory(none) }
; TUNIT: attributes #[[ATTR21]] = { mustprogress } ; TUNIT: attributes #[[ATTR21]] = { mustprogress }
; TUNIT: attributes #[[ATTR22:[0-9]+]] = { mustprogress memory(read) } ; TUNIT: attributes #[[ATTR22:[0-9]+]] = { mustprogress memory(read) }
; TUNIT: attributes #[[ATTR23]] = { mustprogress willreturn memory(read) } ; TUNIT: attributes #[[ATTR23]] = { mustprogress willreturn memory(read) }
; TUNIT: attributes #[[ATTR24]] = { mustprogress nosync willreturn memory(none) } ; TUNIT: attributes #[[ATTR24]] = { mustprogress nosync willreturn memory(none) }
; TUNIT: attributes #[[ATTR25]] = { willreturn memory(read) } ; TUNIT: attributes #[[ATTR25]] = { nofree nosync nounwind }
; TUNIT: attributes #[[ATTR26]] = { nofree nosync nounwind } ; TUNIT: attributes #[[ATTR26]] = { nounwind willreturn }
; TUNIT: attributes #[[ATTR27]] = { willreturn } ; TUNIT: attributes #[[ATTR27]] = { willreturn }
; TUNIT: attributes #[[ATTR28]] = { nounwind } ; TUNIT: attributes #[[ATTR28]] = { nounwind }
;. ;.
; CGSCC: attributes #[[ATTR0]] = { nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable } ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable }
; CGSCC: attributes #[[ATTR1]] = { nofree noinline nosync nounwind memory(none) uwtable } ; CGSCC: attributes #[[ATTR1]] = { nofree noinline nosync nounwind memory(none) uwtable }
; CGSCC: attributes #[[ATTR2]] = { nofree noinline norecurse nosync nounwind memory(none) uwtable } ; CGSCC: attributes #[[ATTR2]] = { nofree noinline norecurse nosync nounwind memory(none) uwtable }
; CGSCC: attributes #[[ATTR3:[0-9]+]] = { nofree nosync nounwind willreturn } ; CGSCC: attributes #[[ATTR3:[0-9]+]] = { nofree nosync nounwind willreturn }
; CGSCC: attributes #[[ATTR4]] = { nofree noinline nosync nounwind uwtable } ; CGSCC: attributes #[[ATTR4]] = { nofree noinline nosync nounwind uwtable }
; CGSCC: attributes #[[ATTR5]] = { noreturn } ; CGSCC: attributes #[[ATTR5]] = { noreturn }
; CGSCC: attributes #[[ATTR6]] = { noinline noreturn nounwind uwtable } ; CGSCC: attributes #[[ATTR6]] = { noinline noreturn nounwind uwtable }
; CGSCC: attributes #[[ATTR7]] = { noinline nounwind uwtable } ; CGSCC: attributes #[[ATTR7]] = { noinline nounwind uwtable }
; CGSCC: attributes #[[ATTR8:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } ; CGSCC: attributes #[[ATTR8:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
; CGSCC: attributes #[[ATTR9:[0-9]+]] = { norecurse willreturn } ; CGSCC: attributes #[[ATTR9:[0-9]+]] = { norecurse willreturn }
; CGSCC: attributes #[[ATTR10]] = { noinline nounwind willreturn uwtable } ; CGSCC: attributes #[[ATTR10]] = { mustprogress noinline nounwind willreturn uwtable }
; CGSCC: attributes #[[ATTR11:[0-9]+]] = { noinline willreturn uwtable } ; CGSCC: attributes #[[ATTR11:[0-9]+]] = { noinline willreturn uwtable }
; CGSCC: attributes #[[ATTR12]] = { nounwind willreturn } ; CGSCC: attributes #[[ATTR12]] = { mustprogress nounwind willreturn }
; CGSCC: attributes #[[ATTR13]] = { nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable } ; CGSCC: attributes #[[ATTR13]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: read) uwtable }
; CGSCC: attributes #[[ATTR14]] = { nofree noinline norecurse nosync nounwind memory(argmem: read) uwtable } ; CGSCC: attributes #[[ATTR14]] = { nofree noinline norecurse nosync nounwind memory(argmem: read) uwtable }
; CGSCC: attributes #[[ATTR15]] = { nofree noinline norecurse noreturn nosync nounwind memory(none) uwtable } ; CGSCC: attributes #[[ATTR15]] = { nofree noinline norecurse noreturn nosync nounwind memory(none) uwtable }
; CGSCC: attributes #[[ATTR16:[0-9]+]] = { noreturn nounwind } ; CGSCC: attributes #[[ATTR16:[0-9]+]] = { noreturn nounwind }
; CGSCC: attributes #[[ATTR17]] = { nofree norecurse nosync nounwind memory(none) } ; CGSCC: attributes #[[ATTR17]] = { nofree norecurse nosync nounwind memory(none) }
; CGSCC: attributes #[[ATTR18]] = { nofree norecurse nosync nounwind willreturn memory(none) } ; CGSCC: attributes #[[ATTR18]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
; CGSCC: attributes #[[ATTR19]] = { nofree nosync nounwind memory(none) } ; CGSCC: attributes #[[ATTR19]] = { nofree nosync nounwind memory(none) }
; CGSCC: attributes #[[ATTR20:[0-9]+]] = { memory(read) } ; CGSCC: attributes #[[ATTR20:[0-9]+]] = { memory(read) }
; CGSCC: attributes #[[ATTR21:[0-9]+]] = { memory(none) } ; CGSCC: attributes #[[ATTR21:[0-9]+]] = { memory(none) }
; CGSCC: attributes #[[ATTR22]] = { mustprogress } ; CGSCC: attributes #[[ATTR22]] = { mustprogress }
; CGSCC: attributes #[[ATTR23:[0-9]+]] = { mustprogress memory(read) } ; CGSCC: attributes #[[ATTR23:[0-9]+]] = { mustprogress memory(read) }
; CGSCC: attributes #[[ATTR24]] = { mustprogress willreturn memory(read) } ; CGSCC: attributes #[[ATTR24]] = { mustprogress willreturn memory(read) }
; CGSCC: attributes #[[ATTR25]] = { mustprogress nosync willreturn memory(none) } ; CGSCC: attributes #[[ATTR25]] = { mustprogress nosync willreturn memory(none) }
; CGSCC: attributes #[[ATTR26]] = { willreturn memory(read) } ; CGSCC: attributes #[[ATTR26]] = { nofree nosync nounwind }
; CGSCC: attributes #[[ATTR27]] = { nofree nosync nounwind } ; CGSCC: attributes #[[ATTR27]] = { nounwind willreturn }
; CGSCC: attributes #[[ATTR28]] = { willreturn } ; CGSCC: attributes #[[ATTR28]] = { willreturn }
; CGSCC: attributes #[[ATTR29]] = { nounwind } ; CGSCC: attributes #[[ATTR29]] = { nounwind }
;. ;.

llvm/test/Transforms/Attributor/wrapper.ll

; RUN: opt -passes=attributor-cgscc -attributor-annotate-decl-cs -attributor-allow-shallow-wrappers -S < %s | FileCheck %s --check-prefix=CHECK ; RUN: opt -passes=attributor-cgscc -attributor-annotate-decl-cs -attributor-allow-shallow-wrappers -S < %s | FileCheck %s --check-prefix=CHECK
; TEST 1: simple test, without argument ; TEST 1: simple test, without argument
; A wrapper will be generated for this function, Check the wrapper first ; A wrapper will be generated for this function, Check the wrapper first
; CHECK-NOT: Function Attrs: ; CHECK-NOT: Function Attrs:
; CHECK: define linkonce i32 @inner1() ; CHECK: define linkonce i32 @inner1()
; CHECK: tail call i32 @0() ; CHECK: tail call i32 @0()
; CHECK: ret ; CHECK: ret
; ;
; Check the original function, which is wrapped and becomes anonymous ; Check the original function, which is wrapped and becomes anonymous
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK: define internal noundef i32 @0() ; CHECK: define internal noundef i32 @0()
; CHECK: ret i32 1 ; CHECK: ret i32 1
define linkonce i32 @inner1() { define linkonce i32 @inner1() {
entry: entry:
%a = alloca i32 %a = alloca i32
store i32 1, ptr %a store i32 1, ptr %a
%b = load i32, ptr %a %b = load i32, ptr %a
ret i32 %b ret i32 %b
Show All 10 Lines
} }
; TEST 2: with argument ; TEST 2: with argument
; CHECK-NOT: Function Attrs ; CHECK-NOT: Function Attrs
; CHECK: define linkonce i32 @inner2(i32 %a, i32 %b) ; CHECK: define linkonce i32 @inner2(i32 %a, i32 %b)
; CHECK: tail call i32 @1(i32 %a, i32 %b) ; CHECK: tail call i32 @1(i32 %a, i32 %b)
; CHECK: ret ; CHECK: ret
; ;
; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none) ; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
; CHECK: define internal i32 @1(i32 %a, i32 %b) ; CHECK: define internal i32 @1(i32 %a, i32 %b)
; CHECK: %c = add i32 %a, %b ; CHECK: %c = add i32 %a, %b
; CHECK: ret i32 %c ; CHECK: ret i32 %c
define linkonce i32 @inner2(i32 %a, i32 %b) { define linkonce i32 @inner2(i32 %a, i32 %b) {
entry: entry:
%c = add i32 %a, %b %c = add i32 %a, %b
ret i32 %c ret i32 %c
} }
Show All 39 Lines

llvm/test/Transforms/OpenMP/parallel_deletion.ll

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Linesentry:
call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr nonnull @0, i32 0, ptr @.omp_outlined.willreturn.2) call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr nonnull @0, i32 0, ptr @.omp_outlined.willreturn.2)
ret void ret void
} }
define internal void @.omp_outlined.willreturn(ptr noalias %.global_tid., ptr noalias %.bound_tid.) { define internal void @.omp_outlined.willreturn(ptr noalias %.global_tid., ptr noalias %.bound_tid.) {
; CHECK-LABEL: define {{[^@]+}}@.omp_outlined.willreturn ; CHECK-LABEL: define {{[^@]+}}@.omp_outlined.willreturn
; CHECK-SAME: (ptr noalias nocapture nofree readnone [[DOTGLOBAL_TID_:%.*]], ptr noalias nocapture nofree readnone [[DOTBOUND_TID_:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-SAME: (ptr noalias nocapture nofree readnone [[DOTGLOBAL_TID_:%.*]], ptr noalias nocapture nofree readnone [[DOTBOUND_TID_:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: call void @unknown() #[[ATTR0]] ; CHECK-NEXT: call void @unknown() #[[ATTR14:[0-9]+]]
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
; CHECK1-LABEL: define {{[^@]+}}@.omp_outlined.willreturn ; CHECK1-LABEL: define {{[^@]+}}@.omp_outlined.willreturn
; CHECK1-SAME: (ptr noalias nocapture nofree readnone [[DOTGLOBAL_TID_:%.*]], ptr noalias nocapture nofree readnone [[DOTBOUND_TID_:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK1-SAME: (ptr noalias nocapture nofree readnone [[DOTGLOBAL_TID_:%.*]], ptr noalias nocapture nofree readnone [[DOTBOUND_TID_:%.*]]) #[[ATTR0:[0-9]+]] {
; CHECK1-NEXT: entry: ; CHECK1-NEXT: entry:
; CHECK1-NEXT: call void @unknown() #[[ATTR0]] ; CHECK1-NEXT: call void @unknown() #[[ATTR0]]
; CHECK1-NEXT: ret void ; CHECK1-NEXT: ret void
; CHECK2-LABEL: define {{[^@]+}}@.omp_outlined.willreturn ; CHECK2-LABEL: define {{[^@]+}}@.omp_outlined.willreturn
Show All 27 Linesentry:
call void @readonly() call void @readonly()
ret void ret void
} }
define internal void @.omp_outlined.willreturn.1(ptr noalias %.global_tid., ptr noalias %.bound_tid.) { define internal void @.omp_outlined.willreturn.1(ptr noalias %.global_tid., ptr noalias %.bound_tid.) {
; CHECK-LABEL: define {{[^@]+}}@.omp_outlined.willreturn.1 ; CHECK-LABEL: define {{[^@]+}}@.omp_outlined.willreturn.1
; CHECK-SAME: (ptr noalias nocapture nofree readnone [[DOTGLOBAL_TID_:%.*]], ptr noalias nocapture nofree readnone [[DOTBOUND_TID_:%.*]]) #[[ATTR2:[0-9]+]] { ; CHECK-SAME: (ptr noalias nocapture nofree readnone [[DOTGLOBAL_TID_:%.*]], ptr noalias nocapture nofree readnone [[DOTBOUND_TID_:%.*]]) #[[ATTR2:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: call void @readnone() #[[ATTR0]] ; CHECK-NEXT: call void @readnone() #[[ATTR14]]
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
; CHECK1-LABEL: define {{[^@]+}}@.omp_outlined.willreturn.1 ; CHECK1-LABEL: define {{[^@]+}}@.omp_outlined.willreturn.1
; CHECK1-SAME: (ptr noalias nocapture nofree readnone [[DOTGLOBAL_TID_:%.*]], ptr noalias nocapture nofree readnone [[DOTBOUND_TID_:%.*]]) #[[ATTR2:[0-9]+]] { ; CHECK1-SAME: (ptr noalias nocapture nofree readnone [[DOTGLOBAL_TID_:%.*]], ptr noalias nocapture nofree readnone [[DOTBOUND_TID_:%.*]]) #[[ATTR2:[0-9]+]] {
; CHECK1-NEXT: entry: ; CHECK1-NEXT: entry:
; CHECK1-NEXT: call void @readnone() #[[ATTR0]] ; CHECK1-NEXT: call void @readnone() #[[ATTR0]]
; CHECK1-NEXT: ret void ; CHECK1-NEXT: ret void
; CHECK2-LABEL: define {{[^@]+}}@.omp_outlined.willreturn.1 ; CHECK2-LABEL: define {{[^@]+}}@.omp_outlined.willreturn.1
▲ Show 20 Lines • Show All 172 Lines • ▼ Show 20 Lines
; } ; }
; ;
; FIXME: We do not realize that `a` is dead and all accesses to it can be removed ; FIXME: We do not realize that `a` is dead and all accesses to it can be removed
; making the parallel regions readonly and deletable. ; making the parallel regions readonly and deletable.
define void @delete_parallel_2() { define void @delete_parallel_2() {
; CHECK-LABEL: define {{[^@]+}}@delete_parallel_2() { ; CHECK-LABEL: define {{[^@]+}}@delete_parallel_2() {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4 ; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 4, ptr noundef nonnull align 4 dereferenceable(4) [[A]]) #[[ATTR0]] ; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 4, ptr noundef nonnull align 4 dereferenceable(4) [[A]]) #[[ATTR14]]
; CHECK-NEXT: store i32 0, ptr [[A]], align 4 ; CHECK-NEXT: store i32 0, ptr [[A]], align 4
; CHECK-NEXT: call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr noundef nonnull align 8 dereferenceable(24) @[[GLOB0]], i32 noundef 1, ptr noundef @.omp_outlined..3, ptr nocapture nofree noundef nonnull align 4 dereferenceable(4) [[A]]) ; CHECK-NEXT: call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr noundef nonnull align 8 dereferenceable(24) @[[GLOB0]], i32 noundef 1, ptr noundef @.omp_outlined..3, ptr nocapture nofree noundef nonnull align 4 dereferenceable(4) [[A]])
; CHECK-NEXT: call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr noundef nonnull align 8 dereferenceable(24) @[[GLOB0]], i32 noundef 1, ptr noundef @.omp_outlined..4, ptr nocapture nofree noundef nonnull align 4 dereferenceable(4) [[A]]) ; CHECK-NEXT: call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr noundef nonnull align 8 dereferenceable(24) @[[GLOB0]], i32 noundef 1, ptr noundef @.omp_outlined..4, ptr nocapture nofree noundef nonnull align 4 dereferenceable(4) [[A]])
; CHECK-NEXT: call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr noundef nonnull align 8 dereferenceable(24) @[[GLOB0]], i32 noundef 1, ptr noundef @.omp_outlined..5, ptr nocapture nofree noundef nonnull align 4 dereferenceable(4) [[A]]) ; CHECK-NEXT: call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr noundef nonnull align 8 dereferenceable(24) @[[GLOB0]], i32 noundef 1, ptr noundef @.omp_outlined..5, ptr nocapture nofree noundef nonnull align 4 dereferenceable(4) [[A]])
; CHECK-NEXT: call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr noundef nonnull align 8 dereferenceable(24) @[[GLOB0]], i32 noundef 1, ptr noundef @.omp_outlined..6, ptr nocapture noundef nonnull align 4 dereferenceable(4) [[A]]) ; CHECK-NEXT: call void (ptr, i32, ptr, ...) @__kmpc_fork_call(ptr noundef nonnull align 8 dereferenceable(24) @[[GLOB0]], i32 noundef 1, ptr noundef @.omp_outlined..6, ptr nocapture noundef nonnull align 4 dereferenceable(4) [[A]])
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 noundef 4, ptr noundef nonnull [[A]]) ; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 noundef 4, ptr noundef nonnull [[A]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
▲ Show 20 Lines • Show All 232 Lines • ▼ Show 20 Lines
} }
define internal void @.omp_outlined..6(ptr noalias %.global_tid., ptr noalias %.bound_tid., ptr dereferenceable(4) %a) { define internal void @.omp_outlined..6(ptr noalias %.global_tid., ptr noalias %.bound_tid., ptr dereferenceable(4) %a) {
; CHECK-LABEL: define {{[^@]+}}@.omp_outlined..6 ; CHECK-LABEL: define {{[^@]+}}@.omp_outlined..6
; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[DOTGLOBAL_TID_:%.*]], ptr noalias nocapture nofree readnone [[DOTBOUND_TID_:%.*]], ptr nocapture noundef nonnull align 4 dereferenceable(4) [[A:%.*]]) { ; CHECK-SAME: (ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[DOTGLOBAL_TID_:%.*]], ptr noalias nocapture nofree readnone [[DOTBOUND_TID_:%.*]], ptr nocapture noundef nonnull align 4 dereferenceable(4) [[A:%.*]]) {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[A1:%.*]] = alloca i32, align 4 ; CHECK-NEXT: [[A1:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[DOTOMP_REDUCTION_RED_LIST:%.*]] = alloca [1 x ptr], align 8 ; CHECK-NEXT: [[DOTOMP_REDUCTION_RED_LIST:%.*]] = alloca [1 x ptr], align 8
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 4, ptr noundef nonnull align 4 [[A1]]) #[[ATTR14:[0-9]+]] ; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 noundef 4, ptr noundef nonnull align 4 [[A1]]) #[[ATTR15:[0-9]+]]
; CHECK-NEXT: store i32 1, ptr [[A1]], align 4 ; CHECK-NEXT: store i32 1, ptr [[A1]], align 4
; CHECK-NEXT: store ptr [[A1]], ptr [[DOTOMP_REDUCTION_RED_LIST]], align 8 ; CHECK-NEXT: store ptr [[A1]], ptr [[DOTOMP_REDUCTION_RED_LIST]], align 8
; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[DOTGLOBAL_TID_]], align 4 ; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[DOTGLOBAL_TID_]], align 4
; CHECK-NEXT: [[TMP4:%.*]] = call i32 @__kmpc_reduce_nowait(ptr noundef nonnull @[[GLOB2:[0-9]+]], i32 [[TMP2]], i32 noundef 1, i64 noundef 8, ptr noundef nonnull align 8 [[DOTOMP_REDUCTION_RED_LIST]], ptr noundef nonnull @.omp.reduction.reduction_func, ptr noundef nonnull @.gomp_critical_user_.reduction.var) ; CHECK-NEXT: [[TMP4:%.*]] = call i32 @__kmpc_reduce_nowait(ptr noundef nonnull @[[GLOB2:[0-9]+]], i32 [[TMP2]], i32 noundef 1, i64 noundef 8, ptr noundef nonnull align 8 [[DOTOMP_REDUCTION_RED_LIST]], ptr noundef nonnull @.omp.reduction.reduction_func, ptr noundef nonnull @.gomp_critical_user_.reduction.var)
; CHECK-NEXT: switch i32 [[TMP4]], label [[DOTOMP_REDUCTION_DEFAULT:%.*]] [ ; CHECK-NEXT: switch i32 [[TMP4]], label [[DOTOMP_REDUCTION_DEFAULT:%.*]] [
; CHECK-NEXT: i32 1, label [[DOTOMP_REDUCTION_CASE1:%.*]] ; CHECK-NEXT: i32 1, label [[DOTOMP_REDUCTION_CASE1:%.*]]
; CHECK-NEXT: i32 2, label [[DOTOMP_REDUCTION_CASE2:%.*]] ; CHECK-NEXT: i32 2, label [[DOTOMP_REDUCTION_CASE2:%.*]]
; CHECK-NEXT: ] ; CHECK-NEXT: ]
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines