mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-19 11:02:59 +02:00
fc4e6d1d1a
Summary:
It was supposed that Ref LazyCallGraph::Edge's were being inserted by
inlining, but that doesn't seem to be the case. Instead, it seems that
there was no test for a blockaddress Constant in an instruction that
referenced the function that contained the instruction. Ex:
```
define void @f() {
%1 = alloca i8*, align 8
2:
store i8* blockaddress(@f, %2), i8** %1, align 8
ret void
}
```
When iterating blockaddresses, do not add the function they refer to
back to the worklist if the blockaddress is referring to the contained
function (as opposed to an external function).
Because blockaddress has sligtly different semantics than GNU C's
address of labels, there are 3 cases that can occur with blockaddress,
where only 1 can happen in GNU C due to C's scoping rules:
* blockaddress is within the function it refers to (possible in GNU C).
* blockaddress is within a different function than the one it refers to
(not possible in GNU C).
* blockaddress is used in to declare a global (not possible in GNU C).
The second case is tested in:
```
$ ./llvm/build/unittests/Analysis/AnalysisTests \
--gtest_filter=LazyCallGraphTest.HandleBlockAddress
```
This patch adjusts the iteration of blockaddresses in
LazyCallGraph::visitReferences to not revisit the blockaddresses
function in the first case.
The Linux kernel contains code that's not semantically valid at -O0;
specifically code passed to asm goto. It requires that asm goto be
inline-able. This patch conservatively does not attempt to handle the
more general case of inlining blockaddresses that have non-callbr users
(pr/39560).
https://bugs.llvm.org/show_bug.cgi?id=39560
https://bugs.llvm.org/show_bug.cgi?id=40722
https://github.com/ClangBuiltLinux/linux/issues/6
https://reviews.llvm.org/rL212077
Reviewers: jyknight, eli.friedman, chandlerc
Reviewed By: chandlerc
Subscribers: george.burgess.iv, nathanchance, mgorny, craig.topper, mengxu.gatech, void, mehdi_amini, E5ten, chandlerc, efriedma, eraman, hiraditya, haicheng, pirama, llvm-commits, srhines
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D58260
llvm-svn: 361173
131 lines
3.6 KiB
LLVM
131 lines
3.6 KiB
LLVM
; RUN: opt -inline -S < %s | FileCheck %s
|
|
; RUN: opt -passes='cgscc(inline)' -S < %s | FileCheck %s
|
|
; PR10162
|
|
|
|
; Make sure doit is not inlined since the blockaddress is taken
|
|
; which could be unsafe
|
|
; CHECK: store i8* blockaddress(@doit, %here), i8** %pptr, align 8
|
|
|
|
@i = global i32 1, align 4
|
|
@ptr1 = common global i8* null, align 8
|
|
|
|
define void @doit(i8** nocapture %pptr, i32 %cond) nounwind uwtable {
|
|
entry:
|
|
%tobool = icmp eq i32 %cond, 0
|
|
br i1 %tobool, label %if.end, label %here
|
|
|
|
here:
|
|
store i8* blockaddress(@doit, %here), i8** %pptr, align 8
|
|
br label %if.end
|
|
|
|
if.end:
|
|
ret void
|
|
}
|
|
|
|
define void @f(i32 %cond) nounwind uwtable {
|
|
entry:
|
|
call void @doit(i8** @ptr1, i32 %cond)
|
|
ret void
|
|
}
|
|
|
|
; PR27233: We can inline @run into @init. Don't crash on it.
|
|
;
|
|
; CHECK-LABEL: define void @init
|
|
; CHECK: store i8* blockaddress(@run, %bb)
|
|
; CHECK-SAME: @run.bb
|
|
define void @init() {
|
|
entry:
|
|
call void @run()
|
|
ret void
|
|
}
|
|
|
|
define void @run() {
|
|
entry:
|
|
store i8* blockaddress(@run, %bb), i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @run.bb, i64 0, i64 0), align 8
|
|
ret void
|
|
|
|
bb:
|
|
unreachable
|
|
}
|
|
|
|
@run.bb = global [1 x i8*] zeroinitializer
|
|
|
|
; Check that a function referenced by a global blockaddress wont be inlined,
|
|
; even if it contains a callbr. We might be able to relax this in the future
|
|
; as long as the global blockaddress is updated correctly.
|
|
@ba = internal global i8* blockaddress(@foo, %7), align 8
|
|
define internal i32 @foo(i32) {
|
|
%2 = alloca i32, align 4
|
|
%3 = alloca i32, align 4
|
|
store i32 %0, i32* %3, align 4
|
|
%4 = load i32, i32* %3, align 4
|
|
callbr void asm sideeffect "testl $0, $0; jne ${1:l};", "r,X,X,~{dirflag},~{fpsr},~{flags}"(i32 %4, i8* blockaddress(@foo, %7), i8* blockaddress(@foo, %6)) #1
|
|
to label %5 [label %7, label %6]
|
|
|
|
; <label>:5: ; preds = %1
|
|
store i32 0, i32* %2, align 4
|
|
br label %8
|
|
|
|
; <label>:6: ; preds = %1
|
|
store i32 1, i32* %2, align 4
|
|
br label %8
|
|
|
|
; <label>:7: ; preds = %1
|
|
store i32 2, i32* %2, align 4
|
|
br label %8
|
|
|
|
; <label>:8: ; preds = %7, %6, %5
|
|
%9 = load i32, i32* %2, align 4
|
|
ret i32 %9
|
|
}
|
|
define dso_local i32 @bar() {
|
|
%1 = call i32 @foo(i32 0)
|
|
ret i32 %1
|
|
}
|
|
|
|
; CHECK: define dso_local i32 @bar() {
|
|
; CHECK: %1 = call i32 @foo(i32 0)
|
|
; CHECK: ret i32 %1
|
|
; CHECK: }
|
|
|
|
; Triple check that even with a global aggregate whose member is a blockaddress,
|
|
; we still don't inline referred to functions.
|
|
|
|
%struct.foo = type { i8* }
|
|
|
|
@my_foo = dso_local global %struct.foo { i8* blockaddress(@baz, %7) }
|
|
|
|
define internal i32 @baz(i32) {
|
|
%2 = alloca i32, align 4
|
|
%3 = alloca i32, align 4
|
|
store i32 %0, i32* %3, align 4
|
|
%4 = load i32, i32* %3, align 4
|
|
callbr void asm sideeffect "testl $0, $0; jne ${1:l};", "r,X,X,~{dirflag},~{fpsr},~{flags}"(i32 %4, i8* blockaddress(@baz, %7), i8* blockaddress(@baz, %6)) #1
|
|
to label %5 [label %7, label %6]
|
|
|
|
; <label>:5: ; preds = %1
|
|
store i32 0, i32* %2, align 4
|
|
br label %8
|
|
|
|
; <label>:6: ; preds = %1
|
|
store i32 1, i32* %2, align 4
|
|
br label %8
|
|
|
|
; <label>:7: ; preds = %1
|
|
store i32 2, i32* %2, align 4
|
|
br label %8
|
|
|
|
; <label>:8: ; preds = %7, %6, %5
|
|
%9 = load i32, i32* %2, align 4
|
|
ret i32 %9
|
|
}
|
|
define dso_local i32 @quux() {
|
|
%1 = call i32 @baz(i32 0)
|
|
ret i32 %1
|
|
}
|
|
|
|
; CHECK: define dso_local i32 @quux() {
|
|
; CHECK: %1 = call i32 @baz(i32 0)
|
|
; CHECK: ret i32 %1
|
|
; CHECK: }
|