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

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/
1 line
6 lines
15 lines
15 lines
Inline/
30 lines
16 lines

Diff 270468

llvm/lib/Transforms/Utils/InlineFunction.cpp

Show First 20 Lines • Show All 77 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."));
static cl::opt<bool> UseNoAliasIntrinsic( static cl::opt<bool> UseNoAliasIntrinsic(
"use-noalias-intrinsic-during-inlining", cl::Hidden, cl::ZeroOrMore, "use-noalias-intrinsic-during-inlining", cl::Hidden, cl::ZeroOrMore,
cl::init(false), cl::init(true),
cl::desc("Use the llvm.noalias intrinsic during inlining.")); cl::desc("Use the llvm.noalias intrinsic during inlining."));
// 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
// with frontends that emit comprehensive parameter alignment annotations. // with frontends that emit comprehensive parameter alignment annotations.
static cl::opt<bool> static cl::opt<bool>
PreserveAlignmentAssumptions("preserve-alignment-assumptions-during-inlining", PreserveAlignmentAssumptions("preserve-alignment-assumptions-during-inlining",
cl::init(false), cl::Hidden, cl::init(false), cl::Hidden,
▲ Show 20 Lines • Show All 2,648 Lines • Show Last 20 Lines

llvm/test/Transforms/Coroutines/ArgAddr.ll

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
entry: entry:
%hdl = call i8* @f(i32 4) %hdl = call i8* @f(i32 4)
call void @llvm.coro.resume(i8* %hdl) call void @llvm.coro.resume(i8* %hdl)
call void @llvm.coro.resume(i8* %hdl) call void @llvm.coro.resume(i8* %hdl)
call void @llvm.coro.destroy(i8* %hdl) call void @llvm.coro.destroy(i8* %hdl)
ret i32 0 ret i32 0
; CHECK: call void @ctor ; CHECK: call void @ctor
; CHECK-NEXT: call void @print(i32 4) ; CHECK-NEXT: call void @print(i32 4)
; CHECK-NEXT: bitcast i8*
; CHECK-NEXT: call void @print(i32 3) ; CHECK-NEXT: call void @print(i32 3)
; CHECK-NEXT: call void @print(i32 2) ; CHECK-NEXT: call void @print(i32 2)
; CHECK: ret i32 0 ; CHECK: ret i32 0
} }
declare i8* @malloc(i32) declare i8* @malloc(i32)
declare void @free(i8*) declare void @free(i8*)
declare void @print(i32) declare void @print(i32)
Show All 11 Lines

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

Show First 20 Lines • Show All 59 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 69 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 59 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
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)
br label %loop br label %loop
Show All 28 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=0 < %s | FileCheck %s --check-prefixes=CHECK,CHECK_SCOPED
; RUN: opt -S -O3 < %s | FileCheck %s ; RUN: opt -S -O3 --use-noalias-intrinsic-during-inlining=0 < %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=0 < %s | FileCheck %s --check-prefixes=CHECK,CHECK_SCOPED
; RUN: opt -S -inline --use-noalias-intrinsic-during-inlining=1 < %s | FileCheck %s --check-prefixes=CHECK,CHECK_NOALIAS
; RUN: opt -S -O3 --use-noalias-intrinsic-during-inlining=1 < %s | FileCheck %s --check-prefixes=CHECK,CHECK_PROVENANCE,CHECK_OPT
; RUN: opt -S -inline -inline-threshold=1 --use-noalias-intrinsic-during-inlining=1 < %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/parallel-loop-md-merge.ll

; RUN: opt -always-inline -globalopt -S < %s | FileCheck %s ; RUN: opt -always-inline -globalopt --use-noalias-intrinsic-during-inlining=0 -S < %s | FileCheck %s --check-prefixes=CHECK,CHECK_SCOPE
; RUN: opt -always-inline -globalopt --use-noalias-intrinsic-during-inlining=1 -S < %s | FileCheck %s --check-prefixes=CHECK,CHECK_NOALIAS
; ;
; 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_SCOPE: ![[ACCESS_GROUP_LIST_3]] = !{![[ACCESS_GROUP_INNER:[0-9]+]], ![[ACCESS_GROUP_OUTER:[0-9]+]]}
; CHECK: ![[ACCESS_GROUP_OUTER]] = distinct !{} ; CHECK_SCOPE: ![[ACCESS_GROUP_INNER]] = distinct !{}
; CHECK_SCOPE: ![[ACCESS_GROUP_OUTER]] = distinct !{}
; CHECK_NOALIAS: ![[ACCESS_GROUP_OUTER:[0-9]+]] = distinct !{}
; CHECK_NOALIAS: ![[ACCESS_GROUP_LIST_3]] = !{![[ACCESS_GROUP_INNER:[0-9]+]], ![[ACCESS_GROUP_OUTER]]}
; CHECK_NOALIAS: ![[ACCESS_GROUP_INNER]] = distinct !{}
; CHECK: ![[LOOP_INNER]] = distinct !{![[LOOP_INNER]], ![[ACCESSES_INNER:[0-9]+]]} ; CHECK: ![[LOOP_INNER]] = distinct !{![[LOOP_INNER]], ![[ACCESSES_INNER:[0-9]+]]}
; CHECK: ![[ACCESSES_INNER]] = !{!"llvm.loop.parallel_accesses", ![[ACCESS_GROUP_INNER]]} ; CHECK: ![[ACCESSES_INNER]] = !{!"llvm.loop.parallel_accesses", ![[ACCESS_GROUP_INNER]]}
; CHECK: ![[LOOP_OUTER]] = distinct !{![[LOOP_OUTER]], ![[ACCESSES_OUTER:[0-9]+]]} ; CHECK: ![[LOOP_OUTER]] = distinct !{![[LOOP_OUTER]], ![[ACCESSES_OUTER:[0-9]+]]}
; CHECK: ![[ACCESSES_OUTER]] = !{!"llvm.loop.parallel_accesses", ![[ACCESS_GROUP_OUTER]]} ; CHECK: ![[ACCESSES_OUTER]] = !{!"llvm.loop.parallel_accesses", ![[ACCESS_GROUP_OUTER]]}