This is an archive of the discontinued LLVM Phabricator instance.

Differential D86361

[Attributor] fix AANoUndef initialization
ClosedPublic

Authored by okura on Aug 21 2020, 11:16 AM.

Details

Reviewers
uenoku
jdoerfert
homerdin
sstefan1
baziotis
Commits
rGe21a22a7a8b7: [Attributor] fix AANoUndef initialization
Summary

Currently, AANoUndefImpl::initialize mistakenly always indicates optimistic fixpoint for function returned position.
This is because an associated value is Function in the case, and isGuaranteedNotToBeUndefOrPoison returns true for Function.

Diff Detail

Event Timeline

okura created this revision.Aug 21 2020, 11:16 AM
Herald added a reviewer: uenoku. · View Herald TranscriptAug 21 2020, 11:16 AM
Herald added a reviewer: jdoerfert. · View Herald Transcript
Herald added a reviewer: homerdin. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: llvm-commits, kuter, uenoku, hiraditya. · View Herald Transcript
okura requested review of this revision.Aug 21 2020, 11:16 AM
Herald added a reviewer: sstefan1. · View Herald TranscriptAug 21 2020, 11:16 AM
Herald added a reviewer: baziotis. · View Herald Transcript
Herald added a subscriber: bbn. · View Herald Transcript
jdoerfert added inline comments.Aug 21 2020, 11:56 AM
llvm/lib/Transforms/IPO/AttributorAttributes.cpp
7718–7719

can we check the position kind instead? This impacts function pointers as well.

okura updated this revision to Diff 287080.Aug 21 2020, 12:20 PM
  • change to check IR position
okura marked an inline comment as done.Aug 21 2020, 12:20 PM
okura updated this revision to Diff 287086.Aug 21 2020, 12:52 PM
  • delete unnecessary format change
jdoerfert accepted this revision.Aug 21 2020, 1:01 PM

LGTM thx

This revision is now accepted and ready to land.Aug 21 2020, 1:01 PM
Closed by commit rGe21a22a7a8b7: [Attributor] fix AANoUndef initialization (authored by okura). · Explain WhyAug 21 2020, 1:21 PM
This revision was automatically updated to reflect the committed changes.
okura added a commit: rGe21a22a7a8b7: [Attributor] fix AANoUndef initialization.

Revision Contents

PathSize
llvm/
lib/
Transforms/
IPO/
3 lines
test/
Transforms/
Attributor/
ArgumentPromotion/
X86/
8 lines
IPConstantProp/
8 lines
22 lines
98 lines
610 lines
26 lines
141 lines
18 lines
16 lines
40 lines

Diff 287086

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 7,709 Lines • ▼ Show 20 Linesstruct AANoUndefImpl : AANoUndef {
/// See AbstractAttribute::initialize(...). /// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override { void initialize(Attributor &A) override {
Value &V = getAssociatedValue(); Value &V = getAssociatedValue();
if (isa<UndefValue>(V)) if (isa<UndefValue>(V))
indicatePessimisticFixpoint(); indicatePessimisticFixpoint();
else if (isa<FreezeInst>(V)) else if (isa<FreezeInst>(V))
indicateOptimisticFixpoint(); indicateOptimisticFixpoint();
else if (isGuaranteedNotToBeUndefOrPoison(&V)) else if (getPositionKind() != IRPosition::IRP_RETURNED &&
isGuaranteedNotToBeUndefOrPoison(&V))
jdoerfertUnsubmitted
Done
ReplyInline Actions

can we check the position kind instead? This impacts function pointers as well.

jdoerfert: can we check the position kind instead? This impacts function pointers as well.
indicateOptimisticFixpoint(); indicateOptimisticFixpoint();
else else
AANoUndef::initialize(A); AANoUndef::initialize(A);
} }
/// See followUsesInMBEC /// See followUsesInMBEC
bool followUseInMBEC(Attributor &A, const Use *U, const Instruction *I, bool followUseInMBEC(Attributor &A, const Use *U, const Instruction *I,
AANoUndef::StateType &State) { AANoUndef::StateType &State) {
▲ Show 20 Lines • Show All 247 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Linesentry:
call void @ext(<{ %struct.a }>* inalloca %argmem) call void @ext(<{ %struct.a }>* inalloca %argmem)
ret void ret void
} }
; This is here to ensure @internalfun is live. ; This is here to ensure @internalfun is live.
define void @exportedfun(%struct.a* %a) { define void @exportedfun(%struct.a* %a) {
; IS__TUNIT____-LABEL: define {{[^@]+}}@exportedfun ; IS__TUNIT____-LABEL: define {{[^@]+}}@exportedfun
; IS__TUNIT____-SAME: (%struct.a* nocapture nofree readnone [[A:%.*]]) ; IS__TUNIT____-SAME: (%struct.a* nocapture nofree readnone [[A:%.*]])
; IS__TUNIT____-NEXT: [[INALLOCA_SAVE:%.*]] = tail call noundef i8* @llvm.stacksave() ; IS__TUNIT____-NEXT: [[INALLOCA_SAVE:%.*]] = tail call i8* @llvm.stacksave()
; IS__TUNIT____-NEXT: [[ARGMEM:%.*]] = alloca inalloca <{ [[STRUCT_A:%.*]] }>, align 4 ; IS__TUNIT____-NEXT: [[ARGMEM:%.*]] = alloca inalloca <{ [[STRUCT_A:%.*]] }>, align 4
; IS__TUNIT____-NEXT: call x86_thiscallcc void @internalfun(%struct.a* noalias nocapture nofree readnone undef, <{ [[STRUCT_A]] }>* inalloca noundef nonnull align 4 dereferenceable(1) [[ARGMEM]]) ; IS__TUNIT____-NEXT: call x86_thiscallcc void @internalfun(%struct.a* noalias nocapture nofree readnone undef, <{ [[STRUCT_A]] }>* inalloca noundef nonnull align 4 dereferenceable(1) [[ARGMEM]])
; IS__TUNIT____-NEXT: call void @llvm.stackrestore(i8* noundef [[INALLOCA_SAVE]]) ; IS__TUNIT____-NEXT: call void @llvm.stackrestore(i8* [[INALLOCA_SAVE]])
; IS__TUNIT____-NEXT: ret void ; IS__TUNIT____-NEXT: ret void
; ;
; IS__CGSCC____-LABEL: define {{[^@]+}}@exportedfun ; IS__CGSCC____-LABEL: define {{[^@]+}}@exportedfun
; IS__CGSCC____-SAME: (%struct.a* nocapture nofree readnone [[A:%.*]]) ; IS__CGSCC____-SAME: (%struct.a* nocapture nofree readnone [[A:%.*]])
; IS__CGSCC____-NEXT: [[INALLOCA_SAVE:%.*]] = tail call noundef i8* @llvm.stacksave() ; IS__CGSCC____-NEXT: [[INALLOCA_SAVE:%.*]] = tail call i8* @llvm.stacksave()
; IS__CGSCC____-NEXT: [[ARGMEM:%.*]] = alloca inalloca <{ [[STRUCT_A:%.*]] }>, align 4 ; IS__CGSCC____-NEXT: [[ARGMEM:%.*]] = alloca inalloca <{ [[STRUCT_A:%.*]] }>, align 4
; IS__CGSCC____-NEXT: call x86_thiscallcc void @internalfun(%struct.a* noalias nocapture nofree readnone [[A]], <{ [[STRUCT_A]] }>* inalloca noundef nonnull align 4 dereferenceable(1) [[ARGMEM]]) ; IS__CGSCC____-NEXT: call x86_thiscallcc void @internalfun(%struct.a* noalias nocapture nofree readnone [[A]], <{ [[STRUCT_A]] }>* inalloca noundef nonnull align 4 dereferenceable(1) [[ARGMEM]])
; IS__CGSCC____-NEXT: call void @llvm.stackrestore(i8* noundef [[INALLOCA_SAVE]]) ; IS__CGSCC____-NEXT: call void @llvm.stackrestore(i8* [[INALLOCA_SAVE]])
; IS__CGSCC____-NEXT: ret void ; IS__CGSCC____-NEXT: ret void
; ;
%inalloca.save = tail call i8* @llvm.stacksave() %inalloca.save = tail call i8* @llvm.stacksave()
%argmem = alloca inalloca <{ %struct.a }>, align 4 %argmem = alloca inalloca <{ %struct.a }>, align 4
call x86_thiscallcc void @internalfun(%struct.a* %a, <{ %struct.a }>* inalloca %argmem) call x86_thiscallcc void @internalfun(%struct.a* %a, <{ %struct.a }>* inalloca %argmem)
call void @llvm.stackrestore(i8* %inalloca.save) call void @llvm.stackrestore(i8* %inalloca.save)
ret void ret void
} }
declare x86_thiscallcc %struct.a* @copy_ctor(%struct.a* returned, %struct.a* dereferenceable(1)) declare x86_thiscallcc %struct.a* @copy_ctor(%struct.a* returned, %struct.a* dereferenceable(1))
declare void @ext(<{ %struct.a }>* inalloca) declare void @ext(<{ %struct.a }>* inalloca)
declare i8* @llvm.stacksave() declare i8* @llvm.stacksave()
declare void @llvm.stackrestore(i8*) declare void @llvm.stackrestore(i8*)

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

Show All 24 Lines
; IS__TUNIT____-NEXT: [[CA2:%.*]] = musttail call i8* @dont_zap_me(i8 undef) ; IS__TUNIT____-NEXT: [[CA2:%.*]] = musttail call i8* @dont_zap_me(i8 undef)
; IS__TUNIT____-NEXT: ret i8* [[CA2]] ; IS__TUNIT____-NEXT: ret i8* [[CA2]]
; ;
; IS__CGSCC____-LABEL: define {{[^@]+}}@start ; IS__CGSCC____-LABEL: define {{[^@]+}}@start
; IS__CGSCC____-SAME: (i8 [[V:%.*]]) ; IS__CGSCC____-SAME: (i8 [[V:%.*]])
; IS__CGSCC____-NEXT: [[C1:%.*]] = icmp eq i8 [[V]], 0 ; IS__CGSCC____-NEXT: [[C1:%.*]] = icmp eq i8 [[V]], 0
; IS__CGSCC____-NEXT: br i1 [[C1]], label [[TRUE:%.*]], label [[FALSE:%.*]] ; IS__CGSCC____-NEXT: br i1 [[C1]], label [[TRUE:%.*]], label [[FALSE:%.*]]
; IS__CGSCC____: true: ; IS__CGSCC____: true:
; IS__CGSCC____-NEXT: [[CA:%.*]] = musttail call noalias align 536870912 i8* @side_effects(i8 [[V]]) ; IS__CGSCC____-NEXT: [[CA:%.*]] = musttail call noalias noundef align 536870912 i8* @side_effects(i8 [[V]])
; IS__CGSCC____-NEXT: ret i8* [[CA]] ; IS__CGSCC____-NEXT: ret i8* [[CA]]
; IS__CGSCC____: false: ; IS__CGSCC____: false:
; IS__CGSCC____-NEXT: [[C2:%.*]] = icmp eq i8 [[V]], 1 ; IS__CGSCC____-NEXT: [[C2:%.*]] = icmp eq i8 [[V]], 1
; IS__CGSCC____-NEXT: br i1 [[C2]], label [[C2_TRUE:%.*]], label [[C2_FALSE:%.*]] ; IS__CGSCC____-NEXT: br i1 [[C2]], label [[C2_TRUE:%.*]], label [[C2_FALSE:%.*]]
; IS__CGSCC____: c2_true: ; IS__CGSCC____: c2_true:
; IS__CGSCC____-NEXT: [[CA1:%.*]] = musttail call noalias align 536870912 i8* @no_side_effects(i8 [[V]]) ; IS__CGSCC____-NEXT: [[CA1:%.*]] = musttail call noalias noundef align 536870912 i8* @no_side_effects(i8 [[V]])
; IS__CGSCC____-NEXT: ret i8* [[CA1]] ; IS__CGSCC____-NEXT: ret i8* [[CA1]]
; IS__CGSCC____: c2_false: ; IS__CGSCC____: c2_false:
; IS__CGSCC____-NEXT: [[CA2:%.*]] = musttail call noalias align 536870912 i8* @dont_zap_me(i8 [[V]]) ; IS__CGSCC____-NEXT: [[CA2:%.*]] = musttail call noalias noundef align 536870912 i8* @dont_zap_me(i8 [[V]])
; IS__CGSCC____-NEXT: ret i8* [[CA2]] ; IS__CGSCC____-NEXT: ret i8* [[CA2]]
; ;
%c1 = icmp eq i8 %v, 0 %c1 = icmp eq i8 %v, 0
br i1 %c1, label %true, label %false br i1 %c1, label %true, label %false
true: true:
; FIXME: propagate the value information for %v ; FIXME: propagate the value information for %v
%ca = musttail call i8* @side_effects(i8 %v) %ca = musttail call i8* @side_effects(i8 %v)
ret i8* %ca ret i8* %ca
Show All 14 Lines
; IS__TUNIT____-SAME: (i8 [[V:%.*]]) ; IS__TUNIT____-SAME: (i8 [[V:%.*]])
; IS__TUNIT____-NEXT: [[I1:%.*]] = call i32 @external() ; IS__TUNIT____-NEXT: [[I1:%.*]] = call i32 @external()
; IS__TUNIT____-NEXT: [[CA:%.*]] = musttail call i8* @start(i8 [[V]]) ; IS__TUNIT____-NEXT: [[CA:%.*]] = musttail call i8* @start(i8 [[V]])
; IS__TUNIT____-NEXT: ret i8* [[CA]] ; IS__TUNIT____-NEXT: ret i8* [[CA]]
; ;
; IS__CGSCC____-LABEL: define {{[^@]+}}@side_effects ; IS__CGSCC____-LABEL: define {{[^@]+}}@side_effects
; IS__CGSCC____-SAME: (i8 [[V:%.*]]) ; IS__CGSCC____-SAME: (i8 [[V:%.*]])
; IS__CGSCC____-NEXT: [[I1:%.*]] = call i32 @external() ; IS__CGSCC____-NEXT: [[I1:%.*]] = call i32 @external()
; IS__CGSCC____-NEXT: [[CA:%.*]] = musttail call noalias align 536870912 i8* @start(i8 [[V]]) ; IS__CGSCC____-NEXT: [[CA:%.*]] = musttail call noalias noundef align 536870912 i8* @start(i8 [[V]])
; IS__CGSCC____-NEXT: ret i8* [[CA]] ; IS__CGSCC____-NEXT: ret i8* [[CA]]
; ;
%i1 = call i32 @external() %i1 = call i32 @external()
; since this goes back to `start` the SCPP should be see that the return value ; since this goes back to `start` the SCPP should be see that the return value
; is always `null`. ; is always `null`.
; The call can't be removed due to `external` call above, though. ; The call can't be removed due to `external` call above, though.
Show All 29 Lines

llvm/test/Transforms/Attributor/align.ll

Show First 20 Lines • Show All 228 Lines • ▼ Show 20 Lines
; ;
; IS__CGSCC_OPM: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn ; IS__CGSCC_OPM: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test7() ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test7()
; IS__CGSCC_OPM-NEXT: [[C:%.*]] = tail call i8* @f1(i8* noalias nofree noundef nonnull readnone align 8 dereferenceable(1) @a1) ; IS__CGSCC_OPM-NEXT: [[C:%.*]] = tail call i8* @f1(i8* noalias nofree noundef nonnull readnone align 8 dereferenceable(1) @a1)
; IS__CGSCC_OPM-NEXT: ret i8* [[C]] ; IS__CGSCC_OPM-NEXT: ret i8* [[C]]
; ;
; IS__CGSCC_NPM: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn ; IS__CGSCC_NPM: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn
; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test7() ; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test7()
; IS__CGSCC_NPM-NEXT: [[C:%.*]] = tail call nonnull align 8 dereferenceable(1) i8* @f1() ; IS__CGSCC_NPM-NEXT: [[C:%.*]] = tail call noundef nonnull align 8 dereferenceable(1) i8* @f1()
; IS__CGSCC_NPM-NEXT: ret i8* [[C]] ; IS__CGSCC_NPM-NEXT: ret i8* [[C]]
; ;
%c = tail call i8* @f1(i8* align 8 dereferenceable(1) @a1) %c = tail call i8* @f1(i8* align 8 dereferenceable(1) @a1)
ret i8* %c ret i8* %c
} }
; TEST 7b ; TEST 7b
; Function Attrs: nounwind readnone ssp uwtable ; Function Attrs: nounwind readnone ssp uwtable
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
; ;
tail call i8* @f1b(i8* align 8 dereferenceable(1) @a1) tail call i8* @f1b(i8* align 8 dereferenceable(1) @a1)
ret i32* %p ret i32* %p
} }
; TEST 8 ; TEST 8
define void @test8_helper() { define void @test8_helper() {
; CHECK-LABEL: define {{[^@]+}}@test8_helper() ; CHECK-LABEL: define {{[^@]+}}@test8_helper()
; CHECK-NEXT: [[PTR0:%.*]] = tail call noundef i32* @unknown() ; CHECK-NEXT: [[PTR0:%.*]] = tail call i32* @unknown()
; CHECK-NEXT: [[PTR1:%.*]] = tail call noundef align 4 i32* @unknown() ; CHECK-NEXT: [[PTR1:%.*]] = tail call align 4 i32* @unknown()
; CHECK-NEXT: [[PTR2:%.*]] = tail call noundef align 8 i32* @unknown() ; CHECK-NEXT: [[PTR2:%.*]] = tail call align 8 i32* @unknown()
; CHECK-NEXT: tail call void @test8(i32* noalias nocapture noundef readnone align 4 [[PTR1]], i32* noalias nocapture noundef readnone align 4 [[PTR1]], i32* noalias nocapture noundef readnone [[PTR0]]) ; CHECK-NEXT: tail call void @test8(i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone [[PTR0]])
; CHECK-NEXT: tail call void @test8(i32* noalias nocapture noundef readnone align 8 [[PTR2]], i32* noalias nocapture noundef readnone align 4 [[PTR1]], i32* noalias nocapture noundef readnone align 4 [[PTR1]]) ; CHECK-NEXT: tail call void @test8(i32* noalias nocapture readnone align 8 [[PTR2]], i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone align 4 [[PTR1]])
; CHECK-NEXT: tail call void @test8(i32* noalias nocapture noundef readnone align 8 [[PTR2]], i32* noalias nocapture noundef readnone align 4 [[PTR1]], i32* noalias nocapture noundef readnone align 4 [[PTR1]]) ; CHECK-NEXT: tail call void @test8(i32* noalias nocapture readnone align 8 [[PTR2]], i32* noalias nocapture readnone align 4 [[PTR1]], i32* noalias nocapture readnone align 4 [[PTR1]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%ptr0 = tail call i32* @unknown() %ptr0 = tail call i32* @unknown()
%ptr1 = tail call align 4 i32* @unknown() %ptr1 = tail call align 4 i32* @unknown()
%ptr2 = tail call align 8 i32* @unknown() %ptr2 = tail call align 8 i32* @unknown()
tail call void @test8(i32* %ptr1, i32* %ptr1, i32* %ptr0) tail call void @test8(i32* %ptr1, i32* %ptr1, i32* %ptr0)
tail call void @test8(i32* %ptr2, i32* %ptr1, i32* %ptr1) tail call void @test8(i32* %ptr2, i32* %ptr1, i32* %ptr1)
tail call void @test8(i32* %ptr2, i32* %ptr1, i32* %ptr1) tail call void @test8(i32* %ptr2, i32* %ptr1, i32* %ptr1)
ret void ret void
} }
declare void @user_i32_ptr(i32* nocapture readnone) nounwind declare void @user_i32_ptr(i32* nocapture readnone) nounwind
define internal void @test8(i32* %a, i32* %b, i32* %c) { define internal void @test8(i32* %a, i32* %b, i32* %c) {
; IS__TUNIT____: Function Attrs: nounwind ; IS__TUNIT____: Function Attrs: nounwind
; IS__TUNIT____-LABEL: define {{[^@]+}}@test8 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test8
; IS__TUNIT____-SAME: (i32* noalias nocapture noundef readnone align 4 [[A:%.*]], i32* noalias nocapture noundef readnone align 4 [[B:%.*]], i32* noalias nocapture noundef readnone [[C:%.*]]) ; IS__TUNIT____-SAME: (i32* noalias nocapture readnone align 4 [[A:%.*]], i32* noalias nocapture readnone align 4 [[B:%.*]], i32* noalias nocapture readnone [[C:%.*]])
; IS__TUNIT____-NEXT: call void @user_i32_ptr(i32* noalias nocapture noundef readnone align 4 [[A]]) ; IS__TUNIT____-NEXT: call void @user_i32_ptr(i32* noalias nocapture readnone align 4 [[A]])
; IS__TUNIT____-NEXT: call void @user_i32_ptr(i32* noalias nocapture noundef readnone align 4 [[B]]) ; IS__TUNIT____-NEXT: call void @user_i32_ptr(i32* noalias nocapture readnone align 4 [[B]])
; IS__TUNIT____-NEXT: call void @user_i32_ptr(i32* noalias nocapture noundef readnone [[C]]) ; IS__TUNIT____-NEXT: call void @user_i32_ptr(i32* noalias nocapture readnone [[C]])
; IS__TUNIT____-NEXT: ret void ; IS__TUNIT____-NEXT: ret void
; ;
; IS__CGSCC____: Function Attrs: nounwind ; IS__CGSCC____: Function Attrs: nounwind
; IS__CGSCC____-LABEL: define {{[^@]+}}@test8 ; IS__CGSCC____-LABEL: define {{[^@]+}}@test8
; IS__CGSCC____-SAME: (i32* nocapture readnone align 4 [[A:%.*]], i32* nocapture readnone align 4 [[B:%.*]], i32* nocapture readnone [[C:%.*]]) ; IS__CGSCC____-SAME: (i32* nocapture readnone align 4 [[A:%.*]], i32* nocapture readnone align 4 [[B:%.*]], i32* nocapture readnone [[C:%.*]])
; IS__CGSCC____-NEXT: call void @user_i32_ptr(i32* noalias nocapture readnone align 4 [[A]]) ; IS__CGSCC____-NEXT: call void @user_i32_ptr(i32* noalias nocapture readnone align 4 [[A]])
; IS__CGSCC____-NEXT: call void @user_i32_ptr(i32* noalias nocapture readnone align 4 [[B]]) ; IS__CGSCC____-NEXT: call void @user_i32_ptr(i32* noalias nocapture readnone align 4 [[B]])
; IS__CGSCC____-NEXT: call void @user_i32_ptr(i32* noalias nocapture readnone [[C]]) ; IS__CGSCC____-NEXT: call void @user_i32_ptr(i32* noalias nocapture readnone [[C]])
▲ Show 20 Lines • Show All 556 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 269 Lines • ▼ Show 20 Linesif.true:
%D = tail call i32 @unkown_f(i32* dereferenceable(8) %ptr) %D = tail call i32 @unkown_f(i32* dereferenceable(8) %ptr)
%E = tail call i32 @unkown_f(i32* %ptr) %E = tail call i32 @unkown_f(i32* %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) {
; NOT_CGSCC_NPM: Function Attrs: nounwind willreturn ; CHECK: Function Attrs: nounwind willreturn
; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@f7_2 ; CHECK-LABEL: define {{[^@]+}}@f7_2
; NOT_CGSCC_NPM-SAME: (i1 [[C:%.*]]) ; CHECK-SAME: (i1 [[C:%.*]])
; NOT_CGSCC_NPM-NEXT: [[PTR:%.*]] = tail call noundef nonnull align 4 dereferenceable(4) i32* @unkown_ptr() ; CHECK-NEXT: [[PTR:%.*]] = tail call nonnull align 4 dereferenceable(4) i32* @unkown_ptr()
; NOT_CGSCC_NPM-NEXT: [[A:%.*]] = tail call i32 @unkown_f(i32* noundef nonnull align 4 dereferenceable(4) [[PTR]]) ; CHECK-NEXT: [[A:%.*]] = tail call i32 @unkown_f(i32* nonnull align 4 dereferenceable(4) [[PTR]])
; NOT_CGSCC_NPM-NEXT: [[ARG_A_0:%.*]] = load i32, i32* [[PTR]], align 4 ; CHECK-NEXT: [[ARG_A_0:%.*]] = load i32, i32* [[PTR]], align 4
; NOT_CGSCC_NPM-NEXT: [[B:%.*]] = tail call i32 @unkown_f(i32* noundef nonnull align 4 dereferenceable(4) [[PTR]]) ; CHECK-NEXT: [[B:%.*]] = tail call i32 @unkown_f(i32* nonnull align 4 dereferenceable(4) [[PTR]])
; NOT_CGSCC_NPM-NEXT: br i1 [[C]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]] ; CHECK-NEXT: br i1 [[C]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]]
; NOT_CGSCC_NPM: if.true: ; CHECK: if.true:
; NOT_CGSCC_NPM-NEXT: [[C:%.*]] = tail call i32 @unkown_f(i32* noundef nonnull align 4 dereferenceable(8) [[PTR]]) ; CHECK-NEXT: [[C:%.*]] = tail call i32 @unkown_f(i32* nonnull align 4 dereferenceable(8) [[PTR]])
; NOT_CGSCC_NPM-NEXT: [[D:%.*]] = tail call i32 @unkown_f(i32* noundef nonnull align 4 dereferenceable(8) [[PTR]]) ; CHECK-NEXT: [[D:%.*]] = tail call i32 @unkown_f(i32* nonnull align 4 dereferenceable(8) [[PTR]])
; NOT_CGSCC_NPM-NEXT: [[E:%.*]] = tail call i32 @unkown_f(i32* noundef nonnull align 4 dereferenceable(8) [[PTR]]) ; CHECK-NEXT: [[E:%.*]] = tail call i32 @unkown_f(i32* nonnull align 4 dereferenceable(8) [[PTR]])
; NOT_CGSCC_NPM-NEXT: ret void ; CHECK-NEXT: ret void
; NOT_CGSCC_NPM: if.false: ; CHECK: if.false:
; NOT_CGSCC_NPM-NEXT: ret void ; CHECK-NEXT: ret void
;
; IS__CGSCC_NPM: Function Attrs: nounwind willreturn
; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@f7_2
; IS__CGSCC_NPM-SAME: (i1 [[C:%.*]])
; IS__CGSCC_NPM-NEXT: [[PTR:%.*]] = tail call nonnull align 4 dereferenceable(4) i32* @unkown_ptr()
; IS__CGSCC_NPM-NEXT: [[A:%.*]] = tail call i32 @unkown_f(i32* noundef nonnull align 4 dereferenceable(4) [[PTR]])
; IS__CGSCC_NPM-NEXT: [[ARG_A_0:%.*]] = load i32, i32* [[PTR]], align 4
; IS__CGSCC_NPM-NEXT: [[B:%.*]] = tail call i32 @unkown_f(i32* noundef nonnull align 4 dereferenceable(4) [[PTR]])
; IS__CGSCC_NPM-NEXT: br i1 [[C]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]]
; IS__CGSCC_NPM: if.true:
; IS__CGSCC_NPM-NEXT: [[C:%.*]] = tail call i32 @unkown_f(i32* noundef nonnull align 4 dereferenceable(8) [[PTR]])
; IS__CGSCC_NPM-NEXT: [[D:%.*]] = tail call i32 @unkown_f(i32* noundef nonnull align 4 dereferenceable(8) [[PTR]])
; IS__CGSCC_NPM-NEXT: [[E:%.*]] = tail call i32 @unkown_f(i32* noundef nonnull align 4 dereferenceable(8) [[PTR]])
; IS__CGSCC_NPM-NEXT: ret void
; IS__CGSCC_NPM: if.false:
; IS__CGSCC_NPM-NEXT: ret void
; ;
%ptr = tail call i32* @unkown_ptr() %ptr = tail call i32* @unkown_ptr()
%A = tail call i32 @unkown_f(i32* %ptr) %A = tail call i32 @unkown_f(i32* %ptr)
%arg_a.0 = load i32, i32* %ptr %arg_a.0 = load i32, i32* %ptr
; deref 4 hold ; deref 4 hold
%B = tail call i32 @unkown_f(i32* dereferenceable(1) %ptr) %B = tail call i32 @unkown_f(i32* dereferenceable(1) %ptr)
br i1%c, label %if.true, label %if.false br i1%c, label %if.true, label %if.false
if.true: if.true:
▲ Show 20 Lines • Show All 711 Lines • ▼ Show 20 Lines
; ATTRIBUTOR-NEXT: call void @unknown_use8(i8* nonnull dereferenceable(2) [[ARG1]]) ; ATTRIBUTOR-NEXT: call void @unknown_use8(i8* nonnull dereferenceable(2) [[ARG1]])
; ATTRIBUTOR-NEXT: call void @unknown_use8(i8* nonnull dereferenceable(31) [[ARG2]]) ; ATTRIBUTOR-NEXT: call void @unknown_use8(i8* nonnull dereferenceable(31) [[ARG2]])
; ATTRIBUTOR-NEXT: call void @unknown_use8(i8* nonnull [[ARG3]]) ; ATTRIBUTOR-NEXT: call void @unknown_use8(i8* nonnull [[ARG3]])
; ATTRIBUTOR-NEXT: call void @unknown_use8(i8* nonnull dereferenceable(42) [[ARG4]]) ; ATTRIBUTOR-NEXT: call void @unknown_use8(i8* nonnull dereferenceable(42) [[ARG4]])
; ATTRIBUTOR-NEXT: call void @unknown_use32(i32* nonnull dereferenceable(101) [[P]]) ; ATTRIBUTOR-NEXT: call void @unknown_use32(i32* nonnull dereferenceable(101) [[P]])
; ATTRIBUTOR-NEXT: call void @unknown() ; ATTRIBUTOR-NEXT: call void @unknown()
; ATTRIBUTOR-NEXT: ret void ; ATTRIBUTOR-NEXT: ret void
; ;
; NOT_CGSCC_OPM-LABEL: define {{[^@]+}}@nonnull_assume_call ; CHECK-LABEL: define {{[^@]+}}@nonnull_assume_call
; NOT_CGSCC_OPM-SAME: (i8* [[ARG1:%.*]], i8* [[ARG2:%.*]], i8* [[ARG3:%.*]], i8* [[ARG4:%.*]]) ; CHECK-SAME: (i8* [[ARG1:%.*]], i8* [[ARG2:%.*]], i8* [[ARG3:%.*]], i8* [[ARG4:%.*]])
; NOT_CGSCC_OPM-NEXT: call void @unknown() ; CHECK-NEXT: call void @unknown()
; NOT_CGSCC_OPM-NEXT: [[P:%.*]] = call noundef nonnull dereferenceable(101) i32* @unkown_ptr() ; CHECK-NEXT: [[P:%.*]] = call nonnull dereferenceable(101) i32* @unkown_ptr()
; NOT_CGSCC_OPM-NEXT: call void @unknown_use32(i32* noundef nonnull dereferenceable(101) [[P]]) ; CHECK-NEXT: call void @unknown_use32(i32* nonnull dereferenceable(101) [[P]])
; NOT_CGSCC_OPM-NEXT: call void @unknown_use8(i8* dereferenceable_or_null(42) [[ARG4]]) ; CHECK-NEXT: call void @unknown_use8(i8* dereferenceable_or_null(42) [[ARG4]])
; NOT_CGSCC_OPM-NEXT: call void @unknown_use8(i8* nonnull [[ARG3]]) ; CHECK-NEXT: call void @unknown_use8(i8* nonnull [[ARG3]])
; NOT_CGSCC_OPM-NEXT: call void @unknown_use8(i8* dereferenceable_or_null(31) [[ARG2]]) ; CHECK-NEXT: call void @unknown_use8(i8* dereferenceable_or_null(31) [[ARG2]])
; NOT_CGSCC_OPM-NEXT: call void @unknown_use8(i8* nonnull dereferenceable(2) [[ARG1]]) ; CHECK-NEXT: call void @unknown_use8(i8* nonnull dereferenceable(2) [[ARG1]])
; NOT_CGSCC_OPM-NEXT: call void @llvm.assume(i1 true) [ "nonnull"(i8* [[ARG3]]), "dereferenceable"(i8* [[ARG1]], i64 1), "dereferenceable"(i8* [[ARG1]], i64 2), "dereferenceable"(i32* [[P]], i64 101), "dereferenceable_or_null"(i8* [[ARG2]], i64 31), "dereferenceable_or_null"(i8* [[ARG4]], i64 42) ] ; CHECK-NEXT: call void @llvm.assume(i1 true) [ "nonnull"(i8* [[ARG3]]), "dereferenceable"(i8* [[ARG1]], i64 1), "dereferenceable"(i8* [[ARG1]], i64 2), "dereferenceable"(i32* [[P]], i64 101), "dereferenceable_or_null"(i8* [[ARG2]], i64 31), "dereferenceable_or_null"(i8* [[ARG4]], i64 42) ]
; NOT_CGSCC_OPM-NEXT: call void @unknown_use8(i8* nonnull dereferenceable(2) [[ARG1]]) ; CHECK-NEXT: call void @unknown_use8(i8* nonnull dereferenceable(2) [[ARG1]])
; NOT_CGSCC_OPM-NEXT: call void @unknown_use8(i8* dereferenceable_or_null(31) [[ARG2]]) ; CHECK-NEXT: call void @unknown_use8(i8* dereferenceable_or_null(31) [[ARG2]])
; NOT_CGSCC_OPM-NEXT: call void @unknown_use8(i8* nonnull [[ARG3]]) ; CHECK-NEXT: call void @unknown_use8(i8* nonnull [[ARG3]])
; NOT_CGSCC_OPM-NEXT: call void @unknown_use8(i8* dereferenceable_or_null(42) [[ARG4]]) ; CHECK-NEXT: call void @unknown_use8(i8* dereferenceable_or_null(42) [[ARG4]])
; NOT_CGSCC_OPM-NEXT: call void @unknown_use32(i32* noundef nonnull dereferenceable(101) [[P]]) ; CHECK-NEXT: call void @unknown_use32(i32* nonnull dereferenceable(101) [[P]])
; NOT_CGSCC_OPM-NEXT: call void @unknown() ; CHECK-NEXT: call void @unknown()
; NOT_CGSCC_OPM-NEXT: ret void ; CHECK-NEXT: ret void
;
; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@nonnull_assume_call
; IS__CGSCC_OPM-SAME: (i8* [[ARG1:%.*]], i8* [[ARG2:%.*]], i8* [[ARG3:%.*]], i8* [[ARG4:%.*]])
; IS__CGSCC_OPM-NEXT: call void @unknown()
; IS__CGSCC_OPM-NEXT: [[P:%.*]] = call nonnull dereferenceable(101) i32* @unkown_ptr()
; IS__CGSCC_OPM-NEXT: call void @unknown_use32(i32* noundef nonnull dereferenceable(101) [[P]])
; IS__CGSCC_OPM-NEXT: call void @unknown_use8(i8* dereferenceable_or_null(42) [[ARG4]])
; IS__CGSCC_OPM-NEXT: call void @unknown_use8(i8* nonnull [[ARG3]])
; IS__CGSCC_OPM-NEXT: call void @unknown_use8(i8* dereferenceable_or_null(31) [[ARG2]])
; IS__CGSCC_OPM-NEXT: call void @unknown_use8(i8* nonnull dereferenceable(2) [[ARG1]])
; IS__CGSCC_OPM-NEXT: call void @llvm.assume(i1 true) [ "nonnull"(i8* [[ARG3]]), "dereferenceable"(i8* [[ARG1]], i64 1), "dereferenceable"(i8* [[ARG1]], i64 2), "dereferenceable"(i32* [[P]], i64 101), "dereferenceable_or_null"(i8* [[ARG2]], i64 31), "dereferenceable_or_null"(i8* [[ARG4]], i64 42) ]
; IS__CGSCC_OPM-NEXT: call void @unknown_use8(i8* nonnull dereferenceable(2) [[ARG1]])
; IS__CGSCC_OPM-NEXT: call void @unknown_use8(i8* dereferenceable_or_null(31) [[ARG2]])
; IS__CGSCC_OPM-NEXT: call void @unknown_use8(i8* nonnull [[ARG3]])
; IS__CGSCC_OPM-NEXT: call void @unknown_use8(i8* dereferenceable_or_null(42) [[ARG4]])
; IS__CGSCC_OPM-NEXT: call void @unknown_use32(i32* noundef nonnull dereferenceable(101) [[P]])
; IS__CGSCC_OPM-NEXT: call void @unknown()
; IS__CGSCC_OPM-NEXT: ret void
; ;
call void @unknown() call void @unknown()
%p = call i32* @unkown_ptr() %p = call i32* @unkown_ptr()
call void @unknown_use32(i32* %p) call void @unknown_use32(i32* %p)
call void @unknown_use8(i8* %arg4) call void @unknown_use8(i8* %arg4)
call void @unknown_use8(i8* %arg3) call void @unknown_use8(i8* %arg3)
call void @unknown_use8(i8* %arg2) call void @unknown_use8(i8* %arg2)
call void @unknown_use8(i8* %arg1) call void @unknown_use8(i8* %arg1)
Show All 15 Lines

llvm/test/Transforms/Attributor/heap_to_stack.ll

Show All 37 Lines;
tail call void @free(i8* %p2) tail call void @free(i8* %p2)
tail call void @nofree_func(i8* %p1) tail call void @nofree_func(i8* %p1)
ret void ret void
} }
; TEST 1 - negative, pointer freed in another function. ; TEST 1 - negative, pointer freed in another function.
define void @test1() { define void @test1() {
; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@test1() ; CHECK-LABEL: define {{[^@]+}}@test1()
; NOT_CGSCC_NPM-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; NOT_CGSCC_NPM-NEXT: tail call void @nocapture_func_frees_pointer(i8* noalias nocapture noundef [[TMP1]]) ; CHECK-NEXT: tail call void @nocapture_func_frees_pointer(i8* noalias nocapture [[TMP1]])
; NOT_CGSCC_NPM-NEXT: tail call void (...) @func_throws() ; CHECK-NEXT: tail call void (...) @func_throws()
; NOT_CGSCC_NPM-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP1]]) ; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
; NOT_CGSCC_NPM-NEXT: ret void ; CHECK-NEXT: ret void
;
; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@test1()
; IS__CGSCC_NPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC_NPM-NEXT: tail call void @nocapture_func_frees_pointer(i8* noalias nocapture noundef [[TMP1]])
; IS__CGSCC_NPM-NEXT: tail call void (...) @func_throws()
; IS__CGSCC_NPM-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP1]])
; IS__CGSCC_NPM-NEXT: ret void
; ;
%1 = tail call noalias i8* @malloc(i64 4) %1 = tail call noalias i8* @malloc(i64 4)
tail call void @nocapture_func_frees_pointer(i8* %1) tail call void @nocapture_func_frees_pointer(i8* %1)
tail call void (...) @func_throws() tail call void (...) @func_throws()
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret void ret void
} }
; TEST 2 - negative, call to a sync function. ; TEST 2 - negative, call to a sync function.
define void @test2() { define void @test2() {
; IS__TUNIT____-LABEL: define {{[^@]+}}@test2() ; CHECK-LABEL: define {{[^@]+}}@test2()
; IS__TUNIT____-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__TUNIT____-NEXT: tail call void @sync_func(i8* noundef [[TMP1]]) ; CHECK-NEXT: tail call void @sync_func(i8* [[TMP1]])
; IS__TUNIT____-NEXT: tail call void @free(i8* nocapture noundef [[TMP1]]) ; CHECK-NEXT: tail call void @free(i8* nocapture [[TMP1]])
; IS__TUNIT____-NEXT: ret void ; CHECK-NEXT: ret void
;
; IS__CGSCC____-LABEL: define {{[^@]+}}@test2()
; IS__CGSCC____-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC____-NEXT: tail call void @sync_func(i8* noundef [[TMP1]])
; IS__CGSCC____-NEXT: tail call void @free(i8* nocapture noundef [[TMP1]])
; IS__CGSCC____-NEXT: ret void
; ;
%1 = tail call noalias i8* @malloc(i64 4) %1 = tail call noalias i8* @malloc(i64 4)
tail call void @sync_func(i8* %1) tail call void @sync_func(i8* %1)
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret void ret void
} }
; TEST 3 - 1 malloc, 1 free ; TEST 3 - 1 malloc, 1 free
define void @test3() { define void @test3() {
; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@test3() ; IS________OPM-LABEL: define {{[^@]+}}@test3()
; IS__TUNIT_OPM-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; IS________OPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__TUNIT_OPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) ; IS________OPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
; IS__TUNIT_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP1]]) ; IS________OPM-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
; IS__TUNIT_OPM-NEXT: ret void ; IS________OPM-NEXT: ret void
; ;
; IS________NPM-LABEL: define {{[^@]+}}@test3() ; IS________NPM-LABEL: define {{[^@]+}}@test3()
; IS________NPM-NEXT: [[TMP1:%.*]] = alloca i8, i64 4, align 1 ; IS________NPM-NEXT: [[TMP1:%.*]] = alloca i8, i64 4, align 1
; IS________NPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) ; IS________NPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
; IS________NPM-NEXT: ret void ; IS________NPM-NEXT: ret void
; ;
; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test3()
; IS__CGSCC_OPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC_OPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]])
; IS__CGSCC_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP1]])
; IS__CGSCC_OPM-NEXT: ret void
;
%1 = tail call noalias i8* @malloc(i64 4) %1 = tail call noalias i8* @malloc(i64 4)
tail call void @no_sync_func(i8* %1) tail call void @no_sync_func(i8* %1)
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret void ret void
} }
define void @test3a(i8* %p) { define void @test3a(i8* %p) {
; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@test3a ; IS________OPM-LABEL: define {{[^@]+}}@test3a
; IS__TUNIT_OPM-SAME: (i8* nocapture [[P:%.*]]) ; IS________OPM-SAME: (i8* nocapture [[P:%.*]])
; IS__TUNIT_OPM-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; IS________OPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__TUNIT_OPM-NEXT: tail call void @nofree_arg_only(i8* nocapture nofree noundef [[TMP1]], i8* nocapture [[P]]) ; IS________OPM-NEXT: tail call void @nofree_arg_only(i8* nocapture nofree [[TMP1]], i8* nocapture [[P]])
; IS__TUNIT_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP1]]) ; IS________OPM-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
; IS__TUNIT_OPM-NEXT: ret void ; IS________OPM-NEXT: ret void
; ;
; IS________NPM-LABEL: define {{[^@]+}}@test3a ; IS________NPM-LABEL: define {{[^@]+}}@test3a
; IS________NPM-SAME: (i8* nocapture [[P:%.*]]) ; IS________NPM-SAME: (i8* nocapture [[P:%.*]])
; IS________NPM-NEXT: [[TMP1:%.*]] = alloca i8, i64 4, align 1 ; IS________NPM-NEXT: [[TMP1:%.*]] = alloca i8, i64 4, align 1
; IS________NPM-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree noundef [[TMP1]], i8* nocapture [[P]]) ; IS________NPM-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree [[TMP1]], i8* nocapture [[P]])
; IS________NPM-NEXT: ret void ; IS________NPM-NEXT: ret void
; ;
; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test3a
; IS__CGSCC_OPM-SAME: (i8* nocapture [[P:%.*]])
; IS__CGSCC_OPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC_OPM-NEXT: tail call void @nofree_arg_only(i8* nocapture nofree noundef [[TMP1]], i8* nocapture [[P]])
; IS__CGSCC_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP1]])
; IS__CGSCC_OPM-NEXT: ret void
;
%1 = tail call noalias i8* @malloc(i64 4) %1 = tail call noalias i8* @malloc(i64 4)
tail call void @nofree_arg_only(i8* %1, i8* %p) tail call void @nofree_arg_only(i8* %1, i8* %p)
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret void ret void
} }
declare noalias i8* @aligned_alloc(i64, i64) declare noalias i8* @aligned_alloc(i64, i64)
define void @test3b(i8* %p) { define void @test3b(i8* %p) {
; IS________OPM-LABEL: define {{[^@]+}}@test3b ; IS________OPM-LABEL: define {{[^@]+}}@test3b
; IS________OPM-SAME: (i8* nocapture [[P:%.*]]) ; IS________OPM-SAME: (i8* nocapture [[P:%.*]])
; IS________OPM-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @aligned_alloc(i64 32, i64 128) ; IS________OPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 32, i64 128)
; IS________OPM-NEXT: tail call void @nofree_arg_only(i8* nocapture nofree noundef [[TMP1]], i8* nocapture [[P]]) ; IS________OPM-NEXT: tail call void @nofree_arg_only(i8* nocapture nofree [[TMP1]], i8* nocapture [[P]])
; IS________OPM-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP1]]) ; IS________OPM-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
; IS________OPM-NEXT: ret void ; IS________OPM-NEXT: ret void
; ;
; IS________NPM-LABEL: define {{[^@]+}}@test3b ; IS________NPM-LABEL: define {{[^@]+}}@test3b
; IS________NPM-SAME: (i8* nocapture [[P:%.*]]) ; IS________NPM-SAME: (i8* nocapture [[P:%.*]])
; IS________NPM-NEXT: [[TMP1:%.*]] = alloca i8, i64 128, align 32 ; IS________NPM-NEXT: [[TMP1:%.*]] = alloca i8, i64 128, align 32
; IS________NPM-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree noundef [[TMP1]], i8* nocapture [[P]]) ; IS________NPM-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree [[TMP1]], i8* nocapture [[P]])
; IS________NPM-NEXT: ret void ; IS________NPM-NEXT: ret void
; ;
%1 = tail call noalias i8* @aligned_alloc(i64 32, i64 128) %1 = tail call noalias i8* @aligned_alloc(i64 32, i64 128)
tail call void @nofree_arg_only(i8* %1, i8* %p) tail call void @nofree_arg_only(i8* %1, i8* %p)
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret void ret void
} }
; leave alone non-constant alignments. ; leave alone non-constant alignments.
define void @test3c(i64 %alignment) { define void @test3c(i64 %alignment) {
; NOT_CGSCC_OPM-LABEL: define {{[^@]+}}@test3c ; CHECK-LABEL: define {{[^@]+}}@test3c
; NOT_CGSCC_OPM-SAME: (i64 [[ALIGNMENT:%.*]]) ; CHECK-SAME: (i64 [[ALIGNMENT:%.*]])
; NOT_CGSCC_OPM-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @aligned_alloc(i64 [[ALIGNMENT]], i64 128) ; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 [[ALIGNMENT]], i64 128)
; NOT_CGSCC_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP1]]) ; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
; NOT_CGSCC_OPM-NEXT: ret void ; CHECK-NEXT: ret void
;
; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test3c
; IS__CGSCC_OPM-SAME: (i64 [[ALIGNMENT:%.*]])
; IS__CGSCC_OPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 [[ALIGNMENT]], i64 128)
; IS__CGSCC_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP1]])
; IS__CGSCC_OPM-NEXT: ret void
; ;
%1 = tail call noalias i8* @aligned_alloc(i64 %alignment, i64 128) %1 = tail call noalias i8* @aligned_alloc(i64 %alignment, i64 128)
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret void ret void
} }
declare noalias i8* @calloc(i64, i64) declare noalias i8* @calloc(i64, i64)
define void @test0() { define void @test0() {
; IS________OPM-LABEL: define {{[^@]+}}@test0() ; IS________OPM-LABEL: define {{[^@]+}}@test0()
; IS________OPM-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @calloc(i64 2, i64 4) ; IS________OPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @calloc(i64 2, i64 4)
; IS________OPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) ; IS________OPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
; IS________OPM-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP1]]) ; IS________OPM-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
; IS________OPM-NEXT: ret void ; IS________OPM-NEXT: ret void
; ;
; IS________NPM-LABEL: define {{[^@]+}}@test0() ; IS________NPM-LABEL: define {{[^@]+}}@test0()
; IS________NPM-NEXT: [[TMP1:%.*]] = alloca i8, i64 8, align 1 ; IS________NPM-NEXT: [[TMP1:%.*]] = alloca i8, i64 8, align 1
; IS________NPM-NEXT: [[CALLOC_BC:%.*]] = bitcast i8* [[TMP1]] to i8* ; IS________NPM-NEXT: [[CALLOC_BC:%.*]] = bitcast i8* [[TMP1]] to i8*
; IS________NPM-NEXT: call void @llvm.memset.p0i8.i64(i8* [[CALLOC_BC]], i8 0, i64 8, i1 false) ; IS________NPM-NEXT: call void @llvm.memset.p0i8.i64(i8* [[CALLOC_BC]], i8 0, i64 8, i1 false)
; IS________NPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) ; IS________NPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
; IS________NPM-NEXT: ret void ; IS________NPM-NEXT: ret void
; ;
%1 = tail call noalias i8* @calloc(i64 2, i64 4) %1 = tail call noalias i8* @calloc(i64 2, i64 4)
tail call void @no_sync_func(i8* %1) tail call void @no_sync_func(i8* %1)
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret void ret void
} }
; TEST 4 ; TEST 4
define void @test4() { define void @test4() {
; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@test4() ; IS________OPM-LABEL: define {{[^@]+}}@test4()
; IS__TUNIT_OPM-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; IS________OPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__TUNIT_OPM-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree noundef [[TMP1]]) ; IS________OPM-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree [[TMP1]])
; IS__TUNIT_OPM-NEXT: ret void ; IS________OPM-NEXT: ret void
; ;
; IS________NPM-LABEL: define {{[^@]+}}@test4() ; IS________NPM-LABEL: define {{[^@]+}}@test4()
; IS________NPM-NEXT: [[TMP1:%.*]] = alloca i8, i64 4, align 1 ; IS________NPM-NEXT: [[TMP1:%.*]] = alloca i8, i64 4, align 1
; IS________NPM-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree noundef [[TMP1]]) ; IS________NPM-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree [[TMP1]])
; IS________NPM-NEXT: ret void ; IS________NPM-NEXT: ret void
; ;
; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test4()
; IS__CGSCC_OPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC_OPM-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree noundef [[TMP1]])
; IS__CGSCC_OPM-NEXT: ret void
;
%1 = tail call noalias i8* @malloc(i64 4) %1 = tail call noalias i8* @malloc(i64 4)
tail call void @nofree_func(i8* %1) tail call void @nofree_func(i8* %1)
ret void ret void
} }
; TEST 5 - not all exit paths have a call to free, but all uses of malloc ; TEST 5 - not all exit paths have a call to free, but all uses of malloc
; are in nofree functions and are not captured ; are in nofree functions and are not captured
define void @test5(i32, i8* %p) { define void @test5(i32, i8* %p) {
; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@test5 ; IS________OPM-LABEL: define {{[^@]+}}@test5
; IS__TUNIT_OPM-SAME: (i32 [[TMP0:%.*]], i8* nocapture [[P:%.*]]) ; IS________OPM-SAME: (i32 [[TMP0:%.*]], i8* nocapture [[P:%.*]])
; IS__TUNIT_OPM-NEXT: [[TMP2:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; IS________OPM-NEXT: [[TMP2:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__TUNIT_OPM-NEXT: [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 0 ; IS________OPM-NEXT: [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 0
; IS__TUNIT_OPM-NEXT: br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]] ; IS________OPM-NEXT: br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]]
; IS__TUNIT_OPM: 4: ; IS________OPM: 4:
; IS__TUNIT_OPM-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree noundef [[TMP2]]) ; IS________OPM-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree [[TMP2]])
; IS__TUNIT_OPM-NEXT: br label [[TMP6:%.*]] ; IS________OPM-NEXT: br label [[TMP6:%.*]]
; IS__TUNIT_OPM: 5: ; IS________OPM: 5:
; IS__TUNIT_OPM-NEXT: tail call void @nofree_arg_only(i8* nocapture nofree noundef [[TMP2]], i8* nocapture [[P]]) ; IS________OPM-NEXT: tail call void @nofree_arg_only(i8* nocapture nofree [[TMP2]], i8* nocapture [[P]])
; IS__TUNIT_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP2]]) ; IS________OPM-NEXT: tail call void @free(i8* noalias nocapture [[TMP2]])
; IS__TUNIT_OPM-NEXT: br label [[TMP6]] ; IS________OPM-NEXT: br label [[TMP6]]
; IS__TUNIT_OPM: 6: ; IS________OPM: 6:
; IS__TUNIT_OPM-NEXT: ret void ; IS________OPM-NEXT: ret void
; ;
; IS________NPM-LABEL: define {{[^@]+}}@test5 ; IS________NPM-LABEL: define {{[^@]+}}@test5
; IS________NPM-SAME: (i32 [[TMP0:%.*]], i8* nocapture [[P:%.*]]) ; IS________NPM-SAME: (i32 [[TMP0:%.*]], i8* nocapture [[P:%.*]])
; IS________NPM-NEXT: [[TMP2:%.*]] = alloca i8, i64 4, align 1 ; IS________NPM-NEXT: [[TMP2:%.*]] = alloca i8, i64 4, align 1
; IS________NPM-NEXT: [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 0 ; IS________NPM-NEXT: [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 0
; IS________NPM-NEXT: br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]] ; IS________NPM-NEXT: br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]]
; IS________NPM: 4: ; IS________NPM: 4:
; IS________NPM-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree noundef [[TMP2]]) ; IS________NPM-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree [[TMP2]])
; IS________NPM-NEXT: br label [[TMP6:%.*]] ; IS________NPM-NEXT: br label [[TMP6:%.*]]
; IS________NPM: 5: ; IS________NPM: 5:
; IS________NPM-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree noundef [[TMP2]], i8* nocapture [[P]]) ; IS________NPM-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree [[TMP2]], i8* nocapture [[P]])
; IS________NPM-NEXT: br label [[TMP6]] ; IS________NPM-NEXT: br label [[TMP6]]
; IS________NPM: 6: ; IS________NPM: 6:
; IS________NPM-NEXT: ret void ; IS________NPM-NEXT: ret void
; ;
; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test5
; IS__CGSCC_OPM-SAME: (i32 [[TMP0:%.*]], i8* nocapture [[P:%.*]])
; IS__CGSCC_OPM-NEXT: [[TMP2:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC_OPM-NEXT: [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 0
; IS__CGSCC_OPM-NEXT: br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]]
; IS__CGSCC_OPM: 4:
; IS__CGSCC_OPM-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree noundef [[TMP2]])
; IS__CGSCC_OPM-NEXT: br label [[TMP6:%.*]]
; IS__CGSCC_OPM: 5:
; IS__CGSCC_OPM-NEXT: tail call void @nofree_arg_only(i8* nocapture nofree noundef [[TMP2]], i8* nocapture [[P]])
; IS__CGSCC_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP2]])
; IS__CGSCC_OPM-NEXT: br label [[TMP6]]
; IS__CGSCC_OPM: 6:
; IS__CGSCC_OPM-NEXT: ret void
;
%2 = tail call noalias i8* @malloc(i64 4) %2 = tail call noalias i8* @malloc(i64 4)
%3 = icmp eq i32 %0, 0 %3 = icmp eq i32 %0, 0
br i1 %3, label %5, label %4 br i1 %3, label %5, label %4
4: ; preds = %1 4: ; preds = %1
tail call void @nofree_func(i8* %2) tail call void @nofree_func(i8* %2)
br label %6 br label %6
5: ; preds = %1 5: ; preds = %1
tail call void @nofree_arg_only(i8* %2, i8* %p) tail call void @nofree_arg_only(i8* %2, i8* %p)
tail call void @free(i8* %2) tail call void @free(i8* %2)
br label %6 br label %6
6: ; preds = %5, %4 6: ; preds = %5, %4
ret void ret void
} }
; TEST 6 - all exit paths have a call to free ; TEST 6 - all exit paths have a call to free
define void @test6(i32) { define void @test6(i32) {
; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@test6 ; IS________OPM-LABEL: define {{[^@]+}}@test6
; IS__TUNIT_OPM-SAME: (i32 [[TMP0:%.*]]) ; IS________OPM-SAME: (i32 [[TMP0:%.*]])
; IS__TUNIT_OPM-NEXT: [[TMP2:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; IS________OPM-NEXT: [[TMP2:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__TUNIT_OPM-NEXT: [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 0 ; IS________OPM-NEXT: [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 0
; IS__TUNIT_OPM-NEXT: br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]] ; IS________OPM-NEXT: br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]]
; IS__TUNIT_OPM: 4: ; IS________OPM: 4:
; IS__TUNIT_OPM-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree noundef [[TMP2]]) ; IS________OPM-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree [[TMP2]])
; IS__TUNIT_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP2]]) ; IS________OPM-NEXT: tail call void @free(i8* noalias nocapture [[TMP2]])
; IS__TUNIT_OPM-NEXT: br label [[TMP6:%.*]] ; IS________OPM-NEXT: br label [[TMP6:%.*]]
; IS__TUNIT_OPM: 5: ; IS________OPM: 5:
; IS__TUNIT_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP2]]) ; IS________OPM-NEXT: tail call void @free(i8* noalias nocapture [[TMP2]])
; IS__TUNIT_OPM-NEXT: br label [[TMP6]] ; IS________OPM-NEXT: br label [[TMP6]]
; IS__TUNIT_OPM: 6: ; IS________OPM: 6:
; IS__TUNIT_OPM-NEXT: ret void ; IS________OPM-NEXT: ret void
; ;
; IS________NPM-LABEL: define {{[^@]+}}@test6 ; IS________NPM-LABEL: define {{[^@]+}}@test6
; IS________NPM-SAME: (i32 [[TMP0:%.*]]) ; IS________NPM-SAME: (i32 [[TMP0:%.*]])
; IS________NPM-NEXT: [[TMP2:%.*]] = alloca i8, i64 4, align 1 ; IS________NPM-NEXT: [[TMP2:%.*]] = alloca i8, i64 4, align 1
; IS________NPM-NEXT: [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 0 ; IS________NPM-NEXT: [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 0
; IS________NPM-NEXT: br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]] ; IS________NPM-NEXT: br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]]
; IS________NPM: 4: ; IS________NPM: 4:
; IS________NPM-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree noundef [[TMP2]]) ; IS________NPM-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree [[TMP2]])
; IS________NPM-NEXT: br label [[TMP6:%.*]] ; IS________NPM-NEXT: br label [[TMP6:%.*]]
; IS________NPM: 5: ; IS________NPM: 5:
; IS________NPM-NEXT: br label [[TMP6]] ; IS________NPM-NEXT: br label [[TMP6]]
; IS________NPM: 6: ; IS________NPM: 6:
; IS________NPM-NEXT: ret void ; IS________NPM-NEXT: ret void
; ;
; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test6
; IS__CGSCC_OPM-SAME: (i32 [[TMP0:%.*]])
; IS__CGSCC_OPM-NEXT: [[TMP2:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC_OPM-NEXT: [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 0
; IS__CGSCC_OPM-NEXT: br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]]
; IS__CGSCC_OPM: 4:
; IS__CGSCC_OPM-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree noundef [[TMP2]])
; IS__CGSCC_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP2]])
; IS__CGSCC_OPM-NEXT: br label [[TMP6:%.*]]
; IS__CGSCC_OPM: 5:
; IS__CGSCC_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP2]])
; IS__CGSCC_OPM-NEXT: br label [[TMP6]]
; IS__CGSCC_OPM: 6:
; IS__CGSCC_OPM-NEXT: ret void
;
%2 = tail call noalias i8* @malloc(i64 4) %2 = tail call noalias i8* @malloc(i64 4)
%3 = icmp eq i32 %0, 0 %3 = icmp eq i32 %0, 0
br i1 %3, label %5, label %4 br i1 %3, label %5, label %4
4: ; preds = %1 4: ; preds = %1
tail call void @nofree_func(i8* %2) tail call void @nofree_func(i8* %2)
tail call void @free(i8* %2) tail call void @free(i8* %2)
br label %6 br label %6
Show All 25 Lines;
tail call i32 @no_return_call() tail call i32 @no_return_call()
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret void ret void
} }
; TEST 8 - Negative: bitcast pointer used in capture function ; TEST 8 - Negative: bitcast pointer used in capture function
define void @test8() { define void @test8() {
; IS__TUNIT____-LABEL: define {{[^@]+}}@test8() ; CHECK-LABEL: define {{[^@]+}}@test8()
; IS__TUNIT____-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__TUNIT____-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) ; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
; IS__TUNIT____-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32* ; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
; IS__TUNIT____-NEXT: store i32 10, i32* [[TMP2]], align 4 ; CHECK-NEXT: store i32 10, i32* [[TMP2]], align 4
; IS__TUNIT____-NEXT: tail call void @foo(i32* noundef align 4 [[TMP2]]) ; CHECK-NEXT: tail call void @foo(i32* align 4 [[TMP2]])
; IS__TUNIT____-NEXT: tail call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]]) ; CHECK-NEXT: tail call void @free(i8* nocapture nonnull align 4 dereferenceable(4) [[TMP1]])
; IS__TUNIT____-NEXT: ret void ; CHECK-NEXT: ret void
;
; IS__CGSCC____-LABEL: define {{[^@]+}}@test8()
; IS__CGSCC____-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC____-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]])
; IS__CGSCC____-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
; IS__CGSCC____-NEXT: store i32 10, i32* [[TMP2]], align 4
; IS__CGSCC____-NEXT: tail call void @foo(i32* noundef align 4 [[TMP2]])
; IS__CGSCC____-NEXT: tail call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
; IS__CGSCC____-NEXT: ret void
; ;
%1 = tail call noalias i8* @malloc(i64 4) %1 = tail call noalias i8* @malloc(i64 4)
tail call void @no_sync_func(i8* %1) tail call void @no_sync_func(i8* %1)
%2 = bitcast i8* %1 to i32* %2 = bitcast i8* %1 to i32*
store i32 10, i32* %2 store i32 10, i32* %2
%3 = load i32, i32* %2 %3 = load i32, i32* %2
tail call void @foo(i32* %2) tail call void @foo(i32* %2)
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret void ret void
} }
; TEST 9 - FIXME: malloc should be converted. ; TEST 9 - FIXME: malloc should be converted.
define void @test9() { define void @test9() {
; IS__TUNIT____-LABEL: define {{[^@]+}}@test9() ; CHECK-LABEL: define {{[^@]+}}@test9()
; IS__TUNIT____-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__TUNIT____-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) ; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
; IS__TUNIT____-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32* ; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
; IS__TUNIT____-NEXT: store i32 10, i32* [[TMP2]], align 4 ; CHECK-NEXT: store i32 10, i32* [[TMP2]], align 4
; IS__TUNIT____-NEXT: tail call void @foo_nounw(i32* nofree noundef align 4 [[TMP2]]) ; CHECK-NEXT: tail call void @foo_nounw(i32* nofree align 4 [[TMP2]])
; IS__TUNIT____-NEXT: tail call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]]) ; CHECK-NEXT: tail call void @free(i8* nocapture nonnull align 4 dereferenceable(4) [[TMP1]])
; IS__TUNIT____-NEXT: ret void ; CHECK-NEXT: ret void
;
; IS__CGSCC____-LABEL: define {{[^@]+}}@test9()
; IS__CGSCC____-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC____-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]])
; IS__CGSCC____-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
; IS__CGSCC____-NEXT: store i32 10, i32* [[TMP2]], align 4
; IS__CGSCC____-NEXT: tail call void @foo_nounw(i32* nofree noundef align 4 [[TMP2]])
; IS__CGSCC____-NEXT: tail call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
; IS__CGSCC____-NEXT: ret void
; ;
%1 = tail call noalias i8* @malloc(i64 4) %1 = tail call noalias i8* @malloc(i64 4)
tail call void @no_sync_func(i8* %1) tail call void @no_sync_func(i8* %1)
%2 = bitcast i8* %1 to i32* %2 = bitcast i8* %1 to i32*
store i32 10, i32* %2 store i32 10, i32* %2
%3 = load i32, i32* %2 %3 = load i32, i32* %2
tail call void @foo_nounw(i32* %2) tail call void @foo_nounw(i32* %2)
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret void ret void
} }
; TEST 10 - 1 malloc, 1 free ; TEST 10 - 1 malloc, 1 free
define i32 @test10() { define i32 @test10() {
; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@test10() ; IS________OPM-LABEL: define {{[^@]+}}@test10()
; IS__TUNIT_OPM-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; IS________OPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__TUNIT_OPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) ; IS________OPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
; IS__TUNIT_OPM-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32* ; IS________OPM-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
; IS__TUNIT_OPM-NEXT: store i32 10, i32* [[TMP2]], align 4 ; IS________OPM-NEXT: store i32 10, i32* [[TMP2]], align 4
; IS__TUNIT_OPM-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4 ; IS________OPM-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
; IS__TUNIT_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]]) ; IS________OPM-NEXT: tail call void @free(i8* noalias nocapture nonnull align 4 dereferenceable(4) [[TMP1]])
; IS__TUNIT_OPM-NEXT: ret i32 [[TMP3]] ; IS________OPM-NEXT: ret i32 [[TMP3]]
; ;
; IS________NPM-LABEL: define {{[^@]+}}@test10() ; IS________NPM-LABEL: define {{[^@]+}}@test10()
; IS________NPM-NEXT: [[TMP1:%.*]] = alloca i8, i64 4, align 1 ; IS________NPM-NEXT: [[TMP1:%.*]] = alloca i8, i64 4, align 1
; IS________NPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) ; IS________NPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
; IS________NPM-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32* ; IS________NPM-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
; IS________NPM-NEXT: store i32 10, i32* [[TMP2]], align 4 ; IS________NPM-NEXT: store i32 10, i32* [[TMP2]], align 4
; IS________NPM-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4 ; IS________NPM-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
; IS________NPM-NEXT: ret i32 [[TMP3]] ; IS________NPM-NEXT: ret i32 [[TMP3]]
; ;
; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test10()
; IS__CGSCC_OPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC_OPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]])
; IS__CGSCC_OPM-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
; IS__CGSCC_OPM-NEXT: store i32 10, i32* [[TMP2]], align 4
; IS__CGSCC_OPM-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
; IS__CGSCC_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
; IS__CGSCC_OPM-NEXT: ret i32 [[TMP3]]
;
%1 = tail call noalias i8* @malloc(i64 4) %1 = tail call noalias i8* @malloc(i64 4)
tail call void @no_sync_func(i8* %1) tail call void @no_sync_func(i8* %1)
%2 = bitcast i8* %1 to i32* %2 = bitcast i8* %1 to i32*
store i32 10, i32* %2 store i32 10, i32* %2
%3 = load i32, i32* %2 %3 = load i32, i32* %2
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret i32 %3 ret i32 %3
} }
define i32 @test_lifetime() { define i32 @test_lifetime() {
; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@test_lifetime() ; IS________OPM-LABEL: define {{[^@]+}}@test_lifetime()
; IS__TUNIT_OPM-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; IS________OPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__TUNIT_OPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) ; IS________OPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
; IS__TUNIT_OPM-NEXT: call void @llvm.lifetime.start.p0i8(i64 4, i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]]) ; IS________OPM-NEXT: call void @llvm.lifetime.start.p0i8(i64 4, i8* noalias nocapture nonnull align 4 dereferenceable(4) [[TMP1]])
; IS__TUNIT_OPM-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32* ; IS________OPM-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
; IS__TUNIT_OPM-NEXT: store i32 10, i32* [[TMP2]], align 4 ; IS________OPM-NEXT: store i32 10, i32* [[TMP2]], align 4
; IS__TUNIT_OPM-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4 ; IS________OPM-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
; IS__TUNIT_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]]) ; IS________OPM-NEXT: tail call void @free(i8* noalias nocapture nonnull align 4 dereferenceable(4) [[TMP1]])
; IS__TUNIT_OPM-NEXT: ret i32 [[TMP3]] ; IS________OPM-NEXT: ret i32 [[TMP3]]
; ;
; IS________NPM-LABEL: define {{[^@]+}}@test_lifetime() ; IS________NPM-LABEL: define {{[^@]+}}@test_lifetime()
; IS________NPM-NEXT: [[TMP1:%.*]] = alloca i8, i64 4, align 1 ; IS________NPM-NEXT: [[TMP1:%.*]] = alloca i8, i64 4, align 1
; IS________NPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) ; IS________NPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
; IS________NPM-NEXT: call void @llvm.lifetime.start.p0i8(i64 4, i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]]) ; IS________NPM-NEXT: call void @llvm.lifetime.start.p0i8(i64 4, i8* noalias nocapture nonnull align 4 dereferenceable(4) [[TMP1]])
; IS________NPM-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32* ; IS________NPM-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
; IS________NPM-NEXT: store i32 10, i32* [[TMP2]], align 4 ; IS________NPM-NEXT: store i32 10, i32* [[TMP2]], align 4
; IS________NPM-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4 ; IS________NPM-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
; IS________NPM-NEXT: ret i32 [[TMP3]] ; IS________NPM-NEXT: ret i32 [[TMP3]]
; ;
; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test_lifetime()
; IS__CGSCC_OPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC_OPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]])
; IS__CGSCC_OPM-NEXT: call void @llvm.lifetime.start.p0i8(i64 4, i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
; IS__CGSCC_OPM-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
; IS__CGSCC_OPM-NEXT: store i32 10, i32* [[TMP2]], align 4
; IS__CGSCC_OPM-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
; IS__CGSCC_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
; IS__CGSCC_OPM-NEXT: ret i32 [[TMP3]]
;
%1 = tail call noalias i8* @malloc(i64 4) %1 = tail call noalias i8* @malloc(i64 4)
tail call void @no_sync_func(i8* %1) tail call void @no_sync_func(i8* %1)
call void @llvm.lifetime.start.p0i8(i64 4, i8* %1) call void @llvm.lifetime.start.p0i8(i64 4, i8* %1)
%2 = bitcast i8* %1 to i32* %2 = bitcast i8* %1 to i32*
store i32 10, i32* %2 store i32 10, i32* %2
%3 = load i32, i32* %2 %3 = load i32, i32* %2
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret i32 %3 ret i32 %3
} }
; TEST 11 ; TEST 11
define void @test11() { define void @test11() {
; IS__TUNIT____-LABEL: define {{[^@]+}}@test11() ; CHECK-LABEL: define {{[^@]+}}@test11()
; IS__TUNIT____-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__TUNIT____-NEXT: tail call void @sync_will_return(i8* noundef [[TMP1]]) ; CHECK-NEXT: tail call void @sync_will_return(i8* [[TMP1]])
; IS__TUNIT____-NEXT: tail call void @free(i8* nocapture noundef [[TMP1]]) ; CHECK-NEXT: tail call void @free(i8* nocapture [[TMP1]])
; IS__TUNIT____-NEXT: ret void ; CHECK-NEXT: ret void
;
; IS__CGSCC____-LABEL: define {{[^@]+}}@test11()
; IS__CGSCC____-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC____-NEXT: tail call void @sync_will_return(i8* noundef [[TMP1]])
; IS__CGSCC____-NEXT: tail call void @free(i8* nocapture noundef [[TMP1]])
; IS__CGSCC____-NEXT: ret void
; ;
%1 = tail call noalias i8* @malloc(i64 4) %1 = tail call noalias i8* @malloc(i64 4)
tail call void @sync_will_return(i8* %1) tail call void @sync_will_return(i8* %1)
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret void ret void
} }
; TEST 12 ; TEST 12
define i32 @irreducible_cfg(i32 %0) { define i32 @irreducible_cfg(i32 %0) {
; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@irreducible_cfg ; IS________OPM-LABEL: define {{[^@]+}}@irreducible_cfg
; IS__TUNIT_OPM-SAME: (i32 [[TMP0:%.*]]) ; IS________OPM-SAME: (i32 [[TMP0:%.*]])
; IS__TUNIT_OPM-NEXT: [[TMP2:%.*]] = call noalias noundef i8* @malloc(i64 4) ; IS________OPM-NEXT: [[TMP2:%.*]] = call noalias i8* @malloc(i64 4)
; IS__TUNIT_OPM-NEXT: [[TMP3:%.*]] = bitcast i8* [[TMP2]] to i32* ; IS________OPM-NEXT: [[TMP3:%.*]] = bitcast i8* [[TMP2]] to i32*
; IS__TUNIT_OPM-NEXT: store i32 10, i32* [[TMP3]], align 4 ; IS________OPM-NEXT: store i32 10, i32* [[TMP3]], align 4
; IS__TUNIT_OPM-NEXT: [[TMP4:%.*]] = icmp eq i32 [[TMP0]], 1 ; IS________OPM-NEXT: [[TMP4:%.*]] = icmp eq i32 [[TMP0]], 1
; IS__TUNIT_OPM-NEXT: br i1 [[TMP4]], label [[TMP5:%.*]], label [[TMP7:%.*]] ; IS________OPM-NEXT: br i1 [[TMP4]], label [[TMP5:%.*]], label [[TMP7:%.*]]
; IS__TUNIT_OPM: 5: ; IS________OPM: 5:
; IS__TUNIT_OPM-NEXT: [[TMP6:%.*]] = add nsw i32 [[TMP0]], 5 ; IS________OPM-NEXT: [[TMP6:%.*]] = add nsw i32 [[TMP0]], 5
; IS__TUNIT_OPM-NEXT: br label [[TMP13:%.*]] ; IS________OPM-NEXT: br label [[TMP13:%.*]]
; IS__TUNIT_OPM: 7: ; IS________OPM: 7:
; IS__TUNIT_OPM-NEXT: br label [[TMP8:%.*]] ; IS________OPM-NEXT: br label [[TMP8:%.*]]
; IS__TUNIT_OPM: 8: ; IS________OPM: 8:
; IS__TUNIT_OPM-NEXT: [[DOT0:%.*]] = phi i32 [ [[TMP14:%.*]], [[TMP13]] ], [ 1, [[TMP7]] ] ; IS________OPM-NEXT: [[DOT0:%.*]] = phi i32 [ [[TMP14:%.*]], [[TMP13]] ], [ 1, [[TMP7]] ]
; IS__TUNIT_OPM-NEXT: [[TMP9:%.*]] = load i32, i32* [[TMP3]], align 4 ; IS________OPM-NEXT: [[TMP9:%.*]] = load i32, i32* [[TMP3]], align 4
; IS__TUNIT_OPM-NEXT: [[TMP10:%.*]] = add nsw i32 [[TMP9]], -1 ; IS________OPM-NEXT: [[TMP10:%.*]] = add nsw i32 [[TMP9]], -1
; IS__TUNIT_OPM-NEXT: store i32 [[TMP10]], i32* [[TMP3]], align 4 ; IS________OPM-NEXT: store i32 [[TMP10]], i32* [[TMP3]], align 4
; IS__TUNIT_OPM-NEXT: [[TMP11:%.*]] = icmp ne i32 [[TMP9]], 0 ; IS________OPM-NEXT: [[TMP11:%.*]] = icmp ne i32 [[TMP9]], 0
; IS__TUNIT_OPM-NEXT: br i1 [[TMP11]], label [[TMP12:%.*]], label [[TMP15:%.*]] ; IS________OPM-NEXT: br i1 [[TMP11]], label [[TMP12:%.*]], label [[TMP15:%.*]]
; IS__TUNIT_OPM: 12: ; IS________OPM: 12:
; IS__TUNIT_OPM-NEXT: br label [[TMP13]] ; IS________OPM-NEXT: br label [[TMP13]]
; IS__TUNIT_OPM: 13: ; IS________OPM: 13:
; IS__TUNIT_OPM-NEXT: [[DOT1:%.*]] = phi i32 [ [[TMP6]], [[TMP5]] ], [ [[DOT0]], [[TMP12]] ] ; IS________OPM-NEXT: [[DOT1:%.*]] = phi i32 [ [[TMP6]], [[TMP5]] ], [ [[DOT0]], [[TMP12]] ]
; IS__TUNIT_OPM-NEXT: [[TMP14]] = add nsw i32 [[DOT1]], 1 ; IS________OPM-NEXT: [[TMP14]] = add nsw i32 [[DOT1]], 1
; IS__TUNIT_OPM-NEXT: br label [[TMP8]] ; IS________OPM-NEXT: br label [[TMP8]]
; IS__TUNIT_OPM: 15: ; IS________OPM: 15:
; IS__TUNIT_OPM-NEXT: [[TMP16:%.*]] = load i32, i32* [[TMP3]], align 4 ; IS________OPM-NEXT: [[TMP16:%.*]] = load i32, i32* [[TMP3]], align 4
; IS__TUNIT_OPM-NEXT: [[TMP17:%.*]] = bitcast i32* [[TMP3]] to i8* ; IS________OPM-NEXT: [[TMP17:%.*]] = bitcast i32* [[TMP3]] to i8*
; IS__TUNIT_OPM-NEXT: call void @free(i8* nocapture noundef [[TMP17]]) ; IS________OPM-NEXT: call void @free(i8* nocapture [[TMP17]])
; IS__TUNIT_OPM-NEXT: [[TMP18:%.*]] = load i32, i32* [[TMP3]], align 4 ; IS________OPM-NEXT: [[TMP18:%.*]] = load i32, i32* [[TMP3]], align 4
; IS__TUNIT_OPM-NEXT: ret i32 [[TMP18]] ; IS________OPM-NEXT: ret i32 [[TMP18]]
; ;
; IS________NPM-LABEL: define {{[^@]+}}@irreducible_cfg ; IS________NPM-LABEL: define {{[^@]+}}@irreducible_cfg
; IS________NPM-SAME: (i32 [[TMP0:%.*]]) ; IS________NPM-SAME: (i32 [[TMP0:%.*]])
; IS________NPM-NEXT: [[TMP2:%.*]] = alloca i8, i64 4, align 1 ; IS________NPM-NEXT: [[TMP2:%.*]] = alloca i8, i64 4, align 1
; IS________NPM-NEXT: [[TMP3:%.*]] = bitcast i8* [[TMP2]] to i32* ; IS________NPM-NEXT: [[TMP3:%.*]] = bitcast i8* [[TMP2]] to i32*
; IS________NPM-NEXT: store i32 10, i32* [[TMP3]], align 4 ; IS________NPM-NEXT: store i32 10, i32* [[TMP3]], align 4
; IS________NPM-NEXT: [[TMP4:%.*]] = icmp eq i32 [[TMP0]], 1 ; IS________NPM-NEXT: [[TMP4:%.*]] = icmp eq i32 [[TMP0]], 1
; IS________NPM-NEXT: br i1 [[TMP4]], label [[TMP5:%.*]], label [[TMP7:%.*]] ; IS________NPM-NEXT: br i1 [[TMP4]], label [[TMP5:%.*]], label [[TMP7:%.*]]
Show All 15 Lines
; IS________NPM-NEXT: [[DOT1:%.*]] = phi i32 [ [[TMP6]], [[TMP5]] ], [ [[DOT0]], [[TMP12]] ] ; IS________NPM-NEXT: [[DOT1:%.*]] = phi i32 [ [[TMP6]], [[TMP5]] ], [ [[DOT0]], [[TMP12]] ]
; IS________NPM-NEXT: [[TMP14]] = add nsw i32 [[DOT1]], 1 ; IS________NPM-NEXT: [[TMP14]] = add nsw i32 [[DOT1]], 1
; IS________NPM-NEXT: br label [[TMP8]] ; IS________NPM-NEXT: br label [[TMP8]]
; IS________NPM: 15: ; IS________NPM: 15:
; IS________NPM-NEXT: [[TMP16:%.*]] = bitcast i32* [[TMP3]] to i8* ; IS________NPM-NEXT: [[TMP16:%.*]] = bitcast i32* [[TMP3]] to i8*
; IS________NPM-NEXT: [[TMP17:%.*]] = load i32, i32* [[TMP3]], align 4 ; IS________NPM-NEXT: [[TMP17:%.*]] = load i32, i32* [[TMP3]], align 4
; IS________NPM-NEXT: ret i32 [[TMP17]] ; IS________NPM-NEXT: ret i32 [[TMP17]]
; ;
; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@irreducible_cfg
; IS__CGSCC_OPM-SAME: (i32 [[TMP0:%.*]])
; IS__CGSCC_OPM-NEXT: [[TMP2:%.*]] = call noalias i8* @malloc(i64 4)
; IS__CGSCC_OPM-NEXT: [[TMP3:%.*]] = bitcast i8* [[TMP2]] to i32*
; IS__CGSCC_OPM-NEXT: store i32 10, i32* [[TMP3]], align 4
; IS__CGSCC_OPM-NEXT: [[TMP4:%.*]] = icmp eq i32 [[TMP0]], 1
; IS__CGSCC_OPM-NEXT: br i1 [[TMP4]], label [[TMP5:%.*]], label [[TMP7:%.*]]
; IS__CGSCC_OPM: 5:
; IS__CGSCC_OPM-NEXT: [[TMP6:%.*]] = add nsw i32 [[TMP0]], 5
; IS__CGSCC_OPM-NEXT: br label [[TMP13:%.*]]
; IS__CGSCC_OPM: 7:
; IS__CGSCC_OPM-NEXT: br label [[TMP8:%.*]]
; IS__CGSCC_OPM: 8:
; IS__CGSCC_OPM-NEXT: [[DOT0:%.*]] = phi i32 [ [[TMP14:%.*]], [[TMP13]] ], [ 1, [[TMP7]] ]
; IS__CGSCC_OPM-NEXT: [[TMP9:%.*]] = load i32, i32* [[TMP3]], align 4
; IS__CGSCC_OPM-NEXT: [[TMP10:%.*]] = add nsw i32 [[TMP9]], -1
; IS__CGSCC_OPM-NEXT: store i32 [[TMP10]], i32* [[TMP3]], align 4
; IS__CGSCC_OPM-NEXT: [[TMP11:%.*]] = icmp ne i32 [[TMP9]], 0
; IS__CGSCC_OPM-NEXT: br i1 [[TMP11]], label [[TMP12:%.*]], label [[TMP15:%.*]]
; IS__CGSCC_OPM: 12:
; IS__CGSCC_OPM-NEXT: br label [[TMP13]]
; IS__CGSCC_OPM: 13:
; IS__CGSCC_OPM-NEXT: [[DOT1:%.*]] = phi i32 [ [[TMP6]], [[TMP5]] ], [ [[DOT0]], [[TMP12]] ]
; IS__CGSCC_OPM-NEXT: [[TMP14]] = add nsw i32 [[DOT1]], 1
; IS__CGSCC_OPM-NEXT: br label [[TMP8]]
; IS__CGSCC_OPM: 15:
; IS__CGSCC_OPM-NEXT: [[TMP16:%.*]] = load i32, i32* [[TMP3]], align 4
; IS__CGSCC_OPM-NEXT: [[TMP17:%.*]] = bitcast i32* [[TMP3]] to i8*
; IS__CGSCC_OPM-NEXT: call void @free(i8* nocapture noundef [[TMP17]])
; IS__CGSCC_OPM-NEXT: [[TMP18:%.*]] = load i32, i32* [[TMP3]], align 4
; IS__CGSCC_OPM-NEXT: ret i32 [[TMP18]]
;
%2 = call noalias i8* @malloc(i64 4) %2 = call noalias i8* @malloc(i64 4)
%3 = bitcast i8* %2 to i32* %3 = bitcast i8* %2 to i32*
store i32 10, i32* %3, align 4 store i32 10, i32* %3, align 4
%4 = icmp eq i32 %0, 1 %4 = icmp eq i32 %0, 1
br i1 %4, label %5, label %7 br i1 %4, label %5, label %7
5: ; preds = %1 5: ; preds = %1
%6 = add nsw i32 %0, 5 %6 = add nsw i32 %0, 5
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Lines8: ; preds = %4
br label %4 br label %4
11: ; preds = %4 11: ; preds = %4
ret i32 5 ret i32 5
} }
; Malloc/Calloc too large ; Malloc/Calloc too large
define i32 @test13() { define i32 @test13() {
; IS__TUNIT____-LABEL: define {{[^@]+}}@test13() ; CHECK-LABEL: define {{[^@]+}}@test13()
; IS__TUNIT____-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @malloc(i64 256) ; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 256)
; IS__TUNIT____-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) ; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
; IS__TUNIT____-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32* ; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
; IS__TUNIT____-NEXT: store i32 10, i32* [[TMP2]], align 4 ; CHECK-NEXT: store i32 10, i32* [[TMP2]], align 4
; IS__TUNIT____-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4 ; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
; IS__TUNIT____-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]]) ; CHECK-NEXT: tail call void @free(i8* noalias nocapture nonnull align 4 dereferenceable(4) [[TMP1]])
; IS__TUNIT____-NEXT: ret i32 [[TMP3]] ; CHECK-NEXT: ret i32 [[TMP3]]
;
; IS__CGSCC____-LABEL: define {{[^@]+}}@test13()
; IS__CGSCC____-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 256)
; IS__CGSCC____-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]])
; IS__CGSCC____-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
; IS__CGSCC____-NEXT: store i32 10, i32* [[TMP2]], align 4
; IS__CGSCC____-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
; IS__CGSCC____-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
; IS__CGSCC____-NEXT: ret i32 [[TMP3]]
; ;
%1 = tail call noalias i8* @malloc(i64 256) %1 = tail call noalias i8* @malloc(i64 256)
tail call void @no_sync_func(i8* %1) tail call void @no_sync_func(i8* %1)
%2 = bitcast i8* %1 to i32* %2 = bitcast i8* %1 to i32*
store i32 10, i32* %2 store i32 10, i32* %2
%3 = load i32, i32* %2 %3 = load i32, i32* %2
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret i32 %3 ret i32 %3
} }
define i32 @test_sle() { define i32 @test_sle() {
; IS__TUNIT____-LABEL: define {{[^@]+}}@test_sle() ; CHECK-LABEL: define {{[^@]+}}@test_sle()
; IS__TUNIT____-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @malloc(i64 -1) ; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 -1)
; IS__TUNIT____-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) ; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
; IS__TUNIT____-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32* ; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
; IS__TUNIT____-NEXT: store i32 10, i32* [[TMP2]], align 4 ; CHECK-NEXT: store i32 10, i32* [[TMP2]], align 4
; IS__TUNIT____-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4 ; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
; IS__TUNIT____-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]]) ; CHECK-NEXT: tail call void @free(i8* noalias nocapture nonnull align 4 dereferenceable(4) [[TMP1]])
; IS__TUNIT____-NEXT: ret i32 [[TMP3]] ; CHECK-NEXT: ret i32 [[TMP3]]
;
; IS__CGSCC____-LABEL: define {{[^@]+}}@test_sle()
; IS__CGSCC____-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 -1)
; IS__CGSCC____-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]])
; IS__CGSCC____-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
; IS__CGSCC____-NEXT: store i32 10, i32* [[TMP2]], align 4
; IS__CGSCC____-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
; IS__CGSCC____-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
; IS__CGSCC____-NEXT: ret i32 [[TMP3]]
; ;
%1 = tail call noalias i8* @malloc(i64 -1) %1 = tail call noalias i8* @malloc(i64 -1)
tail call void @no_sync_func(i8* %1) tail call void @no_sync_func(i8* %1)
%2 = bitcast i8* %1 to i32* %2 = bitcast i8* %1 to i32*
store i32 10, i32* %2 store i32 10, i32* %2
%3 = load i32, i32* %2 %3 = load i32, i32* %2
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret i32 %3 ret i32 %3
} }
define i32 @test_overflow() { define i32 @test_overflow() {
; IS__TUNIT____-LABEL: define {{[^@]+}}@test_overflow() ; CHECK-LABEL: define {{[^@]+}}@test_overflow()
; IS__TUNIT____-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @calloc(i64 65537, i64 65537) ; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @calloc(i64 65537, i64 65537)
; IS__TUNIT____-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) ; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
; IS__TUNIT____-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32* ; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
; IS__TUNIT____-NEXT: store i32 10, i32* [[TMP2]], align 4 ; CHECK-NEXT: store i32 10, i32* [[TMP2]], align 4
; IS__TUNIT____-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4 ; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
; IS__TUNIT____-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]]) ; CHECK-NEXT: tail call void @free(i8* noalias nocapture nonnull align 4 dereferenceable(4) [[TMP1]])
; IS__TUNIT____-NEXT: ret i32 [[TMP3]] ; CHECK-NEXT: ret i32 [[TMP3]]
;
; IS__CGSCC____-LABEL: define {{[^@]+}}@test_overflow()
; IS__CGSCC____-NEXT: [[TMP1:%.*]] = tail call noalias i8* @calloc(i64 65537, i64 65537)
; IS__CGSCC____-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]])
; IS__CGSCC____-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
; IS__CGSCC____-NEXT: store i32 10, i32* [[TMP2]], align 4
; IS__CGSCC____-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
; IS__CGSCC____-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
; IS__CGSCC____-NEXT: ret i32 [[TMP3]]
; ;
%1 = tail call noalias i8* @calloc(i64 65537, i64 65537) %1 = tail call noalias i8* @calloc(i64 65537, i64 65537)
tail call void @no_sync_func(i8* %1) tail call void @no_sync_func(i8* %1)
%2 = bitcast i8* %1 to i32* %2 = bitcast i8* %1 to i32*
store i32 10, i32* %2 store i32 10, i32* %2
%3 = load i32, i32* %2 %3 = load i32, i32* %2
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret i32 %3 ret i32 %3
} }
define void @test14() { define void @test14() {
; NOT_CGSCC_OPM-LABEL: define {{[^@]+}}@test14() ; CHECK-LABEL: define {{[^@]+}}@test14()
; NOT_CGSCC_OPM-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @calloc(i64 64, i64 4) ; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @calloc(i64 64, i64 4)
; NOT_CGSCC_OPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) ; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
; NOT_CGSCC_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP1]]) ; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
; NOT_CGSCC_OPM-NEXT: ret void ; CHECK-NEXT: ret void
;
; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test14()
; IS__CGSCC_OPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @calloc(i64 64, i64 4)
; IS__CGSCC_OPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]])
; IS__CGSCC_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP1]])
; IS__CGSCC_OPM-NEXT: ret void
; ;
%1 = tail call noalias i8* @calloc(i64 64, i64 4) %1 = tail call noalias i8* @calloc(i64 64, i64 4)
tail call void @no_sync_func(i8* %1) tail call void @no_sync_func(i8* %1)
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret void ret void
} }
define void @test15(i64 %S) { define void @test15(i64 %S) {
; IS__TUNIT____-LABEL: define {{[^@]+}}@test15 ; CHECK-LABEL: define {{[^@]+}}@test15
; IS__TUNIT____-SAME: (i64 [[S:%.*]]) ; CHECK-SAME: (i64 [[S:%.*]])
; IS__TUNIT____-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @malloc(i64 [[S]]) ; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 [[S]])
; IS__TUNIT____-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]]) ; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
; IS__TUNIT____-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP1]]) ; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
; IS__TUNIT____-NEXT: ret void ; CHECK-NEXT: ret void
;
; IS__CGSCC____-LABEL: define {{[^@]+}}@test15
; IS__CGSCC____-SAME: (i64 [[S:%.*]])
; IS__CGSCC____-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 [[S]])
; IS__CGSCC____-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef [[TMP1]])
; IS__CGSCC____-NEXT: tail call void @free(i8* noalias nocapture noundef [[TMP1]])
; IS__CGSCC____-NEXT: ret void
; ;
%1 = tail call noalias i8* @malloc(i64 %S) %1 = tail call noalias i8* @malloc(i64 %S)
tail call void @no_sync_func(i8* %1) tail call void @no_sync_func(i8* %1)
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret void ret void
} }
define void @test16a(i8 %v, i8** %P) { define void @test16a(i8 %v, i8** %P) {
; IS__TUNIT_OPM-LABEL: define {{[^@]+}}@test16a ; IS________OPM-LABEL: define {{[^@]+}}@test16a
; IS__TUNIT_OPM-SAME: (i8 [[V:%.*]], i8** nocapture nofree readnone [[P:%.*]]) ; IS________OPM-SAME: (i8 [[V:%.*]], i8** nocapture nofree readnone [[P:%.*]])
; IS__TUNIT_OPM-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; IS________OPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__TUNIT_OPM-NEXT: store i8 [[V]], i8* [[TMP1]], align 1 ; IS________OPM-NEXT: store i8 [[V]], i8* [[TMP1]], align 1
; IS__TUNIT_OPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[TMP1]]) ; IS________OPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree nonnull dereferenceable(1) [[TMP1]])
; IS__TUNIT_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull dereferenceable(1) [[TMP1]]) ; IS________OPM-NEXT: tail call void @free(i8* noalias nocapture nonnull dereferenceable(1) [[TMP1]])
; IS__TUNIT_OPM-NEXT: ret void ; IS________OPM-NEXT: ret void
; ;
; IS________NPM-LABEL: define {{[^@]+}}@test16a ; IS________NPM-LABEL: define {{[^@]+}}@test16a
; IS________NPM-SAME: (i8 [[V:%.*]], i8** nocapture nofree readnone [[P:%.*]]) ; IS________NPM-SAME: (i8 [[V:%.*]], i8** nocapture nofree readnone [[P:%.*]])
; IS________NPM-NEXT: [[TMP1:%.*]] = alloca i8, i64 4, align 1 ; IS________NPM-NEXT: [[TMP1:%.*]] = alloca i8, i64 4, align 1
; IS________NPM-NEXT: store i8 [[V]], i8* [[TMP1]], align 1 ; IS________NPM-NEXT: store i8 [[V]], i8* [[TMP1]], align 1
; IS________NPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[TMP1]]) ; IS________NPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree nonnull dereferenceable(1) [[TMP1]])
; IS________NPM-NEXT: ret void ; IS________NPM-NEXT: ret void
; ;
; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test16a
; IS__CGSCC_OPM-SAME: (i8 [[V:%.*]], i8** nocapture nofree readnone [[P:%.*]])
; IS__CGSCC_OPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC_OPM-NEXT: store i8 [[V]], i8* [[TMP1]], align 1
; IS__CGSCC_OPM-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[TMP1]])
; IS__CGSCC_OPM-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull dereferenceable(1) [[TMP1]])
; IS__CGSCC_OPM-NEXT: ret void
;
%1 = tail call noalias i8* @malloc(i64 4) %1 = tail call noalias i8* @malloc(i64 4)
store i8 %v, i8* %1 store i8 %v, i8* %1
tail call void @no_sync_func(i8* %1) tail call void @no_sync_func(i8* %1)
tail call void @free(i8* nonnull dereferenceable(1) %1) tail call void @free(i8* nonnull dereferenceable(1) %1)
ret void ret void
} }
define void @test16b(i8 %v, i8** %P) { define void @test16b(i8 %v, i8** %P) {
; IS__TUNIT____-LABEL: define {{[^@]+}}@test16b ; CHECK-LABEL: define {{[^@]+}}@test16b
; IS__TUNIT____-SAME: (i8 [[V:%.*]], i8** nocapture writeonly [[P:%.*]]) ; CHECK-SAME: (i8 [[V:%.*]], i8** nocapture writeonly [[P:%.*]])
; IS__TUNIT____-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__TUNIT____-NEXT: store i8* [[TMP1]], i8** [[P]], align 8 ; CHECK-NEXT: store i8* [[TMP1]], i8** [[P]], align 8
; IS__TUNIT____-NEXT: tail call void @no_sync_func(i8* nocapture nofree noundef [[TMP1]]) ; CHECK-NEXT: tail call void @no_sync_func(i8* nocapture nofree [[TMP1]])
; IS__TUNIT____-NEXT: tail call void @free(i8* nocapture noundef [[TMP1]]) ; CHECK-NEXT: tail call void @free(i8* nocapture [[TMP1]])
; IS__TUNIT____-NEXT: ret void ; CHECK-NEXT: ret void
;
; IS__CGSCC____-LABEL: define {{[^@]+}}@test16b
; IS__CGSCC____-SAME: (i8 [[V:%.*]], i8** nocapture writeonly [[P:%.*]])
; IS__CGSCC____-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC____-NEXT: store i8* [[TMP1]], i8** [[P]], align 8
; IS__CGSCC____-NEXT: tail call void @no_sync_func(i8* nocapture nofree noundef [[TMP1]])
; IS__CGSCC____-NEXT: tail call void @free(i8* nocapture noundef [[TMP1]])
; IS__CGSCC____-NEXT: ret void
; ;
%1 = tail call noalias i8* @malloc(i64 4) %1 = tail call noalias i8* @malloc(i64 4)
store i8* %1, i8** %P store i8* %1, i8** %P
tail call void @no_sync_func(i8* %1) tail call void @no_sync_func(i8* %1)
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret void ret void
} }
define void @test16c(i8 %v, i8** %P) { define void @test16c(i8 %v, i8** %P) {
; NOT_CGSCC_OPM-LABEL: define {{[^@]+}}@test16c ; CHECK-LABEL: define {{[^@]+}}@test16c
; NOT_CGSCC_OPM-SAME: (i8 [[V:%.*]], i8** nocapture writeonly [[P:%.*]]) ; CHECK-SAME: (i8 [[V:%.*]], i8** nocapture writeonly [[P:%.*]])
; NOT_CGSCC_OPM-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; NOT_CGSCC_OPM-NEXT: store i8* [[TMP1]], i8** [[P]], align 8 ; CHECK-NEXT: store i8* [[TMP1]], i8** [[P]], align 8
; NOT_CGSCC_OPM-NEXT: tail call void @no_sync_func(i8* nocapture nofree noundef [[TMP1]]) ; CHECK-NEXT: tail call void @no_sync_func(i8* nocapture nofree [[TMP1]])
; NOT_CGSCC_OPM-NEXT: tail call void @free(i8* nocapture noundef [[TMP1]]) ; CHECK-NEXT: tail call void @free(i8* nocapture [[TMP1]])
; NOT_CGSCC_OPM-NEXT: ret void ; CHECK-NEXT: ret void
;
; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test16c
; IS__CGSCC_OPM-SAME: (i8 [[V:%.*]], i8** nocapture writeonly [[P:%.*]])
; IS__CGSCC_OPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC_OPM-NEXT: store i8* [[TMP1]], i8** [[P]], align 8
; IS__CGSCC_OPM-NEXT: tail call void @no_sync_func(i8* nocapture nofree noundef [[TMP1]])
; IS__CGSCC_OPM-NEXT: tail call void @free(i8* nocapture noundef [[TMP1]])
; IS__CGSCC_OPM-NEXT: ret void
; ;
%1 = tail call noalias i8* @malloc(i64 4) %1 = tail call noalias i8* @malloc(i64 4)
store i8* %1, i8** %P store i8* %1, i8** %P
tail call void @no_sync_func(i8* %1) nounwind tail call void @no_sync_func(i8* %1) nounwind
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret void ret void
} }
Show All 11 Lines

llvm/test/Transforms/Attributor/memory_locations.ll

Show First 20 Lines • Show All 340 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[TMP1:%.*]] = call i8* @inaccesible_argmem_only_decl(i8* noundef nonnull dereferenceable(1) [[STACK]]) ; CHECK-NEXT: [[TMP1:%.*]] = call i8* @inaccesible_argmem_only_decl(i8* noundef nonnull dereferenceable(1) [[STACK]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%stack = alloca i8 %stack = alloca i8
call i8* @inaccesible_argmem_only_decl(i8* %stack) call i8* @inaccesible_argmem_only_decl(i8* %stack)
ret void ret void
} }
define void @callerC1() { define void @callerC1() {
; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@callerC1() ; CHECK-LABEL: define {{[^@]+}}@callerC1()
; NOT_CGSCC_NPM-NEXT: [[UNKNOWN:%.*]] = call noundef i8* @unknown_ptr() ; CHECK-NEXT: [[UNKNOWN:%.*]] = call i8* @unknown_ptr()
; NOT_CGSCC_NPM-NEXT: [[TMP1:%.*]] = call i8* @argmem_only(i8* noundef [[UNKNOWN]]) ; CHECK-NEXT: [[TMP1:%.*]] = call i8* @argmem_only(i8* [[UNKNOWN]])
; NOT_CGSCC_NPM-NEXT: ret void ; CHECK-NEXT: ret void
;
; IS__CGSCC_NPM-LABEL: define {{[^@]+}}@callerC1()
; IS__CGSCC_NPM-NEXT: [[UNKNOWN:%.*]] = call i8* @unknown_ptr()
; IS__CGSCC_NPM-NEXT: [[TMP1:%.*]] = call i8* @argmem_only(i8* noundef [[UNKNOWN]])
; IS__CGSCC_NPM-NEXT: ret void
; ;
%unknown = call i8* @unknown_ptr() %unknown = call i8* @unknown_ptr()
call i8* @argmem_only(i8* %unknown) call i8* @argmem_only(i8* %unknown)
ret void ret void
} }
define void @callerC2() { define void @callerC2() {
; NOT_CGSCC_OPM-LABEL: define {{[^@]+}}@callerC2() ; CHECK-LABEL: define {{[^@]+}}@callerC2()
; NOT_CGSCC_OPM-NEXT: [[UNKNOWN:%.*]] = call noundef i8* @unknown_ptr() ; CHECK-NEXT: [[UNKNOWN:%.*]] = call i8* @unknown_ptr()
; NOT_CGSCC_OPM-NEXT: [[TMP1:%.*]] = call i8* @inaccesible_argmem_only_decl(i8* noundef [[UNKNOWN]]) ; CHECK-NEXT: [[TMP1:%.*]] = call i8* @inaccesible_argmem_only_decl(i8* [[UNKNOWN]])
; NOT_CGSCC_OPM-NEXT: ret void ; CHECK-NEXT: ret void
;
; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@callerC2()
; IS__CGSCC_OPM-NEXT: [[UNKNOWN:%.*]] = call i8* @unknown_ptr()
; IS__CGSCC_OPM-NEXT: [[TMP1:%.*]] = call i8* @inaccesible_argmem_only_decl(i8* noundef [[UNKNOWN]])
; IS__CGSCC_OPM-NEXT: ret void
; ;
%unknown = call i8* @unknown_ptr() %unknown = call i8* @unknown_ptr()
call i8* @inaccesible_argmem_only_decl(i8* %unknown) call i8* @inaccesible_argmem_only_decl(i8* %unknown)
ret void ret void
} }
define void @callerD1() { define void @callerD1() {
; CHECK-LABEL: define {{[^@]+}}@callerD1() ; CHECK-LABEL: define {{[^@]+}}@callerD1()
; CHECK-NEXT: [[UNKNOWN:%.*]] = call i8* @argmem_only(i8* noalias nocapture noundef align 536870912 null) ; CHECK-NEXT: [[UNKNOWN:%.*]] = call i8* @argmem_only(i8* noalias nocapture noundef align 536870912 null)
▲ Show 20 Lines • Show All 278 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/noalias.ll

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
; IS__CGSCC____-LABEL: define {{[^@]+}}@nocapture ; IS__CGSCC____-LABEL: define {{[^@]+}}@nocapture
; IS__CGSCC____-SAME: (i8* nocapture nofree readnone [[A:%.*]]) ; IS__CGSCC____-SAME: (i8* nocapture nofree readnone [[A:%.*]])
; IS__CGSCC____-NEXT: ret void ; IS__CGSCC____-NEXT: ret void
; ;
ret void ret void
} }
define i8* @return_noalias_looks_like_capture(){ define i8* @return_noalias_looks_like_capture(){
; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@return_noalias_looks_like_capture() ; CHECK-LABEL: define {{[^@]+}}@return_noalias_looks_like_capture()
; NOT_CGSCC_NPM-NEXT: [[TMP1:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; NOT_CGSCC_NPM-NEXT: ret i8* [[TMP1]] ; CHECK-NEXT: ret i8* [[TMP1]]
;
; IS__CGSCC____-LABEL: define {{[^@]+}}@return_noalias_looks_like_capture()
; IS__CGSCC____-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC____-NEXT: ret i8* [[TMP1]]
; ;
%1 = tail call noalias i8* @malloc(i64 4) %1 = tail call noalias i8* @malloc(i64 4)
call void @nocapture(i8* %1) call void @nocapture(i8* %1)
ret i8* %1 ret i8* %1
} }
define i16* @return_noalias_casted(){ define i16* @return_noalias_casted(){
; CHECK-LABEL: define {{[^@]+}}@return_noalias_casted() ; CHECK-LABEL: define {{[^@]+}}@return_noalias_casted()
▲ Show 20 Lines • Show All 278 Lines • ▼ Show 20 Lines
} }
; TEST 12 ; TEST 12
; CallSite Argument ; CallSite Argument
declare void @use_nocapture(i8* nocapture) declare void @use_nocapture(i8* nocapture)
declare void @use(i8*) declare void @use(i8*)
define void @test12_1() { define void @test12_1() {
; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@test12_1() ; CHECK-LABEL: define {{[^@]+}}@test12_1()
; NOT_CGSCC_NPM-NEXT: [[A:%.*]] = alloca i8, align 4 ; CHECK-NEXT: [[A:%.*]] = alloca i8, align 4
; NOT_CGSCC_NPM-NEXT: [[B:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; CHECK-NEXT: [[B:%.*]] = tail call noalias i8* @malloc(i64 4)
; NOT_CGSCC_NPM-NEXT: tail call void @use_nocapture(i8* noalias nocapture noundef nonnull align 4 dereferenceable(1) [[A]]) ; CHECK-NEXT: tail call void @use_nocapture(i8* noalias nocapture noundef nonnull align 4 dereferenceable(1) [[A]])
; NOT_CGSCC_NPM-NEXT: tail call void @use_nocapture(i8* noalias nocapture noundef nonnull align 4 dereferenceable(1) [[A]]) ; CHECK-NEXT: tail call void @use_nocapture(i8* noalias nocapture noundef nonnull align 4 dereferenceable(1) [[A]])
; NOT_CGSCC_NPM-NEXT: tail call void @use_nocapture(i8* noalias nocapture noundef [[B]]) ; CHECK-NEXT: tail call void @use_nocapture(i8* noalias nocapture [[B]])
; NOT_CGSCC_NPM-NEXT: tail call void @use_nocapture(i8* noalias nocapture noundef [[B]]) ; CHECK-NEXT: tail call void @use_nocapture(i8* noalias nocapture [[B]])
; NOT_CGSCC_NPM-NEXT: ret void ; CHECK-NEXT: ret void
;
; IS__CGSCC____-LABEL: define {{[^@]+}}@test12_1()
; IS__CGSCC____-NEXT: [[A:%.*]] = alloca i8, align 4
; IS__CGSCC____-NEXT: [[B:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC____-NEXT: tail call void @use_nocapture(i8* noalias nocapture noundef nonnull align 4 dereferenceable(1) [[A]])
; IS__CGSCC____-NEXT: tail call void @use_nocapture(i8* noalias nocapture noundef nonnull align 4 dereferenceable(1) [[A]])
; IS__CGSCC____-NEXT: tail call void @use_nocapture(i8* noalias nocapture noundef [[B]])
; IS__CGSCC____-NEXT: tail call void @use_nocapture(i8* noalias nocapture noundef [[B]])
; IS__CGSCC____-NEXT: ret void
; ;
%A = alloca i8, align 4 %A = alloca i8, align 4
%B = tail call noalias i8* @malloc(i64 4) %B = tail call noalias i8* @malloc(i64 4)
tail call void @use_nocapture(i8* %A) tail call void @use_nocapture(i8* %A)
tail call void @use_nocapture(i8* %A) tail call void @use_nocapture(i8* %A)
tail call void @use_nocapture(i8* %B) tail call void @use_nocapture(i8* %B)
tail call void @use_nocapture(i8* %B) tail call void @use_nocapture(i8* %B)
ret void ret void
} }
define void @test12_2(){ define void @test12_2(){
; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@test12_2() ; CHECK-LABEL: define {{[^@]+}}@test12_2()
; NOT_CGSCC_NPM-NEXT: [[A:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; CHECK-NEXT: [[A:%.*]] = tail call noalias i8* @malloc(i64 4)
; NOT_CGSCC_NPM-NEXT: tail call void @use_nocapture(i8* noalias nocapture noundef [[A]]) ; CHECK-NEXT: tail call void @use_nocapture(i8* noalias nocapture [[A]])
; NOT_CGSCC_NPM-NEXT: tail call void @use_nocapture(i8* noalias nocapture noundef [[A]]) ; CHECK-NEXT: tail call void @use_nocapture(i8* noalias nocapture [[A]])
; NOT_CGSCC_NPM-NEXT: tail call void @use(i8* noundef [[A]]) ; CHECK-NEXT: tail call void @use(i8* [[A]])
; NOT_CGSCC_NPM-NEXT: tail call void @use_nocapture(i8* nocapture noundef [[A]]) ; CHECK-NEXT: tail call void @use_nocapture(i8* nocapture [[A]])
; NOT_CGSCC_NPM-NEXT: ret void ; CHECK-NEXT: ret void
;
; IS__CGSCC____-LABEL: define {{[^@]+}}@test12_2()
; IS__CGSCC____-NEXT: [[A:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC____-NEXT: tail call void @use_nocapture(i8* noalias nocapture noundef [[A]])
; IS__CGSCC____-NEXT: tail call void @use_nocapture(i8* noalias nocapture noundef [[A]])
; IS__CGSCC____-NEXT: tail call void @use(i8* noundef [[A]])
; IS__CGSCC____-NEXT: tail call void @use_nocapture(i8* nocapture noundef [[A]])
; IS__CGSCC____-NEXT: ret void
; ;
; FIXME: This should be @use_nocapture(i8* noalias [[A]]) ; FIXME: This should be @use_nocapture(i8* noalias [[A]])
; FIXME: This should be @use_nocapture(i8* noalias nocapture [[A]]) ; FIXME: This should be @use_nocapture(i8* noalias nocapture [[A]])
%A = tail call noalias i8* @malloc(i64 4) %A = tail call noalias i8* @malloc(i64 4)
tail call void @use_nocapture(i8* %A) tail call void @use_nocapture(i8* %A)
tail call void @use_nocapture(i8* %A) tail call void @use_nocapture(i8* %A)
tail call void @use(i8* %A) tail call void @use(i8* %A)
tail call void @use_nocapture(i8* %A) tail call void @use_nocapture(i8* %A)
ret void ret void
} }
declare void @two_args(i8* nocapture , i8* nocapture) declare void @two_args(i8* nocapture , i8* nocapture)
define void @test12_3(){ define void @test12_3(){
; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@test12_3() ; CHECK-LABEL: define {{[^@]+}}@test12_3()
; NOT_CGSCC_NPM-NEXT: [[A:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; CHECK-NEXT: [[A:%.*]] = tail call noalias i8* @malloc(i64 4)
; NOT_CGSCC_NPM-NEXT: tail call void @two_args(i8* nocapture noundef [[A]], i8* nocapture noundef [[A]]) ; CHECK-NEXT: tail call void @two_args(i8* nocapture [[A]], i8* nocapture [[A]])
; NOT_CGSCC_NPM-NEXT: ret void ; CHECK-NEXT: ret void
;
; IS__CGSCC____-LABEL: define {{[^@]+}}@test12_3()
; IS__CGSCC____-NEXT: [[A:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC____-NEXT: tail call void @two_args(i8* nocapture noundef [[A]], i8* nocapture noundef [[A]])
; IS__CGSCC____-NEXT: ret void
; ;
%A = tail call noalias i8* @malloc(i64 4) %A = tail call noalias i8* @malloc(i64 4)
tail call void @two_args(i8* %A, i8* %A) tail call void @two_args(i8* %A, i8* %A)
ret void ret void
} }
define void @test12_4(){ define void @test12_4(){
; IS________OPM-LABEL: define {{[^@]+}}@test12_4() ; IS________OPM-LABEL: define {{[^@]+}}@test12_4()
; IS________OPM-NEXT: [[A:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; IS________OPM-NEXT: [[A:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS________OPM-NEXT: [[B:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; IS________OPM-NEXT: [[B:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS________OPM-NEXT: [[A_0:%.*]] = getelementptr i8, i8* [[A]], i64 0 ; IS________OPM-NEXT: [[A_0:%.*]] = getelementptr i8, i8* [[A]], i64 0
; IS________OPM-NEXT: [[A_1:%.*]] = getelementptr i8, i8* [[A]], i64 1 ; IS________OPM-NEXT: [[A_1:%.*]] = getelementptr i8, i8* [[A]], i64 1
; IS________OPM-NEXT: [[B_0:%.*]] = getelementptr i8, i8* [[B]], i64 0 ; IS________OPM-NEXT: [[B_0:%.*]] = getelementptr i8, i8* [[B]], i64 0
; IS________OPM-NEXT: tail call void @two_args(i8* nocapture noundef [[A]], i8* nocapture noundef [[B]]) ; IS________OPM-NEXT: tail call void @two_args(i8* nocapture [[A]], i8* nocapture [[B]])
; IS________OPM-NEXT: tail call void @two_args(i8* nocapture noundef [[A]], i8* nocapture noundef [[A_0]]) ; IS________OPM-NEXT: tail call void @two_args(i8* nocapture [[A]], i8* nocapture [[A_0]])
; IS________OPM-NEXT: tail call void @two_args(i8* nocapture noundef [[A]], i8* nocapture [[A_1]]) ; IS________OPM-NEXT: tail call void @two_args(i8* nocapture [[A]], i8* nocapture [[A_1]])
; IS________OPM-NEXT: tail call void @two_args(i8* nocapture noundef [[A_0]], i8* nocapture noundef [[B_0]]) ; IS________OPM-NEXT: tail call void @two_args(i8* nocapture [[A_0]], i8* nocapture [[B_0]])
; IS________OPM-NEXT: ret void ; IS________OPM-NEXT: ret void
; ;
; IS__TUNIT_NPM-LABEL: define {{[^@]+}}@test12_4() ; NOT_TUNIT_OPM-LABEL: define {{[^@]+}}@test12_4()
; IS__TUNIT_NPM-NEXT: [[A:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; NOT_TUNIT_OPM-NEXT: [[A:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__TUNIT_NPM-NEXT: [[B:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; NOT_TUNIT_OPM-NEXT: [[B:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__TUNIT_NPM-NEXT: [[A_0:%.*]] = getelementptr i8, i8* [[A]], i64 0 ; NOT_TUNIT_OPM-NEXT: [[A_0:%.*]] = getelementptr i8, i8* [[A]], i64 0
; IS__TUNIT_NPM-NEXT: [[A_1:%.*]] = getelementptr i8, i8* [[A]], i64 1 ; NOT_TUNIT_OPM-NEXT: [[A_1:%.*]] = getelementptr i8, i8* [[A]], i64 1
; IS__TUNIT_NPM-NEXT: [[B_0:%.*]] = getelementptr i8, i8* [[B]], i64 0 ; NOT_TUNIT_OPM-NEXT: [[B_0:%.*]] = getelementptr i8, i8* [[B]], i64 0
; IS__TUNIT_NPM-NEXT: tail call void @two_args(i8* noalias nocapture noundef [[A]], i8* noalias nocapture noundef [[B]]) ; NOT_TUNIT_OPM-NEXT: tail call void @two_args(i8* noalias nocapture [[A]], i8* noalias nocapture [[B]])
; IS__TUNIT_NPM-NEXT: tail call void @two_args(i8* nocapture noundef [[A]], i8* nocapture noundef [[A_0]]) ; NOT_TUNIT_OPM-NEXT: tail call void @two_args(i8* nocapture [[A]], i8* nocapture [[A_0]])
; IS__TUNIT_NPM-NEXT: tail call void @two_args(i8* nocapture noundef [[A]], i8* nocapture [[A_1]]) ; NOT_TUNIT_OPM-NEXT: tail call void @two_args(i8* nocapture [[A]], i8* nocapture [[A_1]])
; IS__TUNIT_NPM-NEXT: tail call void @two_args(i8* nocapture noundef [[A_0]], i8* nocapture noundef [[B_0]]) ; NOT_TUNIT_OPM-NEXT: tail call void @two_args(i8* nocapture [[A_0]], i8* nocapture [[B_0]])
; IS__TUNIT_NPM-NEXT: ret void ; NOT_TUNIT_OPM-NEXT: ret void
;
; IS__CGSCC____-LABEL: define {{[^@]+}}@test12_4()
; IS__CGSCC____-NEXT: [[A:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC____-NEXT: [[B:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC____-NEXT: [[A_0:%.*]] = getelementptr i8, i8* [[A]], i64 0
; IS__CGSCC____-NEXT: [[A_1:%.*]] = getelementptr i8, i8* [[A]], i64 1
; IS__CGSCC____-NEXT: [[B_0:%.*]] = getelementptr i8, i8* [[B]], i64 0
; IS__CGSCC____-NEXT: tail call void @two_args(i8* noalias nocapture noundef [[A]], i8* noalias nocapture noundef [[B]])
; IS__CGSCC____-NEXT: tail call void @two_args(i8* nocapture noundef [[A]], i8* nocapture noundef [[A_0]])
; IS__CGSCC____-NEXT: tail call void @two_args(i8* nocapture noundef [[A]], i8* nocapture noundef [[A_1]])
; IS__CGSCC____-NEXT: tail call void @two_args(i8* nocapture noundef [[A_0]], i8* nocapture noundef [[B_0]])
; IS__CGSCC____-NEXT: ret void
; ;
%A = tail call noalias i8* @malloc(i64 4) %A = tail call noalias i8* @malloc(i64 4)
%B = tail call noalias i8* @malloc(i64 4) %B = tail call noalias i8* @malloc(i64 4)
%A_0 = getelementptr i8, i8* %A, i64 0 %A_0 = getelementptr i8, i8* %A, i64 0
%A_1 = getelementptr i8, i8* %A, i64 1 %A_1 = getelementptr i8, i8* %A, i64 1
%B_0 = getelementptr i8, i8* %B, i64 0 %B_0 = getelementptr i8, i8* %B, i64 0
tail call void @two_args(i8* %A, i8* %B) tail call void @two_args(i8* %A, i8* %B)
Show All 14 Lines
; CHECK-NEXT: call void @use_i8(i8* nocapture [[A]]) ; CHECK-NEXT: call void @use_i8(i8* nocapture [[A]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @use_i8(i8* %a) call void @use_i8(i8* %a)
ret void ret void
} }
define void @test13_use_noalias(){ define void @test13_use_noalias(){
; NOT_CGSCC_NPM-LABEL: define {{[^@]+}}@test13_use_noalias() ; CHECK-LABEL: define {{[^@]+}}@test13_use_noalias()
; NOT_CGSCC_NPM-NEXT: [[M1:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; CHECK-NEXT: [[M1:%.*]] = tail call noalias i8* @malloc(i64 4)
; NOT_CGSCC_NPM-NEXT: [[C1:%.*]] = bitcast i8* [[M1]] to i16* ; CHECK-NEXT: [[C1:%.*]] = bitcast i8* [[M1]] to i16*
; NOT_CGSCC_NPM-NEXT: [[C2:%.*]] = bitcast i16* [[C1]] to i8* ; CHECK-NEXT: [[C2:%.*]] = bitcast i16* [[C1]] to i8*
; NOT_CGSCC_NPM-NEXT: call void @use_i8_internal(i8* noalias nocapture noundef [[C2]]) ; CHECK-NEXT: call void @use_i8_internal(i8* noalias nocapture [[C2]])
; NOT_CGSCC_NPM-NEXT: ret void ; CHECK-NEXT: ret void
;
; IS__CGSCC____-LABEL: define {{[^@]+}}@test13_use_noalias()
; IS__CGSCC____-NEXT: [[M1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC____-NEXT: [[C1:%.*]] = bitcast i8* [[M1]] to i16*
; IS__CGSCC____-NEXT: [[C2:%.*]] = bitcast i16* [[C1]] to i8*
; IS__CGSCC____-NEXT: call void @use_i8_internal(i8* noalias nocapture noundef [[C2]])
; IS__CGSCC____-NEXT: ret void
; ;
; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test13_use_noalias() ; IS__CGSCC_OPM-LABEL: define {{[^@]+}}@test13_use_noalias()
; IS__CGSCC_OPM-NEXT: [[M1:%.*]] = tail call noalias i8* @malloc(i64 4) ; IS__CGSCC_OPM-NEXT: [[M1:%.*]] = tail call noalias i8* @malloc(i64 4)
; IS__CGSCC_OPM-NEXT: [[C1:%.*]] = bitcast i8* [[M1]] to i16* ; IS__CGSCC_OPM-NEXT: [[C1:%.*]] = bitcast i8* [[M1]] to i16*
; IS__CGSCC_OPM-NEXT: [[C2:%.*]] = bitcast i16* [[C1]] to i8* ; IS__CGSCC_OPM-NEXT: [[C2:%.*]] = bitcast i16* [[C1]] to i8*
; IS__CGSCC_OPM-NEXT: call void @use_i8_internal(i8* noalias [[C2]]) ; IS__CGSCC_OPM-NEXT: call void @use_i8_internal(i8* noalias [[C2]])
; IS__CGSCC_OPM-NEXT: ret void ; IS__CGSCC_OPM-NEXT: ret void
%m1 = tail call noalias i8* @malloc(i64 4) %m1 = tail call noalias i8* @malloc(i64 4)
%c1 = bitcast i8* %m1 to i16* %c1 = bitcast i8* %m1 to i16*
%c2 = bitcast i16* %c1 to i8* %c2 = bitcast i16* %c1 to i8*
call void @use_i8_internal(i8* %c2) call void @use_i8_internal(i8* %c2)
ret void ret void
} }
define void @test13_use_alias(){ define void @test13_use_alias(){
; CHECK-LABEL: define {{[^@]+}}@test13_use_alias() ; CHECK-LABEL: define {{[^@]+}}@test13_use_alias()
; CHECK-NEXT: [[M1:%.*]] = tail call noalias noundef i8* @malloc(i64 4) ; CHECK-NEXT: [[M1:%.*]] = tail call noalias i8* @malloc(i64 4)
; CHECK-NEXT: [[C1:%.*]] = bitcast i8* [[M1]] to i16* ; CHECK-NEXT: [[C1:%.*]] = bitcast i8* [[M1]] to i16*
; CHECK-NEXT: [[C2A:%.*]] = bitcast i16* [[C1]] to i8* ; CHECK-NEXT: [[C2A:%.*]] = bitcast i16* [[C1]] to i8*
; CHECK-NEXT: [[C2B:%.*]] = bitcast i16* [[C1]] to i8* ; CHECK-NEXT: [[C2B:%.*]] = bitcast i16* [[C1]] to i8*
; CHECK-NEXT: call void @use_i8_internal(i8* nocapture noundef [[C2A]]) ; CHECK-NEXT: call void @use_i8_internal(i8* nocapture [[C2A]])
; CHECK-NEXT: call void @use_i8_internal(i8* nocapture noundef [[C2B]]) ; CHECK-NEXT: call void @use_i8_internal(i8* nocapture [[C2B]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%m1 = tail call noalias i8* @malloc(i64 4) %m1 = tail call noalias i8* @malloc(i64 4)
%c1 = bitcast i8* %m1 to i16* %c1 = bitcast i8* %m1 to i16*
%c2a = bitcast i16* %c1 to i8* %c2a = bitcast i16* %c1 to i8*
%c2b = bitcast i16* %c1 to i8* %c2b = bitcast i16* %c1 to i8*
call void @use_i8_internal(i8* %c2a) call void @use_i8_internal(i8* %c2a)
call void @use_i8_internal(i8* %c2b) call void @use_i8_internal(i8* %c2b)
▲ Show 20 Lines • Show All 425 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 211 Lines • ▼ Show 20 Lines
; CHECK: Function Attrs: nofree nosync nounwind readnone ; CHECK: Function Attrs: nofree nosync nounwind readnone
; CHECK-LABEL: define {{[^@]+}}@scc_A ; CHECK-LABEL: define {{[^@]+}}@scc_A
; CHECK-SAME: (i32* nofree readnone returned dereferenceable_or_null(4) "no-capture-maybe-returned" [[A:%.*]]) ; CHECK-SAME: (i32* nofree readnone returned dereferenceable_or_null(4) "no-capture-maybe-returned" [[A:%.*]])
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TOBOOL:%.*]] = icmp ne i32* [[A]], null ; CHECK-NEXT: [[TOBOOL:%.*]] = icmp ne i32* [[A]], null
; CHECK-NEXT: br i1 [[TOBOOL]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]] ; CHECK-NEXT: br i1 [[TOBOOL]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
; CHECK: cond.true: ; CHECK: cond.true:
; CHECK-NEXT: [[TMP0:%.*]] = bitcast i32* [[A]] to i16* ; CHECK-NEXT: [[TMP0:%.*]] = bitcast i32* [[A]] to i16*
; CHECK-NEXT: [[CALL:%.*]] = call noundef dereferenceable_or_null(4) i8* @scc_C(i16* noalias nofree readnone dereferenceable_or_null(4) "no-capture-maybe-returned" [[TMP0]]) ; CHECK-NEXT: [[CALL:%.*]] = call dereferenceable_or_null(4) i8* @scc_C(i16* noalias nofree readnone dereferenceable_or_null(4) "no-capture-maybe-returned" [[TMP0]])
; CHECK-NEXT: [[TMP1:%.*]] = bitcast i8* [[CALL]] to double* ; CHECK-NEXT: [[TMP1:%.*]] = bitcast i8* [[CALL]] to double*
; CHECK-NEXT: [[CALL1:%.*]] = call noundef dereferenceable_or_null(8) i64* @scc_B(double* noalias nofree noundef readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[TMP1]]) ; CHECK-NEXT: [[CALL1:%.*]] = call dereferenceable_or_null(8) i64* @scc_B(double* noalias nofree readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[TMP1]])
; CHECK-NEXT: [[TMP2:%.*]] = bitcast i64* [[CALL1]] to i32* ; CHECK-NEXT: [[TMP2:%.*]] = bitcast i64* [[CALL1]] to i32*
; CHECK-NEXT: [[CALL2:%.*]] = call float* @scc_A(i32* noalias nofree noundef readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[TMP2]]) ; CHECK-NEXT: [[CALL2:%.*]] = call float* @scc_A(i32* noalias nofree readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[TMP2]])
; CHECK-NEXT: [[TMP3:%.*]] = bitcast float* [[CALL2]] to i32* ; CHECK-NEXT: [[TMP3:%.*]] = bitcast float* [[CALL2]] to i32*
; CHECK-NEXT: br label [[COND_END:%.*]] ; CHECK-NEXT: br label [[COND_END:%.*]]
; CHECK: cond.false: ; CHECK: cond.false:
; CHECK-NEXT: br label [[COND_END]] ; CHECK-NEXT: br label [[COND_END]]
; CHECK: cond.end: ; CHECK: cond.end:
; CHECK-NEXT: [[COND:%.*]] = phi i32* [ [[TMP3]], [[COND_TRUE]] ], [ [[A]], [[COND_FALSE]] ] ; CHECK-NEXT: [[COND:%.*]] = phi i32* [ [[TMP3]], [[COND_TRUE]] ], [ [[A]], [[COND_FALSE]] ]
; CHECK-NEXT: [[TMP4:%.*]] = bitcast i32* [[COND]] to float* ; CHECK-NEXT: [[TMP4:%.*]] = bitcast i32* [[COND]] to float*
; CHECK-NEXT: ret float* [[TMP4]] ; CHECK-NEXT: ret float* [[TMP4]]
Show All 25 Lines
; CHECK: Function Attrs: nofree nosync nounwind readnone ; CHECK: Function Attrs: nofree nosync nounwind readnone
; CHECK-LABEL: define {{[^@]+}}@scc_B ; CHECK-LABEL: define {{[^@]+}}@scc_B
; CHECK-SAME: (double* nofree readnone returned dereferenceable_or_null(8) "no-capture-maybe-returned" [[A:%.*]]) ; CHECK-SAME: (double* nofree readnone returned dereferenceable_or_null(8) "no-capture-maybe-returned" [[A:%.*]])
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TOBOOL:%.*]] = icmp ne double* [[A]], null ; CHECK-NEXT: [[TOBOOL:%.*]] = icmp ne double* [[A]], null
; CHECK-NEXT: br i1 [[TOBOOL]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]] ; CHECK-NEXT: br i1 [[TOBOOL]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
; CHECK: cond.true: ; CHECK: cond.true:
; CHECK-NEXT: [[TMP0:%.*]] = bitcast double* [[A]] to i32* ; CHECK-NEXT: [[TMP0:%.*]] = bitcast double* [[A]] to i32*
; CHECK-NEXT: [[CALL:%.*]] = call noundef dereferenceable_or_null(4) float* @scc_A(i32* noalias nofree readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[TMP0]]) ; CHECK-NEXT: [[CALL:%.*]] = call dereferenceable_or_null(4) float* @scc_A(i32* noalias nofree readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[TMP0]])
; CHECK-NEXT: [[TMP1:%.*]] = bitcast float* [[CALL]] to double* ; CHECK-NEXT: [[TMP1:%.*]] = bitcast float* [[CALL]] to double*
; CHECK-NEXT: [[CALL1:%.*]] = call noundef dereferenceable_or_null(8) i64* @scc_B(double* noalias nofree noundef readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[TMP1]]) ; CHECK-NEXT: [[CALL1:%.*]] = call dereferenceable_or_null(8) i64* @scc_B(double* noalias nofree readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[TMP1]])
; CHECK-NEXT: [[TMP2:%.*]] = bitcast i64* [[CALL1]] to i16* ; CHECK-NEXT: [[TMP2:%.*]] = bitcast i64* [[CALL1]] to i16*
; CHECK-NEXT: [[CALL2:%.*]] = call i8* @scc_C(i16* noalias nofree noundef readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[TMP2]]) ; CHECK-NEXT: [[CALL2:%.*]] = call i8* @scc_C(i16* noalias nofree readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[TMP2]])
; CHECK-NEXT: br label [[COND_END:%.*]] ; CHECK-NEXT: br label [[COND_END:%.*]]
; CHECK: cond.false: ; CHECK: cond.false:
; CHECK-NEXT: [[TMP3:%.*]] = bitcast double* [[A]] to i8* ; CHECK-NEXT: [[TMP3:%.*]] = bitcast double* [[A]] to i8*
; CHECK-NEXT: br label [[COND_END]] ; CHECK-NEXT: br label [[COND_END]]
; CHECK: cond.end: ; CHECK: cond.end:
; CHECK-NEXT: [[COND:%.*]] = phi i8* [ [[CALL2]], [[COND_TRUE]] ], [ [[TMP3]], [[COND_FALSE]] ] ; CHECK-NEXT: [[COND:%.*]] = phi i8* [ [[CALL2]], [[COND_TRUE]] ], [ [[TMP3]], [[COND_FALSE]] ]
; CHECK-NEXT: [[TMP4:%.*]] = bitcast i8* [[COND]] to i64* ; CHECK-NEXT: [[TMP4:%.*]] = bitcast i8* [[COND]] to i64*
; CHECK-NEXT: ret i64* [[TMP4]] ; CHECK-NEXT: ret i64* [[TMP4]]
Show All 28 Lines
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[BC:%.*]] = bitcast i16* [[A]] to i32* ; CHECK-NEXT: [[BC:%.*]] = bitcast i16* [[A]] to i32*
; CHECK-NEXT: [[CALL:%.*]] = call dereferenceable_or_null(4) float* @scc_A(i32* noalias nofree readnone dereferenceable_or_null(4) "no-capture-maybe-returned" [[BC]]) ; CHECK-NEXT: [[CALL:%.*]] = call dereferenceable_or_null(4) float* @scc_A(i32* noalias nofree readnone dereferenceable_or_null(4) "no-capture-maybe-returned" [[BC]])
; CHECK-NEXT: [[BC2:%.*]] = bitcast float* [[CALL]] to i8* ; CHECK-NEXT: [[BC2:%.*]] = bitcast float* [[CALL]] to i8*
; CHECK-NEXT: [[TOBOOL:%.*]] = icmp ne i8* [[BC2]], null ; CHECK-NEXT: [[TOBOOL:%.*]] = icmp ne i8* [[BC2]], null
; CHECK-NEXT: br i1 [[TOBOOL]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]] ; CHECK-NEXT: br i1 [[TOBOOL]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
; CHECK: cond.true: ; CHECK: cond.true:
; CHECK-NEXT: [[TMP0:%.*]] = bitcast i16* [[A]] to double* ; CHECK-NEXT: [[TMP0:%.*]] = bitcast i16* [[A]] to double*
; CHECK-NEXT: [[CALL1:%.*]] = call noundef dereferenceable_or_null(8) i64* @scc_B(double* noalias nofree readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[TMP0]]) ; CHECK-NEXT: [[CALL1:%.*]] = call dereferenceable_or_null(8) i64* @scc_B(double* noalias nofree readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[TMP0]])
; CHECK-NEXT: [[TMP1:%.*]] = bitcast i64* [[CALL1]] to i8* ; CHECK-NEXT: [[TMP1:%.*]] = bitcast i64* [[CALL1]] to i8*
; CHECK-NEXT: br label [[COND_END:%.*]] ; CHECK-NEXT: br label [[COND_END:%.*]]
; CHECK: cond.false: ; CHECK: cond.false:
; CHECK-NEXT: [[CALL2:%.*]] = call noundef dereferenceable_or_null(4) i8* @scc_C(i16* noalias nofree readnone dereferenceable_or_null(4) "no-capture-maybe-returned" [[A]]) ; CHECK-NEXT: [[CALL2:%.*]] = call dereferenceable_or_null(4) i8* @scc_C(i16* noalias nofree readnone dereferenceable_or_null(4) "no-capture-maybe-returned" [[A]])
; CHECK-NEXT: br label [[COND_END]] ; CHECK-NEXT: br label [[COND_END]]
; CHECK: cond.end: ; CHECK: cond.end:
; CHECK-NEXT: [[COND:%.*]] = phi i8* [ [[TMP1]], [[COND_TRUE]] ], [ [[CALL2]], [[COND_FALSE]] ] ; CHECK-NEXT: [[COND:%.*]] = phi i8* [ [[TMP1]], [[COND_TRUE]] ], [ [[CALL2]], [[COND_FALSE]] ]
; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[COND]] to i32* ; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[COND]] to i32*
; CHECK-NEXT: [[CALL3:%.*]] = call float* @scc_A(i32* noalias nofree noundef readnone dereferenceable_or_null(4) "no-capture-maybe-returned" [[TMP2]]) ; CHECK-NEXT: [[CALL3:%.*]] = call float* @scc_A(i32* noalias nofree readnone dereferenceable_or_null(4) "no-capture-maybe-returned" [[TMP2]])
; CHECK-NEXT: [[TMP3:%.*]] = bitcast float* [[CALL3]] to i8* ; CHECK-NEXT: [[TMP3:%.*]] = bitcast float* [[CALL3]] to i8*
; CHECK-NEXT: ret i8* [[TMP3]] ; CHECK-NEXT: ret i8* [[TMP3]]
; ;
entry: entry:
%bc = bitcast i16* %a to i32* %bc = bitcast i16* %a to i32*
%call = call float* @scc_A(i32* %bc) %call = call float* @scc_A(i32* %bc)
%bc2 = bitcast float* %call to i8* %bc2 = bitcast float* %call to i8*
%tobool = icmp ne i8* %bc2, null %tobool = icmp ne i8* %bc2, null
▲ Show 20 Lines • Show All 451 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/nonnull.ll

Show First 20 Lines • Show All 358 Lines • ▼ Show 20 Lines;
ret void ret void
} }
; TEST 13 ; TEST 13
; Simple Argument Tests ; Simple Argument Tests
declare i8* @unknown() declare i8* @unknown()
define void @test13_helper() { define void @test13_helper() {
; CHECK-LABEL: define {{[^@]+}}@test13_helper() ; CHECK-LABEL: define {{[^@]+}}@test13_helper()
; CHECK-NEXT: [[NONNULLPTR:%.*]] = tail call noundef nonnull i8* @ret_nonnull() ; CHECK-NEXT: [[NONNULLPTR:%.*]] = tail call nonnull i8* @ret_nonnull()
; CHECK-NEXT: [[MAYBENULLPTR:%.*]] = tail call noundef i8* @unknown() ; CHECK-NEXT: [[MAYBENULLPTR:%.*]] = tail call i8* @unknown()
; CHECK-NEXT: tail call void @test13(i8* noalias nocapture nofree noundef nonnull readnone [[NONNULLPTR]], i8* noalias nocapture nofree noundef nonnull readnone [[NONNULLPTR]], i8* noalias nocapture nofree noundef readnone [[MAYBENULLPTR]]) ; CHECK-NEXT: tail call void @test13(i8* noalias nocapture nofree nonnull readnone [[NONNULLPTR]], i8* noalias nocapture nofree nonnull readnone [[NONNULLPTR]], i8* noalias nocapture nofree readnone [[MAYBENULLPTR]])
; CHECK-NEXT: tail call void @test13(i8* noalias nocapture nofree noundef nonnull readnone [[NONNULLPTR]], i8* noalias nocapture nofree noundef readnone [[MAYBENULLPTR]], i8* noalias nocapture nofree noundef nonnull readnone [[NONNULLPTR]]) ; CHECK-NEXT: tail call void @test13(i8* noalias nocapture nofree nonnull readnone [[NONNULLPTR]], i8* noalias nocapture nofree readnone [[MAYBENULLPTR]], i8* noalias nocapture nofree nonnull readnone [[NONNULLPTR]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%nonnullptr = tail call i8* @ret_nonnull() %nonnullptr = tail call i8* @ret_nonnull()
%maybenullptr = tail call i8* @unknown() %maybenullptr = tail call i8* @unknown()
tail call void @test13(i8* %nonnullptr, i8* %nonnullptr, i8* %maybenullptr) tail call void @test13(i8* %nonnullptr, i8* %nonnullptr, i8* %maybenullptr)
tail call void @test13(i8* %nonnullptr, i8* %maybenullptr, i8* %nonnullptr) tail call void @test13(i8* %nonnullptr, i8* %maybenullptr, i8* %nonnullptr)
ret void ret void
} }
define internal void @test13(i8* %a, i8* %b, i8* %c) { define internal void @test13(i8* %a, i8* %b, i8* %c) {
; IS__TUNIT____: Function Attrs: nounwind ; IS__TUNIT____: Function Attrs: nounwind
; IS__TUNIT____-LABEL: define {{[^@]+}}@test13 ; IS__TUNIT____-LABEL: define {{[^@]+}}@test13
; IS__TUNIT____-SAME: (i8* noalias nocapture nofree noundef nonnull readnone [[A:%.*]], i8* noalias nocapture nofree noundef readnone [[B:%.*]], i8* noalias nocapture nofree noundef readnone [[C:%.*]]) ; IS__TUNIT____-SAME: (i8* noalias nocapture nofree nonnull readnone [[A:%.*]], i8* noalias nocapture nofree readnone [[B:%.*]], i8* noalias nocapture nofree readnone [[C:%.*]])
; IS__TUNIT____-NEXT: call void @use_i8_ptr(i8* noalias nocapture nofree noundef nonnull readnone [[A]]) ; IS__TUNIT____-NEXT: call void @use_i8_ptr(i8* noalias nocapture nofree nonnull readnone [[A]])
; IS__TUNIT____-NEXT: call void @use_i8_ptr(i8* noalias nocapture nofree noundef readnone [[B]]) ; IS__TUNIT____-NEXT: call void @use_i8_ptr(i8* noalias nocapture nofree readnone [[B]])
; IS__TUNIT____-NEXT: call void @use_i8_ptr(i8* noalias nocapture nofree noundef readnone [[C]]) ; IS__TUNIT____-NEXT: call void @use_i8_ptr(i8* noalias nocapture nofree readnone [[C]])
; IS__TUNIT____-NEXT: ret void ; IS__TUNIT____-NEXT: ret void
; ;
; IS__CGSCC____: Function Attrs: nounwind ; IS__CGSCC____: Function Attrs: nounwind
; IS__CGSCC____-LABEL: define {{[^@]+}}@test13 ; IS__CGSCC____-LABEL: define {{[^@]+}}@test13
; IS__CGSCC____-SAME: (i8* nocapture nofree readnone [[A:%.*]], i8* nocapture nofree readnone [[B:%.*]], i8* nocapture nofree readnone [[C:%.*]]) ; IS__CGSCC____-SAME: (i8* nocapture nofree readnone [[A:%.*]], i8* nocapture nofree readnone [[B:%.*]], i8* nocapture nofree readnone [[C:%.*]])
; IS__CGSCC____-NEXT: call void @use_i8_ptr(i8* noalias nocapture nofree readnone [[A]]) ; IS__CGSCC____-NEXT: call void @use_i8_ptr(i8* noalias nocapture nofree readnone [[A]])
; IS__CGSCC____-NEXT: call void @use_i8_ptr(i8* noalias nocapture nofree readnone [[B]]) ; IS__CGSCC____-NEXT: call void @use_i8_ptr(i8* noalias nocapture nofree readnone [[B]])
; IS__CGSCC____-NEXT: call void @use_i8_ptr(i8* noalias nocapture nofree readnone [[C]]) ; IS__CGSCC____-NEXT: call void @use_i8_ptr(i8* noalias nocapture nofree readnone [[C]])
▲ Show 20 Lines • Show All 1,005 Lines • Show Last 20 Lines

llvm/test/Transforms/Attributor/returned.ll

Show First 20 Lines • Show All 308 Lines • ▼ Show 20 Linesentry:
ret double* %r ret double* %r
} }
define double* @ptr_scc_r1(double* %a, double* %r, double* %b) #0 { define double* @ptr_scc_r1(double* %a, double* %r, double* %b) #0 {
; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable ; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable
; IS__TUNIT____-LABEL: define {{[^@]+}}@ptr_scc_r1 ; IS__TUNIT____-LABEL: define {{[^@]+}}@ptr_scc_r1
; IS__TUNIT____-SAME: (double* nofree readnone [[A:%.*]], double* nofree readnone returned [[R:%.*]], double* nocapture nofree readnone [[B:%.*]]) ; IS__TUNIT____-SAME: (double* nofree readnone [[A:%.*]], double* nofree readnone returned [[R:%.*]], double* nocapture nofree readnone [[B:%.*]])
; IS__TUNIT____-NEXT: entry: ; IS__TUNIT____-NEXT: entry:
; IS__TUNIT____-NEXT: [[CALL:%.*]] = call noundef double* @ptr_sink_r0(double* noalias nofree readnone "no-capture-maybe-returned" [[R]]) ; IS__TUNIT____-NEXT: [[CALL:%.*]] = call double* @ptr_sink_r0(double* noalias nofree readnone "no-capture-maybe-returned" [[R]])
; IS__TUNIT____-NEXT: [[CALL1:%.*]] = call double* @ptr_scc_r2(double* noalias nofree readnone [[R]], double* noalias nofree readnone [[A]], double* noalias nofree noundef readnone [[CALL]]) ; IS__TUNIT____-NEXT: [[CALL1:%.*]] = call double* @ptr_scc_r2(double* noalias nofree readnone [[R]], double* noalias nofree readnone [[A]], double* noalias nofree readnone [[CALL]])
; IS__TUNIT____-NEXT: ret double* [[CALL1]] ; IS__TUNIT____-NEXT: ret double* [[CALL1]]
; ;
; IS__CGSCC____: Function Attrs: nofree noinline nosync nounwind readnone uwtable ; IS__CGSCC____: Function Attrs: nofree noinline nosync nounwind readnone uwtable
; IS__CGSCC____-LABEL: define {{[^@]+}}@ptr_scc_r1 ; IS__CGSCC____-LABEL: define {{[^@]+}}@ptr_scc_r1
; IS__CGSCC____-SAME: (double* nofree readnone [[A:%.*]], double* nofree readnone returned [[R:%.*]], double* nocapture nofree readnone [[B:%.*]]) ; IS__CGSCC____-SAME: (double* nofree readnone [[A:%.*]], double* nofree readnone returned [[R:%.*]], double* nocapture nofree readnone [[B:%.*]])
; IS__CGSCC____-NEXT: entry: ; IS__CGSCC____-NEXT: entry:
; IS__CGSCC____-NEXT: [[CALL:%.*]] = call double* @ptr_sink_r0(double* noalias nofree readnone [[R]]) ; IS__CGSCC____-NEXT: [[CALL:%.*]] = call double* @ptr_sink_r0(double* noalias nofree readnone [[R]])
; IS__CGSCC____-NEXT: [[CALL1:%.*]] = call double* @ptr_scc_r2(double* noalias nofree readnone [[R]], double* noalias nofree readnone [[A]], double* noalias nofree noundef readnone [[CALL]]) ; IS__CGSCC____-NEXT: [[CALL1:%.*]] = call double* @ptr_scc_r2(double* noalias nofree readnone [[R]], double* noalias nofree readnone [[A]], double* noalias nofree readnone [[CALL]])
; IS__CGSCC____-NEXT: ret double* [[CALL1]] ; IS__CGSCC____-NEXT: ret double* [[CALL1]]
; ;
entry: entry:
%call = call double* @ptr_sink_r0(double* %r) %call = call double* @ptr_sink_r0(double* %r)
%call1 = call double* @ptr_scc_r2(double* %r, double* %a, double* %call) %call1 = call double* @ptr_scc_r2(double* %r, double* %a, double* %call)
ret double* %call1 ret double* %call1
} }
define double* @ptr_scc_r2(double* %a, double* %b, double* %r) #0 { define double* @ptr_scc_r2(double* %a, double* %b, double* %r) #0 {
; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable ; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable
; IS__TUNIT____-LABEL: define {{[^@]+}}@ptr_scc_r2 ; IS__TUNIT____-LABEL: define {{[^@]+}}@ptr_scc_r2
; IS__TUNIT____-SAME: (double* nofree readnone [[A:%.*]], double* nofree readnone [[B:%.*]], double* nofree readnone returned [[R:%.*]]) ; IS__TUNIT____-SAME: (double* nofree readnone [[A:%.*]], double* nofree readnone [[B:%.*]], double* nofree readnone returned [[R:%.*]])
; IS__TUNIT____-NEXT: entry: ; IS__TUNIT____-NEXT: entry:
; IS__TUNIT____-NEXT: [[CMP:%.*]] = icmp ugt double* [[A]], [[B]] ; IS__TUNIT____-NEXT: [[CMP:%.*]] = icmp ugt double* [[A]], [[B]]
; IS__TUNIT____-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]] ; IS__TUNIT____-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; IS__TUNIT____: if.then: ; IS__TUNIT____: if.then:
; IS__TUNIT____-NEXT: [[CALL:%.*]] = call noundef double* @ptr_sink_r0(double* noalias nofree readnone "no-capture-maybe-returned" [[R]]) ; IS__TUNIT____-NEXT: [[CALL:%.*]] = call double* @ptr_sink_r0(double* noalias nofree readnone "no-capture-maybe-returned" [[R]])
; IS__TUNIT____-NEXT: [[CALL1:%.*]] = call double* @ptr_scc_r2(double* noalias nofree readnone [[B]], double* noalias nofree readnone [[A]], double* noalias nofree noundef readnone [[CALL]]) ; IS__TUNIT____-NEXT: [[CALL1:%.*]] = call double* @ptr_scc_r2(double* noalias nofree readnone [[B]], double* noalias nofree readnone [[A]], double* noalias nofree readnone [[CALL]])
; IS__TUNIT____-NEXT: br label [[RETURN:%.*]] ; IS__TUNIT____-NEXT: br label [[RETURN:%.*]]
; IS__TUNIT____: if.end: ; IS__TUNIT____: if.end:
; IS__TUNIT____-NEXT: [[CMP2:%.*]] = icmp ult double* [[A]], [[B]] ; IS__TUNIT____-NEXT: [[CMP2:%.*]] = icmp ult double* [[A]], [[B]]
; IS__TUNIT____-NEXT: br i1 [[CMP2]], label [[IF_THEN3:%.*]], label [[IF_END12:%.*]] ; IS__TUNIT____-NEXT: br i1 [[CMP2]], label [[IF_THEN3:%.*]], label [[IF_END12:%.*]]
; IS__TUNIT____: if.then3: ; IS__TUNIT____: if.then3:
; IS__TUNIT____-NEXT: [[CALL4:%.*]] = call noundef double* @ptr_sink_r0(double* noalias nofree readnone "no-capture-maybe-returned" [[B]]) ; IS__TUNIT____-NEXT: [[CALL4:%.*]] = call double* @ptr_sink_r0(double* noalias nofree readnone "no-capture-maybe-returned" [[B]])
; IS__TUNIT____-NEXT: [[CALL5:%.*]] = call noundef double* @ptr_scc_r1(double* noalias nofree readnone [[A]], double* noalias nofree readnone [[B]], double* noalias nocapture nofree readnone undef) ; IS__TUNIT____-NEXT: [[CALL5:%.*]] = call double* @ptr_scc_r1(double* noalias nofree readnone [[A]], double* noalias nofree readnone [[B]], double* noalias nocapture nofree readnone undef)
; IS__TUNIT____-NEXT: [[CALL6:%.*]] = call noundef double* @ptr_scc_r2(double* noalias nofree readnone [[R]], double* noalias nofree readnone [[R]], double* noalias nofree readnone [[R]]) ; IS__TUNIT____-NEXT: [[CALL6:%.*]] = call double* @ptr_scc_r2(double* noalias nofree readnone [[R]], double* noalias nofree readnone [[R]], double* noalias nofree readnone [[R]])
; IS__TUNIT____-NEXT: [[CALL7:%.*]] = call noundef double* @ptr_scc_r1(double* noalias nofree readnone [[A]], double* noalias nofree noundef readnone [[CALL6]], double* noalias nocapture nofree readnone undef) ; IS__TUNIT____-NEXT: [[CALL7:%.*]] = call double* @ptr_scc_r1(double* noalias nofree readnone [[A]], double* noalias nofree readnone [[CALL6]], double* noalias nocapture nofree readnone undef)
; IS__TUNIT____-NEXT: [[CALL8:%.*]] = call noundef double* @ptr_scc_r2(double* noalias nofree readnone [[A]], double* noalias nofree readnone [[B]], double* noalias nofree readnone [[R]]) ; IS__TUNIT____-NEXT: [[CALL8:%.*]] = call double* @ptr_scc_r2(double* noalias nofree readnone [[A]], double* noalias nofree readnone [[B]], double* noalias nofree readnone [[R]])
; IS__TUNIT____-NEXT: [[CALL9:%.*]] = call noundef double* @ptr_scc_r2(double* noalias nofree noundef readnone [[CALL5]], double* noalias nofree noundef readnone [[CALL7]], double* noalias nofree noundef readnone [[CALL8]]) ; IS__TUNIT____-NEXT: [[CALL9:%.*]] = call double* @ptr_scc_r2(double* noalias nofree readnone [[CALL5]], double* noalias nofree readnone [[CALL7]], double* noalias nofree readnone [[CALL8]])
; IS__TUNIT____-NEXT: [[CALL11:%.*]] = call double* @ptr_scc_r1(double* noalias nofree noundef readnone [[CALL4]], double* noalias nofree noundef readnone [[CALL9]], double* noalias nocapture nofree noundef readnone undef) ; IS__TUNIT____-NEXT: [[CALL11:%.*]] = call double* @ptr_scc_r1(double* noalias nofree readnone [[CALL4]], double* noalias nofree readnone [[CALL9]], double* noalias nocapture nofree readnone undef)
; IS__TUNIT____-NEXT: br label [[RETURN]] ; IS__TUNIT____-NEXT: br label [[RETURN]]
; IS__TUNIT____: if.end12: ; IS__TUNIT____: if.end12:
; IS__TUNIT____-NEXT: [[CMP13:%.*]] = icmp eq double* [[A]], [[B]] ; IS__TUNIT____-NEXT: [[CMP13:%.*]] = icmp eq double* [[A]], [[B]]
; IS__TUNIT____-NEXT: br i1 [[CMP13]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]] ; IS__TUNIT____-NEXT: br i1 [[CMP13]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
; IS__TUNIT____: cond.true: ; IS__TUNIT____: cond.true:
; IS__TUNIT____-NEXT: br label [[COND_END:%.*]] ; IS__TUNIT____-NEXT: br label [[COND_END:%.*]]
; IS__TUNIT____: cond.false: ; IS__TUNIT____: cond.false:
; IS__TUNIT____-NEXT: [[CALL14:%.*]] = call double* @ptr_scc_r2(double* noalias nofree readnone [[A]], double* noalias nofree readnone [[B]], double* noalias nofree readnone [[R]]) ; IS__TUNIT____-NEXT: [[CALL14:%.*]] = call double* @ptr_scc_r2(double* noalias nofree readnone [[A]], double* noalias nofree readnone [[B]], double* noalias nofree readnone [[R]])
; IS__TUNIT____-NEXT: br label [[COND_END]] ; IS__TUNIT____-NEXT: br label [[COND_END]]
; IS__TUNIT____: cond.end: ; IS__TUNIT____: cond.end:
; IS__TUNIT____-NEXT: [[COND:%.*]] = phi double* [ [[R]], [[COND_TRUE]] ], [ [[CALL14]], [[COND_FALSE]] ] ; IS__TUNIT____-NEXT: [[COND:%.*]] = phi double* [ [[R]], [[COND_TRUE]] ], [ [[CALL14]], [[COND_FALSE]] ]
; IS__TUNIT____-NEXT: br label [[RETURN]] ; IS__TUNIT____-NEXT: br label [[RETURN]]
; IS__TUNIT____: return: ; IS__TUNIT____: return:
; IS__TUNIT____-NEXT: [[RETVAL_0:%.*]] = phi double* [ [[CALL1]], [[IF_THEN]] ], [ [[CALL11]], [[IF_THEN3]] ], [ [[COND]], [[COND_END]] ] ; IS__TUNIT____-NEXT: [[RETVAL_0:%.*]] = phi double* [ [[CALL1]], [[IF_THEN]] ], [ [[CALL11]], [[IF_THEN3]] ], [ [[COND]], [[COND_END]] ]
; IS__TUNIT____-NEXT: ret double* [[RETVAL_0]] ; IS__TUNIT____-NEXT: ret double* [[RETVAL_0]]
; ;
; IS__CGSCC____: Function Attrs: nofree noinline nosync nounwind readnone uwtable ; IS__CGSCC____: Function Attrs: nofree noinline nosync nounwind readnone uwtable
; IS__CGSCC____-LABEL: define {{[^@]+}}@ptr_scc_r2 ; IS__CGSCC____-LABEL: define {{[^@]+}}@ptr_scc_r2
; IS__CGSCC____-SAME: (double* nofree readnone [[A:%.*]], double* nofree readnone [[B:%.*]], double* nofree readnone returned [[R:%.*]]) ; IS__CGSCC____-SAME: (double* nofree readnone [[A:%.*]], double* nofree readnone [[B:%.*]], double* nofree readnone returned [[R:%.*]])
; IS__CGSCC____-NEXT: entry: ; IS__CGSCC____-NEXT: entry:
; IS__CGSCC____-NEXT: [[CMP:%.*]] = icmp ugt double* [[A]], [[B]] ; IS__CGSCC____-NEXT: [[CMP:%.*]] = icmp ugt double* [[A]], [[B]]
; IS__CGSCC____-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]] ; IS__CGSCC____-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; IS__CGSCC____: if.then: ; IS__CGSCC____: if.then:
; IS__CGSCC____-NEXT: [[CALL:%.*]] = call double* @ptr_sink_r0(double* noalias nofree readnone [[R]]) ; IS__CGSCC____-NEXT: [[CALL:%.*]] = call double* @ptr_sink_r0(double* noalias nofree readnone [[R]])
; IS__CGSCC____-NEXT: [[CALL1:%.*]] = call double* @ptr_scc_r2(double* noalias nofree readnone [[B]], double* noalias nofree readnone [[A]], double* noalias nofree noundef readnone [[CALL]]) ; IS__CGSCC____-NEXT: [[CALL1:%.*]] = call double* @ptr_scc_r2(double* noalias nofree readnone [[B]], double* noalias nofree readnone [[A]], double* noalias nofree readnone [[CALL]])
; IS__CGSCC____-NEXT: br label [[RETURN:%.*]] ; IS__CGSCC____-NEXT: br label [[RETURN:%.*]]
; IS__CGSCC____: if.end: ; IS__CGSCC____: if.end:
; IS__CGSCC____-NEXT: [[CMP2:%.*]] = icmp ult double* [[A]], [[B]] ; IS__CGSCC____-NEXT: [[CMP2:%.*]] = icmp ult double* [[A]], [[B]]
; IS__CGSCC____-NEXT: br i1 [[CMP2]], label [[IF_THEN3:%.*]], label [[IF_END12:%.*]] ; IS__CGSCC____-NEXT: br i1 [[CMP2]], label [[IF_THEN3:%.*]], label [[IF_END12:%.*]]
; IS__CGSCC____: if.then3: ; IS__CGSCC____: if.then3:
; IS__CGSCC____-NEXT: [[CALL4:%.*]] = call double* @ptr_sink_r0(double* noalias nofree readnone [[B]]) ; IS__CGSCC____-NEXT: [[CALL4:%.*]] = call double* @ptr_sink_r0(double* noalias nofree readnone [[B]])
; IS__CGSCC____-NEXT: [[CALL5:%.*]] = call noundef double* @ptr_scc_r1(double* noalias nofree readnone [[A]], double* noalias nofree readnone [[B]], double* noalias nocapture nofree readnone undef) ; IS__CGSCC____-NEXT: [[CALL5:%.*]] = call double* @ptr_scc_r1(double* noalias nofree readnone [[A]], double* noalias nofree readnone [[B]], double* noalias nocapture nofree readnone undef)
; IS__CGSCC____-NEXT: [[CALL6:%.*]] = call noundef double* @ptr_scc_r2(double* noalias nofree readnone [[R]], double* noalias nofree readnone [[R]], double* noalias nofree readnone [[R]]) ; IS__CGSCC____-NEXT: [[CALL6:%.*]] = call double* @ptr_scc_r2(double* noalias nofree readnone [[R]], double* noalias nofree readnone [[R]], double* noalias nofree readnone [[R]])
; IS__CGSCC____-NEXT: [[CALL7:%.*]] = call noundef double* @ptr_scc_r1(double* noalias nofree readnone [[A]], double* noalias nofree noundef readnone [[CALL6]], double* noalias nocapture nofree readnone undef) ; IS__CGSCC____-NEXT: [[CALL7:%.*]] = call double* @ptr_scc_r1(double* noalias nofree readnone [[A]], double* noalias nofree readnone [[CALL6]], double* noalias nocapture nofree readnone undef)
; IS__CGSCC____-NEXT: [[CALL8:%.*]] = call noundef double* @ptr_scc_r2(double* noalias nofree readnone [[A]], double* noalias nofree readnone [[B]], double* noalias nofree readnone [[R]]) ; IS__CGSCC____-NEXT: [[CALL8:%.*]] = call double* @ptr_scc_r2(double* noalias nofree readnone [[A]], double* noalias nofree readnone [[B]], double* noalias nofree readnone [[R]])
; IS__CGSCC____-NEXT: [[CALL9:%.*]] = call noundef double* @ptr_scc_r2(double* noalias nofree noundef readnone [[CALL5]], double* noalias nofree noundef readnone [[CALL7]], double* noalias nofree noundef readnone [[CALL8]]) ; IS__CGSCC____-NEXT: [[CALL9:%.*]] = call double* @ptr_scc_r2(double* noalias nofree readnone [[CALL5]], double* noalias nofree readnone [[CALL7]], double* noalias nofree readnone [[CALL8]])
; IS__CGSCC____-NEXT: [[CALL11:%.*]] = call double* @ptr_scc_r1(double* noalias nofree noundef readnone [[CALL4]], double* noalias nofree noundef readnone [[CALL9]], double* noalias nocapture nofree noundef readnone undef) ; IS__CGSCC____-NEXT: [[CALL11:%.*]] = call double* @ptr_scc_r1(double* noalias nofree readnone [[CALL4]], double* noalias nofree readnone [[CALL9]], double* noalias nocapture nofree readnone undef)
; IS__CGSCC____-NEXT: br label [[RETURN]] ; IS__CGSCC____-NEXT: br label [[RETURN]]
; IS__CGSCC____: if.end12: ; IS__CGSCC____: if.end12:
; IS__CGSCC____-NEXT: [[CMP13:%.*]] = icmp eq double* [[A]], [[B]] ; IS__CGSCC____-NEXT: [[CMP13:%.*]] = icmp eq double* [[A]], [[B]]
; IS__CGSCC____-NEXT: br i1 [[CMP13]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]] ; IS__CGSCC____-NEXT: br i1 [[CMP13]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
; IS__CGSCC____: cond.true: ; IS__CGSCC____: cond.true:
; IS__CGSCC____-NEXT: br label [[COND_END:%.*]] ; IS__CGSCC____-NEXT: br label [[COND_END:%.*]]
; IS__CGSCC____: cond.false: ; IS__CGSCC____: cond.false:
; IS__CGSCC____-NEXT: [[CALL14:%.*]] = call double* @ptr_scc_r2(double* noalias nofree readnone [[A]], double* noalias nofree readnone [[B]], double* noalias nofree readnone [[R]]) ; IS__CGSCC____-NEXT: [[CALL14:%.*]] = call double* @ptr_scc_r2(double* noalias nofree readnone [[A]], double* noalias nofree readnone [[B]], double* noalias nofree readnone [[R]])
▲ Show 20 Lines • Show All 1,026 Lines • ▼ Show 20 Lines
define i32* @dont_use_const() #0 { define i32* @dont_use_const() #0 {
; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn ; IS__TUNIT____: Function Attrs: nofree noinline nosync nounwind readnone uwtable willreturn
; IS__TUNIT____-LABEL: define {{[^@]+}}@dont_use_const() ; IS__TUNIT____-LABEL: define {{[^@]+}}@dont_use_const()
; IS__TUNIT____-NEXT: [[C:%.*]] = musttail call i32* @ret_const() ; IS__TUNIT____-NEXT: [[C:%.*]] = musttail call i32* @ret_const()
; IS__TUNIT____-NEXT: ret i32* [[C]] ; IS__TUNIT____-NEXT: ret i32* [[C]]
; ;
; IS__CGSCC____: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn ; IS__CGSCC____: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable willreturn
; IS__CGSCC____-LABEL: define {{[^@]+}}@dont_use_const() ; IS__CGSCC____-LABEL: define {{[^@]+}}@dont_use_const()
; IS__CGSCC____-NEXT: [[C:%.*]] = musttail call nonnull dereferenceable(1) i32* @ret_const() ; IS__CGSCC____-NEXT: [[C:%.*]] = musttail call noundef nonnull dereferenceable(1) i32* @ret_const()
; IS__CGSCC____-NEXT: ret i32* [[C]] ; IS__CGSCC____-NEXT: ret i32* [[C]]
; ;
%c = musttail call i32* @ret_const() %c = musttail call i32* @ret_const()
ret i32* %c ret i32* %c
} }
; UTC_ARGS: --disable ; UTC_ARGS: --disable
; ;
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines