This is an archive of the discontinued LLVM Phabricator instance.

Differential D51814

Set cost of invariant group intrinsics to 0
ClosedPublic

Authored by Prazek on Sep 7 2018, 1:55 PM.

Details

Reviewers
amharc
rsmith
reames
kuhar
Commits
rG9a925ba61627: Set cost of invariant group intrinsics to 0
rL341725: Set cost of invariant group intrinsics to 0
Summary

Like with other similar intrinsics, presense of strip or
launder.invariant.group should not change the result of inlining cost.
This is because they are just markers and do not perform any computation.

Diff Detail

Repository
rL LLVM

Event Timeline

Prazek created this revision.Sep 7 2018, 1:55 PM
Herald added a subscriber: eraman. · View Herald TranscriptSep 7 2018, 1:55 PM
Harbormaster completed remote builds in B22390: Diff 164509.Sep 7 2018, 1:57 PM
rsmith accepted this revision.Sep 7 2018, 3:22 PM
This revision is now accepted and ready to land.Sep 7 2018, 3:22 PM
Closed by commit rL341725: Set cost of invariant group intrinsics to 0 (authored by Prazek). · Explain WhySep 7 2018, 3:31 PM
This revision was automatically updated to reflect the committed changes.
aeubanks mentioned this in D108837: [SimplifyCFG] Ignore free instructions when computing cost for folding branch to common dest.Aug 30 2021, 11:40 AM

Revision Contents

PathSize
llvm/
trunk/
include/
llvm/
Analysis/
2 lines
test/
Transforms/
Inline/
36 lines

Diff 164529

llvm/trunk/include/llvm/Analysis/TargetTransformInfoImpl.h

Show First 20 Lines • Show All 152 Lines • ▼ Show 20 Lines unsigned getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
case Intrinsic::annotation: case Intrinsic::annotation:
case Intrinsic::assume: case Intrinsic::assume:
case Intrinsic::sideeffect: case Intrinsic::sideeffect:
case Intrinsic::dbg_declare: case Intrinsic::dbg_declare:
case Intrinsic::dbg_value: case Intrinsic::dbg_value:
case Intrinsic::dbg_label: case Intrinsic::dbg_label:
case Intrinsic::invariant_start: case Intrinsic::invariant_start:
case Intrinsic::invariant_end: case Intrinsic::invariant_end:
case Intrinsic::launder_invariant_group:
case Intrinsic::strip_invariant_group:
case Intrinsic::lifetime_start: case Intrinsic::lifetime_start:
case Intrinsic::lifetime_end: case Intrinsic::lifetime_end:
case Intrinsic::objectsize: case Intrinsic::objectsize:
case Intrinsic::ptr_annotation: case Intrinsic::ptr_annotation:
case Intrinsic::var_annotation: case Intrinsic::var_annotation:
case Intrinsic::experimental_gc_result: case Intrinsic::experimental_gc_result:
case Intrinsic::experimental_gc_relocate: case Intrinsic::experimental_gc_relocate:
case Intrinsic::coro_alloc: case Intrinsic::coro_alloc:
▲ Show 20 Lines • Show All 685 Lines • Show Last 20 Lines

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

; RUN: opt -S -inline < %s | FileCheck %s ; RUN: opt -S -inline < %s | FileCheck %s
; RUN: opt -S -O3 < %s | FileCheck %s ; RUN: opt -S -O3 < %s | FileCheck %s
; RUN: opt -S -inline -inline-threshold=1 < %s | FileCheck %s
%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
%struct.A = type <{ i32 (...)**, i32, [4 x i8] }>
; CHECK: define i32 @bar(%struct.A* noalias
define i32 @bar(%struct.A* noalias) { define i32 @bar(%struct.A* noalias) {
; CHECK-NOT: noalias ; CHECK-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-NOT: call i32 @bar(
; CHECK-NOT: noalias ; CHECK-NOT: noalias
%2 = tail call i32 @bar(%struct.A* %0) %2 = tail call i32 @bar(%struct.A* %0)
ret i32 %2 ret i32 %2
} }
; This test checks if invariant group intrinsics have zero cost for inlining.
; CHECK-LABEL: define i8* @caller(i8*
define i8* @caller(i8* %p) {
; CHECK-NOT: call i8* @lot_of_launders_and_strips
%a1 = call i8* @lot_of_launders_and_strips(i8* %p)
%a2 = call i8* @lot_of_launders_and_strips(i8* %a1)
%a3 = call i8* @lot_of_launders_and_strips(i8* %a2)
%a4 = call i8* @lot_of_launders_and_strips(i8* %a3)
ret i8* %a4
}
define i8* @lot_of_launders_and_strips(i8* %p) {
%a1 = call i8* @llvm.launder.invariant.group.p0i8(i8* %p)
%a2 = call i8* @llvm.launder.invariant.group.p0i8(i8* %a1)
%a3 = call i8* @llvm.launder.invariant.group.p0i8(i8* %a2)
%a4 = call i8* @llvm.launder.invariant.group.p0i8(i8* %a3)
%s1 = call i8* @llvm.strip.invariant.group.p0i8(i8* %a4)
%s2 = call i8* @llvm.strip.invariant.group.p0i8(i8* %s1)
%s3 = call i8* @llvm.strip.invariant.group.p0i8(i8* %s2)
%s4 = call i8* @llvm.strip.invariant.group.p0i8(i8* %s3)
ret i8* %s4
}
declare i8* @llvm.launder.invariant.group.p0i8(i8*) declare i8* @llvm.launder.invariant.group.p0i8(i8*)
declare i8* @llvm.strip.invariant.group.p0i8(i8*)