2002-05-02 19:01:39 +02:00
|
|
|
; Tests to make sure elimination of casts is working correctly
|
2009-10-12 09:18:14 +02:00
|
|
|
; RUN: opt < %s -instcombine -S | FileCheck %s
|
2014-02-14 01:49:12 +01:00
|
|
|
target datalayout = "E-p:64:64:64-p1:32:32:32-p2:64:64:64-p3: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-n8:16:32:64"
|
2002-05-02 19:01:39 +02:00
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
@inbuf = external global [32832 x i8] ; <[32832 x i8]*> [#uses=1]
|
2004-02-22 06:24:09 +01:00
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i32 @test1(i32 %A) {
|
|
|
|
|
%c1 = bitcast i32 %A to i32 ; <i32> [#uses=1]
|
|
|
|
|
%c2 = bitcast i32 %c1 to i32 ; <i32> [#uses=1]
|
|
|
|
|
ret i32 %c2
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: ret i32 %A
|
2002-08-02 20:48:09 +02:00
|
|
|
}
|
2002-05-02 19:01:39 +02:00
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i64 @test2(i8 %A) {
|
|
|
|
|
%c1 = zext i8 %A to i16 ; <i16> [#uses=1]
|
|
|
|
|
%c2 = zext i16 %c1 to i32 ; <i32> [#uses=1]
|
|
|
|
|
%Ret = zext i32 %c2 to i64 ; <i64> [#uses=1]
|
|
|
|
|
ret i64 %Ret
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: %Ret = zext i8 %A to i64
|
|
|
|
|
; CHECK: ret i64 %Ret
|
2002-08-02 20:48:09 +02:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
; This function should just use bitwise AND
|
|
|
|
|
define i64 @test3(i64 %A) {
|
|
|
|
|
%c1 = trunc i64 %A to i8 ; <i8> [#uses=1]
|
|
|
|
|
%c2 = zext i8 %c1 to i64 ; <i64> [#uses=1]
|
|
|
|
|
ret i64 %c2
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: %c2 = and i64 %A, 255
|
|
|
|
|
; CHECK: ret i64 %c2
|
2002-08-02 20:48:09 +02:00
|
|
|
}
|
2002-08-15 18:13:29 +02:00
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i32 @test4(i32 %A, i32 %B) {
|
|
|
|
|
%COND = icmp slt i32 %A, %B ; <i1> [#uses=1]
|
|
|
|
|
; Booleans are unsigned integrals
|
|
|
|
|
%c = zext i1 %COND to i8 ; <i8> [#uses=1]
|
|
|
|
|
; for the cast elim purpose
|
|
|
|
|
%result = zext i8 %c to i32 ; <i32> [#uses=1]
|
|
|
|
|
ret i32 %result
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: %COND = icmp slt i32 %A, %B
|
|
|
|
|
; CHECK: %result = zext i1 %COND to i32
|
|
|
|
|
; CHECK: ret i32 %result
|
2002-08-15 18:13:29 +02:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i32 @test5(i1 %B) {
|
|
|
|
|
; This cast should get folded into
|
|
|
|
|
%c = zext i1 %B to i8 ; <i8> [#uses=1]
|
|
|
|
|
; this cast
|
|
|
|
|
%result = zext i8 %c to i32 ; <i32> [#uses=1]
|
|
|
|
|
ret i32 %result
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: %result = zext i1 %B to i32
|
|
|
|
|
; CHECK: ret i32 %result
|
2002-08-15 18:13:29 +02:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i32 @test6(i64 %A) {
|
|
|
|
|
%c1 = trunc i64 %A to i32 ; <i32> [#uses=1]
|
|
|
|
|
%res = bitcast i32 %c1 to i32 ; <i32> [#uses=1]
|
|
|
|
|
ret i32 %res
|
2010-01-05 23:21:18 +01:00
|
|
|
; CHECK: trunc i64 %A to i32
|
|
|
|
|
; CHECK-NEXT: ret i32
|
2002-08-15 18:13:29 +02:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i64 @test7(i1 %A) {
|
|
|
|
|
%c1 = zext i1 %A to i32 ; <i32> [#uses=1]
|
|
|
|
|
%res = sext i32 %c1 to i64 ; <i64> [#uses=1]
|
|
|
|
|
ret i64 %res
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: %res = zext i1 %A to i64
|
|
|
|
|
; CHECK: ret i64 %res
|
2002-08-15 18:13:29 +02:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i64 @test8(i8 %A) {
|
|
|
|
|
%c1 = sext i8 %A to i64 ; <i64> [#uses=1]
|
|
|
|
|
%res = bitcast i64 %c1 to i64 ; <i64> [#uses=1]
|
|
|
|
|
ret i64 %res
|
2010-01-05 23:21:18 +01:00
|
|
|
; CHECK: = sext i8 %A to i64
|
|
|
|
|
; CHECK-NEXT: ret i64
|
2002-08-15 18:13:29 +02:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i16 @test9(i16 %A) {
|
|
|
|
|
%c1 = sext i16 %A to i32 ; <i32> [#uses=1]
|
|
|
|
|
%c2 = trunc i32 %c1 to i16 ; <i16> [#uses=1]
|
|
|
|
|
ret i16 %c2
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: ret i16 %A
|
2002-09-24 01:39:17 +02:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i16 @test10(i16 %A) {
|
|
|
|
|
%c1 = sext i16 %A to i32 ; <i32> [#uses=1]
|
|
|
|
|
%c2 = trunc i32 %c1 to i16 ; <i16> [#uses=1]
|
|
|
|
|
ret i16 %c2
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: ret i16 %A
|
2002-09-24 01:39:17 +02:00
|
|
|
}
|
2003-06-23 23:48:26 +02:00
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
declare void @varargs(i32, ...)
|
2003-10-08 00:53:46 +02:00
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define void @test11(i32* %P) {
|
|
|
|
|
%c = bitcast i32* %P to i16* ; <i16*> [#uses=1]
|
[opaque pointer type] Add textual IR support for explicit type parameter to the call instruction
See r230786 and r230794 for similar changes to gep and load
respectively.
Call is a bit different because it often doesn't have a single explicit
type - usually the type is deduced from the arguments, and just the
return type is explicit. In those cases there's no need to change the
IR.
When that's not the case, the IR usually contains the pointer type of
the first operand - but since typed pointers are going away, that
representation is insufficient so I'm just stripping the "pointerness"
of the explicit type away.
This does make the IR a bit weird - it /sort of/ reads like the type of
the first operand: "call void () %x(" but %x is actually of type "void
()*" and will eventually be just of type "ptr". But this seems not too
bad and I don't think it would benefit from repeating the type
("void (), void () * %x(" and then eventually "void (), ptr %x(") as has
been done with gep and load.
This also has a side benefit: since the explicit type is no longer a
pointer, there's no ambiguity between an explicit type and a function
that returns a function pointer. Previously this case needed an explicit
type (eg: a function returning a void() function was written as
"call void () () * @x(" rather than "call void () * @x(" because of the
ambiguity between a function returning a pointer to a void() function
and a function returning void).
No ambiguity means even function pointer return types can just be
written alone, without writing the whole function's type.
This leaves /only/ the varargs case where the explicit type is required.
Given the special type syntax in call instructions, the regex-fu used
for migration was a bit more involved in its own unique way (as every
one of these is) so here it is. Use it in conjunction with the apply.sh
script and associated find/xargs commands I've provided in rr230786 to
migrate your out of tree tests. Do let me know if any of this doesn't
cover your cases & we can iterate on a more general script/regexes to
help others with out of tree tests.
About 9 test cases couldn't be automatically migrated - half of those
were functions returning function pointers, where I just had to manually
delete the function argument types now that we didn't need an explicit
function type there. The other half were typedefs of function types used
in calls - just had to manually drop the * from those.
import fileinput
import sys
import re
pat = re.compile(r'((?:=|:|^|\s)call\s(?:[^@]*?))(\s*$|\s*(?:(?:\[\[[a-zA-Z0-9_]+\]\]|[@%](?:(")?[\\\?@a-zA-Z0-9_.]*?(?(3)"|)|{{.*}}))(?:\(|$)|undef|inttoptr|bitcast|null|asm).*$)')
addrspace_end = re.compile(r"addrspace\(\d+\)\s*\*$")
func_end = re.compile("(?:void.*|\)\s*)\*$")
def conv(match, line):
if not match or re.search(addrspace_end, match.group(1)) or not re.search(func_end, match.group(1)):
return line
return line[:match.start()] + match.group(1)[:match.group(1).rfind('*')].rstrip() + match.group(2) + line[match.end():]
for line in sys.stdin:
sys.stdout.write(conv(re.search(pat, line), line))
llvm-svn: 235145
2015-04-17 01:24:18 +02:00
|
|
|
call void (i32, ...) @varargs( i32 5, i16* %c )
|
2008-03-25 05:26:08 +01:00
|
|
|
ret void
|
[opaque pointer type] Add textual IR support for explicit type parameter to the call instruction
See r230786 and r230794 for similar changes to gep and load
respectively.
Call is a bit different because it often doesn't have a single explicit
type - usually the type is deduced from the arguments, and just the
return type is explicit. In those cases there's no need to change the
IR.
When that's not the case, the IR usually contains the pointer type of
the first operand - but since typed pointers are going away, that
representation is insufficient so I'm just stripping the "pointerness"
of the explicit type away.
This does make the IR a bit weird - it /sort of/ reads like the type of
the first operand: "call void () %x(" but %x is actually of type "void
()*" and will eventually be just of type "ptr". But this seems not too
bad and I don't think it would benefit from repeating the type
("void (), void () * %x(" and then eventually "void (), ptr %x(") as has
been done with gep and load.
This also has a side benefit: since the explicit type is no longer a
pointer, there's no ambiguity between an explicit type and a function
that returns a function pointer. Previously this case needed an explicit
type (eg: a function returning a void() function was written as
"call void () () * @x(" rather than "call void () * @x(" because of the
ambiguity between a function returning a pointer to a void() function
and a function returning void).
No ambiguity means even function pointer return types can just be
written alone, without writing the whole function's type.
This leaves /only/ the varargs case where the explicit type is required.
Given the special type syntax in call instructions, the regex-fu used
for migration was a bit more involved in its own unique way (as every
one of these is) so here it is. Use it in conjunction with the apply.sh
script and associated find/xargs commands I've provided in rr230786 to
migrate your out of tree tests. Do let me know if any of this doesn't
cover your cases & we can iterate on a more general script/regexes to
help others with out of tree tests.
About 9 test cases couldn't be automatically migrated - half of those
were functions returning function pointers, where I just had to manually
delete the function argument types now that we didn't need an explicit
function type there. The other half were typedefs of function types used
in calls - just had to manually drop the * from those.
import fileinput
import sys
import re
pat = re.compile(r'((?:=|:|^|\s)call\s(?:[^@]*?))(\s*$|\s*(?:(?:\[\[[a-zA-Z0-9_]+\]\]|[@%](?:(")?[\\\?@a-zA-Z0-9_.]*?(?(3)"|)|{{.*}}))(?:\(|$)|undef|inttoptr|bitcast|null|asm).*$)')
addrspace_end = re.compile(r"addrspace\(\d+\)\s*\*$")
func_end = re.compile("(?:void.*|\)\s*)\*$")
def conv(match, line):
if not match or re.search(addrspace_end, match.group(1)) or not re.search(func_end, match.group(1)):
return line
return line[:match.start()] + match.group(1)[:match.group(1).rfind('*')].rstrip() + match.group(2) + line[match.end():]
for line in sys.stdin:
sys.stdout.write(conv(re.search(pat, line), line))
llvm-svn: 235145
2015-04-17 01:24:18 +02:00
|
|
|
; CHECK: call void (i32, ...) @varargs(i32 5, i32* %P)
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: ret void
|
2003-10-08 00:53:46 +02:00
|
|
|
}
|
2003-11-02 06:56:58 +01:00
|
|
|
|
2014-12-04 20:13:45 +01:00
|
|
|
declare i32 @__gxx_personality_v0(...)
|
2015-06-17 22:52:32 +02:00
|
|
|
define void @test_invoke_vararg_cast(i32* %a, i32* %b) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
|
2014-12-04 20:13:45 +01:00
|
|
|
entry:
|
|
|
|
|
%0 = bitcast i32* %b to i8*
|
|
|
|
|
%1 = bitcast i32* %a to i64*
|
2015-04-24 21:32:54 +02:00
|
|
|
invoke void (i32, ...) @varargs(i32 1, i8* %0, i64* %1)
|
2014-12-04 20:13:45 +01:00
|
|
|
to label %invoke.cont unwind label %lpad
|
|
|
|
|
|
|
|
|
|
invoke.cont: ; preds = %entry
|
|
|
|
|
ret void
|
|
|
|
|
|
|
|
|
|
lpad: ; preds = %entry
|
2015-06-17 22:52:32 +02:00
|
|
|
%2 = landingpad { i8*, i32 }
|
2014-12-04 20:13:45 +01:00
|
|
|
cleanup
|
|
|
|
|
ret void
|
|
|
|
|
; CHECK-LABEL: test_invoke_vararg_cast
|
|
|
|
|
; CHECK-LABEL: entry:
|
2015-04-24 21:32:54 +02:00
|
|
|
; CHECK: invoke void (i32, ...) @varargs(i32 1, i32* %b, i32* %a)
|
2014-12-04 20:13:45 +01:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i8* @test13(i64 %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-27 20:29:02 +01:00
|
|
|
%c = getelementptr [0 x i8], [0 x i8]* bitcast ([32832 x i8]* @inbuf to [0 x i8]*), i64 0, i64 %A ; <i8*> [#uses=1]
|
2008-03-25 05:26:08 +01:00
|
|
|
ret i8* %c
|
[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-27 20:29:02 +01:00
|
|
|
; CHECK: %c = getelementptr [32832 x i8], [32832 x i8]* @inbuf, i64 0, i64 %A
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: ret i8* %c
|
2004-02-22 06:24:09 +01:00
|
|
|
}
|
2004-02-23 08:16:03 +01:00
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i1 @test14(i8 %A) {
|
|
|
|
|
%c = bitcast i8 %A to i8 ; <i8> [#uses=1]
|
|
|
|
|
%X = icmp ult i8 %c, -128 ; <i1> [#uses=1]
|
|
|
|
|
ret i1 %X
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: %X = icmp sgt i8 %A, -1
|
|
|
|
|
; CHECK: ret i1 %X
|
2004-02-23 08:16:03 +01:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
|
2006-12-23 07:05:41 +01:00
|
|
|
; This just won't occur when there's no difference between ubyte and sbyte
|
|
|
|
|
;bool %test15(ubyte %A) {
|
|
|
|
|
; %c = cast ubyte %A to sbyte
|
|
|
|
|
; %X = setlt sbyte %c, 0 ; setgt %A, 127
|
|
|
|
|
; ret bool %X
|
|
|
|
|
;}
|
2004-02-23 08:16:03 +01:00
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i1 @test16(i32* %P) {
|
|
|
|
|
%c = icmp ne i32* %P, null ; <i1> [#uses=1]
|
|
|
|
|
ret i1 %c
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: %c = icmp ne i32* %P, null
|
|
|
|
|
; CHECK: ret i1 %c
|
2004-05-25 06:28:43 +02:00
|
|
|
}
|
2004-07-20 02:57:21 +02:00
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i16 @test17(i1 %tmp3) {
|
|
|
|
|
%c = zext i1 %tmp3 to i32 ; <i32> [#uses=1]
|
|
|
|
|
%t86 = trunc i32 %c to i16 ; <i16> [#uses=1]
|
|
|
|
|
ret i16 %t86
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: %t86 = zext i1 %tmp3 to i16
|
|
|
|
|
; CHECK: ret i16 %t86
|
2004-07-20 02:57:21 +02:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i16 @test18(i8 %tmp3) {
|
|
|
|
|
%c = sext i8 %tmp3 to i32 ; <i32> [#uses=1]
|
|
|
|
|
%t86 = trunc i32 %c to i16 ; <i16> [#uses=1]
|
|
|
|
|
ret i16 %t86
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: %t86 = sext i8 %tmp3 to i16
|
|
|
|
|
; CHECK: ret i16 %t86
|
2004-07-20 02:57:21 +02:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i1 @test19(i32 %X) {
|
|
|
|
|
%c = sext i32 %X to i64 ; <i64> [#uses=1]
|
|
|
|
|
%Z = icmp slt i64 %c, 12345 ; <i1> [#uses=1]
|
|
|
|
|
ret i1 %Z
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: %Z = icmp slt i32 %X, 12345
|
|
|
|
|
; CHECK: ret i1 %Z
|
2004-09-29 05:18:20 +02:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i1 @test20(i1 %B) {
|
|
|
|
|
%c = zext i1 %B to i32 ; <i32> [#uses=1]
|
|
|
|
|
%D = icmp slt i32 %c, -1 ; <i1> [#uses=1]
|
|
|
|
|
;; false
|
|
|
|
|
ret i1 %D
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: ret i1 false
|
2004-09-29 05:18:20 +02:00
|
|
|
}
|
2005-01-01 17:13:43 +01:00
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i32 @test21(i32 %X) {
|
|
|
|
|
%c1 = trunc i32 %X to i8 ; <i8> [#uses=1]
|
|
|
|
|
;; sext -> zext -> and -> nop
|
|
|
|
|
%c2 = sext i8 %c1 to i32 ; <i32> [#uses=1]
|
|
|
|
|
%RV = and i32 %c2, 255 ; <i32> [#uses=1]
|
|
|
|
|
ret i32 %RV
|
2015-05-12 18:47:30 +02:00
|
|
|
; CHECK: %c2.1 = and i32 %X, 255
|
|
|
|
|
; CHECK: ret i32 %c2.1
|
2005-01-01 17:13:43 +01:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i32 @test22(i32 %X) {
|
|
|
|
|
%c1 = trunc i32 %X to i8 ; <i8> [#uses=1]
|
|
|
|
|
;; sext -> zext -> and -> nop
|
|
|
|
|
%c2 = sext i8 %c1 to i32 ; <i32> [#uses=1]
|
|
|
|
|
%RV = shl i32 %c2, 24 ; <i32> [#uses=1]
|
|
|
|
|
ret i32 %RV
|
2010-01-10 08:40:50 +01:00
|
|
|
; CHECK: shl i32 %X, 24
|
|
|
|
|
; CHECK-NEXT: ret i32
|
2005-01-01 17:13:43 +01:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i32 @test23(i32 %X) {
|
|
|
|
|
;; Turn into an AND even though X
|
|
|
|
|
%c1 = trunc i32 %X to i16 ; <i16> [#uses=1]
|
|
|
|
|
;; and Z are signed.
|
|
|
|
|
%c2 = zext i16 %c1 to i32 ; <i32> [#uses=1]
|
|
|
|
|
ret i32 %c2
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: %c2 = and i32 %X, 65535
|
|
|
|
|
; CHECK: ret i32 %c2
|
2005-01-01 17:13:43 +01:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i1 @test24(i1 %C) {
|
|
|
|
|
%X = select i1 %C, i32 14, i32 1234 ; <i32> [#uses=1]
|
|
|
|
|
;; Fold cast into select
|
|
|
|
|
%c = icmp ne i32 %X, 0 ; <i1> [#uses=1]
|
|
|
|
|
ret i1 %c
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: ret i1 true
|
2005-01-01 17:13:43 +01:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i32 @test26(float %F) {
|
|
|
|
|
;; no need to cast from float->double.
|
|
|
|
|
%c = fpext float %F to double ; <double> [#uses=1]
|
|
|
|
|
%D = fptosi double %c to i32 ; <i32> [#uses=1]
|
|
|
|
|
ret i32 %D
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: %D = fptosi float %F to i32
|
|
|
|
|
; CHECK: ret i32 %D
|
2006-01-19 08:39:20 +01:00
|
|
|
}
|
2006-04-12 20:07:41 +02:00
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define [4 x float]* @test27([9 x [4 x float]]* %A) {
|
|
|
|
|
%c = bitcast [9 x [4 x float]]* %A to [4 x float]* ; <[4 x float]*> [#uses=1]
|
|
|
|
|
ret [4 x float]* %c
|
[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-27 20:29:02 +01:00
|
|
|
; CHECK: %c = getelementptr inbounds [9 x [4 x float]], [9 x [4 x float]]* %A, i64 0, i64 0
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: ret [4 x float]* %c
|
2006-04-12 20:07:41 +02:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define float* @test28([4 x float]* %A) {
|
|
|
|
|
%c = bitcast [4 x float]* %A to float* ; <float*> [#uses=1]
|
|
|
|
|
ret float* %c
|
[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-27 20:29:02 +01:00
|
|
|
; CHECK: %c = getelementptr inbounds [4 x float], [4 x float]* %A, i64 0, i64 0
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: ret float* %c
|
2006-04-12 20:07:41 +02:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i32 @test29(i32 %c1, i32 %c2) {
|
|
|
|
|
%tmp1 = trunc i32 %c1 to i8 ; <i8> [#uses=1]
|
|
|
|
|
%tmp4.mask = trunc i32 %c2 to i8 ; <i8> [#uses=1]
|
|
|
|
|
%tmp = or i8 %tmp4.mask, %tmp1 ; <i8> [#uses=1]
|
|
|
|
|
%tmp10 = zext i8 %tmp to i32 ; <i32> [#uses=1]
|
|
|
|
|
ret i32 %tmp10
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: %tmp2 = or i32 %c2, %c1
|
|
|
|
|
; CHECK: %tmp10 = and i32 %tmp2, 255
|
|
|
|
|
; CHECK: ret i32 %tmp10
|
2006-05-05 08:38:40 +02:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i32 @test30(i32 %c1) {
|
|
|
|
|
%c2 = trunc i32 %c1 to i8 ; <i8> [#uses=1]
|
|
|
|
|
%c3 = xor i8 %c2, 1 ; <i8> [#uses=1]
|
|
|
|
|
%c4 = zext i8 %c3 to i32 ; <i32> [#uses=1]
|
|
|
|
|
ret i32 %c4
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: %c3 = and i32 %c1, 255
|
|
|
|
|
; CHECK: %c4 = xor i32 %c3, 1
|
|
|
|
|
; CHECK: ret i32 %c4
|
2006-05-13 04:00:07 +02:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i1 @test31(i64 %A) {
|
|
|
|
|
%B = trunc i64 %A to i32 ; <i32> [#uses=1]
|
|
|
|
|
%C = and i32 %B, 42 ; <i32> [#uses=1]
|
|
|
|
|
%D = icmp eq i32 %C, 10 ; <i1> [#uses=1]
|
|
|
|
|
ret i1 %D
|
2011-06-13 00:47:53 +02:00
|
|
|
; CHECK: %C = and i64 %A, 42
|
|
|
|
|
; CHECK: %D = icmp eq i64 %C, 10
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: ret i1 %D
|
2006-09-18 07:25:10 +02:00
|
|
|
}
|
2006-05-13 04:00:07 +02:00
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i32 @test33(i32 %c1) {
|
|
|
|
|
%x = bitcast i32 %c1 to float ; <float> [#uses=1]
|
|
|
|
|
%y = bitcast float %x to i32 ; <i32> [#uses=1]
|
|
|
|
|
ret i32 %y
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: ret i32 %c1
|
2006-11-27 02:05:10 +01:00
|
|
|
}
|
2006-11-29 08:03:00 +01:00
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i16 @test34(i16 %a) {
|
|
|
|
|
%c1 = zext i16 %a to i32 ; <i32> [#uses=1]
|
|
|
|
|
%tmp21 = lshr i32 %c1, 8 ; <i32> [#uses=1]
|
|
|
|
|
%c2 = trunc i32 %tmp21 to i16 ; <i16> [#uses=1]
|
|
|
|
|
ret i16 %c2
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: %tmp21 = lshr i16 %a, 8
|
|
|
|
|
; CHECK: ret i16 %tmp21
|
2006-11-29 08:03:00 +01:00
|
|
|
}
|
|
|
|
|
|
2008-03-25 05:26:08 +01:00
|
|
|
define i16 @test35(i16 %a) {
|
|
|
|
|
%c1 = bitcast i16 %a to i16 ; <i16> [#uses=1]
|
|
|
|
|
%tmp2 = lshr i16 %c1, 8 ; <i16> [#uses=1]
|
|
|
|
|
%c2 = bitcast i16 %tmp2 to i16 ; <i16> [#uses=1]
|
|
|
|
|
ret i16 %c2
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: %tmp2 = lshr i16 %a, 8
|
|
|
|
|
; CHECK: ret i16 %tmp2
|
2006-11-29 08:17:32 +01:00
|
|
|
}
|
|
|
|
|
|
Implement rdar://6480391, extending of equality icmp's to avoid a truncation.
I noticed this in the code compiled for a routine using std::map, which produced
this code:
%25 = tail call i32 @memcmp(i8* %24, i8* %23, i32 6) nounwind readonly
%.lobit.i = lshr i32 %25, 31 ; <i32> [#uses=1]
%tmp.i = trunc i32 %.lobit.i to i8 ; <i8> [#uses=1]
%toBool = icmp eq i8 %tmp.i, 0 ; <i1> [#uses=1]
br i1 %toBool, label %bb3, label %bb4
which compiled to:
call L_memcmp$stub
shrl $31, %eax
testb %al, %al
jne LBB1_11 ##
with this change, we compile it to:
call L_memcmp$stub
testl %eax, %eax
js LBB1_11
This triggers all the time in common code, with patters like this:
%169 = and i32 %ply, 1 ; <i32> [#uses=1]
%170 = trunc i32 %169 to i8 ; <i8> [#uses=1]
%toBool = icmp ne i8 %170, 0 ; <i1> [#uses=1]
%7 = lshr i32 %6, 24 ; <i32> [#uses=1]
%9 = trunc i32 %7 to i8 ; <i8> [#uses=1]
%10 = icmp ne i8 %9, 0 ; <i1> [#uses=1]
etc
llvm-svn: 61985
2009-01-09 08:47:06 +01:00
|
|
|
; icmp sgt i32 %a, -1
|
|
|
|
|
; rdar://6480391
|
|
|
|
|
define i1 @test36(i32 %a) {
|
|
|
|
|
%b = lshr i32 %a, 31
|
|
|
|
|
%c = trunc i32 %b to i8
|
|
|
|
|
%d = icmp eq i8 %c, 0
|
|
|
|
|
ret i1 %d
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: %d = icmp sgt i32 %a, -1
|
|
|
|
|
; CHECK: ret i1 %d
|
Implement rdar://6480391, extending of equality icmp's to avoid a truncation.
I noticed this in the code compiled for a routine using std::map, which produced
this code:
%25 = tail call i32 @memcmp(i8* %24, i8* %23, i32 6) nounwind readonly
%.lobit.i = lshr i32 %25, 31 ; <i32> [#uses=1]
%tmp.i = trunc i32 %.lobit.i to i8 ; <i8> [#uses=1]
%toBool = icmp eq i8 %tmp.i, 0 ; <i1> [#uses=1]
br i1 %toBool, label %bb3, label %bb4
which compiled to:
call L_memcmp$stub
shrl $31, %eax
testb %al, %al
jne LBB1_11 ##
with this change, we compile it to:
call L_memcmp$stub
testl %eax, %eax
js LBB1_11
This triggers all the time in common code, with patters like this:
%169 = and i32 %ply, 1 ; <i32> [#uses=1]
%170 = trunc i32 %169 to i8 ; <i8> [#uses=1]
%toBool = icmp ne i8 %170, 0 ; <i1> [#uses=1]
%7 = lshr i32 %6, 24 ; <i32> [#uses=1]
%9 = trunc i32 %7 to i8 ; <i8> [#uses=1]
%10 = icmp ne i8 %9, 0 ; <i1> [#uses=1]
etc
llvm-svn: 61985
2009-01-09 08:47:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; ret i1 false
|
|
|
|
|
define i1 @test37(i32 %a) {
|
|
|
|
|
%b = lshr i32 %a, 31
|
|
|
|
|
%c = or i32 %b, 512
|
|
|
|
|
%d = trunc i32 %c to i8
|
|
|
|
|
%e = icmp eq i8 %d, 11
|
|
|
|
|
ret i1 %e
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: ret i1 false
|
Implement rdar://6480391, extending of equality icmp's to avoid a truncation.
I noticed this in the code compiled for a routine using std::map, which produced
this code:
%25 = tail call i32 @memcmp(i8* %24, i8* %23, i32 6) nounwind readonly
%.lobit.i = lshr i32 %25, 31 ; <i32> [#uses=1]
%tmp.i = trunc i32 %.lobit.i to i8 ; <i8> [#uses=1]
%toBool = icmp eq i8 %tmp.i, 0 ; <i1> [#uses=1]
br i1 %toBool, label %bb3, label %bb4
which compiled to:
call L_memcmp$stub
shrl $31, %eax
testb %al, %al
jne LBB1_11 ##
with this change, we compile it to:
call L_memcmp$stub
testl %eax, %eax
js LBB1_11
This triggers all the time in common code, with patters like this:
%169 = and i32 %ply, 1 ; <i32> [#uses=1]
%170 = trunc i32 %169 to i8 ; <i8> [#uses=1]
%toBool = icmp ne i8 %170, 0 ; <i1> [#uses=1]
%7 = lshr i32 %6, 24 ; <i32> [#uses=1]
%9 = trunc i32 %7 to i8 ; <i8> [#uses=1]
%10 = icmp ne i8 %9, 0 ; <i1> [#uses=1]
etc
llvm-svn: 61985
2009-01-09 08:47:06 +01:00
|
|
|
}
|
|
|
|
|
|
2009-01-16 03:11:43 +01:00
|
|
|
define i64 @test38(i32 %a) {
|
|
|
|
|
%1 = icmp eq i32 %a, -2
|
|
|
|
|
%2 = zext i1 %1 to i8
|
|
|
|
|
%3 = xor i8 %2, 1
|
|
|
|
|
%4 = zext i8 %3 to i64
|
|
|
|
|
ret i64 %4
|
2009-10-12 09:18:14 +02:00
|
|
|
; CHECK: %1 = icmp ne i32 %a, -2
|
|
|
|
|
; CHECK: %2 = zext i1 %1 to i64
|
|
|
|
|
; CHECK: ret i64 %2
|
2009-01-16 03:11:43 +01:00
|
|
|
}
|
2010-01-05 22:48:13 +01:00
|
|
|
|
|
|
|
|
define i16 @test39(i16 %a) {
|
|
|
|
|
%tmp = zext i16 %a to i32
|
|
|
|
|
%tmp21 = lshr i32 %tmp, 8
|
|
|
|
|
%tmp5 = shl i32 %tmp, 8
|
|
|
|
|
%tmp.upgrd.32 = or i32 %tmp21, %tmp5
|
|
|
|
|
%tmp.upgrd.3 = trunc i32 %tmp.upgrd.32 to i16
|
|
|
|
|
ret i16 %tmp.upgrd.3
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test39(
|
2010-01-05 22:48:13 +01:00
|
|
|
; CHECK: %tmp.upgrd.32 = call i16 @llvm.bswap.i16(i16 %a)
|
|
|
|
|
; CHECK: ret i16 %tmp.upgrd.32
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define i16 @test40(i16 %a) {
|
|
|
|
|
%tmp = zext i16 %a to i32
|
|
|
|
|
%tmp21 = lshr i32 %tmp, 9
|
|
|
|
|
%tmp5 = shl i32 %tmp, 8
|
|
|
|
|
%tmp.upgrd.32 = or i32 %tmp21, %tmp5
|
|
|
|
|
%tmp.upgrd.3 = trunc i32 %tmp.upgrd.32 to i16
|
|
|
|
|
ret i16 %tmp.upgrd.3
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test40(
|
2010-01-05 22:48:13 +01:00
|
|
|
; CHECK: %tmp21 = lshr i16 %a, 9
|
|
|
|
|
; CHECK: %tmp5 = shl i16 %a, 8
|
|
|
|
|
; CHECK: %tmp.upgrd.32 = or i16 %tmp21, %tmp5
|
|
|
|
|
; CHECK: ret i16 %tmp.upgrd.32
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; PR1263
|
|
|
|
|
define i32* @test41(i32* %tmp1) {
|
|
|
|
|
%tmp64 = bitcast i32* %tmp1 to { i32 }*
|
[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-27 20:29:02 +01:00
|
|
|
%tmp65 = getelementptr { i32 }, { i32 }* %tmp64, i32 0, i32 0
|
2010-01-05 22:48:13 +01:00
|
|
|
ret i32* %tmp65
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test41(
|
2010-01-05 22:48:13 +01:00
|
|
|
; CHECK: ret i32* %tmp1
|
|
|
|
|
}
|
|
|
|
|
|
2014-08-12 21:46:13 +02:00
|
|
|
define i32 addrspace(1)* @test41_addrspacecast_smaller(i32* %tmp1) {
|
|
|
|
|
%tmp64 = addrspacecast i32* %tmp1 to { i32 } addrspace(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-27 20:29:02 +01:00
|
|
|
%tmp65 = getelementptr { i32 }, { i32 } addrspace(1)* %tmp64, i32 0, i32 0
|
2014-08-12 21:46:13 +02:00
|
|
|
ret i32 addrspace(1)* %tmp65
|
|
|
|
|
; CHECK-LABEL: @test41_addrspacecast_smaller(
|
|
|
|
|
; CHECK: addrspacecast i32* %tmp1 to i32 addrspace(1)*
|
|
|
|
|
; CHECK-NEXT: ret i32 addrspace(1)*
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define i32* @test41_addrspacecast_larger(i32 addrspace(1)* %tmp1) {
|
|
|
|
|
%tmp64 = addrspacecast i32 addrspace(1)* %tmp1 to { i32 }*
|
[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-27 20:29:02 +01:00
|
|
|
%tmp65 = getelementptr { i32 }, { i32 }* %tmp64, i32 0, i32 0
|
2014-08-12 21:46:13 +02:00
|
|
|
ret i32* %tmp65
|
|
|
|
|
; CHECK-LABEL: @test41_addrspacecast_larger(
|
|
|
|
|
; CHECK: addrspacecast i32 addrspace(1)* %tmp1 to i32*
|
|
|
|
|
; CHECK-NEXT: ret i32*
|
|
|
|
|
}
|
|
|
|
|
|
2010-01-05 22:54:09 +01:00
|
|
|
define i32 @test42(i32 %X) {
|
|
|
|
|
%Y = trunc i32 %X to i8 ; <i8> [#uses=1]
|
|
|
|
|
%Z = zext i8 %Y to i32 ; <i32> [#uses=1]
|
|
|
|
|
ret i32 %Z
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test42(
|
2010-01-05 22:54:09 +01:00
|
|
|
; CHECK: %Z = and i32 %X, 255
|
|
|
|
|
}
|
2010-01-05 22:48:13 +01:00
|
|
|
|
2010-01-06 02:56:21 +01:00
|
|
|
; rdar://6598839
|
|
|
|
|
define zeroext i64 @test43(i8 zeroext %on_off) nounwind readonly {
|
|
|
|
|
%A = zext i8 %on_off to i32
|
|
|
|
|
%B = add i32 %A, -1
|
|
|
|
|
%C = sext i32 %B to i64
|
|
|
|
|
ret i64 %C ;; Should be (add (zext i8 -> i64), -1)
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test43(
|
2010-01-06 02:56:21 +01:00
|
|
|
; CHECK-NEXT: %A = zext i8 %on_off to i64
|
2014-06-03 00:01:04 +02:00
|
|
|
; CHECK-NEXT: %B = add nsw i64 %A, -1
|
2010-01-06 02:56:21 +01:00
|
|
|
; CHECK-NEXT: ret i64 %B
|
|
|
|
|
}
|
2010-01-08 00:41:00 +01:00
|
|
|
|
|
|
|
|
define i64 @test44(i8 %T) {
|
|
|
|
|
%A = zext i8 %T to i16
|
|
|
|
|
%B = or i16 %A, 1234
|
|
|
|
|
%C = zext i16 %B to i64
|
|
|
|
|
ret i64 %C
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test44(
|
2010-01-08 00:41:00 +01:00
|
|
|
; CHECK-NEXT: %A = zext i8 %T to i64
|
|
|
|
|
; CHECK-NEXT: %B = or i64 %A, 1234
|
|
|
|
|
; CHECK-NEXT: ret i64 %B
|
|
|
|
|
}
|
2010-01-10 03:22:12 +01:00
|
|
|
|
|
|
|
|
define i64 @test45(i8 %A, i64 %Q) {
|
|
|
|
|
%D = trunc i64 %Q to i32 ;; should be removed
|
|
|
|
|
%B = sext i8 %A to i32
|
|
|
|
|
%C = or i32 %B, %D
|
|
|
|
|
%E = zext i32 %C to i64
|
|
|
|
|
ret i64 %E
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test45(
|
2010-01-10 03:22:12 +01:00
|
|
|
; CHECK-NEXT: %B = sext i8 %A to i64
|
|
|
|
|
; CHECK-NEXT: %C = or i64 %B, %Q
|
|
|
|
|
; CHECK-NEXT: %E = and i64 %C, 4294967295
|
|
|
|
|
; CHECK-NEXT: ret i64 %E
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
define i64 @test46(i64 %A) {
|
|
|
|
|
%B = trunc i64 %A to i32
|
|
|
|
|
%C = and i32 %B, 42
|
|
|
|
|
%D = shl i32 %C, 8
|
|
|
|
|
%E = zext i32 %D to i64
|
|
|
|
|
ret i64 %E
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test46(
|
2010-01-10 03:22:12 +01:00
|
|
|
; CHECK-NEXT: %C = shl i64 %A, 8
|
|
|
|
|
; CHECK-NEXT: %D = and i64 %C, 10752
|
|
|
|
|
; CHECK-NEXT: ret i64 %D
|
|
|
|
|
}
|
|
|
|
|
|
2010-01-10 03:39:31 +01:00
|
|
|
define i64 @test47(i8 %A) {
|
|
|
|
|
%B = sext i8 %A to i32
|
|
|
|
|
%C = or i32 %B, 42
|
|
|
|
|
%E = zext i32 %C to i64
|
|
|
|
|
ret i64 %E
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test47(
|
2010-01-10 03:39:31 +01:00
|
|
|
; CHECK-NEXT: %B = sext i8 %A to i64
|
2010-09-13 19:59:27 +02:00
|
|
|
; CHECK-NEXT: %C = and i64 %B, 4294967253
|
|
|
|
|
; CHECK-NEXT: %E = or i64 %C, 42
|
2010-01-10 03:39:31 +01:00
|
|
|
; CHECK-NEXT: ret i64 %E
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define i64 @test48(i8 %A, i8 %a) {
|
|
|
|
|
%b = zext i8 %a to i32
|
|
|
|
|
%B = zext i8 %A to i32
|
|
|
|
|
%C = shl i32 %B, 8
|
|
|
|
|
%D = or i32 %C, %b
|
|
|
|
|
%E = zext i32 %D to i64
|
|
|
|
|
ret i64 %E
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test48(
|
2010-01-10 03:39:31 +01:00
|
|
|
; CHECK-NEXT: %b = zext i8 %a to i64
|
|
|
|
|
; CHECK-NEXT: %B = zext i8 %A to i64
|
2011-02-10 06:36:31 +01:00
|
|
|
; CHECK-NEXT: %C = shl nuw nsw i64 %B, 8
|
2010-01-10 03:39:31 +01:00
|
|
|
; CHECK-NEXT: %D = or i64 %C, %b
|
|
|
|
|
; CHECK-NEXT: ret i64 %D
|
|
|
|
|
}
|
2010-01-10 03:22:12 +01:00
|
|
|
|
2010-01-10 08:40:50 +01:00
|
|
|
define i64 @test49(i64 %A) {
|
|
|
|
|
%B = trunc i64 %A to i32
|
|
|
|
|
%C = or i32 %B, 1
|
|
|
|
|
%D = sext i32 %C to i64
|
|
|
|
|
ret i64 %D
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test49(
|
2010-01-10 08:40:50 +01:00
|
|
|
; CHECK-NEXT: %C = shl i64 %A, 32
|
2011-02-10 06:36:31 +01:00
|
|
|
; CHECK-NEXT: ashr exact i64 %C, 32
|
2010-01-10 08:40:50 +01:00
|
|
|
; CHECK-NEXT: %D = or i64 {{.*}}, 1
|
|
|
|
|
; CHECK-NEXT: ret i64 %D
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define i64 @test50(i64 %A) {
|
|
|
|
|
%a = lshr i64 %A, 2
|
|
|
|
|
%B = trunc i64 %a to i32
|
|
|
|
|
%D = add i32 %B, -1
|
|
|
|
|
%E = sext i32 %D to i64
|
|
|
|
|
ret i64 %E
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test50(
|
Reapply r155136 after fixing PR12599.
Original commit message:
Defer some shl transforms to DAGCombine.
The shl instruction is used to represent multiplication by a constant
power of two as well as bitwise left shifts. Some InstCombine
transformations would turn an shl instruction into a bit mask operation,
making it difficult for later analysis passes to recognize the
constsnt multiplication.
Disable those shl transformations, deferring them to DAGCombine time.
An 'shl X, C' instruction is now treated mostly the same was as 'mul X, C'.
These transformations are deferred:
(X >>? C) << C --> X & (-1 << C) (When X >> C has multiple uses)
(X >>? C1) << C2 --> X << (C2-C1) & (-1 << C2) (When C2 > C1)
(X >>? C1) << C2 --> X >>? (C1-C2) & (-1 << C2) (When C1 > C2)
The corresponding exact transformations are preserved, just like
div-exact + mul:
(X >>?,exact C) << C --> X
(X >>?,exact C1) << C2 --> X << (C2-C1)
(X >>?,exact C1) << C2 --> X >>?,exact (C1-C2)
The disabled transformations could also prevent the instruction selector
from recognizing rotate patterns in hash functions and cryptographic
primitives. I have a test case for that, but it is too fragile.
llvm-svn: 155362
2012-04-23 19:39:52 +02:00
|
|
|
; lshr+shl will be handled by DAGCombine.
|
|
|
|
|
; CHECK-NEXT: lshr i64 %A, 2
|
|
|
|
|
; CHECK-NEXT: shl i64 %a, 32
|
2010-01-10 08:40:50 +01:00
|
|
|
; CHECK-NEXT: add i64 {{.*}}, -4294967296
|
Reapply r155136 after fixing PR12599.
Original commit message:
Defer some shl transforms to DAGCombine.
The shl instruction is used to represent multiplication by a constant
power of two as well as bitwise left shifts. Some InstCombine
transformations would turn an shl instruction into a bit mask operation,
making it difficult for later analysis passes to recognize the
constsnt multiplication.
Disable those shl transformations, deferring them to DAGCombine time.
An 'shl X, C' instruction is now treated mostly the same was as 'mul X, C'.
These transformations are deferred:
(X >>? C) << C --> X & (-1 << C) (When X >> C has multiple uses)
(X >>? C1) << C2 --> X << (C2-C1) & (-1 << C2) (When C2 > C1)
(X >>? C1) << C2 --> X >>? (C1-C2) & (-1 << C2) (When C1 > C2)
The corresponding exact transformations are preserved, just like
div-exact + mul:
(X >>?,exact C) << C --> X
(X >>?,exact C1) << C2 --> X << (C2-C1)
(X >>?,exact C1) << C2 --> X >>?,exact (C1-C2)
The disabled transformations could also prevent the instruction selector
from recognizing rotate patterns in hash functions and cryptographic
primitives. I have a test case for that, but it is too fragile.
llvm-svn: 155362
2012-04-23 19:39:52 +02:00
|
|
|
; CHECK-NEXT: %E = ashr exact i64 {{.*}}, 32
|
|
|
|
|
; CHECK-NEXT: ret i64 %E
|
2010-01-10 08:40:50 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define i64 @test51(i64 %A, i1 %cond) {
|
|
|
|
|
%B = trunc i64 %A to i32
|
|
|
|
|
%C = and i32 %B, -2
|
|
|
|
|
%D = or i32 %B, 1
|
|
|
|
|
%E = select i1 %cond, i32 %C, i32 %D
|
|
|
|
|
%F = sext i32 %E to i64
|
|
|
|
|
ret i64 %F
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test51(
|
2012-12-12 21:58:42 +01:00
|
|
|
; CHECK-NEXT: %C = and i64 %A, 4294967294
|
|
|
|
|
; CHECK-NEXT: %D = or i64 %A, 1
|
|
|
|
|
; CHECK-NEXT: %E = select i1 %cond, i64 %C, i64 %D
|
|
|
|
|
; CHECK-NEXT: %sext = shl i64 %E, 32
|
|
|
|
|
; CHECK-NEXT: %F = ashr exact i64 %sext, 32
|
|
|
|
|
; CHECK-NEXT: ret i64 %F
|
2010-01-10 08:40:50 +01:00
|
|
|
}
|
|
|
|
|
|
2010-01-10 21:25:54 +01:00
|
|
|
define i32 @test52(i64 %A) {
|
|
|
|
|
%B = trunc i64 %A to i16
|
|
|
|
|
%C = or i16 %B, -32574
|
|
|
|
|
%D = and i16 %C, -25350
|
|
|
|
|
%E = zext i16 %D to i32
|
|
|
|
|
ret i32 %E
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test52(
|
2010-01-10 21:25:54 +01:00
|
|
|
; CHECK-NEXT: %B = trunc i64 %A to i32
|
2010-09-13 19:59:27 +02:00
|
|
|
; CHECK-NEXT: %C = and i32 %B, 7224
|
|
|
|
|
; CHECK-NEXT: %D = or i32 %C, 32962
|
2010-01-10 21:25:54 +01:00
|
|
|
; CHECK-NEXT: ret i32 %D
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define i64 @test53(i32 %A) {
|
|
|
|
|
%B = trunc i32 %A to i16
|
|
|
|
|
%C = or i16 %B, -32574
|
|
|
|
|
%D = and i16 %C, -25350
|
|
|
|
|
%E = zext i16 %D to i64
|
|
|
|
|
ret i64 %E
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test53(
|
2010-01-10 21:25:54 +01:00
|
|
|
; CHECK-NEXT: %B = zext i32 %A to i64
|
2010-09-13 19:59:27 +02:00
|
|
|
; CHECK-NEXT: %C = and i64 %B, 7224
|
|
|
|
|
; CHECK-NEXT: %D = or i64 %C, 32962
|
2010-01-10 21:25:54 +01:00
|
|
|
; CHECK-NEXT: ret i64 %D
|
|
|
|
|
}
|
2010-01-10 21:30:41 +01:00
|
|
|
|
|
|
|
|
define i32 @test54(i64 %A) {
|
|
|
|
|
%B = trunc i64 %A to i16
|
|
|
|
|
%C = or i16 %B, -32574
|
|
|
|
|
%D = and i16 %C, -25350
|
|
|
|
|
%E = sext i16 %D to i32
|
|
|
|
|
ret i32 %E
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test54(
|
2010-01-10 21:30:41 +01:00
|
|
|
; CHECK-NEXT: %B = trunc i64 %A to i32
|
2010-09-13 19:59:27 +02:00
|
|
|
; CHECK-NEXT: %C = and i32 %B, 7224
|
|
|
|
|
; CHECK-NEXT: %D = or i32 %C, -32574
|
2010-01-10 21:30:41 +01:00
|
|
|
; CHECK-NEXT: ret i32 %D
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define i64 @test55(i32 %A) {
|
|
|
|
|
%B = trunc i32 %A to i16
|
|
|
|
|
%C = or i16 %B, -32574
|
|
|
|
|
%D = and i16 %C, -25350
|
|
|
|
|
%E = sext i16 %D to i64
|
|
|
|
|
ret i64 %E
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test55(
|
2010-01-10 21:30:41 +01:00
|
|
|
; CHECK-NEXT: %B = zext i32 %A to i64
|
2010-09-13 19:59:27 +02:00
|
|
|
; CHECK-NEXT: %C = and i64 %B, 7224
|
|
|
|
|
; CHECK-NEXT: %D = or i64 %C, -32574
|
2010-01-10 21:30:41 +01:00
|
|
|
; CHECK-NEXT: ret i64 %D
|
2010-01-11 04:32:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define i64 @test56(i16 %A) nounwind {
|
|
|
|
|
%tmp353 = sext i16 %A to i32
|
|
|
|
|
%tmp354 = lshr i32 %tmp353, 5
|
|
|
|
|
%tmp355 = zext i32 %tmp354 to i64
|
|
|
|
|
ret i64 %tmp355
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test56(
|
2010-01-11 04:32:00 +01:00
|
|
|
; CHECK-NEXT: %tmp353 = sext i16 %A to i64
|
|
|
|
|
; CHECK-NEXT: %tmp354 = lshr i64 %tmp353, 5
|
|
|
|
|
; CHECK-NEXT: %tmp355 = and i64 %tmp354, 134217727
|
|
|
|
|
; CHECK-NEXT: ret i64 %tmp355
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define i64 @test57(i64 %A) nounwind {
|
|
|
|
|
%B = trunc i64 %A to i32
|
|
|
|
|
%C = lshr i32 %B, 8
|
|
|
|
|
%E = zext i32 %C to i64
|
|
|
|
|
ret i64 %E
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test57(
|
2010-01-11 04:32:00 +01:00
|
|
|
; CHECK-NEXT: %C = lshr i64 %A, 8
|
|
|
|
|
; CHECK-NEXT: %E = and i64 %C, 16777215
|
|
|
|
|
; CHECK-NEXT: ret i64 %E
|
|
|
|
|
}
|
Extend CanEvaluateZExtd to handle and/or/xor more aggressively in the
BitsToClear case. This allows it to promote expressions which have an
and/or/xor after the lshr, promoting cases like test2 (from PR4216)
and test3 (random extample extracted from a spec benchmark).
clang now compiles the code in PR4216 into:
_test_bitfield: ## @test_bitfield
movl %edi, %eax
orl $194, %eax
movl $4294902010, %ecx
andq %rax, %rcx
orl $32768, %edi
andq $39936, %rdi
movq %rdi, %rax
orq %rcx, %rax
ret
instead of:
_test_bitfield: ## @test_bitfield
movl %edi, %eax
orl $194, %eax
movl $4294902010, %ecx
andq %rax, %rcx
shrl $8, %edi
orl $128, %edi
shlq $8, %rdi
andq $39936, %rdi
movq %rdi, %rax
orq %rcx, %rax
ret
which is still not great, but is progress.
llvm-svn: 93145
2010-01-11 05:05:13 +01:00
|
|
|
|
|
|
|
|
define i64 @test58(i64 %A) nounwind {
|
|
|
|
|
%B = trunc i64 %A to i32
|
|
|
|
|
%C = lshr i32 %B, 8
|
|
|
|
|
%D = or i32 %C, 128
|
|
|
|
|
%E = zext i32 %D to i64
|
|
|
|
|
ret i64 %E
|
|
|
|
|
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test58(
|
Extend CanEvaluateZExtd to handle and/or/xor more aggressively in the
BitsToClear case. This allows it to promote expressions which have an
and/or/xor after the lshr, promoting cases like test2 (from PR4216)
and test3 (random extample extracted from a spec benchmark).
clang now compiles the code in PR4216 into:
_test_bitfield: ## @test_bitfield
movl %edi, %eax
orl $194, %eax
movl $4294902010, %ecx
andq %rax, %rcx
orl $32768, %edi
andq $39936, %rdi
movq %rdi, %rax
orq %rcx, %rax
ret
instead of:
_test_bitfield: ## @test_bitfield
movl %edi, %eax
orl $194, %eax
movl $4294902010, %ecx
andq %rax, %rcx
shrl $8, %edi
orl $128, %edi
shlq $8, %rdi
andq $39936, %rdi
movq %rdi, %rax
orq %rcx, %rax
ret
which is still not great, but is progress.
llvm-svn: 93145
2010-01-11 05:05:13 +01:00
|
|
|
; CHECK-NEXT: %C = lshr i64 %A, 8
|
2010-09-13 19:59:27 +02:00
|
|
|
; CHECK-NEXT: %D = and i64 %C, 16777087
|
|
|
|
|
; CHECK-NEXT: %E = or i64 %D, 128
|
Extend CanEvaluateZExtd to handle and/or/xor more aggressively in the
BitsToClear case. This allows it to promote expressions which have an
and/or/xor after the lshr, promoting cases like test2 (from PR4216)
and test3 (random extample extracted from a spec benchmark).
clang now compiles the code in PR4216 into:
_test_bitfield: ## @test_bitfield
movl %edi, %eax
orl $194, %eax
movl $4294902010, %ecx
andq %rax, %rcx
orl $32768, %edi
andq $39936, %rdi
movq %rdi, %rax
orq %rcx, %rax
ret
instead of:
_test_bitfield: ## @test_bitfield
movl %edi, %eax
orl $194, %eax
movl $4294902010, %ecx
andq %rax, %rcx
shrl $8, %edi
orl $128, %edi
shlq $8, %rdi
andq $39936, %rdi
movq %rdi, %rax
orq %rcx, %rax
ret
which is still not great, but is progress.
llvm-svn: 93145
2010-01-11 05:05:13 +01:00
|
|
|
; CHECK-NEXT: ret i64 %E
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define i64 @test59(i8 %A, i8 %B) nounwind {
|
|
|
|
|
%C = zext i8 %A to i32
|
|
|
|
|
%D = shl i32 %C, 4
|
|
|
|
|
%E = and i32 %D, 48
|
|
|
|
|
%F = zext i8 %B to i32
|
|
|
|
|
%G = lshr i32 %F, 4
|
|
|
|
|
%H = or i32 %G, %E
|
|
|
|
|
%I = zext i32 %H to i64
|
|
|
|
|
ret i64 %I
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test59(
|
Extend CanEvaluateZExtd to handle and/or/xor more aggressively in the
BitsToClear case. This allows it to promote expressions which have an
and/or/xor after the lshr, promoting cases like test2 (from PR4216)
and test3 (random extample extracted from a spec benchmark).
clang now compiles the code in PR4216 into:
_test_bitfield: ## @test_bitfield
movl %edi, %eax
orl $194, %eax
movl $4294902010, %ecx
andq %rax, %rcx
orl $32768, %edi
andq $39936, %rdi
movq %rdi, %rax
orq %rcx, %rax
ret
instead of:
_test_bitfield: ## @test_bitfield
movl %edi, %eax
orl $194, %eax
movl $4294902010, %ecx
andq %rax, %rcx
shrl $8, %edi
orl $128, %edi
shlq $8, %rdi
andq $39936, %rdi
movq %rdi, %rax
orq %rcx, %rax
ret
which is still not great, but is progress.
llvm-svn: 93145
2010-01-11 05:05:13 +01:00
|
|
|
; CHECK-NEXT: %C = zext i8 %A to i64
|
|
|
|
|
; CHECK-NOT: i32
|
|
|
|
|
; CHECK: %F = zext i8 %B to i64
|
|
|
|
|
; CHECK-NOT: i32
|
|
|
|
|
; CHECK: ret i64 %H
|
|
|
|
|
}
|
2010-05-08 23:50:26 +02:00
|
|
|
|
|
|
|
|
define <3 x i32> @test60(<4 x i32> %call4) nounwind {
|
|
|
|
|
%tmp11 = bitcast <4 x i32> %call4 to i128
|
|
|
|
|
%tmp9 = trunc i128 %tmp11 to i96
|
|
|
|
|
%tmp10 = bitcast i96 %tmp9 to <3 x i32>
|
|
|
|
|
ret <3 x i32> %tmp10
|
|
|
|
|
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test60(
|
2010-05-08 23:50:26 +02:00
|
|
|
; CHECK-NEXT: shufflevector
|
|
|
|
|
; CHECK-NEXT: ret
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define <4 x i32> @test61(<3 x i32> %call4) nounwind {
|
|
|
|
|
%tmp11 = bitcast <3 x i32> %call4 to i96
|
|
|
|
|
%tmp9 = zext i96 %tmp11 to i128
|
|
|
|
|
%tmp10 = bitcast i128 %tmp9 to <4 x i32>
|
|
|
|
|
ret <4 x i32> %tmp10
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test61(
|
2010-05-08 23:50:26 +02:00
|
|
|
; CHECK-NEXT: shufflevector
|
|
|
|
|
; CHECK-NEXT: ret
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define <4 x i32> @test62(<3 x float> %call4) nounwind {
|
|
|
|
|
%tmp11 = bitcast <3 x float> %call4 to i96
|
|
|
|
|
%tmp9 = zext i96 %tmp11 to i128
|
|
|
|
|
%tmp10 = bitcast i128 %tmp9 to <4 x i32>
|
|
|
|
|
ret <4 x i32> %tmp10
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test62(
|
2010-05-08 23:50:26 +02:00
|
|
|
; CHECK-NEXT: bitcast
|
|
|
|
|
; CHECK-NEXT: shufflevector
|
|
|
|
|
; CHECK-NEXT: ret
|
|
|
|
|
}
|
|
|
|
|
|
2010-07-12 03:19:22 +02:00
|
|
|
; PR7311 - Don't create invalid IR on scalar->vector cast.
|
|
|
|
|
define <2 x float> @test63(i64 %tmp8) nounwind {
|
|
|
|
|
entry:
|
|
|
|
|
%a = bitcast i64 %tmp8 to <2 x i32>
|
|
|
|
|
%vcvt.i = uitofp <2 x i32> %a to <2 x float>
|
|
|
|
|
ret <2 x float> %vcvt.i
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test63(
|
2010-07-12 03:19:22 +02:00
|
|
|
; CHECK: bitcast
|
|
|
|
|
; CHECK: uitofp
|
|
|
|
|
}
|
|
|
|
|
|
2011-08-28 13:51:08 +02:00
|
|
|
define <4 x float> @test64(<4 x float> %c) nounwind {
|
|
|
|
|
%t0 = bitcast <4 x float> %c to <4 x i32>
|
2011-08-29 21:58:36 +02:00
|
|
|
%t1 = bitcast <4 x i32> %t0 to <4 x float>
|
|
|
|
|
ret <4 x float> %t1
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test64(
|
2011-08-28 13:51:08 +02:00
|
|
|
; CHECK-NEXT: ret <4 x float> %c
|
|
|
|
|
}
|
|
|
|
|
|
2011-08-29 21:58:36 +02:00
|
|
|
define <4 x float> @test65(<4 x float> %c) nounwind {
|
|
|
|
|
%t0 = bitcast <4 x float> %c to <2 x double>
|
|
|
|
|
%t1 = bitcast <2 x double> %t0 to <4 x float>
|
|
|
|
|
ret <4 x float> %t1
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test65(
|
2011-08-29 21:58:36 +02:00
|
|
|
; CHECK-NEXT: ret <4 x float> %c
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define <2 x float> @test66(<2 x float> %c) nounwind {
|
|
|
|
|
%t0 = bitcast <2 x float> %c to double
|
|
|
|
|
%t1 = bitcast double %t0 to <2 x float>
|
|
|
|
|
ret <2 x float> %t1
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test66(
|
2011-08-29 21:58:36 +02:00
|
|
|
; CHECK-NEXT: ret <2 x float> %c
|
|
|
|
|
}
|
|
|
|
|
|
2011-08-28 13:51:08 +02:00
|
|
|
define float @test2c() {
|
|
|
|
|
ret float extractelement (<2 x float> bitcast (double bitcast (<2 x float> <float -1.000000e+00, float -1.000000e+00> to double) to <2 x float>), i32 0)
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test2c(
|
2011-08-28 13:51:08 +02:00
|
|
|
; CHECK-NOT: extractelement
|
|
|
|
|
}
|
2011-08-29 21:58:36 +02:00
|
|
|
|
|
|
|
|
define i64 @test_mmx(<2 x i32> %c) nounwind {
|
|
|
|
|
%A = bitcast <2 x i32> %c to x86_mmx
|
|
|
|
|
%B = bitcast x86_mmx %A to <2 x i32>
|
|
|
|
|
%C = bitcast <2 x i32> %B to i64
|
|
|
|
|
ret i64 %C
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test_mmx(
|
2011-08-29 21:58:36 +02:00
|
|
|
; CHECK-NOT: x86_mmx
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define i64 @test_mmx_const(<2 x i32> %c) nounwind {
|
|
|
|
|
%A = bitcast <2 x i32> zeroinitializer to x86_mmx
|
|
|
|
|
%B = bitcast x86_mmx %A to <2 x i32>
|
|
|
|
|
%C = bitcast <2 x i32> %B to i64
|
|
|
|
|
ret i64 %C
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test_mmx_const(
|
2011-08-29 21:58:36 +02:00
|
|
|
; CHECK-NOT: x86_mmx
|
|
|
|
|
}
|
2012-05-11 03:32:59 +02:00
|
|
|
|
|
|
|
|
; PR12514
|
|
|
|
|
define i1 @test67(i1 %a, i32 %b) {
|
|
|
|
|
%tmp2 = zext i1 %a to i32
|
|
|
|
|
%conv6 = xor i32 %tmp2, 1
|
|
|
|
|
%and = and i32 %b, %conv6
|
|
|
|
|
%sext = shl nuw nsw i32 %and, 24
|
|
|
|
|
%neg.i = xor i32 %sext, -16777216
|
|
|
|
|
%conv.i.i = ashr exact i32 %neg.i, 24
|
|
|
|
|
%trunc = trunc i32 %conv.i.i to i8
|
|
|
|
|
%tobool.i = icmp eq i8 %trunc, 0
|
|
|
|
|
ret i1 %tobool.i
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test67(
|
2012-05-11 03:32:59 +02:00
|
|
|
; CHECK: ret i1 false
|
|
|
|
|
}
|
2012-10-23 10:28:26 +02:00
|
|
|
|
|
|
|
|
%s = type { i32, i32, i32 }
|
|
|
|
|
|
|
|
|
|
define %s @test68(%s *%p, i64 %i) {
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test68(
|
2012-10-23 10:28:26 +02:00
|
|
|
%o = mul i64 %i, 12
|
|
|
|
|
%q = bitcast %s* %p to i8*
|
[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-27 20:29:02 +01:00
|
|
|
%pp = getelementptr inbounds i8, i8* %q, i64 %o
|
|
|
|
|
; CHECK-NEXT: getelementptr %s, %s*
|
2012-10-23 10:28:26 +02:00
|
|
|
%r = bitcast i8* %pp to %s*
|
2015-02-27 22:17:42 +01:00
|
|
|
%l = load %s, %s* %r
|
|
|
|
|
; CHECK-NEXT: load %s, %s*
|
2012-10-23 10:28:26 +02:00
|
|
|
ret %s %l
|
|
|
|
|
; CHECK-NEXT: ret %s
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-14 01:49:12 +01:00
|
|
|
; addrspacecasts should be eliminated.
|
|
|
|
|
define %s @test68_addrspacecast(%s* %p, i64 %i) {
|
|
|
|
|
; CHECK-LABEL: @test68_addrspacecast(
|
[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-27 20:29:02 +01:00
|
|
|
; CHECK-NEXT: getelementptr %s, %s*
|
2015-02-27 22:17:42 +01:00
|
|
|
; CHECK-NEXT: load %s, %s*
|
2014-02-14 01:49:12 +01:00
|
|
|
; CHECK-NEXT: ret %s
|
|
|
|
|
%o = mul i64 %i, 12
|
|
|
|
|
%q = addrspacecast %s* %p to i8 addrspace(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-27 20:29:02 +01:00
|
|
|
%pp = getelementptr inbounds i8, i8 addrspace(2)* %q, i64 %o
|
2014-02-14 01:49:12 +01:00
|
|
|
%r = addrspacecast i8 addrspace(2)* %pp to %s*
|
2015-02-27 22:17:42 +01:00
|
|
|
%l = load %s, %s* %r
|
2014-02-14 01:49:12 +01:00
|
|
|
ret %s %l
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define %s @test68_addrspacecast_2(%s* %p, i64 %i) {
|
|
|
|
|
; CHECK-LABEL: @test68_addrspacecast_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-27 20:29:02 +01:00
|
|
|
; CHECK-NEXT: getelementptr %s, %s* %p
|
2014-02-14 01:49:12 +01:00
|
|
|
; CHECK-NEXT: addrspacecast
|
2015-02-27 22:17:42 +01:00
|
|
|
; CHECK-NEXT: load %s, %s addrspace(1)*
|
2014-02-14 01:49:12 +01:00
|
|
|
; CHECK-NEXT: ret %s
|
|
|
|
|
%o = mul i64 %i, 12
|
|
|
|
|
%q = addrspacecast %s* %p to i8 addrspace(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-27 20:29:02 +01:00
|
|
|
%pp = getelementptr inbounds i8, i8 addrspace(2)* %q, i64 %o
|
2014-02-14 01:49:12 +01:00
|
|
|
%r = addrspacecast i8 addrspace(2)* %pp to %s addrspace(1)*
|
2015-02-27 22:17:42 +01:00
|
|
|
%l = load %s, %s addrspace(1)* %r
|
2014-02-14 01:49:12 +01:00
|
|
|
ret %s %l
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-20 00:17:40 +02:00
|
|
|
define %s @test68_as1(%s addrspace(1)* %p, i32 %i) {
|
|
|
|
|
; CHECK-LABEL: @test68_as1(
|
|
|
|
|
%o = mul i32 %i, 12
|
|
|
|
|
%q = bitcast %s addrspace(1)* %p to i8 addrspace(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-27 20:29:02 +01:00
|
|
|
%pp = getelementptr inbounds i8, i8 addrspace(1)* %q, i32 %o
|
|
|
|
|
; CHECK-NEXT: getelementptr %s, %s addrspace(1)*
|
2013-08-20 00:17:40 +02:00
|
|
|
%r = bitcast i8 addrspace(1)* %pp to %s addrspace(1)*
|
2015-02-27 22:17:42 +01:00
|
|
|
%l = load %s, %s addrspace(1)* %r
|
|
|
|
|
; CHECK-NEXT: load %s, %s addrspace(1)*
|
2013-08-20 00:17:40 +02:00
|
|
|
ret %s %l
|
|
|
|
|
; CHECK-NEXT: ret %s
|
|
|
|
|
}
|
|
|
|
|
|
2012-10-23 10:28:26 +02:00
|
|
|
define double @test69(double *%p, i64 %i) {
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test69(
|
2012-10-23 10:28:26 +02:00
|
|
|
%o = shl nsw i64 %i, 3
|
|
|
|
|
%q = bitcast double* %p to i8*
|
[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-27 20:29:02 +01:00
|
|
|
%pp = getelementptr inbounds i8, i8* %q, i64 %o
|
|
|
|
|
; CHECK-NEXT: getelementptr inbounds double, double*
|
2012-10-23 10:28:26 +02:00
|
|
|
%r = bitcast i8* %pp to double*
|
2015-02-27 22:17:42 +01:00
|
|
|
%l = load double, double* %r
|
|
|
|
|
; CHECK-NEXT: load double, double*
|
2012-10-23 10:28:26 +02:00
|
|
|
ret double %l
|
|
|
|
|
; CHECK-NEXT: ret double
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define %s @test70(%s *%p, i64 %i) {
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test70(
|
2012-10-23 10:28:26 +02:00
|
|
|
%o = mul nsw i64 %i, 36
|
|
|
|
|
; CHECK-NEXT: mul nsw i64 %i, 3
|
|
|
|
|
%q = bitcast %s* %p to i8*
|
[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-27 20:29:02 +01:00
|
|
|
%pp = getelementptr inbounds i8, i8* %q, i64 %o
|
|
|
|
|
; CHECK-NEXT: getelementptr inbounds %s, %s*
|
2012-10-23 10:28:26 +02:00
|
|
|
%r = bitcast i8* %pp to %s*
|
2015-02-27 22:17:42 +01:00
|
|
|
%l = load %s, %s* %r
|
|
|
|
|
; CHECK-NEXT: load %s, %s*
|
2012-10-23 10:28:26 +02:00
|
|
|
ret %s %l
|
|
|
|
|
; CHECK-NEXT: ret %s
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define double @test71(double *%p, i64 %i) {
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test71(
|
2012-10-23 10:28:26 +02:00
|
|
|
%o = shl i64 %i, 5
|
|
|
|
|
; CHECK-NEXT: shl i64 %i, 2
|
|
|
|
|
%q = bitcast double* %p to i8*
|
[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-27 20:29:02 +01:00
|
|
|
%pp = getelementptr i8, i8* %q, i64 %o
|
|
|
|
|
; CHECK-NEXT: getelementptr double, double*
|
2012-10-23 10:28:26 +02:00
|
|
|
%r = bitcast i8* %pp to double*
|
2015-02-27 22:17:42 +01:00
|
|
|
%l = load double, double* %r
|
|
|
|
|
; CHECK-NEXT: load double, double*
|
2012-10-23 10:28:26 +02:00
|
|
|
ret double %l
|
|
|
|
|
; CHECK-NEXT: ret double
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define double @test72(double *%p, i32 %i) {
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test72(
|
2014-10-11 12:19:52 +02:00
|
|
|
%so = shl nsw i32 %i, 3
|
2012-10-23 10:28:26 +02:00
|
|
|
%o = sext i32 %so to i64
|
|
|
|
|
; CHECK-NEXT: sext i32 %i to i64
|
|
|
|
|
%q = bitcast double* %p to i8*
|
[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-27 20:29:02 +01:00
|
|
|
%pp = getelementptr inbounds i8, i8* %q, i64 %o
|
|
|
|
|
; CHECK-NEXT: getelementptr inbounds double, double*
|
2012-10-23 10:28:26 +02:00
|
|
|
%r = bitcast i8* %pp to double*
|
2015-02-27 22:17:42 +01:00
|
|
|
%l = load double, double* %r
|
|
|
|
|
; CHECK-NEXT: load double, double*
|
2012-10-23 10:28:26 +02:00
|
|
|
ret double %l
|
|
|
|
|
; CHECK-NEXT: ret double
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define double @test73(double *%p, i128 %i) {
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test73(
|
2014-10-11 12:19:52 +02:00
|
|
|
%lo = shl nsw i128 %i, 3
|
2012-10-23 10:28:26 +02:00
|
|
|
%o = trunc i128 %lo to i64
|
|
|
|
|
; CHECK-NEXT: trunc i128 %i to i64
|
|
|
|
|
%q = bitcast double* %p to i8*
|
[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-27 20:29:02 +01:00
|
|
|
%pp = getelementptr inbounds i8, i8* %q, i64 %o
|
|
|
|
|
; CHECK-NEXT: getelementptr double, double*
|
2012-10-23 10:28:26 +02:00
|
|
|
%r = bitcast i8* %pp to double*
|
2015-02-27 22:17:42 +01:00
|
|
|
%l = load double, double* %r
|
|
|
|
|
; CHECK-NEXT: load double, double*
|
2012-10-23 10:28:26 +02:00
|
|
|
ret double %l
|
|
|
|
|
; CHECK-NEXT: ret double
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define double @test74(double *%p, i64 %i) {
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test74(
|
2012-10-23 10:28:26 +02:00
|
|
|
%q = bitcast double* %p to i64*
|
[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-27 20:29:02 +01:00
|
|
|
%pp = getelementptr inbounds i64, i64* %q, i64 %i
|
|
|
|
|
; CHECK-NEXT: getelementptr inbounds double, double*
|
2012-10-23 10:28:26 +02:00
|
|
|
%r = bitcast i64* %pp to double*
|
2015-02-27 22:17:42 +01:00
|
|
|
%l = load double, double* %r
|
|
|
|
|
; CHECK-NEXT: load double, double*
|
2012-10-23 10:28:26 +02:00
|
|
|
ret double %l
|
|
|
|
|
; CHECK-NEXT: ret double
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define i32* @test75(i32* %p, i32 %x) {
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test75(
|
2012-10-23 10:28:26 +02:00
|
|
|
%y = shl i32 %x, 3
|
|
|
|
|
; CHECK-NEXT: shl i32 %x, 3
|
|
|
|
|
%z = sext i32 %y to i64
|
|
|
|
|
; CHECK-NEXT: sext i32 %y to i64
|
|
|
|
|
%q = bitcast i32* %p to i8*
|
[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-27 20:29:02 +01:00
|
|
|
%r = getelementptr i8, i8* %q, i64 %z
|
2012-10-23 10:28:26 +02:00
|
|
|
%s = bitcast i8* %r to i32*
|
|
|
|
|
ret i32* %s
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define %s @test76(%s *%p, i64 %i, i64 %j) {
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test76(
|
2012-10-23 10:28:26 +02:00
|
|
|
%o = mul i64 %i, 12
|
|
|
|
|
%o2 = mul nsw i64 %o, %j
|
|
|
|
|
; CHECK-NEXT: %o2 = mul i64 %i, %j
|
|
|
|
|
%q = bitcast %s* %p to i8*
|
[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-27 20:29:02 +01:00
|
|
|
%pp = getelementptr inbounds i8, i8* %q, i64 %o2
|
|
|
|
|
; CHECK-NEXT: getelementptr %s, %s* %p, i64 %o2
|
2012-10-23 10:28:26 +02:00
|
|
|
%r = bitcast i8* %pp to %s*
|
2015-02-27 22:17:42 +01:00
|
|
|
%l = load %s, %s* %r
|
|
|
|
|
; CHECK-NEXT: load %s, %s*
|
2012-10-23 10:28:26 +02:00
|
|
|
ret %s %l
|
|
|
|
|
; CHECK-NEXT: ret %s
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define %s @test77(%s *%p, i64 %i, i64 %j) {
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test77(
|
2012-10-23 10:28:26 +02:00
|
|
|
%o = mul nsw i64 %i, 36
|
|
|
|
|
%o2 = mul nsw i64 %o, %j
|
|
|
|
|
; CHECK-NEXT: %o = mul nsw i64 %i, 3
|
|
|
|
|
; CHECK-NEXT: %o2 = mul nsw i64 %o, %j
|
|
|
|
|
%q = bitcast %s* %p to i8*
|
[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-27 20:29:02 +01:00
|
|
|
%pp = getelementptr inbounds i8, i8* %q, i64 %o2
|
|
|
|
|
; CHECK-NEXT: getelementptr inbounds %s, %s* %p, i64 %o2
|
2012-10-23 10:28:26 +02:00
|
|
|
%r = bitcast i8* %pp to %s*
|
2015-02-27 22:17:42 +01:00
|
|
|
%l = load %s, %s* %r
|
|
|
|
|
; CHECK-NEXT: load %s, %s*
|
2012-10-23 10:28:26 +02:00
|
|
|
ret %s %l
|
|
|
|
|
; CHECK-NEXT: ret %s
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define %s @test78(%s *%p, i64 %i, i64 %j, i32 %k, i32 %l, i128 %m, i128 %n) {
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test78(
|
2012-10-23 10:28:26 +02:00
|
|
|
%a = mul nsw i32 %k, 36
|
|
|
|
|
; CHECK-NEXT: mul nsw i32 %k, 3
|
|
|
|
|
%b = mul nsw i32 %a, %l
|
|
|
|
|
; CHECK-NEXT: mul nsw i32 %a, %l
|
|
|
|
|
%c = sext i32 %b to i128
|
|
|
|
|
; CHECK-NEXT: sext i32 %b to i128
|
|
|
|
|
%d = mul nsw i128 %c, %m
|
|
|
|
|
; CHECK-NEXT: mul nsw i128 %c, %m
|
|
|
|
|
%e = mul i128 %d, %n
|
|
|
|
|
; CHECK-NEXT: mul i128 %d, %n
|
|
|
|
|
%f = trunc i128 %e to i64
|
|
|
|
|
; CHECK-NEXT: trunc i128 %e to i64
|
|
|
|
|
%g = mul nsw i64 %f, %i
|
|
|
|
|
; CHECK-NEXT: mul i64 %f, %i
|
|
|
|
|
%h = mul nsw i64 %g, %j
|
|
|
|
|
; CHECK-NEXT: mul i64 %g, %j
|
|
|
|
|
%q = bitcast %s* %p to i8*
|
[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-27 20:29:02 +01:00
|
|
|
%pp = getelementptr inbounds i8, i8* %q, i64 %h
|
|
|
|
|
; CHECK-NEXT: getelementptr %s, %s* %p, i64 %h
|
2012-10-23 10:28:26 +02:00
|
|
|
%r = bitcast i8* %pp to %s*
|
2015-02-27 22:17:42 +01:00
|
|
|
%load = load %s, %s* %r
|
|
|
|
|
; CHECK-NEXT: load %s, %s*
|
2012-10-23 10:28:26 +02:00
|
|
|
ret %s %load
|
|
|
|
|
; CHECK-NEXT: ret %s
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define %s @test79(%s *%p, i64 %i, i32 %j) {
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test79(
|
2012-10-23 10:28:26 +02:00
|
|
|
%a = mul nsw i64 %i, 36
|
|
|
|
|
; CHECK: mul nsw i64 %i, 36
|
|
|
|
|
%b = trunc i64 %a to i32
|
|
|
|
|
%c = mul i32 %b, %j
|
|
|
|
|
%q = bitcast %s* %p to i8*
|
|
|
|
|
; CHECK: bitcast
|
[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-27 20:29:02 +01:00
|
|
|
%pp = getelementptr inbounds i8, i8* %q, i32 %c
|
2012-10-23 10:28:26 +02:00
|
|
|
%r = bitcast i8* %pp to %s*
|
2015-02-27 22:17:42 +01:00
|
|
|
%l = load %s, %s* %r
|
2012-10-23 10:28:26 +02:00
|
|
|
ret %s %l
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define double @test80([100 x double]* %p, i32 %i) {
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test80(
|
2014-10-11 12:19:52 +02:00
|
|
|
%tmp = shl nsw i32 %i, 3
|
2012-10-23 10:28:26 +02:00
|
|
|
; CHECK-NEXT: sext i32 %i to i64
|
|
|
|
|
%q = bitcast [100 x double]* %p to i8*
|
[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-27 20:29:02 +01:00
|
|
|
%pp = getelementptr i8, i8* %q, i32 %tmp
|
|
|
|
|
; CHECK-NEXT: getelementptr [100 x double], [100 x double]*
|
2012-10-23 10:28:26 +02:00
|
|
|
%r = bitcast i8* %pp to double*
|
2015-02-27 22:17:42 +01:00
|
|
|
%l = load double, double* %r
|
|
|
|
|
; CHECK-NEXT: load double, double*
|
2012-10-23 10:28:26 +02:00
|
|
|
ret double %l
|
|
|
|
|
; CHECK-NEXT: ret double
|
|
|
|
|
}
|
2012-10-24 09:17:20 +02:00
|
|
|
|
2014-02-14 01:49:12 +01:00
|
|
|
define double @test80_addrspacecast([100 x double] addrspace(1)* %p, i32 %i) {
|
|
|
|
|
; CHECK-LABEL: @test80_addrspacecast(
|
[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-27 20:29:02 +01:00
|
|
|
; CHECK-NEXT: getelementptr [100 x double], [100 x double] addrspace(1)* %p
|
2015-02-27 22:17:42 +01:00
|
|
|
; CHECK-NEXT: load double, double addrspace(1)*
|
2014-02-14 01:49:12 +01:00
|
|
|
; CHECK-NEXT: ret double
|
2014-10-11 12:19:52 +02:00
|
|
|
%tmp = shl nsw i32 %i, 3
|
2014-02-14 01:49:12 +01:00
|
|
|
%q = addrspacecast [100 x double] addrspace(1)* %p to i8 addrspace(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-27 20:29:02 +01:00
|
|
|
%pp = getelementptr i8, i8 addrspace(2)* %q, i32 %tmp
|
2014-02-14 01:49:12 +01:00
|
|
|
%r = addrspacecast i8 addrspace(2)* %pp to double addrspace(1)*
|
2015-02-27 22:17:42 +01:00
|
|
|
%l = load double, double addrspace(1)* %r
|
2014-02-14 01:49:12 +01:00
|
|
|
ret double %l
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define double @test80_addrspacecast_2([100 x double] addrspace(1)* %p, i32 %i) {
|
|
|
|
|
; CHECK-LABEL: @test80_addrspacecast_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-27 20:29:02 +01:00
|
|
|
; CHECK-NEXT: getelementptr [100 x double], [100 x double] addrspace(1)*
|
2014-02-14 01:49:12 +01:00
|
|
|
; CHECK-NEXT: addrspacecast double addrspace(1)*
|
2015-02-27 22:17:42 +01:00
|
|
|
; CHECK-NEXT: load double, double addrspace(3)*
|
2014-02-14 01:49:12 +01:00
|
|
|
; CHECK-NEXT: ret double
|
2014-10-11 12:19:52 +02:00
|
|
|
%tmp = shl nsw i32 %i, 3
|
2014-02-14 01:49:12 +01:00
|
|
|
%q = addrspacecast [100 x double] addrspace(1)* %p to i8 addrspace(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-27 20:29:02 +01:00
|
|
|
%pp = getelementptr i8, i8 addrspace(2)* %q, i32 %tmp
|
2014-02-14 01:49:12 +01:00
|
|
|
%r = addrspacecast i8 addrspace(2)* %pp to double addrspace(3)*
|
2015-02-27 22:17:42 +01:00
|
|
|
%l = load double, double addrspace(3)* %r
|
2014-02-14 01:49:12 +01:00
|
|
|
ret double %l
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-20 00:17:40 +02:00
|
|
|
define double @test80_as1([100 x double] addrspace(1)* %p, i16 %i) {
|
|
|
|
|
; CHECK-LABEL: @test80_as1(
|
2014-10-11 12:19:52 +02:00
|
|
|
%tmp = shl nsw i16 %i, 3
|
2013-08-20 00:17:40 +02:00
|
|
|
; CHECK-NEXT: sext i16 %i to i32
|
|
|
|
|
%q = bitcast [100 x double] addrspace(1)* %p to i8 addrspace(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-27 20:29:02 +01:00
|
|
|
%pp = getelementptr i8, i8 addrspace(1)* %q, i16 %tmp
|
|
|
|
|
; CHECK-NEXT: getelementptr [100 x double], [100 x double] addrspace(1)*
|
2013-08-20 00:17:40 +02:00
|
|
|
%r = bitcast i8 addrspace(1)* %pp to double addrspace(1)*
|
2015-02-27 22:17:42 +01:00
|
|
|
%l = load double, double addrspace(1)* %r
|
|
|
|
|
; CHECK-NEXT: load double, double addrspace(1)*
|
2013-08-20 00:17:40 +02:00
|
|
|
ret double %l
|
|
|
|
|
; CHECK-NEXT: ret double
|
|
|
|
|
}
|
|
|
|
|
|
2012-10-24 09:17:20 +02:00
|
|
|
define double @test81(double *%p, float %f) {
|
|
|
|
|
%i = fptosi float %f to i64
|
|
|
|
|
%q = bitcast double* %p to i8*
|
[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-27 20:29:02 +01:00
|
|
|
%pp = getelementptr i8, i8* %q, i64 %i
|
2012-10-24 09:17:20 +02:00
|
|
|
%r = bitcast i8* %pp to double*
|
2015-02-27 22:17:42 +01:00
|
|
|
%l = load double, double* %r
|
2012-10-24 09:17:20 +02:00
|
|
|
ret double %l
|
|
|
|
|
}
|
2013-05-10 18:26:37 +02:00
|
|
|
|
|
|
|
|
define i64 @test82(i64 %A) nounwind {
|
|
|
|
|
%B = trunc i64 %A to i32
|
|
|
|
|
%C = lshr i32 %B, 8
|
|
|
|
|
%D = shl i32 %C, 9
|
|
|
|
|
%E = zext i32 %D to i64
|
|
|
|
|
ret i64 %E
|
|
|
|
|
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test82(
|
2013-05-10 18:26:37 +02:00
|
|
|
; CHECK-NEXT: [[REG:%[0-9]*]] = shl i64 %A, 1
|
|
|
|
|
; CHECK-NEXT: %E = and i64 [[REG]], 4294966784
|
|
|
|
|
; CHECK-NEXT: ret i64 %E
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; PR15959
|
|
|
|
|
define i64 @test83(i16 %a, i64 %k) {
|
|
|
|
|
%conv = sext i16 %a to i32
|
|
|
|
|
%sub = add nsw i64 %k, -1
|
|
|
|
|
%sh_prom = trunc i64 %sub to i32
|
|
|
|
|
%shl = shl i32 %conv, %sh_prom
|
|
|
|
|
%sh_prom1 = zext i32 %shl to i64
|
|
|
|
|
ret i64 %sh_prom1
|
|
|
|
|
|
2013-07-14 03:42:54 +02:00
|
|
|
; CHECK-LABEL: @test83(
|
2014-08-22 09:56:32 +02:00
|
|
|
; CHECK: %sub = add i64 %k, 4294967295
|
2013-05-10 18:26:37 +02:00
|
|
|
; CHECK: %sh_prom = trunc i64 %sub to i32
|
|
|
|
|
; CHECK: %shl = shl i32 %conv, %sh_prom
|
|
|
|
|
}
|
2014-08-22 09:56:32 +02:00
|
|
|
|
|
|
|
|
define i8 @test84(i32 %a) {
|
|
|
|
|
%add = add nsw i32 %a, -16777216
|
|
|
|
|
%shr = lshr exact i32 %add, 23
|
|
|
|
|
%trunc = trunc i32 %shr to i8
|
|
|
|
|
ret i8 %trunc
|
|
|
|
|
|
|
|
|
|
; CHECK-LABEL: @test84(
|
|
|
|
|
; CHECK: [[ADD:%.*]] = add i32 %a, 2130706432
|
|
|
|
|
; CHECK: [[SHR:%.*]] = lshr exact i32 [[ADD]], 23
|
|
|
|
|
; CHECK: [[CST:%.*]] = trunc i32 [[SHR]] to i8
|
|
|
|
|
}
|
2014-08-22 19:11:04 +02:00
|
|
|
|
|
|
|
|
define i8 @test85(i32 %a) {
|
|
|
|
|
%add = add nuw i32 %a, -16777216
|
|
|
|
|
%shr = lshr exact i32 %add, 23
|
|
|
|
|
%trunc = trunc i32 %shr to i8
|
|
|
|
|
ret i8 %trunc
|
|
|
|
|
|
|
|
|
|
; CHECK-LABEL: @test85(
|
|
|
|
|
; CHECK: [[ADD:%.*]] = add i32 %a, 2130706432
|
|
|
|
|
; CHECK: [[SHR:%.*]] = lshr exact i32 [[ADD]], 23
|
|
|
|
|
; CHECK: [[CST:%.*]] = trunc i32 [[SHR]] to i8
|
|
|
|
|
}
|
2014-10-11 01:00:21 +02:00
|
|
|
|
2015-09-10 13:31:20 +02:00
|
|
|
define i16 @test86(i16 %v) {
|
|
|
|
|
%a = sext i16 %v to i32
|
|
|
|
|
%s = ashr i32 %a, 4
|
|
|
|
|
%t = trunc i32 %s to i16
|
|
|
|
|
ret i16 %t
|
|
|
|
|
|
|
|
|
|
; CHECK-LABEL: @test86(
|
|
|
|
|
; CHECK: [[ASHR:%.*]] = ashr i16 %v, 4
|
|
|
|
|
; CHECK-NEXT: ret i16 [[ASHR]]
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define i16 @test87(i16 %v) {
|
|
|
|
|
%c = sext i16 %v to i32
|
|
|
|
|
%m = mul nsw i32 %c, 16
|
|
|
|
|
%a = ashr i32 %m, 16
|
|
|
|
|
%t = trunc i32 %a to i16
|
|
|
|
|
ret i16 %t
|
|
|
|
|
|
|
|
|
|
; CHECK-LABEL: @test87(
|
|
|
|
|
; CHECK: [[ASHR:%.*]] = ashr i16 %v, 12
|
|
|
|
|
; CHECK-NEXT: ret i16 [[ASHR]]
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define i16 @test88(i16 %v) {
|
|
|
|
|
%a = sext i16 %v to i32
|
|
|
|
|
%s = ashr i32 %a, 18
|
|
|
|
|
%t = trunc i32 %s to i16
|
|
|
|
|
ret i16 %t
|
|
|
|
|
|
|
|
|
|
; Do not optimize to ashr i16 (shift by 18)
|
|
|
|
|
; CHECK-LABEL: @test88(
|
|
|
|
|
; CHECK: [[SEXT:%.*]] = sext i16 %v to i32
|
|
|
|
|
; CHECK-NEXT: [[ASHR:%.*]] = ashr i32 [[SEXT]], 18
|
|
|
|
|
; CHECK-NEXT: [[TRUNC:%.*]] = trunc i32 [[ASHR]] to i16
|
|
|
|
|
; CHECK-NEXT: ret i16 [[TRUNC]]
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-11 01:00:21 +02:00
|
|
|
; Overflow on a float to int or int to float conversion is undefined (PR21130).
|
|
|
|
|
|
|
|
|
|
define i8 @overflow_fptosi() {
|
|
|
|
|
%i = fptosi double 1.56e+02 to i8
|
|
|
|
|
ret i8 %i
|
|
|
|
|
; CHECK-LABEL: @overflow_fptosi(
|
|
|
|
|
; CHECK-NEXT: ret i8 undef
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define i8 @overflow_fptoui() {
|
|
|
|
|
%i = fptoui double 2.56e+02 to i8
|
|
|
|
|
ret i8 %i
|
|
|
|
|
; CHECK-LABEL: @overflow_fptoui(
|
|
|
|
|
; CHECK-NEXT: ret i8 undef
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
; The maximum float is approximately 2 ** 128 which is 3.4E38.
|
|
|
|
|
; The constant below is 4E38. Use a 130 bit integer to hold that
|
|
|
|
|
; number; 129-bits for the value + 1 bit for the sign.
|
|
|
|
|
define float @overflow_uitofp() {
|
|
|
|
|
%i = uitofp i130 400000000000000000000000000000000000000 to float
|
|
|
|
|
ret float %i
|
|
|
|
|
; CHECK-LABEL: @overflow_uitofp(
|
|
|
|
|
; CHECK-NEXT: ret float undef
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
define float @overflow_sitofp() {
|
|
|
|
|
%i = sitofp i130 400000000000000000000000000000000000000 to float
|
|
|
|
|
ret float %i
|
|
|
|
|
; CHECK-LABEL: @overflow_sitofp(
|
|
|
|
|
; CHECK-NEXT: ret float undef
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-27 06:47:49 +01:00
|
|
|
define i32 @PR21388(i32* %v) {
|
|
|
|
|
%icmp = icmp slt i32* %v, null
|
|
|
|
|
%sext = sext i1 %icmp to i32
|
|
|
|
|
ret i32 %sext
|
|
|
|
|
; CHECK-LABEL: @PR21388(
|
|
|
|
|
; CHECK-NEXT: %[[icmp:.*]] = icmp slt i32* %v, null
|
|
|
|
|
; CHECK-NEXT: %[[sext:.*]] = sext i1 %[[icmp]] to i32
|
|
|
|
|
; CHECK-NEXT: ret i32 %[[sext]]
|
|
|
|
|
}
|
2015-04-21 02:05:41 +02:00
|
|
|
|
|
|
|
|
define float @sitofp_zext(i16 %a) {
|
|
|
|
|
; CHECK-LABEL: @sitofp_zext(
|
|
|
|
|
; CHECK-NEXT: %[[sitofp:.*]] = uitofp i16 %a to float
|
|
|
|
|
; CHECK-NEXT: ret float %[[sitofp]]
|
|
|
|
|
%zext = zext i16 %a to i32
|
|
|
|
|
%sitofp = sitofp i32 %zext to float
|
|
|
|
|
ret float %sitofp
|
|
|
|
|
}
|
2015-04-22 22:59:28 +02:00
|
|
|
|
|
|
|
|
define i1 @PR23309(i32 %A, i32 %B) {
|
|
|
|
|
; CHECK-LABEL: @PR23309(
|
|
|
|
|
; CHECK-NEXT: %[[sub:.*]] = sub i32 %A, %B
|
|
|
|
|
; CHECK-NEXT: %[[and:.*]] = and i32 %[[sub]], 1
|
|
|
|
|
; CHECK-NEXT: %[[cmp:.*]] = icmp ne i32 %[[and]], 0
|
|
|
|
|
; CHECK-NEXT: ret i1 %[[cmp]]
|
|
|
|
|
%add = add i32 %A, -4
|
|
|
|
|
%sub = sub nsw i32 %add, %B
|
|
|
|
|
%trunc = trunc i32 %sub to i1
|
|
|
|
|
ret i1 %trunc
|
|
|
|
|
}
|
2015-04-23 00:42:05 +02:00
|
|
|
|
|
|
|
|
define i1 @PR23309v2(i32 %A, i32 %B) {
|
|
|
|
|
; CHECK-LABEL: @PR23309v2(
|
|
|
|
|
; CHECK-NEXT: %[[sub:.*]] = add i32 %A, %B
|
|
|
|
|
; CHECK-NEXT: %[[and:.*]] = and i32 %[[sub]], 1
|
|
|
|
|
; CHECK-NEXT: %[[cmp:.*]] = icmp ne i32 %[[and]], 0
|
|
|
|
|
; CHECK-NEXT: ret i1 %[[cmp]]
|
|
|
|
|
%add = add i32 %A, -4
|
|
|
|
|
%sub = add nuw i32 %add, %B
|
|
|
|
|
%trunc = trunc i32 %sub to i1
|
|
|
|
|
ret i1 %trunc
|
|
|
|
|
}
|
2015-09-10 13:31:20 +02:00
|
|
|
|
|
|
|
|
define i16 @PR24763(i8 %V) {
|
|
|
|
|
; CHECK-LABEL: @PR24763(
|
|
|
|
|
; CHECK-NEXT: %[[sh:.*]] = ashr i8
|
|
|
|
|
; CHECK-NEXT: %[[ext:.*]] = sext i8 %[[sh]] to i16
|
|
|
|
|
; CHECK-NEXT: ret i16 %[[ext]]
|
|
|
|
|
%conv = sext i8 %V to i32
|
|
|
|
|
%l = lshr i32 %conv, 1
|
|
|
|
|
%t = trunc i32 %l to i16
|
|
|
|
|
ret i16 %t
|
|
|
|
|
}
|
