2016-06-15 08:19:09 +08:00
|
|
|
; RUN: opt < %s -inline -sroa -S | FileCheck %s
|
[PM] Provide an initial, minimal port of the inliner to the new pass manager.
This doesn't implement *every* feature of the existing inliner, but
tries to implement the most important ones for building a functional
optimization pipeline and beginning to sort out bugs, regressions, and
other problems.
Notable, but intentional omissions:
- No alloca merging support. Why? Because it isn't clear we want to do
this at all. Active discussion and investigation is going on to remove
it, so for simplicity I omitted it.
- No support for trying to iterate on "internally" devirtualized calls.
Why? Because it adds what I suspect is inappropriate coupling for
little or no benefit. We will have an outer iteration system that
tracks devirtualization including that from function passes and
iterates already. We should improve that rather than approximate it
here.
- Optimization remarks. Why? Purely to make the patch smaller, no other
reason at all.
The last one I'll probably work on almost immediately. But I wanted to
skip it in the initial patch to try to focus the change as much as
possible as there is already a lot of code moving around and both of
these *could* be skipped without really disrupting the core logic.
A summary of the different things happening here:
1) Adding the usual new PM class and rigging.
2) Fixing minor underlying assumptions in the inline cost analysis or
inline logic that don't generally hold in the new PM world.
3) Adding the core pass logic which is in essence a loop over the calls
in the nodes in the call graph. This is a bit duplicated from the old
inliner, but only a handful of lines could realistically be shared.
(I tried at first, and it really didn't help anything.) All told,
this is only about 100 lines of code, and most of that is the
mechanics of wiring up analyses from the new PM world.
4) Updating the LazyCallGraph (in the new PM) based on the *newly
inlined* calls and references. This is very minimal because we cannot
form cycles.
5) When inlining removes the last use of a function, eagerly nuking the
body of the function so that any "one use remaining" inline cost
heuristics are immediately refined, and queuing these functions to be
completely deleted once inlining is complete and the call graph
updated to reflect that they have become dead.
6) After all the inlining for a particular function, updating the
LazyCallGraph and the CGSCC pass manager to reflect the
function-local simplifications that are done immediately and
internally by the inline utilties. These are the exact same
fundamental set of CG updates done by arbitrary function passes.
7) Adding a bunch of test cases to specifically target CGSCC and other
subtle aspects in the new PM world.
Many thanks to the careful review from Easwaran and Sanjoy and others!
Differential Revision: https://reviews.llvm.org/D24226
llvm-svn: 290161
2016-12-20 11:15:32 +08:00
|
|
|
; RUN: opt < %s -passes='cgscc(inline,function(sroa))' -S | FileCheck %s
|
2009-11-03 23:29:06 +08:00
|
|
|
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
|
2002-06-25 01:46:05 +08:00
|
|
|
|
2009-10-27 13:35:35 +08:00
|
|
|
define i32 @test1f(i32 %i) {
|
2008-03-01 17:15:35 +08:00
|
|
|
ret i32 %i
|
2002-06-25 01:46:05 +08:00
|
|
|
}
|
|
|
|
|
|
2009-10-27 13:35:35 +08:00
|
|
|
define i32 @test1(i32 %W) {
|
|
|
|
|
%X = call i32 @test1f(i32 7)
|
|
|
|
|
%Y = add i32 %X, %W
|
2008-03-01 17:15:35 +08:00
|
|
|
ret i32 %Y
|
2013-07-14 09:42:54 +08:00
|
|
|
; CHECK-LABEL: @test1(
|
2009-10-27 13:35:35 +08:00
|
|
|
; CHECK-NEXT: %Y = add i32 7, %W
|
|
|
|
|
; CHECK-NEXT: ret i32 %Y
|
2002-06-25 01:46:05 +08:00
|
|
|
}
|
2008-03-01 17:15:35 +08:00
|
|
|
|
2009-10-27 13:39:41 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
; rdar://7339069
|
|
|
|
|
|
|
|
|
|
%T = type { i32, i32 }
|
|
|
|
|
|
2013-07-14 10:10:57 +08:00
|
|
|
; CHECK-NOT: @test2f(
|
2009-10-27 13:39:41 +08:00
|
|
|
define internal %T* @test2f(i1 %cond, %T* %P) {
|
|
|
|
|
br i1 %cond, label %T, label %F
|
|
|
|
|
|
|
|
|
|
T:
|
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
llvm-svn: 230786
2015-02-28 03:29:02 +08:00
|
|
|
%A = getelementptr %T, %T* %P, i32 0, i32 0
|
2009-10-27 13:39:41 +08:00
|
|
|
store i32 42, i32* %A
|
|
|
|
|
ret %T* %P
|
|
|
|
|
|
|
|
|
|
F:
|
|
|
|
|
ret %T* %P
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define i32 @test2(i1 %cond) {
|
|
|
|
|
%A = alloca %T
|
|
|
|
|
|
|
|
|
|
%B = call %T* @test2f(i1 %cond, %T* %A)
|
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
llvm-svn: 230786
2015-02-28 03:29:02 +08:00
|
|
|
%C = getelementptr %T, %T* %B, i32 0, i32 0
|
2015-02-28 05:17:42 +08:00
|
|
|
%D = load i32, i32* %C
|
2009-10-27 13:39:41 +08:00
|
|
|
ret i32 %D
|
|
|
|
|
|
2013-07-14 09:42:54 +08:00
|
|
|
; CHECK-LABEL: @test2(
|
2009-10-27 13:39:41 +08:00
|
|
|
; CHECK-NOT: = alloca
|
2011-01-14 15:46:33 +08:00
|
|
|
; CHECK: ret i32
|
2009-10-27 13:39:41 +08:00
|
|
|
}
|
2012-12-21 00:04:27 +08:00
|
|
|
|
|
|
|
|
declare void @barrier() noduplicate
|
|
|
|
|
|
|
|
|
|
define internal i32 @f() {
|
|
|
|
|
call void @barrier() noduplicate
|
|
|
|
|
ret i32 1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define i32 @g() {
|
|
|
|
|
call void @barrier() noduplicate
|
|
|
|
|
ret i32 2
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define internal i32 @h() {
|
|
|
|
|
call void @barrier() noduplicate
|
|
|
|
|
ret i32 3
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define i32 @test3() {
|
|
|
|
|
%b = call i32 @f()
|
|
|
|
|
ret i32 %b
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; The call to @f cannot be inlined as there is another callsite
|
|
|
|
|
; calling @f, and @f contains a noduplicate call.
|
|
|
|
|
;
|
|
|
|
|
; The call to @g cannot be inlined as it has external linkage.
|
|
|
|
|
;
|
|
|
|
|
; The call to @h *can* be inlined.
|
|
|
|
|
|
2013-07-14 09:42:54 +08:00
|
|
|
; CHECK-LABEL: @test(
|
2012-12-21 00:04:27 +08:00
|
|
|
define i32 @test() {
|
|
|
|
|
; CHECK: call i32 @f()
|
|
|
|
|
%a = call i32 @f()
|
|
|
|
|
; CHECK: call i32 @g()
|
|
|
|
|
%b = call i32 @g()
|
|
|
|
|
; CHECK-NOT: call i32 @h()
|
|
|
|
|
%c = call i32 @h()
|
|
|
|
|
|
|
|
|
|
%d = add i32 %a, %b
|
|
|
|
|
%e = add i32 %d, %c
|
|
|
|
|
|
|
|
|
|
ret i32 %e
|
|
|
|
|
; CHECK: }
|
|
|
|
|
}
|