This is an archive of the discontinued LLVM Phabricator instance.

Differential D68522

[PATCH 26/27] [noalias] Inlining: enable --use-noalias-intrinsic-during-inlining by default
Needs ReviewPublic

Authored by jeroen.dobbelaere on Oct 4 2019, 3:30 PM.

Details

Reviewers
hfinkel
jdoerfert
Summary

This is part of the series started by D68484.

This is the llvm-side patch for enabling full restrict by default.
It should be combined with the clang patch.

Diff Detail

Unit TestsFailed

TimeTest
230 msx64 debian > Clang.CodeGen::aarch64-ls64.c
4,460 msx64 debian > Clang.CodeGen::arm_neon_intrinsics.c
200 msx64 debian > Clang.OpenMP::cancel_codegen.cpp
210 msx64 debian > Clang.OpenMP::cancellation_point_codegen.cpp
250 msx64 debian > Clang.OpenMP::distribute_parallel_for_reduction_task_codegen.cpp
View Full Test Results (101 Failed)

Event Timeline

jeroen.dobbelaere created this revision.Oct 4 2019, 3:30 PM
Herald added a project: Restricted Project. · View Herald TranscriptOct 4 2019, 3:30 PM
Herald added subscribers: llvm-commits, hiraditya. · View Herald Transcript
lebedev.ri added a parent revision: D68521: [PATCH 25/27] [noalias] Clang CodeGen for restrict-qualified pointers.Oct 5 2019, 9:54 AM
lebedev.ri added a child revision: D68523: [PATCH 27/27] [noalias] Clang: enable full restrict by default..
jeroen.dobbelaere updated this revision to Diff 223595.Oct 7 2019, 7:25 AM

Adapt to i64 p.objId. (was i32)

jeroen.dobbelaere updated this revision to Diff 224850.Oct 14 2019, 6:38 AM

D68509 (Patch 26/38) was updated (allow --use-noalias-intrinsic-during-inlining to be provided multiple times).

jeroen.dobbelaere updated this revision to Diff 226819.Oct 28 2019, 5:50 PM

Rebased

jeroen.dobbelaere updated this revision to Diff 270468.Jun 12 2020, 11:25 AM
jeroen.dobbelaere retitled this revision from [PATCH 37/38] [noalias] Inlining: enable --use-noalias-intrinsic-during-inlining by default to [PATCH 25/26] [noalias] Inlining: enable --use-noalias-intrinsic-during-inlining by default.
jeroen.dobbelaere updated this revision to Diff 277759.Jul 14 2020, 3:23 AM

Rebased to c06b7e2ab5167ad031745a706204abed1aefd823 (July 14, 2020)

jeroen.dobbelaere updated this revision to Diff 290366.Sep 7 2020, 2:21 PM
jeroen.dobbelaere retitled this revision from [PATCH 25/26] [noalias] Inlining: enable --use-noalias-intrinsic-during-inlining by default to [PATCH 26/27] [noalias] Inlining: enable --use-noalias-intrinsic-during-inlining by default.

Rebased to 9fb46a452d4e5666828c95610ceac8dcd9e4ce16 (September 7, 2020)

jeroen.dobbelaere updated this revision to Diff 291040.Sep 10 2020, 11:34 AM

Updated because D68509 was updated.

jeroen.dobbelaere updated this revision to Diff 346139.May 18 2021, 4:52 AM

Rebased to f8dbd61074176bae92ec360a093ac7bc498c9321.

Herald added a subscriber: lxfind. · View Herald TranscriptMay 18 2021, 4:52 AM
Harbormaster completed remote builds in B105012: Diff 346139.May 18 2021, 8:27 AM

Revision Contents

PathSize
llvm/
lib/
Transforms/
Utils/
2 lines
test/
Transforms/
Coroutines/
6 lines
15 lines
15 lines
Inline/
30 lines
41 lines
4 lines
20 lines
PhaseOrdering/
40 lines

Diff 346139

llvm/lib/Transforms/Utils/InlineFunction.cpp

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines
static cl::opt<bool> static cl::opt<bool>
EnableNoAliasConversion("enable-noalias-to-md-conversion", cl::init(true), EnableNoAliasConversion("enable-noalias-to-md-conversion", cl::init(true),
cl::Hidden, cl::Hidden,
cl::desc("Convert noalias attributes to metadata during inlining.")); cl::desc("Convert noalias attributes to metadata during inlining."));
enum NoAliasIntrinsicKind { NAIK_none, NAIK_scopes, NAIK_full }; enum NoAliasIntrinsicKind { NAIK_none, NAIK_scopes, NAIK_full };
static cl::opt<NoAliasIntrinsicKind> UseNoAliasIntrinsic( static cl::opt<NoAliasIntrinsicKind> UseNoAliasIntrinsic(
"use-noalias-intrinsic-during-inlining", cl::Hidden, cl::ZeroOrMore, "use-noalias-intrinsic-during-inlining", cl::Hidden, cl::ZeroOrMore,
cl::init(NAIK_scopes), cl::desc("Use noalias intrinsics during inlining."), cl::init(NAIK_full), cl::desc("Use noalias intrinsics during inlining."),
cl::values(clEnumValN(NAIK_none, "none", "no intrinsics"), cl::values(clEnumValN(NAIK_none, "none", "no intrinsics"),
clEnumValN(NAIK_scopes, "scopes", clEnumValN(NAIK_scopes, "scopes",
"use llvm.experimental.noalias.scope.decl"), "use llvm.experimental.noalias.scope.decl"),
clEnumValN(NAIK_full, "full", clEnumValN(NAIK_full, "full",
"use llvm.noalias.decl (full restrict)"))); "use llvm.noalias.decl (full restrict)")));
// Disabled by default, because the added alignment assumptions may increase // Disabled by default, because the added alignment assumptions may increase
// compile-time and block optimizations. This option is not suitable for use // compile-time and block optimizations. This option is not suitable for use
▲ Show 20 Lines • Show All 2,792 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/coro-retcon-resume-values.ll

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Linesentry:
ret i32 0 ret i32 0
} }
; Unfortunately, we don't seem to fully optimize this right now due ; Unfortunately, we don't seem to fully optimize this right now due
; to some sort of phase-ordering thing. ; to some sort of phase-ordering thing.
; CHECK-LABEL: define i32 @main ; CHECK-LABEL: define i32 @main
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK: [[BUFFER:%.*]] = alloca [8 x i8], align 4 ; CHECK: [[BUFFER:%.*]] = alloca [8 x i8], align 4
; CHECK: [[SUB:%.*]] = getelementptr inbounds [8 x i8], [8 x i8]* [[BUFFER]], i64 0, i64 0
; CHECK: [[SLOT:%.*]] = bitcast [8 x i8]* [[BUFFER]] to i32* ; CHECK: [[SLOT:%.*]] = bitcast [8 x i8]* [[BUFFER]] to i32*
; CHECK-NEXT: store i32 7, i32* [[SLOT]], align 4 ; CHECK-NEXT: [[SUB_0_DECL:%.*]] = call i8* @llvm.noalias.decl.p0i8.p0p0i8.i64(i8** null, i64 0, metadata [[SUB_0_META:!.*]])
; CHECK-NEXT: [[SUB_0_PROVENANCE:%.*]] = call i8* @llvm.provenance.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i64(i8* nonnull [[SUB]], i8* [[SUB_0_DECL]], i8** null, i8** undef, i64 0, metadata [[SUB_0_META]])
; CHECK-NEXT: [[SUB_0_PROVENANCE_I32:%.*]] = bitcast i8* [[SUB_0_PROVENANCE]] to i32*
; CHECK-NEXT: store i32 7, i32* [[SLOT]], ptr_provenance i32* [[SUB_0_PROVENANCE_I32]], align 4, !noalias [[SUB_0_META]]
; CHECK-NEXT: call void @print(i32 7) ; CHECK-NEXT: call void @print(i32 7)
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
declare token @llvm.coro.id.retcon(i32, i32, i8*, i8*, i8*, i8*) declare token @llvm.coro.id.retcon(i32, i32, i8*, i8*, i8*, i8*)
declare i8* @llvm.coro.begin(token, i8*) declare i8* @llvm.coro.begin(token, i8*)
declare { i32, i1 } @llvm.coro.suspend.retcon.sl_i32i1s(...) declare { i32, i1 } @llvm.coro.suspend.retcon.sl_i32i1s(...)
declare i1 @llvm.coro.end(i8*, i1) declare i1 @llvm.coro.end(i8*, i1)
declare i8* @llvm.coro.prepare.retcon(i8*) declare i8* @llvm.coro.prepare.retcon(i8*)
declare i8* @prototype(i8*, i32, i1 zeroext) declare i8* @prototype(i8*, i32, i1 zeroext)
declare noalias i8* @allocate(i32 %size) declare noalias i8* @allocate(i32 %size)
declare void @deallocate(i8* %ptr) declare void @deallocate(i8* %ptr)
declare void @print(i32) declare void @print(i32)

llvm/test/Transforms/Coroutines/coro-retcon-value.ll

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Linesentry:
ret i32 0 ret i32 0
} }
; Unfortunately, we don't seem to fully optimize this right now due ; Unfortunately, we don't seem to fully optimize this right now due
; to some sort of phase-ordering thing. ; to some sort of phase-ordering thing.
; CHECK-LABEL: define i32 @main ; CHECK-LABEL: define i32 @main
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK: [[BUFFER:%.*]] = alloca [8 x i8], align 4 ; CHECK: [[BUFFER:%.*]] = alloca [8 x i8], align 4
; CHECK: [[SUB:%.*]] = getelementptr inbounds [8 x i8], [8 x i8]* [[BUFFER]], i64 0, i64 0
; CHECK: [[SLOT:%.*]] = bitcast [8 x i8]* [[BUFFER]] to i32* ; CHECK: [[SLOT:%.*]] = bitcast [8 x i8]* [[BUFFER]] to i32*
; CHECK-NEXT: store i32 4, i32* [[SLOT]], align 4 ; CHECK-NEXT: store i32 4, i32* [[SLOT]], align 4
; CHECK-NEXT: call void @print(i32 4) ; CHECK-NEXT: call void @print(i32 4)
; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32* [[SLOT]], align 4 ; CHECK-NEXT: [[SUB_0_DECL:%.*]] = call i8* @llvm.noalias.decl.p0i8.p0p0i8.i64(i8** null, i64 0, metadata [[SUB_0_META:!.*]])
; CHECK-NEXT: [[SUB_0_PROVENANCE:%.*]] = call i8* @llvm.provenance.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i64(i8* nonnull [[SUB]], i8* [[SUB_0_DECL]], i8** null, i8** undef, i64 0, metadata [[SUB_0_META]])
; CHECK-NEXT: [[SUB_0_PROVENANCE_I32:%.*]] = bitcast i8* [[SUB_0_PROVENANCE]] to i32*
; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32* [[SLOT]], ptr_provenance i32* [[SUB_0_PROVENANCE_I32]], align 4, !noalias [[SUB_0_META]]
; CHECK-NEXT: [[INC:%.*]] = add i32 [[LOAD]], 1 ; CHECK-NEXT: [[INC:%.*]] = add i32 [[LOAD]], 1
; CHECK-NEXT: store i32 [[INC]], i32* [[SLOT]], align 4 ; CHECK-NEXT: store i32 [[INC]], i32* [[SLOT]], ptr_provenance i32* [[SUB_0_PROVENANCE_I32]], align 4, !noalias [[SUB_0_META]]
; CHECK-NEXT: call void @print(i32 [[INC]]) ; CHECK-NEXT: call void @print(i32 [[INC]])
; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32* [[SLOT]], align 4 ; CHECK-NEXT: [[SUB_1_DECL:%.*]] = call i8* @llvm.noalias.decl.p0i8.p0p0i8.i64(i8** null, i64 0, metadata [[SUB_1_META:!.*]])
; CHECK-NEXT: [[SUB_1_PROVENANCE:%.*]] = call i8* @llvm.provenance.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i64(i8* nonnull [[SUB]], i8* [[SUB_1_DECL]], i8** null, i8** undef, i64 0, metadata [[SUB_1_META]])
; CHECK-NEXT: [[SUB_1_PROVENANCE_I32:%.*]] = bitcast i8* [[SUB_1_PROVENANCE]] to i32*
; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32* [[SLOT]], ptr_provenance i32* [[SUB_1_PROVENANCE_I32]], align 4, !noalias [[SUB_1_META]]
; CHECK-NEXT: [[INC:%.*]] = add i32 [[LOAD]], 1 ; CHECK-NEXT: [[INC:%.*]] = add i32 [[LOAD]], 1
; CHECK-NEXT: store i32 [[INC]], i32* [[SLOT]], align 4 ; CHECK-NEXT: store i32 [[INC]], i32* [[SLOT]], ptr_provenance i32* [[SUB_1_PROVENANCE_I32]], align 4, !noalias [[SUB_1_META]]
; CHECK-NEXT: call void @print(i32 [[INC]]) ; CHECK-NEXT: call void @print(i32 [[INC]])
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
declare token @llvm.coro.id.retcon(i32, i32, i8*, i8*, i8*, i8*) declare token @llvm.coro.id.retcon(i32, i32, i8*, i8*, i8*, i8*)
declare i8* @llvm.coro.begin(token, i8*) declare i8* @llvm.coro.begin(token, i8*)
declare i8 @llvm.coro.suspend.retcon.i8(...) declare i8 @llvm.coro.suspend.retcon.i8(...)
declare i1 @llvm.coro.end(i8*, i1) declare i1 @llvm.coro.end(i8*, i1)
declare i8* @llvm.coro.prepare.retcon(i8*) declare i8* @llvm.coro.prepare.retcon(i8*)
declare {i8*, i32} @prototype(i8*, i8 zeroext) declare {i8*, i32} @prototype(i8*, i8 zeroext)
declare noalias i8* @allocate(i32 %size) declare noalias i8* @allocate(i32 %size)
declare void @deallocate(i8* %ptr) declare void @deallocate(i8* %ptr)
declare void @print(i32) declare void @print(i32)

llvm/test/Transforms/Coroutines/coro-retcon.ll

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Linesentry:
ret i32 0 ret i32 0
} }
; Unfortunately, we don't seem to fully optimize this right now due ; Unfortunately, we don't seem to fully optimize this right now due
; to some sort of phase-ordering thing. ; to some sort of phase-ordering thing.
; CHECK-LABEL: define i32 @main ; CHECK-LABEL: define i32 @main
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK: [[BUFFER:%.*]] = alloca [8 x i8], align 4 ; CHECK: [[BUFFER:%.*]] = alloca [8 x i8], align 4
; CHECK: [[SUB:%.*]] = getelementptr inbounds [8 x i8], [8 x i8]* [[BUFFER]], i64 0, i64 0
; CHECK: [[SLOT:%.*]] = bitcast [8 x i8]* [[BUFFER]] to i32* ; CHECK: [[SLOT:%.*]] = bitcast [8 x i8]* [[BUFFER]] to i32*
; CHECK-NEXT: store i32 4, i32* [[SLOT]], align 4 ; CHECK-NEXT: store i32 4, i32* [[SLOT]], align 4
; CHECK-NEXT: call void @print(i32 4) ; CHECK-NEXT: call void @print(i32 4)
; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl ; CHECK-NEXT: [[SUB_0_DECL:%.*]] = call i8* @llvm.noalias.decl.p0i8.p0p0i8.i64(i8** null, i64 0, metadata [[SUB_0_META:!.*]])
; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32* [[SLOT]], align 4 ; CHECK-NEXT: [[SUB_0_PROVENANCE:%.*]] = call i8* @llvm.provenance.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i64(i8* nonnull [[SUB]], i8* [[SUB_0_DECL]], i8** null, i8** undef, i64 0, metadata [[SUB_0_META]])
; CHECK-NEXT: [[SUB_0_PROVENANCE_I32:%.*]] = bitcast i8* [[SUB_0_PROVENANCE]] to i32*
; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32* [[SLOT]], ptr_provenance i32* [[SUB_0_PROVENANCE_I32]], align 4, !noalias [[SUB_0_META]]
; CHECK-NEXT: [[INC:%.*]] = add i32 [[LOAD]], 1 ; CHECK-NEXT: [[INC:%.*]] = add i32 [[LOAD]], 1
; CHECK-NEXT: store i32 [[INC]], i32* [[SLOT]], align 4 ; CHECK-NEXT: store i32 [[INC]], i32* [[SLOT]], ptr_provenance i32* [[SUB_0_PROVENANCE_I32]], align 4, !noalias [[SUB_0_META]]
; CHECK-NEXT: call void @print(i32 [[INC]]) ; CHECK-NEXT: call void @print(i32 [[INC]])
; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl ; CHECK-NEXT: [[SUB_1_DECL:%.*]] = call i8* @llvm.noalias.decl.p0i8.p0p0i8.i64(i8** null, i64 0, metadata [[SUB_1_META:!.*]])
; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32* [[SLOT]], align 4 ; CHECK-NEXT: [[SUB_1_PROVENANCE:%.*]] = call i8* @llvm.provenance.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i64(i8* nonnull [[SUB]], i8* [[SUB_1_DECL]], i8** null, i8** undef, i64 0, metadata [[SUB_1_META]])
; CHECK-NEXT: [[SUB_1_PROVENANCE_I32:%.*]] = bitcast i8* [[SUB_1_PROVENANCE]] to i32*
; CHECK-NEXT: [[LOAD:%.*]] = load i32, i32* [[SLOT]], ptr_provenance i32* [[SUB_1_PROVENANCE_I32]], align 4, !noalias [[SUB_1_META]]
; CHECK-NEXT: [[INC:%.*]] = add i32 [[LOAD]], 1 ; CHECK-NEXT: [[INC:%.*]] = add i32 [[LOAD]], 1
; CHECK-NEXT: call void @print(i32 [[INC]]) ; CHECK-NEXT: call void @print(i32 [[INC]])
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
define hidden { i8*, i8* } @g(i8* %buffer, i16* %ptr) { define hidden { i8*, i8* } @g(i8* %buffer, i16* %ptr) {
entry: entry:
%id = call token @llvm.coro.id.retcon(i32 8, i32 4, i8* %buffer, i8* bitcast ({ i8*, i8* } (i8*, i1)* @g_prototype to i8*), i8* bitcast (i8* (i32)* @allocate to i8*), i8* bitcast (void (i8*)* @deallocate to i8*)) %id = call token @llvm.coro.id.retcon(i32 8, i32 4, i8* %buffer, i8* bitcast ({ i8*, i8* } (i8*, i1)* @g_prototype to i8*), i8* bitcast (i8* (i32)* @allocate to i8*), i8* bitcast (void (i8*)* @deallocate to i8*))
%hdl = call i8* @llvm.coro.begin(token %id, i8* null) %hdl = call i8* @llvm.coro.begin(token %id, i8* null)
Show All 29 Lines

llvm/test/Transforms/Inline/launder.invariant.group.ll

; RUN: opt -S -inline < %s | FileCheck %s ; RUN: opt -S -inline --use-noalias-intrinsic-during-inlining=scopes < %s | FileCheck %s --check-prefixes=CHECK,CHECK_SCOPED
; RUN: opt -S -O3 < %s | FileCheck %s ; RUN: opt -S -O3 --use-noalias-intrinsic-during-inlining=scopes < %s | FileCheck %s --check-prefixes=CHECK,CHECK_SCOPED,CHECK_OPT
; RUN: opt -S -inline -inline-threshold=1 < %s | FileCheck %s ; RUN: opt -S -inline -inline-threshold=1 --use-noalias-intrinsic-during-inlining=scopes < %s | FileCheck %s --check-prefixes=CHECK,CHECK_SCOPED
; RUN: opt -S -inline --use-noalias-intrinsic-during-inlining=full < %s | FileCheck %s --check-prefixes=CHECK,CHECK_NOALIAS
; RUN: opt -S -O3 --use-noalias-intrinsic-during-inlining=full < %s | FileCheck %s --check-prefixes=CHECK,CHECK_PROVENANCE,CHECK_OPT
; RUN: opt -S -inline -inline-threshold=1 --use-noalias-intrinsic-during-inlining=full < %s | FileCheck %s --check-prefixes=CHECK,CHECK_NOALIAS
%struct.A = type <{ i32 (...)**, i32, [4 x i8] }> %struct.A = type <{ i32 (...)**, i32, [4 x i8] }>
; This test checks if value returned from the launder is considered aliasing ; This test checks if value returned from the launder is considered aliasing
; with its argument. Due to bug caused by handling launder in capture tracking ; with its argument. Due to bug caused by handling launder in capture tracking
; sometimes it would be considered noalias. ; sometimes it would be considered noalias.
; CHECK-LABEL: define i32 @bar(%struct.A* noalias ; CHECK-LABEL: define i32 @bar(%struct.A* noalias
define i32 @bar(%struct.A* noalias) { define i32 @bar(%struct.A* noalias) {
; CHECK-NOT: noalias ; CHECK_SCOPED-NOT: noalias
%2 = bitcast %struct.A* %0 to i8* %2 = bitcast %struct.A* %0 to i8*
%3 = call i8* @llvm.launder.invariant.group.p0i8(i8* %2) %3 = call i8* @llvm.launder.invariant.group.p0i8(i8* %2)
%4 = getelementptr inbounds i8, i8* %3, i64 8 %4 = getelementptr inbounds i8, i8* %3, i64 8
%5 = bitcast i8* %4 to i32* %5 = bitcast i8* %4 to i32*
store i32 42, i32* %5, align 8 store i32 42, i32* %5, align 8
%6 = getelementptr inbounds %struct.A, %struct.A* %0, i64 0, i32 1 %6 = getelementptr inbounds %struct.A, %struct.A* %0, i64 0, i32 1
%7 = load i32, i32* %6, align 8 %7 = load i32, i32* %6, align 8
ret i32 %7 ret i32 %7
} }
; CHECK-LABEL: define i32 @foo(%struct.A* noalias ; CHECK-LABEL: define i32 @foo(%struct.A* noalias
define i32 @foo(%struct.A* noalias) { define i32 @foo(%struct.A* noalias) {
; CHECK-NOT: call i32 @bar( ; CHECK_SCOPED-NOT: call i32 @bar(
; CHECK-NOT: !noalias ; CHECK_SCOPED-NOT: !noalias
; CHECK_NOALIAS-NOT: call i32 @bar(
; CHECK_NOALIAS: @llvm.noalias.decl.p0
; CHECK_NOALIAS-NEXT: @llvm.noalias.p0
; CHECK_NOALIAS-NOT: call i32 @bar(
; CHECK_PROVENANCE-NOT: call i32 @bar(
; CHECK_PROVENANCE: @llvm.noalias.decl.p0
; CHECK_PROVENANCE-NEXT: @llvm.provenance.noalias.p0
; CHECK_PROVENANCE-NOT: call i32 @bar(
; CHECK_PROVENANCE: @llvm.noalias.arg.guard.p0
; CHECK_PROVENANCE-NOT: call i32 @bar(
%2 = tail call i32 @bar(%struct.A* %0) %2 = tail call i32 @bar(%struct.A* %0)
ret i32 %2 ret i32 %2
; CHECK_OPT: ret i32 42
} }
; This test checks if invariant group intrinsics have zero cost for inlining. ; This test checks if invariant group intrinsics have zero cost for inlining.
; CHECK-LABEL: define i8* @caller(i8* ; CHECK-LABEL: define i8* @caller(i8*
define i8* @caller(i8* %p) { define i8* @caller(i8* %p) {
; CHECK-NOT: call i8* @lot_of_launders_and_strips ; CHECK-NOT: call i8* @lot_of_launders_and_strips
%a1 = call i8* @lot_of_launders_and_strips(i8* %p) %a1 = call i8* @lot_of_launders_and_strips(i8* %p)
Show All 23 Lines

llvm/test/Transforms/Inline/noalias-calls-always.ll

Show All 25 Linesentry:
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %l, i8* align 16 %c, i64 16, i1 0) call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %l, i8* align 16 %c, i64 16, i1 0)
ret void ret void
} }
define void @foo(i8* nocapture %a, i8* nocapture readonly %c, i8* nocapture %b) #2 { define void @foo(i8* nocapture %a, i8* nocapture readonly %c, i8* nocapture %b) #2 {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[L_I:%.*]] = alloca i8, i32 512, align 1 ; CHECK-NEXT: [[L_I:%.*]] = alloca i8, i32 512, align 1
; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl([[META0:metadata !.*]]) ; CHECK-NEXT: [[TMP0:%.*]] = call i8* @llvm.noalias.decl.p0i8.p0p0i8.i64(i8** null, i64 0, metadata [[META0:![0-9]+]])
; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl([[META3:metadata !.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call i8* @llvm.noalias.p0i8.p0i8.p0p0i8.i64(i8* [[A:%.*]], i8* [[TMP0]], i8** null, i64 0, metadata [[META0]]), !noalias !3
; CHECK-NEXT: [[TMP2:%.*]] = call i8* @llvm.noalias.decl.p0i8.p0p0i8.i64(i8** null, i64 0, metadata [[META5:![0-9]+]])
; CHECK-NEXT: [[TMP3:%.*]] = call i8* @llvm.noalias.p0i8.p0i8.p0p0i8.i64(i8* [[C:%.*]], i8* [[TMP2]], i8** null, i64 0, metadata [[META5]]), !noalias !3
; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 512, i8* [[L_I]]) ; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 512, i8* [[L_I]])
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A:%.*]], i8* align 16 [[B:%.*]], i64 16, i1 false) [[ATTR4:#.*]], !noalias !3 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[TMP1]], i8* align 16 [[B:%.*]], i64 16, i1 false) #[[ATTR6:[0-9]+]], !noalias !3
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[B]], i8* align 16 [[C:%.*]], i64 16, i1 false) [[ATTR4]], !noalias !0 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[B]], i8* align 16 [[TMP3]], i64 16, i1 false) #[[ATTR6]], !noalias !3
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A]], i8* align 16 [[C]], i64 16, i1 false) [[ATTR4]], !alias.scope !5 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[TMP1]], i8* align 16 [[TMP3]], i64 16, i1 false) #[[ATTR6]], !noalias !3
; CHECK-NEXT: call void @hey() [[ATTR4]], !noalias !5 ; CHECK-NEXT: call void @hey() #[[ATTR6]], !noalias !3
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[L_I]], i8* align 16 [[C]], i64 16, i1 false) [[ATTR4]], !noalias !0 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[L_I]], i8* align 16 [[TMP3]], i64 16, i1 false) #[[ATTR6]], !noalias !3
; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 512, i8* [[L_I]]) ; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 512, i8* [[L_I]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
tail call void @hello(i8* %a, i8* %c, i8* %b) tail call void @hello(i8* %a, i8* %c, i8* %b)
ret void ret void
} }
Show All 17 Linesentry:
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %l, i8* align 16 %c, i64 16, i1 0) call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 %l, i8* align 16 %c, i64 16, i1 0)
ret void ret void
} }
define void @foo_cs(i8* nocapture %a, i8* nocapture readonly %c, i8* nocapture %b) #2 { define void @foo_cs(i8* nocapture %a, i8* nocapture readonly %c, i8* nocapture %b) #2 {
; CHECK-LABEL: @foo_cs( ; CHECK-LABEL: @foo_cs(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[L_I:%.*]] = alloca i8, i32 512, align 1 ; CHECK-NEXT: [[L_I:%.*]] = alloca i8, i32 512, align 1
; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl([[META6:metadata !.*]]) ; CHECK-NEXT: [[TMP0:%.*]] = call i8* @llvm.noalias.decl.p0i8.p0p0i8.i64(i8** null, i64 0, metadata [[META6:![0-9]+]])
; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl([[META9:metadata !.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call i8* @llvm.noalias.p0i8.p0i8.p0p0i8.i64(i8* [[A:%.*]], i8* [[TMP0]], i8** null, i64 0, metadata [[META6]]), !noalias !9
; CHECK-NEXT: [[TMP2:%.*]] = call i8* @llvm.noalias.decl.p0i8.p0p0i8.i64(i8** null, i64 0, metadata [[META11:![0-9]+]])
; CHECK-NEXT: [[TMP3:%.*]] = call i8* @llvm.noalias.p0i8.p0i8.p0p0i8.i64(i8* [[C:%.*]], i8* [[TMP2]], i8** null, i64 0, metadata [[META11]]), !noalias !9
; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 512, i8* [[L_I]]) ; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 512, i8* [[L_I]])
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A:%.*]], i8* align 16 [[B:%.*]], i64 16, i1 false) [[ATTR4]], !noalias !9 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[TMP1]], i8* align 16 [[B:%.*]], i64 16, i1 false) #[[ATTR6]], !noalias !9
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[B]], i8* align 16 [[C:%.*]], i64 16, i1 false) [[ATTR4]], !noalias !6 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[B]], i8* align 16 [[TMP3]], i64 16, i1 false) #[[ATTR6]], !noalias !9
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[A]], i8* align 16 [[C]], i64 16, i1 false) [[ATTR4]], !alias.scope !11 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[TMP1]], i8* align 16 [[TMP3]], i64 16, i1 false) #[[ATTR6]], !noalias !9
; CHECK-NEXT: call void @hey() [[ATTR4]], !noalias !11 ; CHECK-NEXT: call void @hey() #[[ATTR6]], !noalias !9
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[L_I]], i8* align 16 [[C]], i64 16, i1 false) [[ATTR4]], !noalias !6 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 [[L_I]], i8* align 16 [[TMP3]], i64 16, i1 false) #[[ATTR6]], !noalias !9
; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 512, i8* [[L_I]]) ; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 512, i8* [[L_I]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
entry: entry:
tail call void @hello_cs(i8* noalias %a, i8* noalias %c, i8* %b) tail call void @hello_cs(i8* noalias %a, i8* noalias %c, i8* %b)
ret void ret void
} }
attributes #0 = { nounwind argmemonly willreturn } attributes #0 = { nounwind argmemonly willreturn }
attributes #1 = { nounwind alwaysinline } attributes #1 = { nounwind alwaysinline }
attributes #2 = { nounwind uwtable } attributes #2 = { nounwind uwtable }
; CHECK: !0 = !{!1} ; CHECK: !0 = !{!1}
; CHECK: !1 = distinct !{!1, !2, !"hello: %a"} ; CHECK: !1 = distinct !{!1, !2, !"hello: %a"}
; CHECK: !2 = distinct !{!2, !"hello"} ; CHECK: !2 = distinct !{!2, !"hello"}
; CHECK: !3 = !{!4} ; CHECK: !3 = !{!1, !4}
; CHECK: !4 = distinct !{!4, !2, !"hello: %c"} ; CHECK: !4 = distinct !{!4, !2, !"hello: %c"}
; CHECK: !5 = !{!1, !4} ; CHECK: !5 = !{!4}
; CHECK: !6 = !{!7} ; CHECK: !6 = !{!7}
; CHECK: !7 = distinct !{!7, !8, !"hello_cs: %a"} ; CHECK: !7 = distinct !{!7, !8, !"hello_cs: %a"}
; CHECK: !8 = distinct !{!8, !"hello_cs"} ; CHECK: !8 = distinct !{!8, !"hello_cs"}
; CHECK: !9 = !{!10} ; CHECK: !9 = !{!7, !10}
; CHECK: !10 = distinct !{!10, !8, !"hello_cs: %c"} ; CHECK: !10 = distinct !{!10, !8, !"hello_cs: %c"}
; CHECK: !11 = !{!7, !10} ; CHECK: !11 = !{!10}

llvm/test/Transforms/Inline/noalias-calls2.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
; RUN: opt -basic-aa -inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s ; RUN: opt -basic-aa -inline -enable-noalias-to-md-conversion --use-noalias-intrinsic-during-inlining=scopes -S < %s | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes=inline -enable-noalias-to-md-conversion -S < %s | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes=inline -enable-noalias-to-md-conversion --use-noalias-intrinsic-during-inlining=scopes -S < %s | FileCheck %s
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare void @llvm.experimental.noalias.scope.decl(metadata) #0 declare void @llvm.experimental.noalias.scope.decl(metadata) #0
define void @caller_equals_callee(i32* noalias %p0, i32* noalias %p1, i32 %cnt) { define void @caller_equals_callee(i32* noalias %p0, i32* noalias %p1, i32 %cnt) {
; CHECK-LABEL: define {{[^@]+}}@caller_equals_callee ; CHECK-LABEL: define {{[^@]+}}@caller_equals_callee
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines

llvm/test/Transforms/Inline/parallel-loop-md-merge.ll

; RUN: opt -always-inline -globalopt -S < %s | FileCheck %s ; RUN: opt -always-inline -globalopt --use-noalias-intrinsic-during-inlining=scopes -S < %s | FileCheck %s --check-prefixes=CHECK
; RUN: opt -always-inline -globalopt --use-noalias-intrinsic-during-inlining=full -S < %s | FileCheck %s --check-prefixes=CHECK
; ;
; static void __attribute__((always_inline)) callee(long n, double A[static const restrict n], long i) { ; static void __attribute__((always_inline)) callee(long n, double A[static const restrict n], long i) {
; for (long j = 0; j < n; j += 1) ; for (long j = 0; j < n; j += 1)
; A[i * n + j] = 42; ; A[i * n + j] = 42;
; } ; }
; ;
; void caller(long n, double A[static const restrict n]) { ; void caller(long n, double A[static const restrict n]) {
; for (long i = 0; i < n; i += 1) ; for (long i = 0; i < n; i += 1)
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
for.end: for.end:
ret void ret void
} }
!10 = distinct !{} ; access group !10 = distinct !{} ; access group
!11 = distinct !{!11, !12} ; LoopID !11 = distinct !{!11, !12} ; LoopID
!12 = !{!"llvm.loop.parallel_accesses", !10} !12 = !{!"llvm.loop.parallel_accesses", !10}
; There is a small reordering when noalias intrinsics are introduced
; CHECK: store double 4.200000e+01, {{.*}} !llvm.access.group ![[ACCESS_GROUP_LIST_3:[0-9]+]] ; CHECK: store double 4.200000e+01, {{.*}} !llvm.access.group ![[ACCESS_GROUP_LIST_3:[0-9]+]]
; CHECK: br label %for.cond.i, !llvm.loop ![[LOOP_INNER:[0-9]+]] ; CHECK: br label %for.cond.i, !llvm.loop ![[LOOP_INNER:[0-9]+]]
; CHECK: br label %for.cond, !llvm.loop ![[LOOP_OUTER:[0-9]+]] ; CHECK: br label %for.cond, !llvm.loop ![[LOOP_OUTER:[0-9]+]]
; CHECK: ![[ACCESS_GROUP_LIST_3]] = !{![[ACCESS_GROUP_INNER:[0-9]+]], ![[ACCESS_GROUP_OUTER:[0-9]+]]}
; CHECK: ![[ACCESS_GROUP_INNER]] = distinct !{} ; CHECK-DAG: ![[ACCESS_GROUP_LIST_3]] = !{![[ACCESS_GROUP_INNER:[0-9]+]], ![[ACCESS_GROUP_OUTER:[0-9]+]]}
; CHECK: ![[ACCESS_GROUP_OUTER]] = distinct !{} ; CHECK-DAG: ![[ACCESS_GROUP_INNER]] = distinct !{}
; CHECK: ![[LOOP_INNER]] = distinct !{![[LOOP_INNER]], ![[ACCESSES_INNER:[0-9]+]]} ; CHECK-DAG: ![[ACCESS_GROUP_OUTER]] = distinct !{}
; CHECK: ![[ACCESSES_INNER]] = !{!"llvm.loop.parallel_accesses", ![[ACCESS_GROUP_INNER]]}
; CHECK: ![[LOOP_OUTER]] = distinct !{![[LOOP_OUTER]], ![[ACCESSES_OUTER:[0-9]+]]} ; CHECK-DAG: ![[LOOP_INNER]] = distinct !{![[LOOP_INNER]], ![[ACCESSES_INNER:[0-9]+]]}
; CHECK: ![[ACCESSES_OUTER]] = !{!"llvm.loop.parallel_accesses", ![[ACCESS_GROUP_OUTER]]} ; CHECK-DAG: ![[ACCESSES_INNER]] = !{!"llvm.loop.parallel_accesses", ![[ACCESS_GROUP_INNER]]}
; CHECK-DAG: ![[LOOP_OUTER]] = distinct !{![[LOOP_OUTER]], ![[ACCESSES_OUTER:[0-9]+]]}
; CHECK-DAG: ![[ACCESSES_OUTER]] = !{!"llvm.loop.parallel_accesses", ![[ACCESS_GROUP_OUTER]]}

llvm/test/Transforms/PhaseOrdering/pr39282.ll

Show All 12 Lines;
ret void ret void
} }
; Consider that %addr1 = %addr2 + 1, in which case %addr2i and %addr1i are ; Consider that %addr1 = %addr2 + 1, in which case %addr2i and %addr1i are
; noalias within one iteration, but may alias across iterations. ; noalias within one iteration, but may alias across iterations.
define void @pr39282(i32* %addr1, i32* %addr2) { define void @pr39282(i32* %addr1, i32* %addr2) {
; CHECK-LABEL: @pr39282( ; CHECK-LABEL: @pr39282(
; CHECK-NEXT: start: ; CHECK-NEXT: start:
; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl ; CHECK-NEXT: [[TMP0:%.*]] = tail call i8* @llvm.noalias.decl.p0i8.p0p0i32.i64(i32** null, i64 0, metadata [[META0:![0-9]+]])
; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl ; CHECK-NEXT: [[TMP1:%.*]] = tail call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64(i32* [[ADDR2:%.*]], i8* [[TMP0]], i32** null, i32** undef, i64 0, metadata [[META0]]), !noalias !3
; CHECK-NEXT: [[X_I:%.*]] = load i32, i32* [[ADDR1:%.*]], align 4, !alias.scope !3, !noalias !0 ; CHECK-NEXT: [[TMP2:%.*]] = tail call i8* @llvm.noalias.decl.p0i8.p0p0i32.i64(i32** null, i64 0, metadata [[META5:![0-9]+]])
; CHECK-NEXT: store i32 [[X_I]], i32* [[ADDR2:%.*]], align 4, !alias.scope !0, !noalias !3 ; CHECK-NEXT: [[TMP3:%.*]] = tail call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64(i32* [[ADDR1:%.*]], i8* [[TMP2]], i32** null, i32** undef, i64 0, metadata [[META5]]), !noalias !3
; CHECK-NEXT: [[X_I:%.*]] = load i32, i32* [[ADDR1]], ptr_provenance i32* [[TMP3]], align 4, !noalias !3
; CHECK-NEXT: store i32 [[X_I]], i32* [[ADDR2]], ptr_provenance i32* [[TMP1]], align 4, !noalias !3
; CHECK-NEXT: [[ADDR1I_1:%.*]] = getelementptr inbounds i32, i32* [[ADDR1]], i64 1 ; CHECK-NEXT: [[ADDR1I_1:%.*]] = getelementptr inbounds i32, i32* [[ADDR1]], i64 1
; CHECK-NEXT: [[ADDR2I_1:%.*]] = getelementptr inbounds i32, i32* [[ADDR2]], i64 1 ; CHECK-NEXT: [[ADDR2I_1:%.*]] = getelementptr inbounds i32, i32* [[ADDR2]], i64 1
; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl ; CHECK-NEXT: [[TMP4:%.*]] = tail call i8* @llvm.noalias.decl.p0i8.p0p0i32.i64(i32** null, i64 0, metadata [[META6:![0-9]+]])
; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl ; CHECK-NEXT: [[TMP5:%.*]] = tail call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64(i32* nonnull [[ADDR2I_1]], i8* [[TMP4]], i32** null, i32** undef, i64 0, metadata [[META6]]), !noalias !8
; CHECK-NEXT: [[X_I_1:%.*]] = load i32, i32* [[ADDR1I_1]], align 4, !alias.scope !7, !noalias !5 ; CHECK-NEXT: [[TMP6:%.*]] = tail call i8* @llvm.noalias.decl.p0i8.p0p0i32.i64(i32** null, i64 0, metadata [[META10:![0-9]+]])
; CHECK-NEXT: store i32 [[X_I_1]], i32* [[ADDR2I_1]], align 4, !alias.scope !5, !noalias !7 ; CHECK-NEXT: [[TMP7:%.*]] = tail call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64(i32* nonnull [[ADDR1I_1]], i8* [[TMP6]], i32** null, i32** undef, i64 0, metadata [[META10]]), !noalias !8
; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl ; CHECK-NEXT: [[X_I_1:%.*]] = load i32, i32* [[ADDR1I_1]], ptr_provenance i32* [[TMP7]], align 4, !noalias !8
; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl ; CHECK-NEXT: store i32 [[X_I_1]], i32* [[ADDR2I_1]], ptr_provenance i32* [[TMP5]], align 4, !noalias !8
; CHECK-NEXT: [[X_I_2:%.*]] = load i32, i32* [[ADDR1]], align 4, !alias.scope !11, !noalias !9 ; CHECK-NEXT: [[TMP8:%.*]] = tail call i8* @llvm.noalias.decl.p0i8.p0p0i32.i64(i32** null, i64 0, metadata [[META11:![0-9]+]])
; CHECK-NEXT: store i32 [[X_I_2]], i32* [[ADDR2]], align 4, !alias.scope !9, !noalias !11 ; CHECK-NEXT: [[TMP9:%.*]] = tail call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64(i32* nonnull [[ADDR2]], i8* [[TMP8]], i32** null, i32** undef, i64 0, metadata [[META11]]), !noalias !13
; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl ; CHECK-NEXT: [[TMP10:%.*]] = tail call i8* @llvm.noalias.decl.p0i8.p0p0i32.i64(i32** null, i64 0, metadata [[META15:![0-9]+]])
; CHECK-NEXT: call void @llvm.experimental.noalias.scope.decl ; CHECK-NEXT: [[TMP11:%.*]] = tail call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64(i32* nonnull [[ADDR1]], i8* [[TMP10]], i32** null, i32** undef, i64 0, metadata [[META15]]), !noalias !13
; CHECK-NEXT: [[X_I_3:%.*]] = load i32, i32* [[ADDR1I_1]], align 4, !alias.scope !15, !noalias !13 ; CHECK-NEXT: [[X_I_2:%.*]] = load i32, i32* [[ADDR1]], ptr_provenance i32* [[TMP11]], align 4, !noalias !13
; CHECK-NEXT: store i32 [[X_I_3]], i32* [[ADDR2I_1]], align 4, !alias.scope !13, !noalias !15 ; CHECK-NEXT: store i32 [[X_I_2]], i32* [[ADDR2]], ptr_provenance i32* [[TMP9]], align 4, !noalias !13
; CHECK-NEXT: [[TMP12:%.*]] = tail call i8* @llvm.noalias.decl.p0i8.p0p0i32.i64(i32** null, i64 0, metadata [[META16:![0-9]+]])
; CHECK-NEXT: [[TMP13:%.*]] = tail call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64(i32* nonnull [[ADDR2I_1]], i8* [[TMP12]], i32** null, i32** undef, i64 0, metadata [[META16]]), !noalias !18
; CHECK-NEXT: [[TMP14:%.*]] = tail call i8* @llvm.noalias.decl.p0i8.p0p0i32.i64(i32** null, i64 0, metadata [[META20:![0-9]+]])
; CHECK-NEXT: [[TMP15:%.*]] = tail call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i64(i32* nonnull [[ADDR1I_1]], i8* [[TMP14]], i32** null, i32** undef, i64 0, metadata [[META20]]), !noalias !18
; CHECK-NEXT: [[X_I_3:%.*]] = load i32, i32* [[ADDR1I_1]], ptr_provenance i32* [[TMP15]], align 4, !noalias !18
; CHECK-NEXT: store i32 [[X_I_3]], i32* [[ADDR2I_1]], ptr_provenance i32* [[TMP13]], align 4, !noalias !18
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
start: start:
br label %body br label %body
body: body:
%i = phi i32 [ 0, %start ], [ %i.next, %body ] %i = phi i32 [ 0, %start ], [ %i.next, %body ]
%j = and i32 %i, 1 %j = and i32 %i, 1
Show All 10 Lines