2017-08-02 08:28:10 +08:00
|
|
|
; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu -asm-verbose=false -post-RA-scheduler=true | FileCheck %s
|
2009-11-12 03:48:59 +08:00
|
|
|
|
|
|
|
declare void @bar(i32)
|
|
|
|
declare void @car(i32)
|
|
|
|
declare void @dar(i32)
|
|
|
|
declare void @ear(i32)
|
|
|
|
declare void @far(i32)
|
|
|
|
declare i1 @qux()
|
|
|
|
|
|
|
|
@GHJK = global i32 0
|
|
|
|
@HABC = global i32 0
|
|
|
|
|
|
|
|
; BranchFolding should tail-merge the stores since they all precede
|
|
|
|
; direct branches to the same place.
|
|
|
|
|
2013-07-14 14:24:09 +08:00
|
|
|
; CHECK-LABEL: tail_merge_me:
|
2009-11-12 03:48:59 +08:00
|
|
|
; CHECK-NOT: GHJK
|
|
|
|
; CHECK: movl $0, GHJK(%rip)
|
|
|
|
; CHECK-NEXT: movl $1, HABC(%rip)
|
|
|
|
; CHECK-NOT: GHJK
|
|
|
|
|
|
|
|
define void @tail_merge_me() nounwind {
|
|
|
|
entry:
|
|
|
|
%a = call i1 @qux()
|
|
|
|
br i1 %a, label %A, label %next
|
|
|
|
next:
|
|
|
|
%b = call i1 @qux()
|
|
|
|
br i1 %b, label %B, label %C
|
|
|
|
|
|
|
|
A:
|
|
|
|
call void @bar(i32 0)
|
|
|
|
store i32 0, i32* @GHJK
|
|
|
|
br label %M
|
|
|
|
|
|
|
|
B:
|
|
|
|
call void @car(i32 1)
|
|
|
|
store i32 0, i32* @GHJK
|
|
|
|
br label %M
|
|
|
|
|
|
|
|
C:
|
|
|
|
call void @dar(i32 2)
|
|
|
|
store i32 0, i32* @GHJK
|
|
|
|
br label %M
|
|
|
|
|
|
|
|
M:
|
|
|
|
store i32 1, i32* @HABC
|
|
|
|
%c = call i1 @qux()
|
|
|
|
br i1 %c, label %return, label %altret
|
|
|
|
|
|
|
|
return:
|
|
|
|
call void @ear(i32 1000)
|
|
|
|
ret void
|
|
|
|
altret:
|
|
|
|
call void @far(i32 1001)
|
|
|
|
ret void
|
|
|
|
}
|
|
|
|
|
2010-01-06 01:55:26 +08:00
|
|
|
declare i8* @choose(i8*, i8*)
|
2009-11-12 03:48:59 +08:00
|
|
|
|
|
|
|
; BranchFolding should tail-duplicate the indirect jump to avoid
|
|
|
|
; redundant branching.
|
|
|
|
|
2013-07-14 14:24:09 +08:00
|
|
|
; CHECK-LABEL: tail_duplicate_me:
|
2009-11-12 03:48:59 +08:00
|
|
|
; CHECK: movl $0, GHJK(%rip)
|
2010-09-18 06:28:18 +08:00
|
|
|
; CHECK-NEXT: jmpq *%r
|
2009-11-12 03:48:59 +08:00
|
|
|
; CHECK: movl $0, GHJK(%rip)
|
2010-09-18 06:28:18 +08:00
|
|
|
; CHECK-NEXT: jmpq *%r
|
2009-11-12 03:48:59 +08:00
|
|
|
; CHECK: movl $0, GHJK(%rip)
|
2010-09-18 06:28:18 +08:00
|
|
|
; CHECK-NEXT: jmpq *%r
|
2009-11-12 03:48:59 +08:00
|
|
|
|
|
|
|
define void @tail_duplicate_me() nounwind {
|
|
|
|
entry:
|
|
|
|
%a = call i1 @qux()
|
|
|
|
%c = call i8* @choose(i8* blockaddress(@tail_duplicate_me, %return),
|
|
|
|
i8* blockaddress(@tail_duplicate_me, %altret))
|
|
|
|
br i1 %a, label %A, label %next
|
|
|
|
next:
|
|
|
|
%b = call i1 @qux()
|
|
|
|
br i1 %b, label %B, label %C
|
|
|
|
|
|
|
|
A:
|
|
|
|
call void @bar(i32 0)
|
|
|
|
store i32 0, i32* @GHJK
|
|
|
|
br label %M
|
|
|
|
|
|
|
|
B:
|
|
|
|
call void @car(i32 1)
|
|
|
|
store i32 0, i32* @GHJK
|
|
|
|
br label %M
|
|
|
|
|
|
|
|
C:
|
|
|
|
call void @dar(i32 2)
|
|
|
|
store i32 0, i32* @GHJK
|
|
|
|
br label %M
|
|
|
|
|
|
|
|
M:
|
|
|
|
indirectbr i8* %c, [label %return, label %altret]
|
|
|
|
|
|
|
|
return:
|
|
|
|
call void @ear(i32 1000)
|
|
|
|
ret void
|
|
|
|
altret:
|
|
|
|
call void @far(i32 1001)
|
|
|
|
ret void
|
|
|
|
}
|
|
|
|
|
|
|
|
; BranchFolding shouldn't try to merge the tails of two blocks
|
|
|
|
; with only a branch in common, regardless of the fallthrough situation.
|
|
|
|
|
2013-07-14 14:24:09 +08:00
|
|
|
; CHECK-LABEL: dont_merge_oddly:
|
2009-11-12 03:48:59 +08:00
|
|
|
; CHECK-NOT: ret
|
2011-04-14 13:15:06 +08:00
|
|
|
; CHECK: ucomiss %xmm{{[0-2]}}, %xmm{{[0-2]}}
|
2010-04-18 00:29:15 +08:00
|
|
|
; CHECK-NEXT: jbe .LBB2_3
|
2011-04-14 13:15:06 +08:00
|
|
|
; CHECK-NEXT: ucomiss %xmm{{[0-2]}}, %xmm{{[0-2]}}
|
2010-04-18 00:29:15 +08:00
|
|
|
; CHECK-NEXT: ja .LBB2_4
|
Codegen: Make chains from trellis-shaped CFGs
Lay out trellis-shaped CFGs optimally.
A trellis of the shape below:
A B
|\ /|
| \ / |
| X |
| / \ |
|/ \|
C D
would be laid out A; B->C ; D by the current layout algorithm. Now we identify
trellises and lay them out either A->C; B->D or A->D; B->C. This scales with an
increasing number of predecessors. A trellis is a a group of 2 or more
predecessor blocks that all have the same successors.
because of this we can tail duplicate to extend existing trellises.
As an example consider the following CFG:
B D F H
/ \ / \ / \ / \
A---C---E---G---Ret
Where A,C,E,G are all small (Currently 2 instructions).
The CFG preserving layout is then A,B,C,D,E,F,G,H,Ret.
The current code will copy C into B, E into D and G into F and yield the layout
A,C,B(C),E,D(E),F(G),G,H,ret
define void @straight_test(i32 %tag) {
entry:
br label %test1
test1: ; A
%tagbit1 = and i32 %tag, 1
%tagbit1eq0 = icmp eq i32 %tagbit1, 0
br i1 %tagbit1eq0, label %test2, label %optional1
optional1: ; B
call void @a()
br label %test2
test2: ; C
%tagbit2 = and i32 %tag, 2
%tagbit2eq0 = icmp eq i32 %tagbit2, 0
br i1 %tagbit2eq0, label %test3, label %optional2
optional2: ; D
call void @b()
br label %test3
test3: ; E
%tagbit3 = and i32 %tag, 4
%tagbit3eq0 = icmp eq i32 %tagbit3, 0
br i1 %tagbit3eq0, label %test4, label %optional3
optional3: ; F
call void @c()
br label %test4
test4: ; G
%tagbit4 = and i32 %tag, 8
%tagbit4eq0 = icmp eq i32 %tagbit4, 0
br i1 %tagbit4eq0, label %exit, label %optional4
optional4: ; H
call void @d()
br label %exit
exit:
ret void
}
here is the layout after D27742:
straight_test: # @straight_test
; ... Prologue elided
; BB#0: # %entry ; A (merged with test1)
; ... More prologue elided
mr 30, 3
andi. 3, 30, 1
bc 12, 1, .LBB0_2
; BB#1: # %test2 ; C
rlwinm. 3, 30, 0, 30, 30
beq 0, .LBB0_3
b .LBB0_4
.LBB0_2: # %optional1 ; B (copy of C)
bl a
nop
rlwinm. 3, 30, 0, 30, 30
bne 0, .LBB0_4
.LBB0_3: # %test3 ; E
rlwinm. 3, 30, 0, 29, 29
beq 0, .LBB0_5
b .LBB0_6
.LBB0_4: # %optional2 ; D (copy of E)
bl b
nop
rlwinm. 3, 30, 0, 29, 29
bne 0, .LBB0_6
.LBB0_5: # %test4 ; G
rlwinm. 3, 30, 0, 28, 28
beq 0, .LBB0_8
b .LBB0_7
.LBB0_6: # %optional3 ; F (copy of G)
bl c
nop
rlwinm. 3, 30, 0, 28, 28
beq 0, .LBB0_8
.LBB0_7: # %optional4 ; H
bl d
nop
.LBB0_8: # %exit ; Ret
ld 30, 96(1) # 8-byte Folded Reload
addi 1, 1, 112
ld 0, 16(1)
mtlr 0
blr
The tail-duplication has produced some benefit, but it has also produced a
trellis which is not laid out optimally. With this patch, we improve the layouts
of such trellises, and decrease the cost calculation for tail-duplication
accordingly.
This patch produces the layout A,C,E,G,B,D,F,H,Ret. This layout does have
back edges, which is a negative, but it has a bigger compensating
positive, which is that it handles the case where there are long strings
of skipped blocks much better than the original layout. Both layouts
handle runs of executed blocks equally well. Branch prediction also
improves if there is any correlation between subsequent optional blocks.
Here is the resulting concrete layout:
straight_test: # @straight_test
; BB#0: # %entry ; A (merged with test1)
mr 30, 3
andi. 3, 30, 1
bc 12, 1, .LBB0_4
; BB#1: # %test2 ; C
rlwinm. 3, 30, 0, 30, 30
bne 0, .LBB0_5
.LBB0_2: # %test3 ; E
rlwinm. 3, 30, 0, 29, 29
bne 0, .LBB0_6
.LBB0_3: # %test4 ; G
rlwinm. 3, 30, 0, 28, 28
bne 0, .LBB0_7
b .LBB0_8
.LBB0_4: # %optional1 ; B (Copy of C)
bl a
nop
rlwinm. 3, 30, 0, 30, 30
beq 0, .LBB0_2
.LBB0_5: # %optional2 ; D (Copy of E)
bl b
nop
rlwinm. 3, 30, 0, 29, 29
beq 0, .LBB0_3
.LBB0_6: # %optional3 ; F (Copy of G)
bl c
nop
rlwinm. 3, 30, 0, 28, 28
beq 0, .LBB0_8
.LBB0_7: # %optional4 ; H
bl d
nop
.LBB0_8: # %exit
Differential Revision: https://reviews.llvm.org/D28522
llvm-svn: 295223
2017-02-16 03:49:14 +08:00
|
|
|
; CHECK-NEXT: .LBB2_2:
|
|
|
|
; CHECK-NEXT: movb $1, %al
|
|
|
|
; CHECK-NEXT: ret
|
2010-04-18 00:29:15 +08:00
|
|
|
; CHECK-NEXT: .LBB2_3:
|
2011-04-14 13:15:06 +08:00
|
|
|
; CHECK-NEXT: ucomiss %xmm{{[0-2]}}, %xmm{{[0-2]}}
|
2010-04-18 00:29:15 +08:00
|
|
|
; CHECK-NEXT: jbe .LBB2_2
|
|
|
|
; CHECK-NEXT: .LBB2_4:
|
2013-05-30 21:19:42 +08:00
|
|
|
; CHECK-NEXT: xorl %eax, %eax
|
2009-11-12 03:48:59 +08:00
|
|
|
; CHECK-NEXT: ret
|
|
|
|
|
|
|
|
define i1 @dont_merge_oddly(float* %result) nounwind {
|
|
|
|
entry:
|
[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
|
|
|
%tmp4 = getelementptr float, float* %result, i32 2
|
2015-02-28 05:17:42 +08:00
|
|
|
%tmp5 = load float, float* %tmp4, align 4
|
[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
|
|
|
%tmp7 = getelementptr float, float* %result, i32 4
|
2015-02-28 05:17:42 +08:00
|
|
|
%tmp8 = load float, float* %tmp7, align 4
|
[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
|
|
|
%tmp10 = getelementptr float, float* %result, i32 6
|
2015-02-28 05:17:42 +08:00
|
|
|
%tmp11 = load float, float* %tmp10, align 4
|
2009-11-12 03:48:59 +08:00
|
|
|
%tmp12 = fcmp olt float %tmp8, %tmp11
|
|
|
|
br i1 %tmp12, label %bb, label %bb21
|
|
|
|
|
|
|
|
bb:
|
|
|
|
%tmp23469 = fcmp olt float %tmp5, %tmp8
|
|
|
|
br i1 %tmp23469, label %bb26, label %bb30
|
|
|
|
|
|
|
|
bb21:
|
|
|
|
%tmp23 = fcmp olt float %tmp5, %tmp11
|
|
|
|
br i1 %tmp23, label %bb26, label %bb30
|
|
|
|
|
|
|
|
bb26:
|
|
|
|
ret i1 0
|
|
|
|
|
|
|
|
bb30:
|
|
|
|
ret i1 1
|
|
|
|
}
|
|
|
|
|
|
|
|
; Do any-size tail-merging when two candidate blocks will both require
|
|
|
|
; an unconditional jump to complete a two-way conditional branch.
|
|
|
|
|
2013-07-14 14:24:09 +08:00
|
|
|
; CHECK-LABEL: c_expand_expr_stmt:
|
2011-04-05 08:32:44 +08:00
|
|
|
;
|
|
|
|
; This test only works when register allocation happens to use %rax for both
|
|
|
|
; load addresses.
|
|
|
|
;
|
|
|
|
; CHE: jmp .LBB3_11
|
|
|
|
; CHE-NEXT: .LBB3_9:
|
|
|
|
; CHE-NEXT: movq 8(%rax), %rax
|
2013-05-30 21:19:42 +08:00
|
|
|
; CHE-NEXT: xorl %edx, %edx
|
2011-04-05 08:32:44 +08:00
|
|
|
; CHE-NEXT: movb 16(%rax), %al
|
|
|
|
; CHE-NEXT: cmpb $16, %al
|
|
|
|
; CHE-NEXT: je .LBB3_11
|
|
|
|
; CHE-NEXT: cmpb $23, %al
|
|
|
|
; CHE-NEXT: jne .LBB3_14
|
|
|
|
; CHE-NEXT: .LBB3_11:
|
2009-11-12 03:48:59 +08:00
|
|
|
|
|
|
|
%0 = type { %struct.rtx_def* }
|
|
|
|
%struct.lang_decl = type opaque
|
|
|
|
%struct.rtx_def = type { i16, i8, i8, [1 x %union.rtunion] }
|
|
|
|
%struct.tree_decl = type { [24 x i8], i8*, i32, %union.tree_node*, i32, i8, i8, i8, i8, %union.tree_node*, %union.tree_node*, %union.tree_node*, %union.tree_node*, %union.tree_node*, %union.tree_node*, %union.tree_node*, %union.tree_node*, %union.tree_node*, %struct.rtx_def*, %union..2anon, %0, %union.tree_node*, %struct.lang_decl* }
|
|
|
|
%union..2anon = type { i32 }
|
|
|
|
%union.rtunion = type { i8* }
|
|
|
|
%union.tree_node = type { %struct.tree_decl }
|
|
|
|
|
|
|
|
define fastcc void @c_expand_expr_stmt(%union.tree_node* %expr) nounwind {
|
|
|
|
entry:
|
2015-02-28 05:17:42 +08:00
|
|
|
%tmp4 = load i8, i8* null, align 8 ; <i8> [#uses=3]
|
2009-11-12 03:48:59 +08:00
|
|
|
switch i8 %tmp4, label %bb3 [
|
|
|
|
i8 18, label %bb
|
|
|
|
]
|
|
|
|
|
|
|
|
bb: ; preds = %entry
|
|
|
|
switch i32 undef, label %bb1 [
|
|
|
|
i32 0, label %bb2.i
|
|
|
|
i32 37, label %bb.i
|
|
|
|
]
|
|
|
|
|
|
|
|
bb.i: ; preds = %bb
|
|
|
|
switch i32 undef, label %bb1 [
|
|
|
|
i32 0, label %lvalue_p.exit
|
|
|
|
]
|
|
|
|
|
|
|
|
bb2.i: ; preds = %bb
|
|
|
|
br label %bb3
|
|
|
|
|
|
|
|
lvalue_p.exit: ; preds = %bb.i
|
2015-02-28 05:17:42 +08:00
|
|
|
%tmp21 = load %union.tree_node*, %union.tree_node** null, align 8 ; <%union.tree_node*> [#uses=3]
|
[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
|
|
|
%tmp22 = getelementptr inbounds %union.tree_node, %union.tree_node* %tmp21, i64 0, i32 0, i32 0, i64 0 ; <i8*> [#uses=1]
|
2015-02-28 05:17:42 +08:00
|
|
|
%tmp23 = load i8, i8* %tmp22, align 8 ; <i8> [#uses=1]
|
2009-11-12 03:48:59 +08:00
|
|
|
%tmp24 = zext i8 %tmp23 to i32 ; <i32> [#uses=1]
|
|
|
|
switch i32 %tmp24, label %lvalue_p.exit4 [
|
|
|
|
i32 0, label %bb2.i3
|
|
|
|
i32 2, label %bb.i1
|
|
|
|
]
|
|
|
|
|
|
|
|
bb.i1: ; preds = %lvalue_p.exit
|
[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
|
|
|
%tmp25 = getelementptr inbounds %union.tree_node, %union.tree_node* %tmp21, i64 0, i32 0, i32 2 ; <i32*> [#uses=1]
|
2009-11-12 03:48:59 +08:00
|
|
|
%tmp26 = bitcast i32* %tmp25 to %union.tree_node** ; <%union.tree_node**> [#uses=1]
|
2015-02-28 05:17:42 +08:00
|
|
|
%tmp27 = load %union.tree_node*, %union.tree_node** %tmp26, align 8 ; <%union.tree_node*> [#uses=2]
|
[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
|
|
|
%tmp28 = getelementptr inbounds %union.tree_node, %union.tree_node* %tmp27, i64 0, i32 0, i32 0, i64 16 ; <i8*> [#uses=1]
|
2015-02-28 05:17:42 +08:00
|
|
|
%tmp29 = load i8, i8* %tmp28, align 8 ; <i8> [#uses=1]
|
2009-11-12 03:48:59 +08:00
|
|
|
%tmp30 = zext i8 %tmp29 to i32 ; <i32> [#uses=1]
|
|
|
|
switch i32 %tmp30, label %lvalue_p.exit4 [
|
|
|
|
i32 0, label %bb2.i.i2
|
|
|
|
i32 2, label %bb.i.i
|
|
|
|
]
|
|
|
|
|
|
|
|
bb.i.i: ; preds = %bb.i1
|
|
|
|
%tmp34 = tail call fastcc i32 @lvalue_p(%union.tree_node* null) nounwind ; <i32> [#uses=1]
|
|
|
|
%phitmp = icmp ne i32 %tmp34, 0 ; <i1> [#uses=1]
|
|
|
|
br label %lvalue_p.exit4
|
|
|
|
|
|
|
|
bb2.i.i2: ; preds = %bb.i1
|
[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
|
|
|
%tmp35 = getelementptr inbounds %union.tree_node, %union.tree_node* %tmp27, i64 0, i32 0, i32 0, i64 8 ; <i8*> [#uses=1]
|
2009-11-12 03:48:59 +08:00
|
|
|
%tmp36 = bitcast i8* %tmp35 to %union.tree_node** ; <%union.tree_node**> [#uses=1]
|
2015-02-28 05:17:42 +08:00
|
|
|
%tmp37 = load %union.tree_node*, %union.tree_node** %tmp36, align 8 ; <%union.tree_node*> [#uses=1]
|
[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
|
|
|
%tmp38 = getelementptr inbounds %union.tree_node, %union.tree_node* %tmp37, i64 0, i32 0, i32 0, i64 16 ; <i8*> [#uses=1]
|
2015-02-28 05:17:42 +08:00
|
|
|
%tmp39 = load i8, i8* %tmp38, align 8 ; <i8> [#uses=1]
|
2009-11-12 03:48:59 +08:00
|
|
|
switch i8 %tmp39, label %bb2 [
|
|
|
|
i8 16, label %lvalue_p.exit4
|
|
|
|
i8 23, label %lvalue_p.exit4
|
|
|
|
]
|
|
|
|
|
|
|
|
bb2.i3: ; preds = %lvalue_p.exit
|
[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
|
|
|
%tmp40 = getelementptr inbounds %union.tree_node, %union.tree_node* %tmp21, i64 0, i32 0, i32 0, i64 8 ; <i8*> [#uses=1]
|
2009-11-12 03:48:59 +08:00
|
|
|
%tmp41 = bitcast i8* %tmp40 to %union.tree_node** ; <%union.tree_node**> [#uses=1]
|
2015-02-28 05:17:42 +08:00
|
|
|
%tmp42 = load %union.tree_node*, %union.tree_node** %tmp41, align 8 ; <%union.tree_node*> [#uses=1]
|
[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
|
|
|
%tmp43 = getelementptr inbounds %union.tree_node, %union.tree_node* %tmp42, i64 0, i32 0, i32 0, i64 16 ; <i8*> [#uses=1]
|
2015-02-28 05:17:42 +08:00
|
|
|
%tmp44 = load i8, i8* %tmp43, align 8 ; <i8> [#uses=1]
|
2009-11-12 03:48:59 +08:00
|
|
|
switch i8 %tmp44, label %bb2 [
|
|
|
|
i8 16, label %lvalue_p.exit4
|
|
|
|
i8 23, label %lvalue_p.exit4
|
|
|
|
]
|
|
|
|
|
|
|
|
lvalue_p.exit4: ; preds = %bb2.i3, %bb2.i3, %bb2.i.i2, %bb2.i.i2, %bb.i.i, %bb.i1, %lvalue_p.exit
|
|
|
|
%tmp45 = phi i1 [ %phitmp, %bb.i.i ], [ false, %bb2.i.i2 ], [ false, %bb2.i.i2 ], [ false, %bb.i1 ], [ false, %bb2.i3 ], [ false, %bb2.i3 ], [ false, %lvalue_p.exit ] ; <i1> [#uses=1]
|
|
|
|
%tmp46 = icmp eq i8 %tmp4, 0 ; <i1> [#uses=1]
|
|
|
|
%or.cond = or i1 %tmp45, %tmp46 ; <i1> [#uses=1]
|
|
|
|
br i1 %or.cond, label %bb2, label %bb3
|
|
|
|
|
|
|
|
bb1: ; preds = %bb2.i.i, %bb.i, %bb
|
|
|
|
%.old = icmp eq i8 %tmp4, 23 ; <i1> [#uses=1]
|
|
|
|
br i1 %.old, label %bb2, label %bb3
|
|
|
|
|
|
|
|
bb2: ; preds = %bb1, %lvalue_p.exit4, %bb2.i3, %bb2.i.i2
|
|
|
|
br label %bb3
|
|
|
|
|
|
|
|
bb3: ; preds = %bb2, %bb1, %lvalue_p.exit4, %bb2.i, %entry
|
|
|
|
%expr_addr.0 = phi %union.tree_node* [ null, %bb2 ], [ %expr, %bb2.i ], [ %expr, %entry ], [ %expr, %bb1 ], [ %expr, %lvalue_p.exit4 ] ; <%union.tree_node*> [#uses=0]
|
|
|
|
unreachable
|
|
|
|
}
|
|
|
|
|
|
|
|
declare fastcc i32 @lvalue_p(%union.tree_node* nocapture) nounwind readonly
|
|
|
|
|
|
|
|
declare fastcc %union.tree_node* @default_conversion(%union.tree_node*) nounwind
|
2009-11-12 08:39:10 +08:00
|
|
|
|
|
|
|
|
|
|
|
; If one tail merging candidate falls through into the other,
|
|
|
|
; tail merging is likely profitable regardless of how few
|
|
|
|
; instructions are involved. This function should have only
|
|
|
|
; one ret instruction.
|
|
|
|
|
2013-07-14 14:24:09 +08:00
|
|
|
; CHECK-LABEL: foo:
|
Instruction fixes, added instructions, and AsmString changes in the
X86 instruction tables.
Also (while I was at it) cleaned up the X86 tables, removing tabs and
80-line violations.
This patch was reviewed by Chris Lattner, but please let me know if
there are any problems.
* X86*.td
Removed tabs and fixed 80-line violations
* X86Instr64bit.td
(IRET, POPCNT, BT_, LSL, SWPGS, PUSH_S, POP_S, L_S, SMSW)
Added
(CALL, CMOV) Added qualifiers
(JMP) Added PC-relative jump instruction
(POPFQ/PUSHFQ) Added qualifiers; renamed PUSHFQ to indicate
that it is 64-bit only (ambiguous since it has no
REX prefix)
(MOV) Added rr form going the other way, which is encoded
differently
(MOV) Changed immediates to offsets, which is more correct;
also fixed MOV64o64a to have to a 64-bit offset
(MOV) Fixed qualifiers
(MOV) Added debug-register and condition-register moves
(MOVZX) Added more forms
(ADC, SUB, SBB, AND, OR, XOR) Added reverse forms, which
(as with MOV) are encoded differently
(ROL) Made REX.W required
(BT) Uncommented mr form for disassembly only
(CVT__2__) Added several missing non-intrinsic forms
(LXADD, XCHG) Reordered operands to make more sense for
MRMSrcMem
(XCHG) Added register-to-register forms
(XADD, CMPXCHG, XCHG) Added non-locked forms
* X86InstrSSE.td
(CVTSS2SI, COMISS, CVTTPS2DQ, CVTPS2PD, CVTPD2PS, MOVQ)
Added
* X86InstrFPStack.td
(COM_FST0, COMP_FST0, COM_FI, COM_FIP, FFREE, FNCLEX, FNOP,
FXAM, FLDL2T, FLDL2E, FLDPI, FLDLG2, FLDLN2, F2XM1, FYL2X,
FPTAN, FPATAN, FXTRACT, FPREM1, FDECSTP, FINCSTP, FPREM,
FYL2XP1, FSINCOS, FRNDINT, FSCALE, FCOMPP, FXSAVE,
FXRSTOR)
Added
(FCOM, FCOMP) Added qualifiers
(FSTENV, FSAVE, FSTSW) Fixed opcode names
(FNSTSW) Added implicit register operand
* X86InstrInfo.td
(opaque512mem) Added for FXSAVE/FXRSTOR
(offset8, offset16, offset32, offset64) Added for MOV
(NOOPW, IRET, POPCNT, IN, BTC, BTR, BTS, LSL, INVLPG, STR,
LTR, PUSHFS, PUSHGS, POPFS, POPGS, LDS, LSS, LES, LFS,
LGS, VERR, VERW, SGDT, SIDT, SLDT, LGDT, LIDT, LLDT,
LODSD, OUTSB, OUTSW, OUTSD, HLT, RSM, FNINIT, CLC, STC,
CLI, STI, CLD, STD, CMC, CLTS, XLAT, WRMSR, RDMSR, RDPMC,
SMSW, LMSW, CPUID, INVD, WBINVD, INVEPT, INVVPID, VMCALL,
VMCLEAR, VMLAUNCH, VMRESUME, VMPTRLD, VMPTRST, VMREAD,
VMWRITE, VMXOFF, VMXON) Added
(NOOPL, POPF, POPFD, PUSHF, PUSHFD) Added qualifier
(JO, JNO, JB, JAE, JE, JNE, JBE, JA, JS, JNS, JP, JNP, JL,
JGE, JLE, JG, JCXZ) Added 32-bit forms
(MOV) Changed some immediate forms to offset forms
(MOV) Added reversed reg-reg forms, which are encoded
differently
(MOV) Added debug-register and condition-register moves
(CMOV) Added qualifiers
(AND, OR, XOR, ADC, SUB, SBB) Added reverse forms, like MOV
(BT) Uncommented memory-register forms for disassembler
(MOVSX, MOVZX) Added forms
(XCHG, LXADD) Made operand order make sense for MRMSrcMem
(XCHG) Added register-register forms
(XADD, CMPXCHG) Added unlocked forms
* X86InstrMMX.td
(MMX_MOVD, MMV_MOVQ) Added forms
* X86InstrInfo.cpp: Changed PUSHFQ to PUSHFQ64 to reflect table
change
* X86RegisterInfo.td: Added debug and condition register sets
* x86-64-pic-3.ll: Fixed testcase to reflect call qualifier
* peep-test-3.ll: Fixed testcase to reflect test qualifier
* cmov.ll: Fixed testcase to reflect cmov qualifier
* loop-blocks.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-11.ll: Fixed testcase to reflect call qualifier
* 2009-11-04-SubregCoalescingBug.ll: Fixed testcase to reflect call
qualifier
* x86-64-pic-2.ll: Fixed testcase to reflect call qualifier
* live-out-reg-info.ll: Fixed testcase to reflect test qualifier
* tail-opts.ll: Fixed testcase to reflect call qualifiers
* x86-64-pic-10.ll: Fixed testcase to reflect call qualifier
* bss-pagealigned.ll: Fixed testcase to reflect call qualifier
* x86-64-pic-1.ll: Fixed testcase to reflect call qualifier
* widen_load-1.ll: Fixed testcase to reflect call qualifier
llvm-svn: 91638
2009-12-18 08:01:26 +08:00
|
|
|
; CHECK: callq func
|
2015-11-25 08:05:13 +08:00
|
|
|
; CHECK-NEXT: popq
|
2015-12-10 07:08:18 +08:00
|
|
|
; CHECK-NEXT: .LBB4_2:
|
2009-11-12 08:39:10 +08:00
|
|
|
; CHECK-NEXT: ret
|
|
|
|
|
|
|
|
define void @foo(i1* %V) nounwind {
|
|
|
|
entry:
|
|
|
|
%t0 = icmp eq i1* %V, null
|
|
|
|
br i1 %t0, label %return, label %bb
|
|
|
|
|
|
|
|
bb:
|
|
|
|
call void @func()
|
|
|
|
ret void
|
|
|
|
|
|
|
|
return:
|
|
|
|
ret void
|
|
|
|
}
|
|
|
|
|
|
|
|
declare void @func()
|
2009-11-14 05:02:15 +08:00
|
|
|
|
|
|
|
; one - One instruction may be tail-duplicated even with optsize.
|
|
|
|
|
2013-07-14 14:24:09 +08:00
|
|
|
; CHECK-LABEL: one:
|
2017-02-15 05:02:24 +08:00
|
|
|
; CHECK: j{{.*}} tail_call_me
|
|
|
|
; CHECK: j{{.*}} tail_call_me
|
2009-11-14 05:02:15 +08:00
|
|
|
|
|
|
|
@XYZ = external global i32
|
|
|
|
|
2017-02-15 05:02:24 +08:00
|
|
|
declare void @tail_call_me()
|
|
|
|
|
|
|
|
define void @one(i32 %v) nounwind optsize {
|
2009-11-14 05:02:15 +08:00
|
|
|
entry:
|
2017-02-15 05:02:24 +08:00
|
|
|
%0 = icmp eq i32 %v, 0
|
2009-11-14 05:02:15 +08:00
|
|
|
br i1 %0, label %bbx, label %bby
|
|
|
|
|
|
|
|
bby:
|
2017-02-15 05:02:24 +08:00
|
|
|
switch i32 %v, label %bb7 [
|
2009-11-14 05:02:15 +08:00
|
|
|
i32 16, label %return
|
|
|
|
]
|
|
|
|
|
|
|
|
bb7:
|
2017-02-15 05:02:24 +08:00
|
|
|
tail call void @tail_call_me()
|
|
|
|
ret void
|
2009-11-14 05:02:15 +08:00
|
|
|
|
|
|
|
bbx:
|
2017-02-15 05:02:24 +08:00
|
|
|
switch i32 %v, label %bb12 [
|
2009-11-14 05:02:15 +08:00
|
|
|
i32 128, label %return
|
|
|
|
]
|
|
|
|
|
|
|
|
bb12:
|
2017-02-15 05:02:24 +08:00
|
|
|
tail call void @tail_call_me()
|
|
|
|
ret void
|
2009-11-14 05:02:15 +08:00
|
|
|
|
|
|
|
return:
|
|
|
|
ret void
|
|
|
|
}
|
|
|
|
|
|
|
|
; two - Same as one, but with two instructions in the common
|
|
|
|
; tail instead of one. This is too much to be merged, given
|
|
|
|
; the optsize attribute.
|
|
|
|
|
2013-07-14 14:24:09 +08:00
|
|
|
; CHECK-LABEL: two:
|
2009-11-14 05:02:15 +08:00
|
|
|
; CHECK-NOT: XYZ
|
2012-04-16 21:49:17 +08:00
|
|
|
; CHECK: ret
|
2009-11-14 05:02:15 +08:00
|
|
|
; CHECK: movl $0, XYZ(%rip)
|
|
|
|
; CHECK: movl $1, XYZ(%rip)
|
|
|
|
; CHECK-NOT: XYZ
|
|
|
|
|
|
|
|
define void @two() nounwind optsize {
|
|
|
|
entry:
|
|
|
|
%0 = icmp eq i32 undef, 0
|
|
|
|
br i1 %0, label %bbx, label %bby
|
|
|
|
|
|
|
|
bby:
|
|
|
|
switch i32 undef, label %bb7 [
|
|
|
|
i32 16, label %return
|
|
|
|
]
|
|
|
|
|
|
|
|
bb7:
|
2011-11-27 14:54:59 +08:00
|
|
|
store volatile i32 0, i32* @XYZ
|
|
|
|
store volatile i32 1, i32* @XYZ
|
2009-11-14 05:02:15 +08:00
|
|
|
unreachable
|
|
|
|
|
|
|
|
bbx:
|
|
|
|
switch i32 undef, label %bb12 [
|
|
|
|
i32 128, label %return
|
|
|
|
]
|
|
|
|
|
|
|
|
bb12:
|
2011-11-27 14:54:59 +08:00
|
|
|
store volatile i32 0, i32* @XYZ
|
|
|
|
store volatile i32 1, i32* @XYZ
|
2009-11-14 05:02:15 +08:00
|
|
|
unreachable
|
|
|
|
|
|
|
|
return:
|
|
|
|
ret void
|
|
|
|
}
|
|
|
|
|
2015-08-11 07:07:26 +08:00
|
|
|
; two_minsize - Same as two, but with minsize instead of optsize.
|
|
|
|
|
|
|
|
; CHECK-LABEL: two_minsize:
|
|
|
|
; CHECK-NOT: XYZ
|
|
|
|
; CHECK: ret
|
2016-03-26 02:11:31 +08:00
|
|
|
; CHECK: andl $0, XYZ(%rip)
|
2015-08-11 07:07:26 +08:00
|
|
|
; CHECK: movl $1, XYZ(%rip)
|
|
|
|
; CHECK-NOT: XYZ
|
|
|
|
|
|
|
|
define void @two_minsize() nounwind minsize {
|
|
|
|
entry:
|
|
|
|
%0 = icmp eq i32 undef, 0
|
|
|
|
br i1 %0, label %bbx, label %bby
|
|
|
|
|
|
|
|
bby:
|
|
|
|
switch i32 undef, label %bb7 [
|
|
|
|
i32 16, label %return
|
|
|
|
]
|
|
|
|
|
|
|
|
bb7:
|
|
|
|
store volatile i32 0, i32* @XYZ
|
|
|
|
store volatile i32 1, i32* @XYZ
|
|
|
|
unreachable
|
|
|
|
|
|
|
|
bbx:
|
|
|
|
switch i32 undef, label %bb12 [
|
|
|
|
i32 128, label %return
|
|
|
|
]
|
|
|
|
|
|
|
|
bb12:
|
|
|
|
store volatile i32 0, i32* @XYZ
|
|
|
|
store volatile i32 1, i32* @XYZ
|
|
|
|
unreachable
|
|
|
|
|
|
|
|
return:
|
|
|
|
ret void
|
|
|
|
}
|
|
|
|
|
2009-11-14 05:02:15 +08:00
|
|
|
; two_nosize - Same as two, but without the optsize attribute.
|
|
|
|
; Now two instructions are enough to be tail-duplicated.
|
|
|
|
|
2013-07-14 14:24:09 +08:00
|
|
|
; CHECK-LABEL: two_nosize:
|
2009-11-14 05:02:15 +08:00
|
|
|
; CHECK: movl $0, XYZ(%rip)
|
2017-02-15 05:02:24 +08:00
|
|
|
; CHECK: jmp tail_call_me
|
2009-11-14 05:02:15 +08:00
|
|
|
; CHECK: movl $0, XYZ(%rip)
|
2017-02-15 05:02:24 +08:00
|
|
|
; CHECK: jmp tail_call_me
|
2009-11-14 05:02:15 +08:00
|
|
|
|
|
|
|
define void @two_nosize() nounwind {
|
|
|
|
entry:
|
|
|
|
%0 = icmp eq i32 undef, 0
|
|
|
|
br i1 %0, label %bbx, label %bby
|
|
|
|
|
|
|
|
bby:
|
|
|
|
switch i32 undef, label %bb7 [
|
|
|
|
i32 16, label %return
|
|
|
|
]
|
|
|
|
|
|
|
|
bb7:
|
2011-11-27 14:54:59 +08:00
|
|
|
store volatile i32 0, i32* @XYZ
|
2017-02-15 05:02:24 +08:00
|
|
|
tail call void @tail_call_me()
|
|
|
|
ret void
|
2009-11-14 05:02:15 +08:00
|
|
|
|
|
|
|
bbx:
|
|
|
|
switch i32 undef, label %bb12 [
|
|
|
|
i32 128, label %return
|
|
|
|
]
|
|
|
|
|
|
|
|
bb12:
|
2011-11-27 14:54:59 +08:00
|
|
|
store volatile i32 0, i32* @XYZ
|
2017-02-15 05:02:24 +08:00
|
|
|
tail call void @tail_call_me()
|
|
|
|
ret void
|
2009-11-14 05:02:15 +08:00
|
|
|
|
|
|
|
return:
|
|
|
|
ret void
|
|
|
|
}
|
2010-05-03 22:35:47 +08:00
|
|
|
|
|
|
|
; Tail-merging should merge the two ret instructions since one side
|
|
|
|
; can fall-through into the ret and the other side has to branch anyway.
|
|
|
|
|
2013-07-14 14:24:09 +08:00
|
|
|
; CHECK-LABEL: TESTE:
|
2011-05-05 07:54:51 +08:00
|
|
|
; CHECK: ret
|
|
|
|
; CHECK-NOT: ret
|
|
|
|
; CHECK: size TESTE
|
2010-05-03 22:35:47 +08:00
|
|
|
|
|
|
|
define i64 @TESTE(i64 %parami, i64 %paraml) nounwind readnone {
|
|
|
|
entry:
|
|
|
|
%cmp = icmp slt i64 %parami, 1 ; <i1> [#uses=1]
|
|
|
|
%varx.0 = select i1 %cmp, i64 1, i64 %parami ; <i64> [#uses=1]
|
|
|
|
%cmp410 = icmp slt i64 %paraml, 1 ; <i1> [#uses=1]
|
|
|
|
br i1 %cmp410, label %for.end, label %bb.nph
|
|
|
|
|
|
|
|
bb.nph: ; preds = %entry
|
|
|
|
%tmp15 = mul i64 %paraml, %parami ; <i64> [#uses=1]
|
|
|
|
ret i64 %tmp15
|
|
|
|
|
|
|
|
for.end: ; preds = %entry
|
|
|
|
ret i64 %varx.0
|
|
|
|
}
|
2017-02-15 05:02:24 +08:00
|
|
|
|
|
|
|
; We should tail merge small blocks that don't end in a tail call or return
|
|
|
|
; instruction. Those blocks are typically unreachable and will be placed
|
|
|
|
; out-of-line after the main return, so we should try to eliminate as many of
|
|
|
|
; them as possible.
|
|
|
|
|
|
|
|
; CHECK-LABEL: merge_aborts:
|
|
|
|
; CHECK-NOT: callq abort
|
|
|
|
; CHECK: ret
|
|
|
|
; CHECK: callq abort
|
|
|
|
; CHECK-NOT: callq abort
|
|
|
|
; CHECK: .Lfunc_end{{.*}}:
|
|
|
|
|
|
|
|
declare void @abort()
|
|
|
|
define void @merge_aborts() {
|
|
|
|
entry:
|
|
|
|
%c1 = call i1 @qux()
|
|
|
|
br i1 %c1, label %cont1, label %abort1
|
|
|
|
abort1:
|
|
|
|
call void @abort()
|
|
|
|
unreachable
|
|
|
|
cont1:
|
|
|
|
%c2 = call i1 @qux()
|
|
|
|
br i1 %c2, label %cont2, label %abort2
|
|
|
|
abort2:
|
|
|
|
call void @abort()
|
|
|
|
unreachable
|
|
|
|
cont2:
|
|
|
|
%c3 = call i1 @qux()
|
|
|
|
br i1 %c3, label %cont3, label %abort3
|
|
|
|
abort3:
|
|
|
|
call void @abort()
|
|
|
|
unreachable
|
|
|
|
cont3:
|
|
|
|
%c4 = call i1 @qux()
|
|
|
|
br i1 %c4, label %cont4, label %abort4
|
|
|
|
abort4:
|
|
|
|
call void @abort()
|
|
|
|
unreachable
|
|
|
|
cont4:
|
|
|
|
ret void
|
|
|
|
}
|
|
|
|
|
|
|
|
; Use alternating abort functions so that the blocks we wish to merge are not
|
|
|
|
; layout successors during branch folding.
|
|
|
|
|
|
|
|
; CHECK-LABEL: merge_alternating_aborts:
|
|
|
|
; CHECK-NOT: callq abort
|
|
|
|
; CHECK: ret
|
|
|
|
; CHECK: callq abort
|
|
|
|
; CHECK: callq alt_abort
|
|
|
|
; CHECK-NOT: callq abort
|
|
|
|
; CHECK-NOT: callq alt_abort
|
|
|
|
; CHECK: .Lfunc_end{{.*}}:
|
|
|
|
|
|
|
|
declare void @alt_abort()
|
|
|
|
|
|
|
|
define void @merge_alternating_aborts() {
|
|
|
|
entry:
|
|
|
|
%c1 = call i1 @qux()
|
|
|
|
br i1 %c1, label %cont1, label %abort1
|
|
|
|
abort1:
|
|
|
|
call void @abort()
|
|
|
|
unreachable
|
|
|
|
cont1:
|
|
|
|
%c2 = call i1 @qux()
|
|
|
|
br i1 %c2, label %cont2, label %abort2
|
|
|
|
abort2:
|
|
|
|
call void @alt_abort()
|
|
|
|
unreachable
|
|
|
|
cont2:
|
|
|
|
%c3 = call i1 @qux()
|
|
|
|
br i1 %c3, label %cont3, label %abort3
|
|
|
|
abort3:
|
|
|
|
call void @abort()
|
|
|
|
unreachable
|
|
|
|
cont3:
|
|
|
|
%c4 = call i1 @qux()
|
|
|
|
br i1 %c4, label %cont4, label %abort4
|
|
|
|
abort4:
|
|
|
|
call void @alt_abort()
|
|
|
|
unreachable
|
|
|
|
cont4:
|
|
|
|
ret void
|
|
|
|
}
|