2009-09-08 23:54:48 +00:00
; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu
2009-04-28 06:24:09 +00:00
; PR4034
%struct.BiContextType = type { i16 , i8 }
%struct.Bitstream = type { i32 , i32 , i32 , i32 , i8 * , i32 }
%struct.DataPartition = type { %struct.Bitstream * , %struct.DecodingEnvironment , i32 ( %struct.SyntaxElement * , %struct.ImageParameters * , %struct.DataPartition * ) * }
%struct.DecRefPicMarking_t = type { i32 , i32 , i32 , i32 , i32 , %struct.DecRefPicMarking_t * }
%struct.DecodingEnvironment = type { i32 , i32 , i32 , i32 , i32 , i8 * , i32 * }
%struct.ImageParameters = type { i32 , i32 , i32 , i32 , i32 * , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , [ 16 x [ 16 x i16 ] ] , [ 6 x [ 32 x i32 ] ] , [ 16 x [ 16 x i32 ] ] , [ 4 x [ 12 x [ 4 x [ 4 x i32 ] ] ] ] , [ 16 x i32 ] , i8 * * , i32 * , i32 * * * , i32 * * , i32 , i32 , i32 , i32 , %struct.Slice * , %struct.Macroblock * , i32 , i32 , i32 , i32 , i32 , i32 , %struct.DecRefPicMarking_t * , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , [ 3 x i32 ] , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 * * * , i32 * * * , i32 * * * * , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , [ 3 x [ 2 x i32 ] ] , [ 3 x [ 2 x i32 ] ] , i32 , i32 , i64 , i64 , %struct.timeb , %struct.timeb , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 }
%struct.Macroblock = type { i32 , [ 2 x i32 ] , i32 , i32 , %struct.Macroblock * , %struct.Macroblock * , i32 , [ 2 x [ 4 x [ 4 x [ 2 x i32 ] ] ] ] , i32 , i64 , i64 , i32 , i32 , [ 4 x i8 ] , [ 4 x i8 ] , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 }
%struct.MotionInfoContexts = type { [ 4 x [ 11 x %struct.BiContextType ] ] , [ 2 x [ 9 x %struct.BiContextType ] ] , [ 2 x [ 10 x %struct.BiContextType ] ] , [ 2 x [ 6 x %struct.BiContextType ] ] , [ 4 x %struct.BiContextType ] , [ 4 x %struct.BiContextType ] , [ 3 x %struct.BiContextType ] }
%struct.PixelPos = type { i32 , i32 , i32 , i32 , i32 , i32 }
%struct.Slice = type { i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , %struct.DataPartition * , %struct.MotionInfoContexts * , %struct.TextureInfoContexts * , i32 , i32 * , i32 * , i32 * , i32 , i32 * , i32 * , i32 * , i32 ( %struct.ImageParameters * , %struct.inp_par * ) * , i32 , i32 , i32 , i32 }
%struct.SyntaxElement = type { i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 , void ( i32 , i32 , i32 * , i32 * ) * , void ( %struct.SyntaxElement * , %struct.ImageParameters * , %struct.DecodingEnvironment * ) * }
%struct.TextureInfoContexts = type { [ 2 x %struct.BiContextType ] , [ 4 x %struct.BiContextType ] , [ 3 x [ 4 x %struct.BiContextType ] ] , [ 10 x [ 4 x %struct.BiContextType ] ] , [ 10 x [ 15 x %struct.BiContextType ] ] , [ 10 x [ 15 x %struct.BiContextType ] ] , [ 10 x [ 5 x %struct.BiContextType ] ] , [ 10 x [ 5 x %struct.BiContextType ] ] , [ 10 x [ 15 x %struct.BiContextType ] ] , [ 10 x [ 15 x %struct.BiContextType ] ] }
%struct.inp_par = type { [ 1000 x i8 ] , [ 1000 x i8 ] , [ 1000 x i8 ] , i32 , i32 , i32 , i32 , i32 , i32 , i32 , i32 }
%struct.timeb = type { i64 , i16 , i16 , i16 }
@get_mb_block_pos = external global void ( i32 , i32 * , i32 * ) * ; <void (i32, i32*, i32*)**> [#uses=1]
@img = external global %struct.ImageParameters * ; <%struct.ImageParameters**> [#uses=14]
@llvm.used = appending global [ 1 x i8 * ] [ i8 * bitcast ( void ( i32 , i32 , i32 , i32 , %struct.PixelPos * ) * @getAffNeighbour to i8 * ) ] , section "llvm.metadata" ; <[1 x i8*]*> [#uses=0]
define void @getAffNeighbour ( i32 %curr_mb_nr , i32 %xN , i32 %yN , i32 %is_chroma , %struct.PixelPos * %pix ) nounwind {
entry:
%Opq.sa.calc = add i32 0 , 2 ; <i32> [#uses=2]
2015-02-27 21:17:42 +00:00
%0 = load %struct.ImageParameters * , %struct.ImageParameters * * @img , align 8 ; <%struct.ImageParameters*> [#uses=3]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%1 = getelementptr %struct.ImageParameters , %struct.ImageParameters * %0 , i64 0 , i32 39 ; <%struct.Macroblock**> [#uses=1]
2015-02-27 21:17:42 +00:00
%2 = load %struct.Macroblock * , %struct.Macroblock * * %1 , align 8 ; <%struct.Macroblock*> [#uses=24]
2009-04-28 06:24:09 +00:00
%3 = zext i32 %curr_mb_nr to i64 ; <i64> [#uses=24]
%4 = sext i32 %is_chroma to i64 ; <i64> [#uses=8]
br label %meshBB392
entry.fragment: ; preds = %meshBB392
%Opq.sa.calc747 = add i32 %Opq.sa.calc921 , 70 ; <i32> [#uses=0]
[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
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%5 = getelementptr %struct.ImageParameters , %struct.ImageParameters * %0 , i64 0 , i32 119 , i64 %4 , i64 0 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%6 = load i32 , i32 * %5 , align 4 ; <i32> [#uses=2]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%7 = getelementptr %struct.ImageParameters , %struct.ImageParameters * %0 , i64 0 , i32 119 , i64 %4 , i64 1 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%8 = load i32 , i32 * %7 , align 4 ; <i32> [#uses=5]
2009-04-28 06:24:09 +00:00
br label %entry.fragment181
entry.fragment181: ; preds = %entry.fragment
%Opq.sa.calc863 = add i32 %Opq.sa.calc921 , -50 ; <i32> [#uses=4]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%9 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 0 ; <i32*> [#uses=4]
2009-04-28 06:24:09 +00:00
store i32 0 , i32 * %9 , align 4
%10 = add i32 %8 , -1 ; <i32> [#uses=6]
%11 = icmp slt i32 %10 , %yN ; <i1> [#uses=1]
br i1 %11 , label %meshBB448 , label %bb
bb: ; preds = %entry.fragment181
%Opq.sa.calc460 = add i32 %Opq.sa.calc863 , 50 ; <i32> [#uses=0]
%12 = add i32 %6 , -1 ; <i32> [#uses=5]
%13 = icmp slt i32 %12 , %xN ; <i1> [#uses=1]
br label %bb.fragment
bb.fragment: ; preds = %bb
%Opq.sa.calc976 = add i32 %Opq.sa.calc863 , 13 ; <i32> [#uses=3]
%.not8 = icmp sgt i32 %yN , -1 ; <i1> [#uses=1]
%14 = icmp sgt i32 %8 , %yN ; <i1> [#uses=1]
%or.cond.not = and i1 %14 , %.not8 ; <i1> [#uses=3]
%or.cond1 = and i1 %or.cond.not , %13 ; <i1> [#uses=1]
br i1 %or.cond1 , label %meshBB396 , label %bb3
bb3: ; preds = %bb.fragment
%Opq.sa.calc462 = sub i32 %Opq.sa.calc976 , -152 ; <i32> [#uses=5]
%Opq.sa.calc461 = sub i32 %Opq.sa.calc462 , 168 ; <i32> [#uses=2]
%15 = icmp slt i32 %xN , 0 ; <i1> [#uses=1]
br i1 %15 , label %bb4 , label %meshBB404
bb4: ; preds = %bb3
%Opq.sa.calc467 = xor i32 %Opq.sa.calc462 , 171 ; <i32> [#uses=2]
%Opq.sa.calc465 = sub i32 %Opq.sa.calc467 , %Opq.sa.calc462 ; <i32> [#uses=1]
%Opq.sa.calc466 = xor i32 %Opq.sa.calc465 , -164 ; <i32> [#uses=1]
%16 = icmp slt i32 %yN , 0 ; <i1> [#uses=1]
br i1 %16 , label %meshBB428 , label %meshBB392
bb5: ; preds = %meshBB428
%Opq.sa.calc470 = sub i32 %Opq.sa.calc897 , -49 ; <i32> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%17 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 20 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%18 = load i32 , i32 * %17 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %bb5.fragment
bb5.fragment: ; preds = %bb5
%Opq.sa.calc873 = sub i32 %Opq.sa.calc470 , 169 ; <i32> [#uses=7]
%19 = icmp eq i32 %18 , 0 ; <i1> [#uses=1]
%20 = and i32 %curr_mb_nr , 1 ; <i32> [#uses=1]
%21 = icmp eq i32 %20 , 0 ; <i1> [#uses=2]
br i1 %19 , label %bb6 , label %bb13
bb6: ; preds = %bb5.fragment
%Opq.sa.calc473 = xor i32 %Opq.sa.calc873 , 81 ; <i32> [#uses=1]
br i1 %21 , label %bb7 , label %meshBB348
bb7: ; preds = %bb6
%Opq.sa.calc476 = add i32 %Opq.sa.calc873 , -58 ; <i32> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%22 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 25 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%23 = load i32 , i32 * %22 , align 8 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%24 = add i32 %23 , 1 ; <i32> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%25 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 1 ; <i32*> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %meshBB388
bb7.fragment: ; preds = %meshBB388
%Opq.sa.calc709 = sub i32 %Opq.sa.calc886 , 143 ; <i32> [#uses=1]
%Opq.sa.calc707 = add i32 %Opq.sa.calc709 , %Opq.sa.calc886 ; <i32> [#uses=1]
%Opq.sa.calc708 = xor i32 %Opq.sa.calc707 , 474 ; <i32> [#uses=0]
store i32 %.SV194.phi , i32 * %.SV196.phi , align 4
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%26 = getelementptr %struct.Macroblock , %struct.Macroblock * %.load17.SV.phi , i64 %.load36.SV.phi , i32 29 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%27 = load i32 , i32 * %26 , align 8 ; <i32> [#uses=2]
2009-04-28 06:24:09 +00:00
store i32 %27 , i32 * %.load67.SV.phi , align 4
br label %bb96
bb8: ; preds = %meshBB348
%Opq.sa.calc479 = sub i32 %Opq.sa.calc805 , 141 ; <i32> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%28 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 22 ; <i32*> [#uses=2]
2015-02-27 21:17:42 +00:00
%29 = load i32 , i32 * %28 , align 4 ; <i32> [#uses=2]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%30 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 1 ; <i32*> [#uses=2]
2009-04-28 06:24:09 +00:00
br label %meshBB368
bb8.fragment: ; preds = %meshBB368
%Opq.sa.calc765 = sub i32 %Opq.sa.calc768 , -115 ; <i32> [#uses=2]
store i32 %.SV198.phi , i32 * %.SV200.phi , align 4
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%31 = getelementptr %struct.Macroblock , %struct.Macroblock * %.load16.SV.phi , i64 %.load35.SV.phi , i32 26 ; <i32*> [#uses=2]
2015-02-27 21:17:42 +00:00
%32 = load i32 , i32 * %31 , align 4 ; <i32> [#uses=4]
2009-04-28 06:24:09 +00:00
store i32 %32 , i32 * %.load66.SV.phi , align 4
2015-02-27 21:17:42 +00:00
%33 = load i32 , i32 * %31 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%34 = icmp eq i32 %33 , 0 ; <i1> [#uses=1]
br i1 %34 , label %bb96 , label %bb9
bb9: ; preds = %bb8.fragment
%Opq.sa.calc482 = xor i32 %Opq.sa.calc765 , 163 ; <i32> [#uses=0]
2015-02-27 21:17:42 +00:00
%35 = load %struct.ImageParameters * , %struct.ImageParameters * * @img , align 8 ; <%struct.ImageParameters*> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%36 = getelementptr %struct.ImageParameters , %struct.ImageParameters * %35 , i64 0 , i32 39 ; <%struct.Macroblock**> [#uses=1]
2015-02-27 21:17:42 +00:00
%37 = load %struct.Macroblock * , %struct.Macroblock * * %36 , align 8 ; <%struct.Macroblock*> [#uses=1]
%38 = load i32 , i32 * %.SV76.phi , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %bb9.fragment
bb9.fragment: ; preds = %bb9
%Opq.sa.calc999 = add i32 %Opq.sa.calc765 , -44 ; <i32> [#uses=1]
%39 = sext i32 %38 to i64 ; <i64> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%40 = getelementptr %struct.Macroblock , %struct.Macroblock * %37 , i64 %39 , i32 20 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%41 = load i32 , i32 * %40 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%42 = icmp eq i32 %41 , 0 ; <i1> [#uses=1]
br i1 %42 , label %bb96 , label %bb11
bb11: ; preds = %bb9.fragment
%Opq.sa.calc485 = sub i32 %Opq.sa.calc999 , 200 ; <i32> [#uses=2]
%43 = add i32 %.SV78.phi , 1 ; <i32> [#uses=1]
br label %meshBB332
bb11.fragment: ; preds = %meshBB332
%Opq.sa.calc954 = xor i32 %Opq.link.mask859 , 233 ; <i32> [#uses=0]
store i32 %.SV206.phi , i32 * %.load81.SV.phi , align 4
%44 = add i32 %.load50.SV.phi , %yN ; <i32> [#uses=1]
%45 = ashr i32 %44 , 1 ; <i32> [#uses=1]
br label %bb96
bb13: ; preds = %bb5.fragment
%Opq.sa.calc490 = xor i32 %Opq.sa.calc873 , 175 ; <i32> [#uses=1]
%Opq.sa.calc488 = sub i32 %Opq.sa.calc490 , %Opq.sa.calc873 ; <i32> [#uses=1]
%Opq.sa.calc489 = sub i32 %Opq.sa.calc488 , 133 ; <i32> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%46 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 25 ; <i32*> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %meshBB360
bb13.fragment: ; preds = %meshBB360
%Opq.sa.calc870 = add i32 %Opq.sa.calc866 , -129 ; <i32> [#uses=3]
2015-02-27 21:17:42 +00:00
%47 = load i32 , i32 * %.SV208.phi , align 8 ; <i32> [#uses=3]
2009-04-28 06:24:09 +00:00
br i1 %.load74.SV.phi , label %bb14 , label %meshBB412
bb14: ; preds = %bb13.fragment
%Opq.sa.calc493 = add i32 %Opq.sa.calc870 , 103 ; <i32> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%48 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 1 ; <i32*> [#uses=2]
2009-04-28 06:24:09 +00:00
store i32 %47 , i32 * %48 , align 4
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%49 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 29 ; <i32*> [#uses=2]
2009-04-28 06:24:09 +00:00
br label %bb14.fragment
bb14.fragment: ; preds = %bb14
%Opq.sa.calc723 = sub i32 %Opq.sa.calc493 , 117 ; <i32> [#uses=4]
2015-02-27 21:17:42 +00:00
%50 = load i32 , i32 * %49 , align 8 ; <i32> [#uses=4]
2009-04-28 06:24:09 +00:00
store i32 %50 , i32 * %.SV52.phi1113 , align 4
2015-02-27 21:17:42 +00:00
%51 = load i32 , i32 * %49 , align 8 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%52 = icmp eq i32 %51 , 0 ; <i1> [#uses=1]
br i1 %52 , label %meshBB , label %bb15
bb15: ; preds = %bb14.fragment
%Opq.sa.calc496 = sub i32 %Opq.sa.calc723 , -8 ; <i32> [#uses=1]
2015-02-27 21:17:42 +00:00
%53 = load %struct.ImageParameters * , %struct.ImageParameters * * @img , align 8 ; <%struct.ImageParameters*> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%54 = getelementptr %struct.ImageParameters , %struct.ImageParameters * %53 , i64 0 , i32 39 ; <%struct.Macroblock**> [#uses=1]
2015-02-27 21:17:42 +00:00
%55 = load %struct.Macroblock * , %struct.Macroblock * * %54 , align 8 ; <%struct.Macroblock*> [#uses=1]
%56 = load i32 , i32 * %.SV208.phi , align 8 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %meshBB324
bb15.fragment: ; preds = %meshBB324
%Opq.sa.calc925 = xor i32 %Opq.sa.calc750 , 215 ; <i32> [#uses=2]
%57 = sext i32 %.SV214.phi to i64 ; <i64> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%58 = getelementptr %struct.Macroblock , %struct.Macroblock * %.SV212.phi , i64 %57 , i32 20 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%59 = load i32 , i32 * %58 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%60 = icmp eq i32 %59 , 0 ; <i1> [#uses=1]
br i1 %60 , label %bb16 , label %bb96
bb16: ; preds = %bb15.fragment
%Opq.sa.calc499 = sub i32 %Opq.sa.calc925 , -140 ; <i32> [#uses=0]
%61 = add i32 %.SV87.phi , 1 ; <i32> [#uses=1]
br label %bb16.fragment
bb16.fragment: ; preds = %bb16
%Opq.sa.calc968 = add i32 %Opq.sa.calc925 , 129 ; <i32> [#uses=0]
store i32 %61 , i32 * %.SV91.phi , align 4
%62 = shl i32 %yN , 1 ; <i32> [#uses=1]
br label %bb96
bb19: ; preds = %meshBB412
%Opq.sa.calc502 = sub i32 %Opq.sa.calc932 , -94 ; <i32> [#uses=0]
%63 = add i32 %.SV87.phi1030 , 1 ; <i32> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%64 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 1 ; <i32*> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %bb19.fragment
bb19.fragment: ; preds = %bb19
%Opq.sa.calc880 = xor i32 %Opq.sa.calc932 , 246 ; <i32> [#uses=0]
store i32 %63 , i32 * %64 , align 4
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%65 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 29 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%66 = load i32 , i32 * %65 , align 8 ; <i32> [#uses=2]
2009-04-28 06:24:09 +00:00
store i32 %66 , i32 * %.SV52.phi1186 , align 4
br label %bb96
bb21: ; preds = %meshBB392
%Opq.sa.calc505 = add i32 %Opq.sa.calc921 , -40 ; <i32> [#uses=2]
br i1 %or.cond.not.SV.phi , label %meshBB360 , label %bb97
bb23: ; preds = %meshBB360
%Opq.sa.calc509 = xor i32 %Opq.sa.calc866 , 70 ; <i32> [#uses=1]
%Opq.sa.calc508 = sub i32 %Opq.sa.calc509 , -19 ; <i32> [#uses=0]
[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
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%67 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 20 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%68 = load i32 , i32 * %67 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%69 = icmp eq i32 %68 , 0 ; <i1> [#uses=1]
%70 = and i32 %curr_mb_nr , 1 ; <i32> [#uses=1]
%71 = icmp eq i32 %70 , 0 ; <i1> [#uses=2]
br label %bb23.fragment
bb23.fragment: ; preds = %bb23
%Opq.sa.calc847 = sub i32 %Opq.sa.calc866 , -9 ; <i32> [#uses=2]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%72 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 22 ; <i32*> [#uses=3]
2015-02-27 21:17:42 +00:00
%73 = load i32 , i32 * %72 , align 4 ; <i32> [#uses=3]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%74 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 1 ; <i32*> [#uses=3]
2009-04-28 06:24:09 +00:00
store i32 %73 , i32 * %74 , align 4
br label %bb23.fragment182
bb23.fragment182: ; preds = %bb23.fragment
%Opq.sa.calc744 = xor i32 %Opq.sa.calc847 , 152 ; <i32> [#uses=4]
%Opq.sa.calc742 = add i32 %Opq.sa.calc744 , %Opq.sa.calc847 ; <i32> [#uses=1]
%Opq.sa.calc743 = add i32 %Opq.sa.calc742 , -149 ; <i32> [#uses=2]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%75 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 26 ; <i32*> [#uses=2]
2015-02-27 21:17:42 +00:00
%76 = load i32 , i32 * %75 , align 4 ; <i32> [#uses=3]
2009-04-28 06:24:09 +00:00
store i32 %76 , i32 * %.SV52.phi1113 , align 4
2015-02-27 21:17:42 +00:00
%77 = load i32 , i32 * %75 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%78 = icmp ne i32 %77 , 0 ; <i1> [#uses=2]
br i1 %69 , label %meshBB344 , label %meshBB432
bb24: ; preds = %meshBB344
%Opq.sa.calc512 = add i32 %Opq.sa.calc716 , -55 ; <i32> [#uses=3]
br i1 %.SV96.phi , label %bb25 , label %bb32
bb25: ; preds = %bb24
%Opq.sa.calc515 = sub i32 %Opq.sa.calc716 , 18 ; <i32> [#uses=1]
br i1 %.SV135.phi , label %bb26 , label %bb96
bb26: ; preds = %bb25
%Opq.sa.calc519 = xor i32 %Opq.sa.calc515 , 23 ; <i32> [#uses=2]
%Opq.sa.calc518 = xor i32 %Opq.sa.calc519 , 84 ; <i32> [#uses=1]
2015-02-27 21:17:42 +00:00
%79 = load %struct.ImageParameters * , %struct.ImageParameters * * @img , align 8 ; <%struct.ImageParameters*> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%80 = getelementptr %struct.ImageParameters , %struct.ImageParameters * %79 , i64 0 , i32 39 ; <%struct.Macroblock**> [#uses=1]
2015-02-27 21:17:42 +00:00
%81 = load %struct.Macroblock * , %struct.Macroblock * * %80 , align 8 ; <%struct.Macroblock*> [#uses=1]
%82 = load i32 , i32 * %.SV99.phi , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %meshBB340
bb26.fragment: ; preds = %meshBB340
%Opq.sa.calc918 = xor i32 %Opq.sa.calc754 , 228 ; <i32> [#uses=4]
%Opq.sa.calc916 = add i32 %Opq.sa.calc918 , %Opq.sa.calc754 ; <i32> [#uses=1]
%Opq.sa.calc917 = add i32 %Opq.sa.calc916 , -237 ; <i32> [#uses=1]
%83 = sext i32 %.SV230.phi to i64 ; <i64> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%84 = getelementptr %struct.Macroblock , %struct.Macroblock * %.SV228.phi , i64 %83 , i32 20 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%85 = load i32 , i32 * %84 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%86 = icmp eq i32 %85 , 0 ; <i1> [#uses=1]
br i1 %86 , label %meshBB420 , label %meshBB356
bb28: ; preds = %meshBB356
%Opq.sa.calc522 = xor i32 %Opq.sa.calc983 , 107 ; <i32> [#uses=2]
%87 = and i32 %yN , 1 ; <i32> [#uses=1]
%88 = icmp eq i32 %87 , 0 ; <i1> [#uses=1]
br i1 %88 , label %bb29 , label %bb30
bb29: ; preds = %bb28
%Opq.sa.calc525 = xor i32 %Opq.sa.calc522 , 151 ; <i32> [#uses=2]
%89 = ashr i32 %yN , 1 ; <i32> [#uses=1]
br label %meshBB340
bb30: ; preds = %bb28
%Opq.sa.calc528 = sub i32 %Opq.sa.calc522 , -64 ; <i32> [#uses=1]
%90 = add i32 %.SV104.phi1160 , 1 ; <i32> [#uses=1]
br label %bb30.fragment
bb30.fragment: ; preds = %bb30
%Opq.sa.calc791 = add i32 %Opq.sa.calc528 , -14 ; <i32> [#uses=0]
store i32 %90 , i32 * %.SV111.phi1159 , align 4
%91 = ashr i32 %yN , 1 ; <i32> [#uses=1]
br label %bb96
bb32: ; preds = %bb24
%Opq.sa.calc531 = xor i32 %Opq.sa.calc512 , 50 ; <i32> [#uses=1]
br i1 %.SV135.phi , label %bb33 , label %meshBB324
bb33: ; preds = %bb32
%Opq.sa.calc534 = sub i32 %Opq.sa.calc512 , -75 ; <i32> [#uses=2]
2015-02-27 21:17:42 +00:00
%92 = load %struct.ImageParameters * , %struct.ImageParameters * * @img , align 8 ; <%struct.ImageParameters*> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%93 = getelementptr %struct.ImageParameters , %struct.ImageParameters * %92 , i64 0 , i32 39 ; <%struct.Macroblock**> [#uses=1]
2015-02-27 21:17:42 +00:00
%94 = load %struct.Macroblock * , %struct.Macroblock * * %93 , align 8 ; <%struct.Macroblock*> [#uses=1]
%95 = load i32 , i32 * %.SV99.phi , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %bb33.fragment
bb33.fragment: ; preds = %bb33
%Opq.sa.calc712 = add i32 %Opq.sa.calc534 , -109 ; <i32> [#uses=3]
%96 = sext i32 %95 to i64 ; <i64> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%97 = getelementptr %struct.Macroblock , %struct.Macroblock * %94 , i64 %96 , i32 20 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%98 = load i32 , i32 * %97 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%99 = icmp eq i32 %98 , 0 ; <i1> [#uses=1]
br i1 %99 , label %bb34 , label %meshBB
bb34: ; preds = %bb33.fragment
%Opq.sa.calc537 = add i32 %Opq.sa.calc712 , 8 ; <i32> [#uses=1]
%100 = add i32 %.SV104.phi , 1 ; <i32> [#uses=1]
br label %meshBB328
bb34.fragment: ; preds = %meshBB328
%Opq.sa.calc965 = xor i32 %Opq.sa.calc787 , 251 ; <i32> [#uses=0]
store i32 %.SV238.phi , i32 * %.load116.SV.phi , align 4
br label %bb96
bb35: ; preds = %meshBB
%Opq.sa.calc541 = add i32 %Opq.sa.calc828 , -112 ; <i32> [#uses=3]
%Opq.sa.calc540 = xor i32 %Opq.sa.calc541 , 3 ; <i32> [#uses=1]
%101 = and i32 %yN , 1 ; <i32> [#uses=1]
%102 = icmp eq i32 %101 , 0 ; <i1> [#uses=1]
br i1 %102 , label %meshBB372 , label %meshBB448
bb36: ; preds = %meshBB372
%Opq.sa.calc544 = sub i32 %Opq.sa.calc812 , -10 ; <i32> [#uses=0]
%103 = add i32 %.SV43.phi1015 , %yN ; <i32> [#uses=1]
br label %bb36.fragment
bb36.fragment: ; preds = %bb36
%Opq.sa.calc762 = add i32 %Opq.sa.calc812 , -69 ; <i32> [#uses=0]
%104 = ashr i32 %103 , 1 ; <i32> [#uses=1]
br label %bb96
bb37: ; preds = %meshBB448
%Opq.sa.calc547 = add i32 %Opq.sa.calc958 , -49 ; <i32> [#uses=1]
%105 = add i32 %.SV104.phi1157 , 1 ; <i32> [#uses=1]
br label %meshBB348
bb37.fragment: ; preds = %meshBB348
%Opq.sa.calc728 = add i32 %Opq.sa.calc805 , -5 ; <i32> [#uses=0]
store i32 %.SV242.phi , i32 * %.load115.SV.phi , align 4
%106 = add i32 %.load48.SV.phi , %yN ; <i32> [#uses=1]
%107 = ashr i32 %106 , 1 ; <i32> [#uses=1]
br label %bb96
bb39: ; preds = %meshBB432
%Opq.sa.calc550 = sub i32 %Opq.sa.calc798 , -214 ; <i32> [#uses=0]
br i1 %.SV96.phi1038 , label %bb40 , label %bb48
bb40: ; preds = %bb39
%Opq.sa.calc554 = xor i32 %Opq.sa.calc798 , 14 ; <i32> [#uses=4]
%Opq.sa.calc553 = sub i32 %Opq.sa.calc554 , 7 ; <i32> [#uses=1]
br i1 %.SV135.phi1039 , label %meshBB336 , label %meshBB444
bb41: ; preds = %meshBB336
%Opq.sa.calc557 = sub i32 %Opq.sa.calc979 , 143 ; <i32> [#uses=1]
2015-02-27 21:17:42 +00:00
%108 = load %struct.ImageParameters * , %struct.ImageParameters * * @img , align 8 ; <%struct.ImageParameters*> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%109 = getelementptr %struct.ImageParameters , %struct.ImageParameters * %108 , i64 0 , i32 39 ; <%struct.Macroblock**> [#uses=1]
2015-02-27 21:17:42 +00:00
%110 = load %struct.Macroblock * , %struct.Macroblock * * %109 , align 8 ; <%struct.Macroblock*> [#uses=1]
%111 = load i32 , i32 * %.SV99.phi1128 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %bb41.fragment
bb41.fragment: ; preds = %bb41
%Opq.sa.calc987 = xor i32 %Opq.sa.calc557 , 213 ; <i32> [#uses=4]
%112 = sext i32 %111 to i64 ; <i64> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%113 = getelementptr %struct.Macroblock , %struct.Macroblock * %110 , i64 %112 , i32 20 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%114 = load i32 , i32 * %113 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%115 = icmp eq i32 %114 , 0 ; <i1> [#uses=1]
br i1 %115 , label %bb42 , label %bb96
bb42: ; preds = %bb41.fragment
%Opq.sa.calc560 = add i32 %Opq.sa.calc987 , -221 ; <i32> [#uses=1]
%116 = ashr i32 %.SV43.phi1230 , 1 ; <i32> [#uses=1]
%117 = icmp sgt i32 %116 , %yN ; <i1> [#uses=1]
br i1 %117 , label %meshBB432 , label %bb44
bb43: ; preds = %meshBB432
%Opq.sa.calc563 = xor i32 %Opq.sa.calc798 , 31 ; <i32> [#uses=0]
%118 = shl i32 %yN , 1 ; <i32> [#uses=1]
br label %bb96
bb44: ; preds = %bb42
%Opq.sa.calc566 = sub i32 %Opq.sa.calc987 , 217 ; <i32> [#uses=1]
%119 = add i32 %.SV104.phi1127 , 1 ; <i32> [#uses=1]
br label %meshBB332
bb44.fragment: ; preds = %meshBB332
%Opq.sa.calc894 = add i32 %Opq.sa.calc856 , -200 ; <i32> [#uses=1]
store i32 %.SV248.phi , i32 * %.load114.SV.phi , align 4
%120 = shl i32 %yN , 1 ; <i32> [#uses=1]
%121 = sub i32 %120 , %.load46.SV.phi ; <i32> [#uses=1]
br label %meshBB376
bb48: ; preds = %bb39
%Opq.sa.calc569 = sub i32 %Opq.sa.calc798 , -110 ; <i32> [#uses=1]
br i1 %.SV135.phi1039 , label %bb49 , label %bb96
bb49: ; preds = %bb48
%Opq.sa.calc572 = add i32 %Opq.sa.calc798 , 84 ; <i32> [#uses=0]
2015-02-27 21:17:42 +00:00
%122 = load %struct.ImageParameters * , %struct.ImageParameters * * @img , align 8 ; <%struct.ImageParameters*> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%123 = getelementptr %struct.ImageParameters , %struct.ImageParameters * %122 , i64 0 , i32 39 ; <%struct.Macroblock**> [#uses=1]
2015-02-27 21:17:42 +00:00
%124 = load %struct.Macroblock * , %struct.Macroblock * * %123 , align 8 ; <%struct.Macroblock*> [#uses=1]
%125 = load i32 , i32 * %.SV99.phi1037 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %bb49.fragment
bb49.fragment: ; preds = %bb49
%Opq.sa.calc860 = sub i32 %Opq.sa.calc569 , 114 ; <i32> [#uses=5]
%126 = sext i32 %125 to i64 ; <i64> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%127 = getelementptr %struct.Macroblock , %struct.Macroblock * %124 , i64 %126 , i32 20 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%128 = load i32 , i32 * %127 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%129 = icmp eq i32 %128 , 0 ; <i1> [#uses=1]
br i1 %129 , label %bb50 , label %meshBB380
bb50: ; preds = %bb49.fragment
%Opq.sa.calc577 = add i32 %Opq.sa.calc860 , 12 ; <i32> [#uses=2]
%130 = ashr i32 %.SV43.phi1178 , 1 ; <i32> [#uses=1]
%131 = icmp sgt i32 %130 , %yN ; <i1> [#uses=1]
br i1 %131 , label %meshBB328 , label %bb52
bb51: ; preds = %meshBB328
%Opq.sa.calc580 = xor i32 %Opq.sa.calc787 , 194 ; <i32> [#uses=0]
%132 = shl i32 %yN , 1 ; <i32> [#uses=1]
%133 = or i32 %132 , 1 ; <i32> [#uses=1]
br label %bb96
bb52: ; preds = %bb50
%Opq.sa.calc584 = sub i32 %Opq.sa.calc860 , -65 ; <i32> [#uses=2]
%Opq.sa.calc583 = sub i32 %Opq.sa.calc584 , 50 ; <i32> [#uses=1]
%134 = add i32 %.SV104.phi1036 , 1 ; <i32> [#uses=1]
store i32 %134 , i32 * %.SV111.phi1035 , align 4
br label %meshBB384
bb52.fragment: ; preds = %meshBB384
%Opq.sa.calc844 = add i32 %Opq.sa.calc901 , -214 ; <i32> [#uses=1]
%135 = shl i32 %yN , 1 ; <i32> [#uses=1]
%136 = or i32 %135 , 1 ; <i32> [#uses=1]
%137 = sub i32 %136 , %.load44.SV.phi ; <i32> [#uses=1]
br label %meshBB388
bb54: ; preds = %meshBB380
%Opq.sa.calc589 = add i32 %Opq.sa.calc946 , 108 ; <i32> [#uses=1]
%138 = add i32 %.SV104.phi1124 , 1 ; <i32> [#uses=1]
br label %bb54.fragment
bb54.fragment: ; preds = %bb54
%Opq.sa.calc883 = xor i32 %Opq.sa.calc589 , 119 ; <i32> [#uses=2]
store i32 %138 , i32 * %.SV111.phi1123 , align 4
br label %meshBB440
bb56: ; preds = %meshBB404
%Opq.sa.calc592 = sub i32 %Opq.sa.calc939 , 87 ; <i32> [#uses=2]
%.not4 = icmp sgt i32 %xN , -1 ; <i1> [#uses=1]
%139 = icmp sgt i32 %.SV40.phi , %xN ; <i1> [#uses=1]
br label %meshBB364
bb56.fragment: ; preds = %meshBB364
%Opq.sa.calc1002 = xor i32 %Opq.link.mask737 , 77 ; <i32> [#uses=6]
%or.cond5 = and i1 %.SV256.phi , %.not4.SV.phi ; <i1> [#uses=1]
%140 = icmp slt i32 %yN , 0 ; <i1> [#uses=2]
br i1 %or.cond5 , label %bb58 , label %bb83
bb58: ; preds = %bb56.fragment
%Opq.sa.calc596 = xor i32 %Opq.sa.calc1002 , 73 ; <i32> [#uses=1]
%Opq.sa.calc595 = add i32 %Opq.sa.calc596 , 147 ; <i32> [#uses=0]
br i1 %140 , label %bb59 , label %bb76
bb59: ; preds = %bb58
%Opq.sa.calc599 = add i32 %Opq.sa.calc1002 , 151 ; <i32> [#uses=0]
[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
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%141 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 20 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%142 = load i32 , i32 * %141 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %bb59.fragment
bb59.fragment: ; preds = %bb59
%Opq.sa.calc731 = sub i32 %Opq.sa.calc1002 , -161 ; <i32> [#uses=3]
%143 = icmp eq i32 %142 , 0 ; <i1> [#uses=1]
%144 = and i32 %curr_mb_nr , 1 ; <i32> [#uses=1]
%145 = icmp eq i32 %144 , 0 ; <i1> [#uses=2]
br i1 %143 , label %bb60 , label %bb68
bb60: ; preds = %bb59.fragment
%Opq.sa.calc602 = xor i32 %Opq.sa.calc731 , 1 ; <i32> [#uses=2]
br i1 %145 , label %bb61 , label %bb66
bb61: ; preds = %bb60
%Opq.sa.calc605 = xor i32 %Opq.sa.calc731 , 57 ; <i32> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%146 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 23 ; <i32*> [#uses=2]
2015-02-27 21:17:42 +00:00
%147 = load i32 , i32 * %146 , align 8 ; <i32> [#uses=3]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%148 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 1 ; <i32*> [#uses=3]
2009-04-28 06:24:09 +00:00
br label %bb61.fragment
bb61.fragment: ; preds = %bb61
%Opq.sa.calc700 = sub i32 %Opq.sa.calc605 , 108 ; <i32> [#uses=3]
store i32 %147 , i32 * %148 , align 4
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%149 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 27 ; <i32*> [#uses=4]
2015-02-27 21:17:42 +00:00
%150 = load i32 , i32 * %149 , align 8 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%151 = icmp eq i32 %150 , 0 ; <i1> [#uses=1]
br i1 %151 , label %bb65 , label %bb62
bb62: ; preds = %bb61.fragment
%Opq.sa.calc608 = add i32 %Opq.sa.calc700 , -94 ; <i32> [#uses=1]
2015-02-27 21:17:42 +00:00
%152 = load %struct.ImageParameters * , %struct.ImageParameters * * @img , align 8 ; <%struct.ImageParameters*> [#uses=2]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%153 = getelementptr %struct.ImageParameters , %struct.ImageParameters * %152 , i64 0 , i32 45 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%154 = load i32 , i32 * %153 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%155 = icmp eq i32 %154 , 1 ; <i1> [#uses=1]
br i1 %155 , label %bb63 , label %bb64
bb63: ; preds = %bb62
%Opq.sa.calc611 = add i32 %Opq.sa.calc700 , -101 ; <i32> [#uses=2]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%156 = getelementptr %struct.ImageParameters , %struct.ImageParameters * %152 , i64 0 , i32 39 ; <%struct.Macroblock**> [#uses=1]
2015-02-27 21:17:42 +00:00
%157 = load %struct.Macroblock * , %struct.Macroblock * * %156 , align 8 ; <%struct.Macroblock*> [#uses=1]
%158 = load i32 , i32 * %146 , align 8 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %meshBB452
bb63.fragment: ; preds = %meshBB452
%Opq.sa.calc891 = add i32 %Opq.link.mask823 , 18 ; <i32> [#uses=2]
%Opq.sa.calc890 = add i32 %Opq.sa.calc891 , -3 ; <i32> [#uses=2]
%159 = sext i32 %.SV266.phi to i64 ; <i64> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%160 = getelementptr %struct.Macroblock , %struct.Macroblock * %.SV264.phi , i64 %159 , i32 20 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%161 = load i32 , i32 * %160 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%162 = icmp eq i32 %161 , 0 ; <i1> [#uses=1]
br i1 %162 , label %bb64 , label %meshBB456
bb64: ; preds = %bb63.fragment, %bb62
%.SV38.phi1132 = phi i64 [ %.SV38.phi1110 , %bb63.fragment ] , [ %.SV38.phi1098 , %bb62 ] ; <i64> [#uses=1]
%.SV52.phi1131 = phi i32 * [ %.SV52.phi1109 , %bb63.fragment ] , [ %.SV52.phi1097 , %bb62 ] ; <i32*> [#uses=1]
%.SV68.phi1130 = phi i32 [ %.SV68.phi1108 , %bb63.fragment ] , [ %.SV68.phi1096 , %bb62 ] ; <i32> [#uses=1]
%.SV70.phi1129 = phi i32 [ %.SV70.phi1107 , %bb63.fragment ] , [ %.SV70.phi1095 , %bb62 ] ; <i32> [#uses=1]
%Opq.link.SV615.phi = phi i32 [ %Opq.sa.calc890 , %bb63.fragment ] , [ %Opq.sa.calc608 , %bb62 ] ; <i32> [#uses=1]
%.SV150.phi = phi i32 * [ %.SV150.phi1060 , %bb63.fragment ] , [ %148 , %bb62 ] ; <i32*> [#uses=1]
%.SV152.phi = phi i32 * [ %.SV152.phi1059 , %bb63.fragment ] , [ %149 , %bb62 ] ; <i32*> [#uses=1]
%.SV148.phi = phi i32 [ %.SV148.phi1057 , %bb63.fragment ] , [ %147 , %bb62 ] ; <i32> [#uses=1]
%Opq.link.mask = and i32 %Opq.link.SV615.phi , 1 ; <i32> [#uses=1]
%Opq.sa.calc614 = add i32 %Opq.link.mask , 189 ; <i32> [#uses=1]
%163 = add i32 %.SV148.phi , 1 ; <i32> [#uses=1]
store i32 %163 , i32 * %.SV150.phi , align 4
br label %bb65
bb65: ; preds = %meshBB456, %bb64, %bb61.fragment
%.SV38.phi1144 = phi i64 [ %.SV38.phi1137 , %meshBB456 ] , [ %.SV38.phi1098 , %bb61.fragment ] , [ %.SV38.phi1132 , %bb64 ] ; <i64> [#uses=1]
%.SV52.phi1143 = phi i32 * [ %.SV52.phi1136 , %meshBB456 ] , [ %.SV52.phi1097 , %bb61.fragment ] , [ %.SV52.phi1131 , %bb64 ] ; <i32*> [#uses=1]
%.SV68.phi1142 = phi i32 [ %.SV68.phi1135 , %meshBB456 ] , [ %.SV68.phi1096 , %bb61.fragment ] , [ %.SV68.phi1130 , %bb64 ] ; <i32> [#uses=1]
%.SV70.phi1141 = phi i32 [ %.SV70.phi1134 , %meshBB456 ] , [ %.SV70.phi1095 , %bb61.fragment ] , [ %.SV70.phi1129 , %bb64 ] ; <i32> [#uses=1]
%.SV152.phi1058 = phi i32 * [ %.SV152.phi1133 , %meshBB456 ] , [ %149 , %bb61.fragment ] , [ %.SV152.phi , %bb64 ] ; <i32*> [#uses=1]
%Opq.link.SV618.phi = phi i32 [ %Opq.sa.calc816 , %meshBB456 ] , [ %Opq.sa.calc700 , %bb61.fragment ] , [ %Opq.sa.calc614 , %bb64 ] ; <i32> [#uses=1]
%Opq.link.mask620 = and i32 %Opq.link.SV618.phi , 40 ; <i32> [#uses=1]
%Opq.sa.calc617 = add i32 %Opq.link.mask620 , -35 ; <i32> [#uses=2]
2015-02-27 21:17:42 +00:00
%164 = load i32 , i32 * %.SV152.phi1058 , align 8 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %meshBB436
bb65.fragment: ; preds = %meshBB436
%Opq.sa.calc832 = add i32 %Opq.link.mask706 , 1 ; <i32> [#uses=2]
store i32 %.SV268.phi , i32 * %.load62.SV.phi , align 4
br label %meshBB364
bb66: ; preds = %bb60
%Opq.sa.calc621 = add i32 %Opq.sa.calc602 , -217 ; <i32> [#uses=1]
%165 = add i32 %curr_mb_nr , -1 ; <i32> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%166 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 1 ; <i32*> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %meshBB420
bb66.fragment: ; preds = %meshBB420
%Opq.sa.calc795 = xor i32 %Opq.sa.calc837 , 105 ; <i32> [#uses=2]
%Opq.sa.calc794 = sub i32 %Opq.sa.calc795 , 167 ; <i32> [#uses=1]
store i32 %.SV270.phi , i32 * %.SV272.phi , align 4
store i32 1 , i32 * %.load61.SV.phi , align 4
br label %meshBB444
bb68: ; preds = %bb59.fragment
%Opq.sa.calc624 = sub i32 %Opq.sa.calc731 , 229 ; <i32> [#uses=3]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%167 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 23 ; <i32*> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %meshBB344
bb68.fragment: ; preds = %meshBB344
%Opq.sa.calc784 = sub i32 %Opq.link.mask722 , 3 ; <i32> [#uses=5]
2015-02-27 21:17:42 +00:00
%168 = load i32 , i32 * %.SV274.phi , align 8 ; <i32> [#uses=3]
2009-04-28 06:24:09 +00:00
br i1 %.load144.SV.phi , label %bb69 , label %meshBB412
bb69: ; preds = %bb68.fragment
%Opq.sa.calc627 = add i32 %Opq.sa.calc784 , 163 ; <i32> [#uses=0]
[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
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%169 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 1 ; <i32*> [#uses=2]
2009-04-28 06:24:09 +00:00
store i32 %168 , i32 * %169 , align 4
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%170 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 27 ; <i32*> [#uses=2]
2009-04-28 06:24:09 +00:00
br label %bb69.fragment
bb69.fragment: ; preds = %bb69
%Opq.sa.calc996 = sub i32 %Opq.sa.calc784 , -9 ; <i32> [#uses=3]
%Opq.sa.calc994 = sub i32 %Opq.sa.calc996 , %Opq.sa.calc784 ; <i32> [#uses=1]
%Opq.sa.calc995 = sub i32 %Opq.sa.calc994 , 3 ; <i32> [#uses=2]
2015-02-27 21:17:42 +00:00
%171 = load i32 , i32 * %170 , align 8 ; <i32> [#uses=3]
2009-04-28 06:24:09 +00:00
store i32 %171 , i32 * %.SV52.phi1170 , align 4
2015-02-27 21:17:42 +00:00
%172 = load i32 , i32 * %170 , align 8 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%173 = icmp eq i32 %172 , 0 ; <i1> [#uses=1]
br i1 %173 , label %meshBB396 , label %meshBB400
bb70: ; preds = %meshBB400
%Opq.sa.calc630 = add i32 %Opq.sa.calc824 , -203 ; <i32> [#uses=2]
2015-02-27 21:17:42 +00:00
%174 = load %struct.ImageParameters * , %struct.ImageParameters * * @img , align 8 ; <%struct.ImageParameters*> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%175 = getelementptr %struct.ImageParameters , %struct.ImageParameters * %174 , i64 0 , i32 39 ; <%struct.Macroblock**> [#uses=1]
2015-02-27 21:17:42 +00:00
%176 = load %struct.Macroblock * , %struct.Macroblock * * %175 , align 8 ; <%struct.Macroblock*> [#uses=1]
%177 = load i32 , i32 * %.SV156.phi , align 8 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %meshBB428
bb70.fragment: ; preds = %meshBB428
%Opq.sa.calc739 = xor i32 %Opq.sa.calc897 , 213 ; <i32> [#uses=2]
%Opq.sa.calc738 = sub i32 %Opq.sa.calc739 , 1 ; <i32> [#uses=2]
%178 = sext i32 %.SV280.phi to i64 ; <i64> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%179 = getelementptr %struct.Macroblock , %struct.Macroblock * %.SV278.phi , i64 %178 , i32 20 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%180 = load i32 , i32 * %179 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%181 = icmp eq i32 %180 , 0 ; <i1> [#uses=1]
br i1 %181 , label %meshBB452 , label %meshBB356
bb71: ; preds = %meshBB452
%Opq.sa.calc633 = xor i32 %Opq.sa.calc820 , 118 ; <i32> [#uses=1]
%182 = add i32 %.SV158.phi1106 , 1 ; <i32> [#uses=1]
br label %meshBB352
bb71.fragment: ; preds = %meshBB352
%Opq.sa.calc809 = sub i32 %Opq.sa.calc876 , 17 ; <i32> [#uses=2]
store i32 %.SV282.phi , i32 * %.load163.SV.phi , align 4
%183 = shl i32 %yN , 1 ; <i32> [#uses=1]
br label %meshBB436
bb74: ; preds = %meshBB412
%Opq.sa.calc636 = xor i32 %Opq.sa.calc932 , 233 ; <i32> [#uses=1]
%184 = add i32 %.SV158.phi1063 , 1 ; <i32> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%185 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 1 ; <i32*> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %bb74.fragment
bb74.fragment: ; preds = %bb74
%Opq.sa.calc1011 = sub i32 %Opq.sa.calc636 , -19 ; <i32> [#uses=0]
store i32 %184 , i32 * %185 , align 4
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%186 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 27 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%187 = load i32 , i32 * %186 , align 8 ; <i32> [#uses=2]
2009-04-28 06:24:09 +00:00
store i32 %187 , i32 * %.SV52.phi1186 , align 4
br label %bb96
bb76: ; preds = %bb58
%Opq.sa.calc640 = xor i32 %Opq.sa.calc1002 , 71 ; <i32> [#uses=4]
%Opq.sa.calc639 = xor i32 %Opq.sa.calc640 , 219 ; <i32> [#uses=0]
%188 = icmp eq i32 %yN , 0 ; <i1> [#uses=1]
br i1 %188 , label %bb77 , label %bb79
bb77: ; preds = %bb76
%Opq.sa.calc643 = add i32 %Opq.sa.calc640 , 2 ; <i32> [#uses=2]
2015-02-27 21:17:42 +00:00
%189 = load %struct.ImageParameters * , %struct.ImageParameters * * @img , align 8 ; <%struct.ImageParameters*> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%190 = getelementptr %struct.ImageParameters , %struct.ImageParameters * %189 , i64 0 , i32 45 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%191 = load i32 , i32 * %190 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%192 = icmp eq i32 %191 , 2 ; <i1> [#uses=1]
br i1 %192 , label %meshBB416 , label %bb79
bb78: ; preds = %meshBB416
%Opq.sa.calc647 = xor i32 %Opq.sa.calc971 , 25 ; <i32> [#uses=2]
%Opq.sa.calc646 = sub i32 %Opq.sa.calc647 , 29 ; <i32> [#uses=0]
[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
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%193 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 23 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%194 = load i32 , i32 * %193 , align 8 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%195 = add i32 %194 , 1 ; <i32> [#uses=1]
br label %bb78.fragment
bb78.fragment: ; preds = %bb78
%Opq.sa.calc850 = sub i32 %Opq.sa.calc647 , -93 ; <i32> [#uses=0]
[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
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%196 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 1 ; <i32*> [#uses=1]
2009-04-28 06:24:09 +00:00
store i32 %195 , i32 * %196 , align 4
store i32 1 , i32 * %.SV52.phi1200 , align 4
%197 = add i32 %yN , -1 ; <i32> [#uses=1]
br label %bb98
bb79: ; preds = %bb77, %bb76
%Opq.link.SV652.phi = phi i32 [ %Opq.sa.calc643 , %bb77 ] , [ %Opq.sa.calc640 , %bb76 ] ; <i32> [#uses=1]
%Opq.link.mask654 = and i32 %Opq.link.SV652.phi , 8 ; <i32> [#uses=1]
%Opq.sa.calc651 = sub i32 %Opq.link.mask654 , -2 ; <i32> [#uses=3]
%Opq.sa.calc650 = xor i32 %Opq.sa.calc651 , 1 ; <i32> [#uses=2]
br i1 %or.cond.not.SV.phi1094 , label %meshBB456 , label %meshBB352
bb81: ; preds = %meshBB456
%Opq.sa.calc655 = add i32 %Opq.sa.calc816 , 56 ; <i32> [#uses=0]
[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
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%198 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 1 ; <i32*> [#uses=1]
2009-04-28 06:24:09 +00:00
store i32 %curr_mb_nr , i32 * %198 , align 4
store i32 1 , i32 * %.SV52.phi1136 , align 4
br label %bb98
bb83: ; preds = %bb56.fragment
%Opq.sa.calc658 = sub i32 %Opq.sa.calc1002 , 73 ; <i32> [#uses=3]
br i1 %140 , label %bb84 , label %meshBB424
bb84: ; preds = %bb83
%Opq.sa.calc661 = xor i32 %Opq.sa.calc658 , 22 ; <i32> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%199 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 20 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%200 = load i32 , i32 * %199 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %meshBB400
bb84.fragment: ; preds = %meshBB400
%Opq.sa.calc802 = xor i32 %Opq.sa.calc824 , 240 ; <i32> [#uses=3]
%201 = icmp eq i32 %.SV290.phi , 0 ; <i1> [#uses=1]
%202 = and i32 %curr_mb_nr , 1 ; <i32> [#uses=1]
%203 = icmp eq i32 %202 , 0 ; <i1> [#uses=2]
br i1 %201 , label %meshBB372 , label %bb89
bb85: ; preds = %meshBB372
%Opq.sa.calc667 = sub i32 %Opq.sa.calc812 , 20 ; <i32> [#uses=3]
%Opq.sa.calc666 = sub i32 %Opq.sa.calc667 , 84 ; <i32> [#uses=2]
%Opq.sa.calc664 = add i32 %Opq.sa.calc666 , %Opq.sa.calc667 ; <i32> [#uses=1]
%Opq.sa.calc665 = add i32 %Opq.sa.calc664 , -112 ; <i32> [#uses=2]
br i1 %.SV167.phi , label %meshBB336 , label %meshBB440
bb86: ; preds = %meshBB336
%Opq.sa.calc670 = sub i32 %Opq.sa.calc979 , 35 ; <i32> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%204 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 24 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%205 = load i32 , i32 * %204 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%206 = add i32 %205 , 1 ; <i32> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%207 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 1 ; <i32*> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %bb86.fragment
bb86.fragment: ; preds = %bb86
%Opq.sa.calc943 = xor i32 %Opq.sa.calc670 , 123 ; <i32> [#uses=2]
store i32 %206 , i32 * %207 , align 4
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%208 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 28 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%209 = load i32 , i32 * %208 , align 4 ; <i32> [#uses=2]
2009-04-28 06:24:09 +00:00
store i32 %209 , i32 * %.SV52.phi1234 , align 4
br label %meshBB424
bb87: ; preds = %meshBB440
%Opq.sa.calc674 = xor i32 %Opq.sa.calc990 , 44 ; <i32> [#uses=1]
%Opq.sa.calc673 = xor i32 %Opq.sa.calc674 , 160 ; <i32> [#uses=1]
store i32 0 , i32 * %.SV52.phi1235 , align 4
br label %meshBB408
bb89: ; preds = %bb84.fragment
%Opq.sa.calc677 = sub i32 %Opq.sa.calc802 , -183 ; <i32> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%210 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 24 ; <i32*> [#uses=2]
2009-04-28 06:24:09 +00:00
br label %bb89.fragment
bb89.fragment: ; preds = %bb89
%Opq.sa.calc962 = add i32 %Opq.sa.calc677 , -188 ; <i32> [#uses=3]
2015-02-27 21:17:42 +00:00
%211 = load i32 , i32 * %210 , align 4 ; <i32> [#uses=3]
2009-04-28 06:24:09 +00:00
br i1 %203 , label %bb90 , label %meshBB408
bb90: ; preds = %bb89.fragment
%Opq.sa.calc680 = xor i32 %Opq.sa.calc962 , 92 ; <i32> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%212 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 1 ; <i32*> [#uses=2]
2009-04-28 06:24:09 +00:00
store i32 %211 , i32 * %212 , align 4
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%213 = getelementptr %struct.Macroblock , %struct.Macroblock * %2 , i64 %3 , i32 28 ; <i32*> [#uses=2]
2009-04-28 06:24:09 +00:00
br label %bb90.fragment
bb90.fragment: ; preds = %bb90
%Opq.sa.calc773 = sub i32 %Opq.sa.calc680 , 60 ; <i32> [#uses=3]
%Opq.sa.calc772 = add i32 %Opq.sa.calc773 , -25 ; <i32> [#uses=2]
2015-02-27 21:17:42 +00:00
%214 = load i32 , i32 * %213 , align 4 ; <i32> [#uses=3]
2009-04-28 06:24:09 +00:00
store i32 %214 , i32 * %.SV52.phi1190 , align 4
2015-02-27 21:17:42 +00:00
%215 = load i32 , i32 * %213 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%216 = icmp eq i32 %215 , 0 ; <i1> [#uses=1]
br i1 %216 , label %meshBB416 , label %meshBB368
bb91: ; preds = %meshBB368
%Opq.sa.calc683 = sub i32 %Opq.sa.calc768 , -7 ; <i32> [#uses=0]
2015-02-27 21:17:42 +00:00
%217 = load %struct.ImageParameters * , %struct.ImageParameters * * @img , align 8 ; <%struct.ImageParameters*> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%218 = getelementptr %struct.ImageParameters , %struct.ImageParameters * %217 , i64 0 , i32 39 ; <%struct.Macroblock**> [#uses=1]
2015-02-27 21:17:42 +00:00
%219 = load %struct.Macroblock * , %struct.Macroblock * * %218 , align 8 ; <%struct.Macroblock*> [#uses=1]
%220 = load i32 , i32 * %.SV170.phi , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %bb91.fragment
bb91.fragment: ; preds = %bb91
%Opq.sa.calc853 = xor i32 %Opq.sa.calc768 , 8 ; <i32> [#uses=1]
%221 = sext i32 %220 to i64 ; <i64> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%222 = getelementptr %struct.Macroblock , %struct.Macroblock * %219 , i64 %221 , i32 20 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%223 = load i32 , i32 * %222 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%224 = icmp eq i32 %223 , 0 ; <i1> [#uses=1]
br i1 %224 , label %bb92 , label %bb96
bb92: ; preds = %bb91.fragment
%Opq.sa.calc686 = xor i32 %Opq.sa.calc853 , 2 ; <i32> [#uses=1]
%225 = add i32 %.SV172.phi , 1 ; <i32> [#uses=1]
br label %bb92.fragment
bb92.fragment: ; preds = %bb92
%Opq.sa.calc1005 = xor i32 %Opq.sa.calc686 , 130 ; <i32> [#uses=2]
store i32 %225 , i32 * %.SV176.phi , align 4
%226 = shl i32 %yN , 1 ; <i32> [#uses=1]
br label %meshBB380
bb95: ; preds = %meshBB408
%Opq.sa.calc689 = xor i32 %Opq.sa.calc912 , 207 ; <i32> [#uses=3]
%227 = add i32 %.SV172.phi1074 , 1 ; <i32> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%228 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 1 ; <i32*> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %meshBB384
bb95.fragment: ; preds = %meshBB384
%Opq.sa.calc841 = sub i32 %Opq.sa.calc901 , 76 ; <i32> [#uses=0]
store i32 %.SV306.phi , i32 * %.SV308.phi , align 4
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%229 = getelementptr %struct.Macroblock , %struct.Macroblock * %.load.SV.phi , i64 %.load20.SV.phi , i32 28 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%230 = load i32 , i32 * %229 , align 4 ; <i32> [#uses=2]
2009-04-28 06:24:09 +00:00
store i32 %230 , i32 * %.load53.SV.phi , align 4
br label %bb96
bb96: ; preds = %meshBB444, %meshBB440, %meshBB436, %meshBB424, %meshBB420, %meshBB416, %meshBB396, %meshBB388, %meshBB380, %meshBB376, %meshBB364, %meshBB356, %meshBB340, %meshBB324, %meshBB, %bb95.fragment, %bb91.fragment, %bb74.fragment, %bb51, %bb48, %bb43, %bb41.fragment, %bb37.fragment, %bb36.fragment, %bb34.fragment, %bb30.fragment, %bb25, %bb19.fragment, %bb16.fragment, %bb15.fragment, %bb11.fragment, %bb9.fragment, %bb8.fragment, %bb7.fragment
%.SV38.phi1087 = phi i64 [ %.SV38.phi1224 , %meshBB444 ] , [ %.SV38.phi1210 , %meshBB440 ] , [ %.SV38.phi1147 , %meshBB436 ] , [ %.SV38.phi1197 , %meshBB424 ] , [ %.SV38.phi1194 , %meshBB420 ] , [ %.SV38.phi1201 , %meshBB416 ] , [ %.SV38.phi , %meshBB396 ] , [ %.SV38.phi1118 , %meshBB388 ] , [ %.SV38.phi1207 , %meshBB380 ] , [ %.SV38.phi1153 , %meshBB376 ] , [ %.SV38.phi1098 , %meshBB364 ] , [ %.SV38.phi1121 , %meshBB356 ] , [ %.SV38.phi1167 , %meshBB340 ] , [ %.SV38.phi1175 , %meshBB324 ] , [ %.SV38.phi1183 , %meshBB ] , [ %.SV38.phi1164 , %bb91.fragment ] , [ %.SV38.phi1179 , %bb48 ] , [ %.SV38.phi1231 , %bb41.fragment ] , [ %.SV38.phi1172 , %bb25 ] , [ %.SV38.phi1175 , %bb15.fragment ] , [ %.SV38.phi1164 , %bb9.fragment ] , [ %.SV38.phi1164 , %bb8.fragment ] , [ %.SV38.phi1221 , %bb95.fragment ] , [ %.SV38.phi1187 , %bb74.fragment ] , [ %.SV38.phi1227 , %bb51 ] , [ %.SV38.phi1179 , %bb43 ] , [ %.SV38.phi1103 , %bb37.fragment ] , [ %.SV38.phi1214 , %bb36.fragment ] , [ %.SV38.phi1227 , %bb34.fragment ] , [ %.SV38.phi1121 , %bb30.fragment ] , [ %.SV38.phi1187 , %bb19.fragment ] , [ %.SV38.phi1175 , %bb16.fragment ] , [ %.SV38.phi1204 , %bb11.fragment ] , [ %.SV38.phi1118 , %bb7.fragment ] ; <i64> [#uses=2]
%.SV68.phi1086 = phi i32 [ %.SV68.phi1223 , %meshBB444 ] , [ %.SV68.phi1209 , %meshBB440 ] , [ %.SV68.phi1146 , %meshBB436 ] , [ %.SV68.phi1196 , %meshBB424 ] , [ %.SV68.phi1193 , %meshBB420 ] , [ %.SV68.phi1199 , %meshBB416 ] , [ %.SV68.phi , %meshBB396 ] , [ %.SV68.phi1117 , %meshBB388 ] , [ %.SV68.phi1206 , %meshBB380 ] , [ %.SV68.phi1152 , %meshBB376 ] , [ %.SV68.phi1096 , %meshBB364 ] , [ %.SV68.phi1120 , %meshBB356 ] , [ %.SV68.phi1166 , %meshBB340 ] , [ %.SV68.phi1174 , %meshBB324 ] , [ %.SV68.phi1181 , %meshBB ] , [ %.SV68.phi1162 , %bb91.fragment ] , [ %.SV68.phi1177 , %bb48 ] , [ %.SV68.phi1229 , %bb41.fragment ] , [ %.SV68.phi1169 , %bb25 ] , [ %.SV68.phi1174 , %bb15.fragment ] , [ %.SV68.phi1162 , %bb9.fragment ] , [ %.SV68.phi1162 , %bb8.fragment ] , [ %.SV68.phi1220 , %bb95.fragment ] , [ %.SV68.phi1185 , %bb74.fragment ] , [ %.SV68.phi1226 , %bb51 ] , [ %.SV68.phi1177 , %bb43 ] , [ %.SV68.phi1100 , %bb37.fragment ] , [ %.SV68.phi1212 , %bb36.fragment ] , [ %.SV68.phi1226 , %bb34.fragment ] , [ %.SV68.phi1120 , %bb30.fragment ] , [ %.SV68.phi1185 , %bb19.fragment ] , [ %.SV68.phi1174 , %bb16.fragment ] , [ %.SV68.phi1203 , %bb11.fragment ] , [ %.SV68.phi1117 , %bb7.fragment ] ; <i32> [#uses=2]
%.SV70.phi1085 = phi i32 [ %.SV70.phi1222 , %meshBB444 ] , [ %.SV70.phi1208 , %meshBB440 ] , [ %.SV70.phi1145 , %meshBB436 ] , [ %.SV70.phi1195 , %meshBB424 ] , [ %.SV70.phi1192 , %meshBB420 ] , [ %.SV70.phi1198 , %meshBB416 ] , [ %.SV70.phi , %meshBB396 ] , [ %.SV70.phi1116 , %meshBB388 ] , [ %.SV70.phi1205 , %meshBB380 ] , [ %.SV70.phi1151 , %meshBB376 ] , [ %.SV70.phi1095 , %meshBB364 ] , [ %.SV70.phi1119 , %meshBB356 ] , [ %.SV70.phi1165 , %meshBB340 ] , [ %.SV70.phi1173 , %meshBB324 ] , [ %.SV70.phi1180 , %meshBB ] , [ %.SV70.phi1161 , %bb91.fragment ] , [ %.SV70.phi1176 , %bb48 ] , [ %.SV70.phi1228 , %bb41.fragment ] , [ %.SV70.phi1168 , %bb25 ] , [ %.SV70.phi1173 , %bb15.fragment ] , [ %.SV70.phi1161 , %bb9.fragment ] , [ %.SV70.phi1161 , %bb8.fragment ] , [ %.SV70.phi1219 , %bb95.fragment ] , [ %.SV70.phi1184 , %bb74.fragment ] , [ %.SV70.phi1225 , %bb51 ] , [ %.SV70.phi1176 , %bb43 ] , [ %.SV70.phi1099 , %bb37.fragment ] , [ %.SV70.phi1211 , %bb36.fragment ] , [ %.SV70.phi1225 , %bb34.fragment ] , [ %.SV70.phi1119 , %bb30.fragment ] , [ %.SV70.phi1184 , %bb19.fragment ] , [ %.SV70.phi1173 , %bb16.fragment ] , [ %.SV70.phi1202 , %bb11.fragment ] , [ %.SV70.phi1116 , %bb7.fragment ] ; <i32> [#uses=2]
%.SV.phi = phi i32 [ %.SV.phi1048 , %meshBB444 ] , [ %.SV.phi1056 , %meshBB440 ] , [ %.SV.phi1067 , %meshBB436 ] , [ %.SV.phi1072 , %meshBB424 ] , [ %.SV.phi1044 , %meshBB420 ] , [ %.SV.phi1076 , %meshBB416 ] , [ %.SV.phi1065 , %meshBB396 ] , [ %.SV.phi1054 , %meshBB388 ] , [ %.SV.phi1052 , %meshBB380 ] , [ %.SV.phi1050 , %meshBB376 ] , [ %.SV.phi1062 , %meshBB364 ] , [ %.SV.phi1046 , %meshBB356 ] , [ %.SV.phi1042 , %meshBB340 ] , [ %.SV.phi1032 , %meshBB324 ] , [ %.SV.phi1034 , %meshBB ] , [ %.SV178.phi , %bb91.fragment ] , [ %.SV118.phi1040 , %bb48 ] , [ %.SV118.phi1125 , %bb41.fragment ] , [ %.SV118.phi , %bb25 ] , [ %.load94.SV.phi , %bb15.fragment ] , [ %32 , %bb9.fragment ] , [ %32 , %bb8.fragment ] , [ %230 , %bb95.fragment ] , [ %187 , %bb74.fragment ] , [ %.SV118.phi1081 , %bb51 ] , [ %.SV118.phi1040 , %bb43 ] , [ %.load131.SV.phi , %bb37.fragment ] , [ %.SV118.phi1154 , %bb36.fragment ] , [ %.load129.SV.phi , %bb34.fragment ] , [ %.SV118.phi1158 , %bb30.fragment ] , [ %66 , %bb19.fragment ] , [ %.SV93.phi , %bb16.fragment ] , [ %.load84.SV.phi , %bb11.fragment ] , [ %27 , %bb7.fragment ] ; <i32> [#uses=1]
%yM.0.SV.phi = phi i32 [ -1 , %meshBB444 ] , [ %yN , %meshBB440 ] , [ %yM.0.SV.phi1066 , %meshBB436 ] , [ %yN , %meshBB424 ] , [ %yN , %meshBB420 ] , [ -1 , %meshBB416 ] , [ -1 , %meshBB396 ] , [ %yM.0.SV.phi1053 , %meshBB388 ] , [ %yM.0.SV.phi1051 , %meshBB380 ] , [ %yM.0.SV.phi1049 , %meshBB376 ] , [ %yN , %meshBB364 ] , [ %yN , %meshBB356 ] , [ %yM.0.SV.phi1041 , %meshBB340 ] , [ -1 , %meshBB324 ] , [ -1 , %meshBB ] , [ %yN , %bb91.fragment ] , [ -1 , %bb48 ] , [ %yN , %bb41.fragment ] , [ -1 , %bb25 ] , [ %yN , %bb15.fragment ] , [ %yN , %bb9.fragment ] , [ -1 , %bb8.fragment ] , [ %yN , %bb95.fragment ] , [ %yN , %bb74.fragment ] , [ %133 , %bb51 ] , [ %118 , %bb43 ] , [ %107 , %bb37.fragment ] , [ %104 , %bb36.fragment ] , [ %yN , %bb34.fragment ] , [ %91 , %bb30.fragment ] , [ %yN , %bb19.fragment ] , [ %62 , %bb16.fragment ] , [ %45 , %bb11.fragment ] , [ %yN , %bb7.fragment ] ; <i32> [#uses=2]
%Opq.sa.calc693 = add i32 0 , 15 ; <i32> [#uses=2]
%Opq.sa.calc692 = xor i32 %Opq.sa.calc693 , 8 ; <i32> [#uses=1]
%231 = icmp eq i32 %.SV.phi , 0 ; <i1> [#uses=1]
br i1 %231 , label %bb97 , label %meshBB404
bb97: ; preds = %meshBB424, %meshBB408, %meshBB352, %bb96, %bb21
%.SV38.phi1150 = phi i64 [ %.SV38.phi1197 , %meshBB424 ] , [ %.SV38.phi1218 , %meshBB408 ] , [ %.SV38.phi1140 , %meshBB352 ] , [ %.SV38.phi1087 , %bb96 ] , [ %4 , %bb21 ] ; <i64> [#uses=1]
%.SV68.phi1149 = phi i32 [ %.SV68.phi1196 , %meshBB424 ] , [ %.SV68.phi1216 , %meshBB408 ] , [ %.SV68.phi1139 , %meshBB352 ] , [ %.SV68.phi1086 , %bb96 ] , [ %.SV68.phi1021 , %bb21 ] ; <i32> [#uses=1]
%.SV70.phi1148 = phi i32 [ %.SV70.phi1195 , %meshBB424 ] , [ %.SV70.phi1215 , %meshBB408 ] , [ %.SV70.phi1138 , %meshBB352 ] , [ %.SV70.phi1085 , %bb96 ] , [ %.SV70.phi1027 , %bb21 ] ; <i32> [#uses=1]
%yM.0.reg2mem.0.SV.phi = phi i32 [ -1 , %meshBB424 ] , [ -1 , %meshBB408 ] , [ -1 , %meshBB352 ] , [ %yM.0.SV.phi , %bb96 ] , [ -1 , %bb21 ] ; <i32> [#uses=1]
%Opq.sa.calc694 = xor i32 0 , 243 ; <i32> [#uses=1]
2015-02-27 21:17:42 +00:00
%232 = load %struct.ImageParameters * , %struct.ImageParameters * * @img , align 8 ; <%struct.ImageParameters*> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%233 = getelementptr %struct.ImageParameters , %struct.ImageParameters * %232 , i64 0 , i32 45 ; <i32*> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %bb97.fragment
bb97.fragment: ; preds = %bb97
%Opq.sa.calc928 = xor i32 %Opq.sa.calc694 , 128 ; <i32> [#uses=1]
2015-02-27 21:17:42 +00:00
%234 = load i32 , i32 * %233 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%235 = icmp eq i32 %234 , 0 ; <i1> [#uses=1]
br i1 %235 , label %return , label %bb98
bb98: ; preds = %meshBB444, %meshBB404, %bb97.fragment, %bb81, %bb78.fragment
%.SV38.phi1093 = phi i64 [ %.SV38.phi1224 , %meshBB444 ] , [ %.SV38.phi1017 , %meshBB404 ] , [ %.SV38.phi1150 , %bb97.fragment ] , [ %.SV38.phi1137 , %bb81 ] , [ %.SV38.phi1201 , %bb78.fragment ] ; <i64> [#uses=2]
%.SV68.phi1092 = phi i32 [ %.SV68.phi1223 , %meshBB444 ] , [ %.SV68.phi1023 , %meshBB404 ] , [ %.SV68.phi1149 , %bb97.fragment ] , [ %.SV68.phi1135 , %bb81 ] , [ %.SV68.phi1199 , %bb78.fragment ] ; <i32> [#uses=2]
%.SV70.phi1091 = phi i32 [ %.SV70.phi1222 , %meshBB444 ] , [ %.SV70.phi1028 , %meshBB404 ] , [ %.SV70.phi1148 , %bb97.fragment ] , [ %.SV70.phi1134 , %bb81 ] , [ %.SV70.phi1198 , %bb78.fragment ] ; <i32> [#uses=2]
%yM.0.reg2mem.1.SV.phi1068 = phi i32 [ %yN , %meshBB444 ] , [ %yM.0.reg2mem.1.SV.phi1077 , %meshBB404 ] , [ %yM.0.reg2mem.0.SV.phi , %bb97.fragment ] , [ %yN , %bb81 ] , [ %197 , %bb78.fragment ] ; <i32> [#uses=1]
%Opq.sa.calc695 = xor i32 0 , 23 ; <i32> [#uses=2]
%236 = and i32 %.SV70.phi1091 , %xN ; <i32> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%237 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 2 ; <i32*> [#uses=2]
2009-04-28 06:24:09 +00:00
store i32 %236 , i32 * %237 , align 4
%238 = and i32 %yM.0.reg2mem.1.SV.phi1068 , %.SV68.phi1092 ; <i32> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%239 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 3 ; <i32*> [#uses=2]
2009-04-28 06:24:09 +00:00
store i32 %238 , i32 * %239 , align 4
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%240 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 5 ; <i32*> [#uses=1]
2009-04-28 06:24:09 +00:00
br label %meshBB376
bb98.fragment: ; preds = %meshBB376
%Opq.sa.calc1008 = sub i32 %Opq.link.mask911 , 13 ; <i32> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%241 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 4 ; <i32*> [#uses=4]
%242 = getelementptr %struct.PixelPos , %struct.PixelPos * %pix , i64 0 , i32 1 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%243 = load i32 , i32 * %242 , align 4 ; <i32> [#uses=1]
%244 = load void ( i32 , i32 * , i32 * ) * , void ( i32 , i32 * , i32 * ) * * @get_mb_block_pos , align 8 ; <void (i32, i32*, i32*)*> [#uses=1]
2009-04-28 06:24:09 +00:00
tail call void %244 ( i32 %243 , i32 * %241 , i32 * %.SV317.phi ) nounwind
2015-02-27 21:17:42 +00:00
%245 = load i32 , i32 * %241 , align 4 ; <i32> [#uses=1]
%246 = load %struct.ImageParameters * , %struct.ImageParameters * * @img , align 8 ; <%struct.ImageParameters*> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%247 = getelementptr %struct.ImageParameters , %struct.ImageParameters * %246 , i64 0 , i32 119 , i64 %.load39.SV.phi , i64 0 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%248 = load i32 , i32 * %247 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%249 = mul i32 %248 , %245 ; <i32> [#uses=2]
store i32 %249 , i32 * %241 , align 4
br label %bb98.fragment183
bb98.fragment183: ; preds = %bb98.fragment
%Opq.sa.calc777 = sub i32 %Opq.sa.calc1008 , -158 ; <i32> [#uses=1]
%Opq.sa.calc776 = sub i32 %Opq.sa.calc777 , 46 ; <i32> [#uses=0]
2015-02-27 21:17:42 +00:00
%250 = load i32 , i32 * %.SV317.phi , align 4 ; <i32> [#uses=1]
%251 = load %struct.ImageParameters * , %struct.ImageParameters * * @img , align 8 ; <%struct.ImageParameters*> [#uses=1]
[opaque pointer type] Add textual IR support for explicit type parameter to getelementptr instruction
One of several parallel first steps to remove the target type of pointers,
replacing them with a single opaque pointer type.
This adds an explicit type parameter to the gep instruction so that when the
first parameter becomes an opaque pointer type, the type to gep through is
still available to the instructions.
* This doesn't modify gep operators, only instructions (operators will be
handled separately)
* Textual IR changes only. Bitcode (including upgrade) and changing the
in-memory representation will be in separate changes.
* geps of vectors are transformed as:
getelementptr <4 x float*> %x, ...
->getelementptr float, <4 x float*> %x, ...
Then, once the opaque pointer type is introduced, this will ultimately look
like:
getelementptr float, <4 x ptr> %x
with the unambiguous interpretation that it is a vector of pointers to float.
* address spaces remain on the pointer, not the type:
getelementptr float addrspace(1)* %x
->getelementptr float, float addrspace(1)* %x
Then, eventually:
getelementptr float, ptr addrspace(1) %x
Importantly, the massive amount of test case churn has been automated by
same crappy python code. I had to manually update a few test cases that
wouldn't fit the script's model (r228970,r229196,r229197,r229198). The
python script just massages stdin and writes the result to stdout, I
then wrapped that in a shell script to handle replacing files, then
using the usual find+xargs to migrate all the files.
update.py:
import fileinput
import sys
import re
ibrep = re.compile(r"(^.*?[^%\w]getelementptr inbounds )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
normrep = re.compile( r"(^.*?[^%\w]getelementptr )(((?:<\d* x )?)(.*?)(| addrspace\(\d\)) *\*(|>)(?:$| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$))")
def conv(match, line):
if not match:
return line
line = match.groups()[0]
if len(match.groups()[5]) == 0:
line += match.groups()[2]
line += match.groups()[3]
line += ", "
line += match.groups()[1]
line += "\n"
return line
for line in sys.stdin:
if line.find("getelementptr ") == line.find("getelementptr inbounds"):
if line.find("getelementptr inbounds") != line.find("getelementptr inbounds ("):
line = conv(re.match(ibrep, line), line)
elif line.find("getelementptr ") != line.find("getelementptr ("):
line = conv(re.match(normrep, line), line)
sys.stdout.write(line)
apply.sh:
for name in "$@"
do
python3 `dirname "$0"`/update.py < "$name" > "$name.tmp" && mv "$name.tmp" "$name"
rm -f "$name.tmp"
done
The actual commands:
From llvm/src:
find test/ -name *.ll | xargs ./apply.sh
From llvm/src/tools/clang:
find test/ -name *.mm -o -name *.m -o -name *.cpp -o -name *.c | xargs -I '{}' ../../apply.sh "{}"
From llvm/src/tools/polly:
find test/ -name *.ll | xargs ./apply.sh
After that, check-all (with llvm, clang, clang-tools-extra, lld,
compiler-rt, and polly all checked out).
The extra 'rm' in the apply.sh script is due to a few files in clang's test
suite using interesting unicode stuff that my python script was throwing
exceptions on. None of those files needed to be migrated, so it seemed
sufficient to ignore those cases.
Reviewers: rafael, dexonsmith, grosser
Differential Revision: http://reviews.llvm.org/D7636
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230786 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-27 19:29:02 +00:00
%252 = getelementptr %struct.ImageParameters , %struct.ImageParameters * %251 , i64 0 , i32 119 , i64 %.load39.SV.phi , i64 1 ; <i32*> [#uses=1]
2015-02-27 21:17:42 +00:00
%253 = load i32 , i32 * %252 , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%254 = mul i32 %253 , %250 ; <i32> [#uses=1]
2015-02-27 21:17:42 +00:00
%255 = load i32 , i32 * %.SV313.phi , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%256 = add i32 %255 , %249 ; <i32> [#uses=1]
store i32 %256 , i32 * %241 , align 4
2015-02-27 21:17:42 +00:00
%257 = load i32 , i32 * %.SV315.phi , align 4 ; <i32> [#uses=1]
2009-04-28 06:24:09 +00:00
%258 = add i32 %257 , %254 ; <i32> [#uses=1]
store i32 %258 , i32 * %.SV317.phi , align 4
ret void
return: ; preds = %meshBB448, %meshBB396, %bb97.fragment
%Opq.link.SV697.phi = phi i32 [ %Opq.sa.calc957 , %meshBB448 ] , [ %Opq.sa.calc758 , %meshBB396 ] , [ %Opq.sa.calc928 , %bb97.fragment ] ; <i32> [#uses=1]
%Opq.link.mask699 = and i32 %Opq.link.SV697.phi , 0 ; <i32> [#uses=1]
%Opq.sa.calc696 = add i32 %Opq.link.mask699 , 238 ; <i32> [#uses=0]
ret void
meshBB: ; preds = %bb33.fragment, %bb14.fragment
%.SV38.phi1183 = phi i64 [ %.SV38.phi1115 , %bb14.fragment ] , [ %.SV38.phi1172 , %bb33.fragment ] ; <i64> [#uses=3]
%.SV68.phi1181 = phi i32 [ %.SV68.phi1112 , %bb14.fragment ] , [ %.SV68.phi1169 , %bb33.fragment ] ; <i32> [#uses=3]
%.SV70.phi1180 = phi i32 [ %.SV70.phi1111 , %bb14.fragment ] , [ %.SV70.phi1168 , %bb33.fragment ] ; <i32> [#uses=3]
%.SV104.phi1084 = phi i32 [ undef , %bb14.fragment ] , [ %.SV104.phi , %bb33.fragment ] ; <i32> [#uses=1]
%.SV111.phi1083 = phi i32 * [ undef , %bb14.fragment ] , [ %.SV111.phi , %bb33.fragment ] ; <i32*> [#uses=1]
%.SV118.phi1082 = phi i32 [ undef , %bb14.fragment ] , [ %.SV118.phi , %bb33.fragment ] ; <i32> [#uses=2]
%.SV.phi1034 = phi i32 [ %50 , %bb14.fragment ] , [ undef , %bb33.fragment ] ; <i32> [#uses=1]
%meshStackVariable.phi = phi i32 [ %Opq.sa.calc723 , %bb14.fragment ] , [ %Opq.sa.calc712 , %bb33.fragment ] ; <i32> [#uses=1]
%Opq.link.SV829.phi = phi i32 [ %Opq.sa.calc723 , %bb14.fragment ] , [ %Opq.sa.calc534 , %bb33.fragment ] ; <i32> [#uses=1]
%Opq.link.mask831 = and i32 %Opq.link.SV829.phi , 0 ; <i32> [#uses=1]
%Opq.sa.calc828 = sub i32 %Opq.link.mask831 , -117 ; <i32> [#uses=2]
%meshCmp = icmp eq i32 %meshStackVariable.phi , 3 ; <i1> [#uses=1]
br i1 %meshCmp , label %bb35 , label %bb96
meshBB324: ; preds = %bb32, %bb15
%.SV38.phi1175 = phi i64 [ %.SV38.phi1172 , %bb32 ] , [ %.SV38.phi1115 , %bb15 ] ; <i64> [#uses=3]
%.SV68.phi1174 = phi i32 [ %.SV68.phi1169 , %bb32 ] , [ %.SV68.phi1112 , %bb15 ] ; <i32> [#uses=3]
%.SV70.phi1173 = phi i32 [ %.SV70.phi1168 , %bb32 ] , [ %.SV70.phi1111 , %bb15 ] ; <i32> [#uses=3]
%.load94.SV.phi = phi i32 [ undef , %bb32 ] , [ %50 , %bb15 ] ; <i32> [#uses=1]
%.SV212.phi = phi %struct.Macroblock * [ undef , %bb32 ] , [ %55 , %bb15 ] ; <%struct.Macroblock*> [#uses=1]
%.SV214.phi = phi i32 [ undef , %bb32 ] , [ %56 , %bb15 ] ; <i32> [#uses=1]
%meshStackVariable325.phi = phi i32 [ %Opq.sa.calc531 , %bb32 ] , [ %Opq.sa.calc496 , %bb15 ] ; <i32> [#uses=1]
%Opq.link.SV751.phi = phi i32 [ %Opq.sa.calc512 , %bb32 ] , [ %Opq.sa.calc723 , %bb15 ] ; <i32> [#uses=1]
%.SV.phi1032 = phi i32 [ %.SV118.phi , %bb32 ] , [ undef , %bb15 ] ; <i32> [#uses=1]
%.SV93.phi = phi i32 [ undef , %bb32 ] , [ %50 , %bb15 ] ; <i32> [#uses=1]
%.SV91.phi = phi i32 * [ undef , %bb32 ] , [ %48 , %bb15 ] ; <i32*> [#uses=1]
%.SV87.phi = phi i32 [ undef , %bb32 ] , [ %47 , %bb15 ] ; <i32> [#uses=1]
%Opq.link.mask753 = and i32 %Opq.link.SV751.phi , 4 ; <i32> [#uses=1]
%Opq.sa.calc750 = add i32 %Opq.link.mask753 , 203 ; <i32> [#uses=1]
%meshCmp327 = icmp eq i32 %meshStackVariable325.phi , 14 ; <i1> [#uses=1]
br i1 %meshCmp327 , label %bb15.fragment , label %bb96
meshBB328: ; preds = %bb50, %bb34
%.SV38.phi1227 = phi i64 [ %.SV38.phi1179 , %bb50 ] , [ %.SV38.phi1172 , %bb34 ] ; <i64> [#uses=2]
%.SV68.phi1226 = phi i32 [ %.SV68.phi1177 , %bb50 ] , [ %.SV68.phi1169 , %bb34 ] ; <i32> [#uses=2]
%.SV70.phi1225 = phi i32 [ %.SV70.phi1176 , %bb50 ] , [ %.SV70.phi1168 , %bb34 ] ; <i32> [#uses=2]
%.SV118.phi1081 = phi i32 [ %.SV118.phi1040 , %bb50 ] , [ %.SV118.phi , %bb34 ] ; <i32> [#uses=1]
%.load129.SV.phi = phi i32 [ undef , %bb50 ] , [ %.SV118.phi , %bb34 ] ; <i32> [#uses=1]
%.load116.SV.phi = phi i32 * [ undef , %bb50 ] , [ %.SV111.phi , %bb34 ] ; <i32*> [#uses=1]
%.SV238.phi = phi i32 [ undef , %bb50 ] , [ %100 , %bb34 ] ; <i32> [#uses=1]
%meshStackVariable329.phi = phi i32 [ %Opq.sa.calc577 , %bb50 ] , [ %Opq.sa.calc537 , %bb34 ] ; <i32> [#uses=1]
%Opq.link.SV788.phi = phi i32 [ %Opq.sa.calc577 , %bb50 ] , [ %Opq.sa.calc712 , %bb34 ] ; <i32> [#uses=1]
%Opq.link.mask790 = and i32 %Opq.link.SV788.phi , 1 ; <i32> [#uses=1]
%Opq.sa.calc787 = sub i32 %Opq.link.mask790 , -227 ; <i32> [#uses=2]
%meshCmp331 = icmp eq i32 %meshStackVariable329.phi , 11 ; <i1> [#uses=1]
br i1 %meshCmp331 , label %bb34.fragment , label %bb51
meshBB332: ; preds = %bb44, %bb11
%.SV38.phi1204 = phi i64 [ %.SV38.phi1231 , %bb44 ] , [ %.SV38.phi1164 , %bb11 ] ; <i64> [#uses=2]
%.SV68.phi1203 = phi i32 [ %.SV68.phi1229 , %bb44 ] , [ %.SV68.phi1162 , %bb11 ] ; <i32> [#uses=2]
%.SV70.phi1202 = phi i32 [ %.SV70.phi1228 , %bb44 ] , [ %.SV70.phi1161 , %bb11 ] ; <i32> [#uses=2]
%.load127.SV.phi = phi i32 [ %.SV118.phi1125 , %bb44 ] , [ undef , %bb11 ] ; <i32> [#uses=1]
%.load114.SV.phi = phi i32 * [ %.SV111.phi1126 , %bb44 ] , [ undef , %bb11 ] ; <i32*> [#uses=1]
%.load46.SV.phi = phi i32 [ %.SV43.phi1230 , %bb44 ] , [ undef , %bb11 ] ; <i32> [#uses=1]
%.SV248.phi = phi i32 [ %119 , %bb44 ] , [ undef , %bb11 ] ; <i32> [#uses=1]
%.load84.SV.phi = phi i32 [ undef , %bb44 ] , [ %32 , %bb11 ] ; <i32> [#uses=1]
%.load81.SV.phi = phi i32 * [ undef , %bb44 ] , [ %.SV80.phi , %bb11 ] ; <i32*> [#uses=1]
%.load50.SV.phi = phi i32 [ undef , %bb44 ] , [ %.SV43.phi1163 , %bb11 ] ; <i32> [#uses=1]
%.SV206.phi = phi i32 [ undef , %bb44 ] , [ %43 , %bb11 ] ; <i32> [#uses=1]
%meshStackVariable333.phi = phi i32 [ %Opq.sa.calc566 , %bb44 ] , [ %Opq.sa.calc485 , %bb11 ] ; <i32> [#uses=1]
%Opq.link.SV857.phi = phi i32 [ %Opq.sa.calc987 , %bb44 ] , [ %Opq.sa.calc485 , %bb11 ] ; <i32> [#uses=1]
%Opq.link.mask859 = and i32 %Opq.link.SV857.phi , 4 ; <i32> [#uses=2]
%Opq.sa.calc856 = add i32 %Opq.link.mask859 , 204 ; <i32> [#uses=2]
%meshCmp335 = icmp eq i32 %meshStackVariable333.phi , 4 ; <i1> [#uses=1]
br i1 %meshCmp335 , label %bb11.fragment , label %bb44.fragment
meshBB336: ; preds = %bb85, %bb40
%.SV52.phi1234 = phi i32 * [ %.SV52.phi1213 , %bb85 ] , [ undef , %bb40 ] ; <i32*> [#uses=1]
%.SV38.phi1231 = phi i64 [ %.SV38.phi1214 , %bb85 ] , [ %.SV38.phi1179 , %bb40 ] ; <i64> [#uses=4]
%.SV43.phi1230 = phi i32 [ undef , %bb85 ] , [ %.SV43.phi1178 , %bb40 ] ; <i32> [#uses=3]
%.SV68.phi1229 = phi i32 [ %.SV68.phi1212 , %bb85 ] , [ %.SV68.phi1177 , %bb40 ] ; <i32> [#uses=4]
%.SV70.phi1228 = phi i32 [ %.SV70.phi1211 , %bb85 ] , [ %.SV70.phi1176 , %bb40 ] ; <i32> [#uses=4]
%.SV99.phi1128 = phi i32 * [ undef , %bb85 ] , [ %.SV99.phi1037 , %bb40 ] ; <i32*> [#uses=1]
%.SV104.phi1127 = phi i32 [ undef , %bb85 ] , [ %.SV104.phi1036 , %bb40 ] ; <i32> [#uses=2]
%.SV111.phi1126 = phi i32 * [ undef , %bb85 ] , [ %.SV111.phi1035 , %bb40 ] ; <i32*> [#uses=2]
%.SV118.phi1125 = phi i32 [ undef , %bb85 ] , [ %.SV118.phi1040 , %bb40 ] ; <i32> [#uses=3]
%meshStackVariable337.phi = phi i32 [ %Opq.sa.calc665 , %bb85 ] , [ %Opq.sa.calc553 , %bb40 ] ; <i32> [#uses=1]
%Opq.link.SV980.phi = phi i32 [ %Opq.sa.calc667 , %bb85 ] , [ %Opq.sa.calc554 , %bb40 ] ; <i32> [#uses=1]
%Opq.link.mask982 = and i32 %Opq.link.SV980.phi , 1 ; <i32> [#uses=1]
%Opq.sa.calc979 = sub i32 %Opq.link.mask982 , -153 ; <i32> [#uses=2]
%meshCmp339 = icmp eq i32 %meshStackVariable337.phi , 4 ; <i1> [#uses=1]
br i1 %meshCmp339 , label %bb41 , label %bb86
meshBB340: ; preds = %bb29, %bb26
%.SV38.phi1167 = phi i64 [ %.SV38.phi1121 , %bb29 ] , [ %.SV38.phi1172 , %bb26 ] ; <i64> [#uses=3]
%.SV68.phi1166 = phi i32 [ %.SV68.phi1120 , %bb29 ] , [ %.SV68.phi1169 , %bb26 ] ; <i32> [#uses=3]
%.SV70.phi1165 = phi i32 [ %.SV70.phi1119 , %bb29 ] , [ %.SV70.phi1168 , %bb26 ] ; <i32> [#uses=3]
%.SV104.phi1080 = phi i32 [ undef , %bb29 ] , [ %.SV104.phi , %bb26 ] ; <i32> [#uses=1]
%.SV111.phi1079 = phi i32 * [ undef , %bb29 ] , [ %.SV111.phi , %bb26 ] ; <i32*> [#uses=1]
%.SV118.phi1078 = phi i32 [ %.SV118.phi1158 , %bb29 ] , [ %.SV118.phi , %bb26 ] ; <i32> [#uses=1]
%.load123.SV.phi = phi i32 [ undef , %bb29 ] , [ %.SV118.phi , %bb26 ] ; <i32> [#uses=2]
%.SV228.phi = phi %struct.Macroblock * [ undef , %bb29 ] , [ %81 , %bb26 ] ; <%struct.Macroblock*> [#uses=1]
%.SV230.phi = phi i32 [ undef , %bb29 ] , [ %82 , %bb26 ] ; <i32> [#uses=1]
%meshStackVariable341.phi = phi i32 [ %Opq.sa.calc525 , %bb29 ] , [ %Opq.sa.calc518 , %bb26 ] ; <i32> [#uses=1]
%Opq.link.SV755.phi = phi i32 [ %Opq.sa.calc525 , %bb29 ] , [ %Opq.sa.calc519 , %bb26 ] ; <i32> [#uses=1]
%.SV.phi1042 = phi i32 [ %.SV118.phi1158 , %bb29 ] , [ undef , %bb26 ] ; <i32> [#uses=1]
%yM.0.SV.phi1041 = phi i32 [ %89 , %bb29 ] , [ undef , %bb26 ] ; <i32> [#uses=1]
%Opq.link.mask757 = and i32 %Opq.link.SV755.phi , 12 ; <i32> [#uses=1]
%Opq.sa.calc754 = add i32 %Opq.link.mask757 , 225 ; <i32> [#uses=2]
%meshCmp343 = icmp eq i32 %meshStackVariable341.phi , 9 ; <i1> [#uses=1]
br i1 %meshCmp343 , label %bb26.fragment , label %bb96
meshBB344: ; preds = %bb68, %bb23.fragment182
%.SV38.phi1172 = phi i64 [ %.SV38.phi1115 , %bb23.fragment182 ] , [ %.SV38.phi1098 , %bb68 ] ; <i64> [#uses=8]
%.SV52.phi1170 = phi i32 * [ undef , %bb23.fragment182 ] , [ %.SV52.phi1097 , %bb68 ] ; <i32*> [#uses=2]
%.SV68.phi1169 = phi i32 [ %.SV68.phi1112 , %bb23.fragment182 ] , [ %.SV68.phi1096 , %bb68 ] ; <i32> [#uses=8]
%.SV70.phi1168 = phi i32 [ %.SV70.phi1111 , %bb23.fragment182 ] , [ %.SV70.phi1095 , %bb68 ] ; <i32> [#uses=8]
%.load144.SV.phi = phi i1 [ undef , %bb23.fragment182 ] , [ %145 , %bb68 ] ; <i1> [#uses=1]
%.SV274.phi = phi i32 * [ undef , %bb23.fragment182 ] , [ %167 , %bb68 ] ; <i32*> [#uses=2]
%.SV118.phi = phi i32 [ %76 , %bb23.fragment182 ] , [ undef , %bb68 ] ; <i32> [#uses=7]
%.SV135.phi = phi i1 [ %78 , %bb23.fragment182 ] , [ undef , %bb68 ] ; <i1> [#uses=2]
%meshStackVariable345.phi = phi i32 [ %Opq.sa.calc743 , %bb23.fragment182 ] , [ %Opq.sa.calc624 , %bb68 ] ; <i32> [#uses=1]
%Opq.link.SV717.phi = phi i32 [ %Opq.sa.calc744 , %bb23.fragment182 ] , [ %Opq.sa.calc624 , %bb68 ] ; <i32> [#uses=1]
%Opq.link.SV720.phi = phi i32 [ %Opq.sa.calc743 , %bb23.fragment182 ] , [ %Opq.sa.calc624 , %bb68 ] ; <i32> [#uses=1]
%.SV96.phi = phi i1 [ %71 , %bb23.fragment182 ] , [ undef , %bb68 ] ; <i1> [#uses=1]
%.SV99.phi = phi i32 * [ %72 , %bb23.fragment182 ] , [ undef , %bb68 ] ; <i32*> [#uses=2]
%.SV104.phi = phi i32 [ %73 , %bb23.fragment182 ] , [ undef , %bb68 ] ; <i32> [#uses=3]
%.SV111.phi = phi i32 * [ %74 , %bb23.fragment182 ] , [ undef , %bb68 ] ; <i32*> [#uses=3]
%Opq.link.mask722 = and i32 %Opq.link.SV720.phi , 9 ; <i32> [#uses=3]
%Opq.link.mask719 = and i32 %Opq.link.SV717.phi , 0 ; <i32> [#uses=1]
%Opq.sa.calc715 = sub i32 %Opq.link.mask719 , %Opq.link.mask722 ; <i32> [#uses=1]
%Opq.sa.calc716 = sub i32 %Opq.sa.calc715 , -101 ; <i32> [#uses=2]
%meshCmp347 = icmp eq i32 %meshStackVariable345.phi , 9 ; <i1> [#uses=1]
br i1 %meshCmp347 , label %bb68.fragment , label %bb24
meshBB348: ; preds = %bb37, %bb6
%.SV38.phi1103 = phi i64 [ %.SV38.phi1014 , %bb6 ] , [ %.SV38.phi1019 , %bb37 ] ; <i64> [#uses=2]
%.SV43.phi1102 = phi i32 [ %.SV43.phi , %bb6 ] , [ %.SV43.phi1018 , %bb37 ] ; <i32> [#uses=1]
%.SV52.phi1101 = phi i32 * [ %.SV52.phi , %bb6 ] , [ undef , %bb37 ] ; <i32*> [#uses=1]
%.SV68.phi1100 = phi i32 [ %.SV68.phi1020 , %bb6 ] , [ %.SV68.phi1025 , %bb37 ] ; <i32> [#uses=2]
%.SV70.phi1099 = phi i32 [ %.SV70.phi1026 , %bb6 ] , [ %.SV70.phi1233 , %bb37 ] ; <i32> [#uses=2]
%.load131.SV.phi = phi i32 [ undef , %bb6 ] , [ %.SV118.phi1155 , %bb37 ] ; <i32> [#uses=1]
%.load115.SV.phi = phi i32 * [ undef , %bb6 ] , [ %.SV111.phi1156 , %bb37 ] ; <i32*> [#uses=1]
%.load48.SV.phi = phi i32 [ undef , %bb6 ] , [ %.SV43.phi1018 , %bb37 ] ; <i32> [#uses=1]
%.SV242.phi = phi i32 [ undef , %bb6 ] , [ %105 , %bb37 ] ; <i32> [#uses=1]
%meshStackVariable349.phi = phi i32 [ %Opq.sa.calc473 , %bb6 ] , [ %Opq.sa.calc547 , %bb37 ] ; <i32> [#uses=1]
%Opq.link.SV806.phi = phi i32 [ %Opq.sa.calc873 , %bb6 ] , [ %Opq.sa.calc958 , %bb37 ] ; <i32> [#uses=1]
%Opq.link.mask808 = and i32 %Opq.link.SV806.phi , 12 ; <i32> [#uses=1]
%Opq.sa.calc805 = sub i32 %Opq.link.mask808 , -147 ; <i32> [#uses=3]
%meshCmp351 = icmp eq i32 %meshStackVariable349.phi , 13 ; <i1> [#uses=1]
br i1 %meshCmp351 , label %bb37.fragment , label %bb8
meshBB352: ; preds = %bb79, %bb71
%.SV38.phi1140 = phi i64 [ %.SV38.phi1110 , %bb71 ] , [ %.SV38.phi1098 , %bb79 ] ; <i64> [#uses=2]
%.SV68.phi1139 = phi i32 [ %.SV68.phi1108 , %bb71 ] , [ %.SV68.phi1096 , %bb79 ] ; <i32> [#uses=2]
%.SV70.phi1138 = phi i32 [ %.SV70.phi1107 , %bb71 ] , [ %.SV70.phi1095 , %bb79 ] ; <i32> [#uses=2]
%.load166.SV.phi = phi i32 [ %.SV164.phi1104 , %bb71 ] , [ undef , %bb79 ] ; <i32> [#uses=1]
%.load163.SV.phi = phi i32 * [ %.SV162.phi1105 , %bb71 ] , [ undef , %bb79 ] ; <i32*> [#uses=1]
%.SV282.phi = phi i32 [ %182 , %bb71 ] , [ undef , %bb79 ] ; <i32> [#uses=1]
%meshStackVariable353.phi = phi i32 [ %Opq.sa.calc633 , %bb71 ] , [ %Opq.sa.calc650 , %bb79 ] ; <i32> [#uses=1]
%Opq.link.SV877.phi = phi i32 [ %Opq.sa.calc820 , %bb71 ] , [ %Opq.sa.calc650 , %bb79 ] ; <i32> [#uses=1]
%Opq.link.mask879 = and i32 %Opq.link.SV877.phi , 1 ; <i32> [#uses=1]
%Opq.sa.calc876 = add i32 %Opq.link.mask879 , 18 ; <i32> [#uses=1]
%meshCmp355 = icmp eq i32 %meshStackVariable353.phi , 11 ; <i1> [#uses=1]
br i1 %meshCmp355 , label %bb97 , label %bb71.fragment
meshBB356: ; preds = %bb70.fragment, %bb26.fragment
%.SV104.phi1160 = phi i32 [ undef , %bb70.fragment ] , [ %.SV104.phi1080 , %bb26.fragment ] ; <i32> [#uses=1]
%.SV111.phi1159 = phi i32 * [ undef , %bb70.fragment ] , [ %.SV111.phi1079 , %bb26.fragment ] ; <i32*> [#uses=1]
%.SV118.phi1158 = phi i32 [ undef , %bb70.fragment ] , [ %.SV118.phi1078 , %bb26.fragment ] ; <i32> [#uses=3]
%.SV38.phi1121 = phi i64 [ %.SV38.phi1014 , %bb70.fragment ] , [ %.SV38.phi1167 , %bb26.fragment ] ; <i64> [#uses=3]
%.SV68.phi1120 = phi i32 [ %.SV68.phi1020 , %bb70.fragment ] , [ %.SV68.phi1166 , %bb26.fragment ] ; <i32> [#uses=3]
%.SV70.phi1119 = phi i32 [ %.SV70.phi1026 , %bb70.fragment ] , [ %.SV70.phi1165 , %bb26.fragment ] ; <i32> [#uses=3]
%.SV.phi1046 = phi i32 [ %.load165.SV.phi , %bb70.fragment ] , [ %.load123.SV.phi , %bb26.fragment ] ; <i32> [#uses=1]
%meshStackVariable357.phi = phi i32 [ %Opq.sa.calc738 , %bb70.fragment ] , [ %Opq.sa.calc917 , %bb26.fragment ] ; <i32> [#uses=1]
%Opq.link.SV984.phi = phi i32 [ %Opq.sa.calc738 , %bb70.fragment ] , [ %Opq.sa.calc918 , %bb26.fragment ] ; <i32> [#uses=1]
%Opq.link.mask986 = and i32 %Opq.link.SV984.phi , 9 ; <i32> [#uses=1]
%Opq.sa.calc983 = xor i32 %Opq.link.mask986 , 251 ; <i32> [#uses=1]
%meshCmp359 = icmp eq i32 %meshStackVariable357.phi , 9 ; <i1> [#uses=1]
br i1 %meshCmp359 , label %bb28 , label %bb96
meshBB360: ; preds = %bb21, %bb13
%.SV38.phi1115 = phi i64 [ %4 , %bb21 ] , [ %.SV38.phi1014 , %bb13 ] ; <i64> [#uses=5]
%.SV52.phi1113 = phi i32 * [ %.SV52.phi1022 , %bb21 ] , [ %.SV52.phi , %bb13 ] ; <i32*> [#uses=3]
%.SV68.phi1112 = phi i32 [ %.SV68.phi1021 , %bb21 ] , [ %.SV68.phi1020 , %bb13 ] ; <i32> [#uses=5]
%.SV70.phi1111 = phi i32 [ %.SV70.phi1027 , %bb21 ] , [ %.SV70.phi1026 , %bb13 ] ; <i32> [#uses=5]
%.load74.SV.phi = phi i1 [ undef , %bb21 ] , [ %21 , %bb13 ] ; <i1> [#uses=1]
%.SV208.phi = phi i32 * [ undef , %bb21 ] , [ %46 , %bb13 ] ; <i32*> [#uses=2]
%meshStackVariable361.phi = phi i32 [ %Opq.sa.calc505 , %bb21 ] , [ %Opq.sa.calc489 , %bb13 ] ; <i32> [#uses=1]
%Opq.link.SV867.phi = phi i32 [ %Opq.sa.calc505 , %bb21 ] , [ %Opq.sa.calc873 , %bb13 ] ; <i32> [#uses=1]
%Opq.link.mask869 = and i32 %Opq.link.SV867.phi , 1 ; <i32> [#uses=1]
%Opq.sa.calc866 = add i32 %Opq.link.mask869 , 148 ; <i32> [#uses=4]
%meshCmp363 = icmp eq i32 %meshStackVariable361.phi , 16 ; <i1> [#uses=1]
br i1 %meshCmp363 , label %bb13.fragment , label %bb23
meshBB364: ; preds = %bb65.fragment, %bb56
%.SV38.phi1098 = phi i64 [ %.SV38.phi1017 , %bb56 ] , [ %.SV38.phi1147 , %bb65.fragment ] ; <i64> [#uses=11]
%.SV52.phi1097 = phi i32 * [ %.SV52.phi1024 , %bb56 ] , [ undef , %bb65.fragment ] ; <i32*> [#uses=8]
%.SV68.phi1096 = phi i32 [ %.SV68.phi1023 , %bb56 ] , [ %.SV68.phi1146 , %bb65.fragment ] ; <i32> [#uses=11]
%.SV70.phi1095 = phi i32 [ %.SV70.phi1028 , %bb56 ] , [ %.SV70.phi1145 , %bb65.fragment ] ; <i32> [#uses=11]
%or.cond.not.SV.phi1094 = phi i1 [ %or.cond.not.SV.phi1029 , %bb56 ] , [ undef , %bb65.fragment ] ; <i1> [#uses=1]
%.SV.phi1062 = phi i32 [ undef , %bb56 ] , [ %.SV268.phi , %bb65.fragment ] ; <i32> [#uses=1]
%.not4.SV.phi = phi i1 [ %.not4 , %bb56 ] , [ undef , %bb65.fragment ] ; <i1> [#uses=1]
%.SV256.phi = phi i1 [ %139 , %bb56 ] , [ undef , %bb65.fragment ] ; <i1> [#uses=1]
%meshStackVariable365.phi = phi i32 [ %Opq.sa.calc592 , %bb56 ] , [ %Opq.sa.calc832 , %bb65.fragment ] ; <i32> [#uses=1]
%Opq.link.SV735.phi = phi i32 [ %Opq.sa.calc592 , %bb56 ] , [ %Opq.sa.calc832 , %bb65.fragment ] ; <i32> [#uses=1]
%Opq.link.mask737 = and i32 %Opq.link.SV735.phi , 0 ; <i32> [#uses=2]
%Opq.sa.calc734 = sub i32 %Opq.link.mask737 , -242 ; <i32> [#uses=0]
%meshCmp367 = icmp eq i32 %meshStackVariable365.phi , 1 ; <i1> [#uses=1]
br i1 %meshCmp367 , label %bb96 , label %bb56.fragment
meshBB368: ; preds = %bb90.fragment, %bb8
%.SV38.phi1164 = phi i64 [ %.SV38.phi1103 , %bb8 ] , [ %.SV38.phi1191 , %bb90.fragment ] ; <i64> [#uses=5]
%.SV43.phi1163 = phi i32 [ %.SV43.phi1102 , %bb8 ] , [ undef , %bb90.fragment ] ; <i32> [#uses=1]
%.SV68.phi1162 = phi i32 [ %.SV68.phi1100 , %bb8 ] , [ %.SV68.phi1189 , %bb90.fragment ] ; <i32> [#uses=5]
%.SV70.phi1161 = phi i32 [ %.SV70.phi1099 , %bb8 ] , [ %.SV70.phi1188 , %bb90.fragment ] ; <i32> [#uses=5]
%.SV178.phi = phi i32 [ undef , %bb8 ] , [ %214 , %bb90.fragment ] ; <i32> [#uses=2]
%.SV176.phi = phi i32 * [ undef , %bb8 ] , [ %212 , %bb90.fragment ] ; <i32*> [#uses=1]
%.SV170.phi = phi i32 * [ undef , %bb8 ] , [ %210 , %bb90.fragment ] ; <i32*> [#uses=1]
%.SV172.phi = phi i32 [ undef , %bb8 ] , [ %211 , %bb90.fragment ] ; <i32> [#uses=1]
%.SV76.phi = phi i32 * [ %28 , %bb8 ] , [ undef , %bb90.fragment ] ; <i32*> [#uses=1]
%.SV78.phi = phi i32 [ %29 , %bb8 ] , [ undef , %bb90.fragment ] ; <i32> [#uses=1]
%.SV80.phi = phi i32 * [ %30 , %bb8 ] , [ undef , %bb90.fragment ] ; <i32*> [#uses=1]
%.load66.SV.phi = phi i32 * [ %.SV52.phi1101 , %bb8 ] , [ undef , %bb90.fragment ] ; <i32*> [#uses=1]
%.load35.SV.phi = phi i64 [ %3 , %bb8 ] , [ undef , %bb90.fragment ] ; <i64> [#uses=1]
%.load16.SV.phi = phi %struct.Macroblock * [ %2 , %bb8 ] , [ undef , %bb90.fragment ] ; <%struct.Macroblock*> [#uses=1]
%.SV198.phi = phi i32 [ %29 , %bb8 ] , [ undef , %bb90.fragment ] ; <i32> [#uses=1]
%.SV200.phi = phi i32 * [ %30 , %bb8 ] , [ undef , %bb90.fragment ] ; <i32*> [#uses=1]
%meshStackVariable369.phi = phi i32 [ %Opq.sa.calc479 , %bb8 ] , [ %Opq.sa.calc772 , %bb90.fragment ] ; <i32> [#uses=1]
%Opq.link.SV769.phi = phi i32 [ %Opq.sa.calc805 , %bb8 ] , [ %Opq.sa.calc772 , %bb90.fragment ] ; <i32> [#uses=1]
%Opq.link.mask771 = and i32 %Opq.link.SV769.phi , 2 ; <i32> [#uses=1]
%Opq.sa.calc768 = xor i32 %Opq.link.mask771 , 135 ; <i32> [#uses=3]
%meshCmp371 = icmp eq i32 %meshStackVariable369.phi , 2 ; <i1> [#uses=1]
br i1 %meshCmp371 , label %bb91 , label %bb8.fragment
meshBB372: ; preds = %bb84.fragment, %bb35
%.SV38.phi1214 = phi i64 [ %.SV38.phi1191 , %bb84.fragment ] , [ %.SV38.phi1183 , %bb35 ] ; <i64> [#uses=3]
%.SV52.phi1213 = phi i32 * [ %.SV52.phi1190 , %bb84.fragment ] , [ undef , %bb35 ] ; <i32*> [#uses=2]
%.SV68.phi1212 = phi i32 [ %.SV68.phi1189 , %bb84.fragment ] , [ %.SV68.phi1181 , %bb35 ] ; <i32> [#uses=3]
%.SV70.phi1211 = phi i32 [ %.SV70.phi1188 , %bb84.fragment ] , [ %.SV70.phi1180 , %bb35 ] ; <i32> [#uses=3]
%.SV118.phi1154 = phi i32 [ undef , %bb84.fragment ] , [ %.SV118.phi1082 , %bb35 ] ; <i32> [#uses=1]
%.SV167.phi = phi i1 [ %203 , %bb84.fragment ] , [ undef , %bb35 ] ; <i1> [#uses=1]
%meshStackVariable373.phi = phi i32 [ %Opq.sa.calc802 , %bb84.fragment ] , [ %Opq.sa.calc540 , %bb35 ] ; <i32> [#uses=1]
%Opq.link.SV813.phi = phi i32 [ %Opq.sa.calc802 , %bb84.fragment ] , [ %Opq.sa.calc541 , %bb35 ] ; <i32> [#uses=1]
%Opq.link.mask815 = and i32 %Opq.link.SV813.phi , 0 ; <i32> [#uses=1]
%Opq.sa.calc812 = sub i32 %Opq.link.mask815 , -121 ; <i32> [#uses=3]
%meshCmp375 = icmp eq i32 %meshStackVariable373.phi , 6 ; <i1> [#uses=1]
br i1 %meshCmp375 , label %bb36 , label %bb85
meshBB376: ; preds = %bb98, %bb44.fragment
%.SV38.phi1153 = phi i64 [ %.SV38.phi1093 , %bb98 ] , [ %.SV38.phi1204 , %bb44.fragment ] ; <i64> [#uses=1]
%.SV68.phi1152 = phi i32 [ %.SV68.phi1092 , %bb98 ] , [ %.SV68.phi1203 , %bb44.fragment ] ; <i32> [#uses=1]
%.SV70.phi1151 = phi i32 [ %.SV70.phi1091 , %bb98 ] , [ %.SV70.phi1202 , %bb44.fragment ] ; <i32> [#uses=1]
%.load39.SV.phi = phi i64 [ %.SV38.phi1093 , %bb98 ] , [ undef , %bb44.fragment ] ; <i64> [#uses=2]
%.SV313.phi = phi i32 * [ %237 , %bb98 ] , [ undef , %bb44.fragment ] ; <i32*> [#uses=1]
%.SV315.phi = phi i32 * [ %239 , %bb98 ] , [ undef , %bb44.fragment ] ; <i32*> [#uses=1]
%.SV317.phi = phi i32 * [ %240 , %bb98 ] , [ undef , %bb44.fragment ] ; <i32*> [#uses=3]
%.SV.phi1050 = phi i32 [ undef , %bb98 ] , [ %.load127.SV.phi , %bb44.fragment ] ; <i32> [#uses=1]
%yM.0.SV.phi1049 = phi i32 [ undef , %bb98 ] , [ %121 , %bb44.fragment ] ; <i32> [#uses=1]
%meshStackVariable377.phi = phi i32 [ %Opq.sa.calc695 , %bb98 ] , [ %Opq.sa.calc894 , %bb44.fragment ] ; <i32> [#uses=1]
%Opq.link.SV909.phi = phi i32 [ %Opq.sa.calc695 , %bb98 ] , [ %Opq.sa.calc856 , %bb44.fragment ] ; <i32> [#uses=1]
%Opq.link.mask911 = and i32 %Opq.link.SV909.phi , 16 ; <i32> [#uses=2]
%Opq.sa.calc908 = add i32 %Opq.link.mask911 , -11 ; <i32> [#uses=0]
%meshCmp379 = icmp eq i32 %meshStackVariable377.phi , 8 ; <i1> [#uses=1]
br i1 %meshCmp379 , label %bb96 , label %bb98.fragment
meshBB380: ; preds = %bb92.fragment, %bb49.fragment
%.SV38.phi1207 = phi i64 [ %.SV38.phi1164 , %bb92.fragment ] , [ %.SV38.phi1179 , %bb49.fragment ] ; <i64> [#uses=2]
%.SV68.phi1206 = phi i32 [ %.SV68.phi1162 , %bb92.fragment ] , [ %.SV68.phi1177 , %bb49.fragment ] ; <i32> [#uses=2]
%.SV70.phi1205 = phi i32 [ %.SV70.phi1161 , %bb92.fragment ] , [ %.SV70.phi1176 , %bb49.fragment ] ; <i32> [#uses=2]
%.SV104.phi1124 = phi i32 [ undef , %bb92.fragment ] , [ %.SV104.phi1036 , %bb49.fragment ] ; <i32> [#uses=1]
%.SV111.phi1123 = phi i32 * [ undef , %bb92.fragment ] , [ %.SV111.phi1035 , %bb49.fragment ] ; <i32*> [#uses=1]
%.SV118.phi1122 = phi i32 [ undef , %bb92.fragment ] , [ %.SV118.phi1040 , %bb49.fragment ] ; <i32> [#uses=1]
%meshStackVariable381.phi = phi i32 [ %Opq.sa.calc1005 , %bb92.fragment ] , [ %Opq.sa.calc860 , %bb49.fragment ] ; <i32> [#uses=1]
%Opq.link.SV947.phi = phi i32 [ %Opq.sa.calc1005 , %bb92.fragment ] , [ %Opq.sa.calc860 , %bb49.fragment ] ; <i32> [#uses=1]
%.SV.phi1052 = phi i32 [ %.SV178.phi , %bb92.fragment ] , [ undef , %bb49.fragment ] ; <i32> [#uses=1]
%yM.0.SV.phi1051 = phi i32 [ %226 , %bb92.fragment ] , [ undef , %bb49.fragment ] ; <i32> [#uses=1]
%Opq.link.mask949 = and i32 %Opq.link.SV947.phi , 1 ; <i32> [#uses=1]
%Opq.sa.calc946 = sub i32 %Opq.link.mask949 , -4 ; <i32> [#uses=1]
%meshCmp383 = icmp eq i32 %meshStackVariable381.phi , 1 ; <i1> [#uses=1]
br i1 %meshCmp383 , label %bb54 , label %bb96
meshBB384: ; preds = %bb95, %bb52
%.SV38.phi1221 = phi i64 [ %.SV38.phi1179 , %bb52 ] , [ %.SV38.phi1218 , %bb95 ] ; <i64> [#uses=2]
%.SV68.phi1220 = phi i32 [ %.SV68.phi1177 , %bb52 ] , [ %.SV68.phi1216 , %bb95 ] ; <i32> [#uses=2]
%.SV70.phi1219 = phi i32 [ %.SV70.phi1176 , %bb52 ] , [ %.SV70.phi1215 , %bb95 ] ; <i32> [#uses=2]
%.load53.SV.phi = phi i32 * [ undef , %bb52 ] , [ %.SV52.phi1217 , %bb95 ] ; <i32*> [#uses=1]
%.load20.SV.phi = phi i64 [ undef , %bb52 ] , [ %3 , %bb95 ] ; <i64> [#uses=1]
%.load.SV.phi = phi %struct.Macroblock * [ undef , %bb52 ] , [ %2 , %bb95 ] ; <%struct.Macroblock*> [#uses=1]
%.SV306.phi = phi i32 [ undef , %bb52 ] , [ %227 , %bb95 ] ; <i32> [#uses=1]
%.SV308.phi = phi i32 * [ undef , %bb52 ] , [ %228 , %bb95 ] ; <i32*> [#uses=1]
%.load126.SV.phi = phi i32 [ %.SV118.phi1040 , %bb52 ] , [ undef , %bb95 ] ; <i32> [#uses=1]
%.load44.SV.phi = phi i32 [ %.SV43.phi1178 , %bb52 ] , [ undef , %bb95 ] ; <i32> [#uses=1]
%meshStackVariable385.phi = phi i32 [ %Opq.sa.calc583 , %bb52 ] , [ %Opq.sa.calc689 , %bb95 ] ; <i32> [#uses=1]
%Opq.link.SV902.phi = phi i32 [ %Opq.sa.calc860 , %bb52 ] , [ %Opq.sa.calc689 , %bb95 ] ; <i32> [#uses=1]
%Opq.link.SV905.phi = phi i32 [ %Opq.sa.calc584 , %bb52 ] , [ %Opq.sa.calc689 , %bb95 ] ; <i32> [#uses=1]
%Opq.link.mask907 = and i32 %Opq.link.SV905.phi , 0 ; <i32> [#uses=0]
%Opq.link.mask904 = and i32 %Opq.link.SV902.phi , 1 ; <i32> [#uses=1]
%Opq.sa.calc901 = xor i32 %Opq.link.mask904 , 227 ; <i32> [#uses=3]
%meshCmp387 = icmp eq i32 %meshStackVariable385.phi , 5 ; <i1> [#uses=1]
br i1 %meshCmp387 , label %bb95.fragment , label %bb52.fragment
meshBB388: ; preds = %bb52.fragment, %bb7
%.SV38.phi1118 = phi i64 [ %.SV38.phi1014 , %bb7 ] , [ %.SV38.phi1221 , %bb52.fragment ] ; <i64> [#uses=2]
%.SV68.phi1117 = phi i32 [ %.SV68.phi1020 , %bb7 ] , [ %.SV68.phi1220 , %bb52.fragment ] ; <i32> [#uses=2]
%.SV70.phi1116 = phi i32 [ %.SV70.phi1026 , %bb7 ] , [ %.SV70.phi1219 , %bb52.fragment ] ; <i32> [#uses=2]
%.SV.phi1054 = phi i32 [ undef , %bb7 ] , [ %.load126.SV.phi , %bb52.fragment ] ; <i32> [#uses=1]
%yM.0.SV.phi1053 = phi i32 [ undef , %bb7 ] , [ %137 , %bb52.fragment ] ; <i32> [#uses=1]
%.load67.SV.phi = phi i32 * [ %.SV52.phi , %bb7 ] , [ undef , %bb52.fragment ] ; <i32*> [#uses=1]
%.load36.SV.phi = phi i64 [ %3 , %bb7 ] , [ undef , %bb52.fragment ] ; <i64> [#uses=1]
%.load17.SV.phi = phi %struct.Macroblock * [ %2 , %bb7 ] , [ undef , %bb52.fragment ] ; <%struct.Macroblock*> [#uses=1]
%.SV194.phi = phi i32 [ %24 , %bb7 ] , [ undef , %bb52.fragment ] ; <i32> [#uses=1]
%.SV196.phi = phi i32 * [ %25 , %bb7 ] , [ undef , %bb52.fragment ] ; <i32*> [#uses=1]
%meshStackVariable389.phi = phi i32 [ %Opq.sa.calc476 , %bb7 ] , [ %Opq.sa.calc844 , %bb52.fragment ] ; <i32> [#uses=1]
%Opq.link.SV887.phi = phi i32 [ %Opq.sa.calc873 , %bb7 ] , [ %Opq.sa.calc901 , %bb52.fragment ] ; <i32> [#uses=1]
%Opq.link.mask889 = and i32 %Opq.link.SV887.phi , 64 ; <i32> [#uses=1]
%Opq.sa.calc886 = sub i32 %Opq.link.mask889 , -170 ; <i32> [#uses=2]
%meshCmp391 = icmp eq i32 %meshStackVariable389.phi , 12 ; <i1> [#uses=1]
br i1 %meshCmp391 , label %bb96 , label %bb7.fragment
meshBB392: ; preds = %bb4, %entry
%meshStackVariable393.phi = phi i32 [ %Opq.sa.calc466 , %bb4 ] , [ %Opq.sa.calc , %entry ] ; <i32> [#uses=1]
%Opq.link.SV922.phi = phi i32 [ %Opq.sa.calc462 , %bb4 ] , [ %Opq.sa.calc , %entry ] ; <i32> [#uses=1]
%or.cond.not.SV.phi = phi i1 [ %or.cond.not , %bb4 ] , [ undef , %entry ] ; <i1> [#uses=1]
%.SV70.phi1027 = phi i32 [ %12 , %bb4 ] , [ undef , %entry ] ; <i32> [#uses=2]
%.SV52.phi1022 = phi i32 * [ %9 , %bb4 ] , [ undef , %entry ] ; <i32*> [#uses=1]
%.SV68.phi1021 = phi i32 [ %10 , %bb4 ] , [ undef , %entry ] ; <i32> [#uses=2]
%.SV43.phi1015 = phi i32 [ %8 , %bb4 ] , [ undef , %entry ] ; <i32> [#uses=3]
%Opq.link.mask924 = and i32 %Opq.link.SV922.phi , 2 ; <i32> [#uses=1]
%Opq.sa.calc921 = add i32 %Opq.link.mask924 , 57 ; <i32> [#uses=3]
%meshCmp395 = icmp eq i32 %meshStackVariable393.phi , 2 ; <i1> [#uses=1]
br i1 %meshCmp395 , label %entry.fragment , label %bb21
meshBB396: ; preds = %bb69.fragment, %bb.fragment
%.SV.phi1065 = phi i32 [ undef , %bb.fragment ] , [ %171 , %bb69.fragment ] ; <i32> [#uses=1]
%meshStackVariable397.phi = phi i32 [ %Opq.sa.calc976 , %bb.fragment ] , [ %Opq.sa.calc995 , %bb69.fragment ] ; <i32> [#uses=1]
%Opq.link.SV759.phi = phi i32 [ %Opq.sa.calc976 , %bb.fragment ] , [ %Opq.sa.calc995 , %bb69.fragment ] ; <i32> [#uses=1]
%.SV70.phi = phi i32 [ %12 , %bb.fragment ] , [ %.SV70.phi1168 , %bb69.fragment ] ; <i32> [#uses=1]
%.SV68.phi = phi i32 [ %10 , %bb.fragment ] , [ %.SV68.phi1169 , %bb69.fragment ] ; <i32> [#uses=1]
%.SV38.phi = phi i64 [ %4 , %bb.fragment ] , [ %.SV38.phi1172 , %bb69.fragment ] ; <i64> [#uses=1]
%Opq.link.mask761 = and i32 %Opq.link.SV759.phi , 6 ; <i32> [#uses=1]
%Opq.sa.calc758 = add i32 %Opq.link.mask761 , 53 ; <i32> [#uses=1]
%meshCmp399 = icmp eq i32 %meshStackVariable397.phi , 6 ; <i1> [#uses=1]
br i1 %meshCmp399 , label %bb96 , label %return
meshBB400: ; preds = %bb84, %bb69.fragment
%.SV38.phi1191 = phi i64 [ %.SV38.phi1098 , %bb84 ] , [ %.SV38.phi1172 , %bb69.fragment ] ; <i64> [#uses=5]
%.SV52.phi1190 = phi i32 * [ %.SV52.phi1097 , %bb84 ] , [ undef , %bb69.fragment ] ; <i32*> [#uses=3]
%.SV68.phi1189 = phi i32 [ %.SV68.phi1096 , %bb84 ] , [ %.SV68.phi1169 , %bb69.fragment ] ; <i32> [#uses=5]
%.SV70.phi1188 = phi i32 [ %.SV70.phi1095 , %bb84 ] , [ %.SV70.phi1168 , %bb69.fragment ] ; <i32> [#uses=5]
%.SV290.phi = phi i32 [ %200 , %bb84 ] , [ undef , %bb69.fragment ] ; <i32> [#uses=1]
%.SV164.phi = phi i32 [ undef , %bb84 ] , [ %171 , %bb69.fragment ] ; <i32> [#uses=2]
%meshStackVariable401.phi = phi i32 [ %Opq.sa.calc661 , %bb84 ] , [ %Opq.sa.calc996 , %bb69.fragment ] ; <i32> [#uses=1]
%Opq.link.SV825.phi = phi i32 [ %Opq.sa.calc658 , %bb84 ] , [ %Opq.sa.calc996 , %bb69.fragment ] ; <i32> [#uses=1]
%.SV162.phi = phi i32 * [ undef , %bb84 ] , [ %169 , %bb69.fragment ] ; <i32*> [#uses=1]
%.SV156.phi = phi i32 * [ undef , %bb84 ] , [ %.SV274.phi , %bb69.fragment ] ; <i32*> [#uses=1]
%.SV158.phi = phi i32 [ undef , %bb84 ] , [ %168 , %bb69.fragment ] ; <i32> [#uses=1]
%Opq.link.mask827 = and i32 %Opq.link.SV825.phi , 4 ; <i32> [#uses=1]
%Opq.sa.calc824 = xor i32 %Opq.link.mask827 , 228 ; <i32> [#uses=2]
%meshCmp403 = icmp eq i32 %meshStackVariable401.phi , 15 ; <i1> [#uses=1]
br i1 %meshCmp403 , label %bb70 , label %bb84.fragment
meshBB404: ; preds = %bb96, %bb3
%yM.0.reg2mem.1.SV.phi1077 = phi i32 [ %yM.0.SV.phi , %bb96 ] , [ undef , %bb3 ] ; <i32> [#uses=1]
%meshStackVariable405.phi = phi i32 [ %Opq.sa.calc692 , %bb96 ] , [ %Opq.sa.calc461 , %bb3 ] ; <i32> [#uses=1]
%Opq.link.SV940.phi = phi i32 [ %Opq.sa.calc693 , %bb96 ] , [ %Opq.sa.calc461 , %bb3 ] ; <i32> [#uses=1]
%or.cond.not.SV.phi1029 = phi i1 [ undef , %bb96 ] , [ %or.cond.not , %bb3 ] ; <i1> [#uses=1]
%.SV70.phi1028 = phi i32 [ %.SV70.phi1085 , %bb96 ] , [ %12 , %bb3 ] ; <i32> [#uses=2]
%.SV52.phi1024 = phi i32 * [ undef , %bb96 ] , [ %9 , %bb3 ] ; <i32*> [#uses=1]
%.SV68.phi1023 = phi i32 [ %.SV68.phi1086 , %bb96 ] , [ %10 , %bb3 ] ; <i32> [#uses=2]
%.SV38.phi1017 = phi i64 [ %.SV38.phi1087 , %bb96 ] , [ %4 , %bb3 ] ; <i64> [#uses=2]
%.SV40.phi = phi i32 [ undef , %bb96 ] , [ %6 , %bb3 ] ; <i32> [#uses=1]
%Opq.link.mask942 = and i32 %Opq.link.SV940.phi , 6 ; <i32> [#uses=1]
%Opq.sa.calc939 = sub i32 %Opq.link.mask942 , -87 ; <i32> [#uses=1]
%meshCmp407 = icmp eq i32 %meshStackVariable405.phi , 6 ; <i1> [#uses=1]
br i1 %meshCmp407 , label %bb56 , label %bb98
meshBB408: ; preds = %bb89.fragment, %bb87
%.SV38.phi1218 = phi i64 [ %.SV38.phi1191 , %bb89.fragment ] , [ %.SV38.phi1210 , %bb87 ] ; <i64> [#uses=2]
%.SV52.phi1217 = phi i32 * [ %.SV52.phi1190 , %bb89.fragment ] , [ %.SV52.phi1235 , %bb87 ] ; <i32*> [#uses=1]
%.SV68.phi1216 = phi i32 [ %.SV68.phi1189 , %bb89.fragment ] , [ %.SV68.phi1209 , %bb87 ] ; <i32> [#uses=2]
%.SV70.phi1215 = phi i32 [ %.SV70.phi1188 , %bb89.fragment ] , [ %.SV70.phi1208 , %bb87 ] ; <i32> [#uses=2]
%.SV172.phi1074 = phi i32 [ %211 , %bb89.fragment ] , [ undef , %bb87 ] ; <i32> [#uses=1]
%meshStackVariable409.phi = phi i32 [ %Opq.sa.calc962 , %bb89.fragment ] , [ %Opq.sa.calc673 , %bb87 ] ; <i32> [#uses=1]
%Opq.link.SV913.phi = phi i32 [ %Opq.sa.calc962 , %bb89.fragment ] , [ %Opq.sa.calc990 , %bb87 ] ; <i32> [#uses=1]
%Opq.link.mask915 = and i32 %Opq.link.SV913.phi , 9 ; <i32> [#uses=1]
%Opq.sa.calc912 = xor i32 %Opq.link.mask915 , 195 ; <i32> [#uses=1]
%meshCmp411 = icmp eq i32 %meshStackVariable409.phi , 1 ; <i1> [#uses=1]
br i1 %meshCmp411 , label %bb97 , label %bb95
meshBB412: ; preds = %bb68.fragment, %bb13.fragment
%.SV38.phi1187 = phi i64 [ %.SV38.phi1115 , %bb13.fragment ] , [ %.SV38.phi1172 , %bb68.fragment ] ; <i64> [#uses=2]
%.SV52.phi1186 = phi i32 * [ %.SV52.phi1113 , %bb13.fragment ] , [ %.SV52.phi1170 , %bb68.fragment ] ; <i32*> [#uses=2]
%.SV68.phi1185 = phi i32 [ %.SV68.phi1112 , %bb13.fragment ] , [ %.SV68.phi1169 , %bb68.fragment ] ; <i32> [#uses=2]
%.SV70.phi1184 = phi i32 [ %.SV70.phi1111 , %bb13.fragment ] , [ %.SV70.phi1168 , %bb68.fragment ] ; <i32> [#uses=2]
%.SV158.phi1063 = phi i32 [ undef , %bb13.fragment ] , [ %168 , %bb68.fragment ] ; <i32> [#uses=1]
%.SV87.phi1030 = phi i32 [ %47 , %bb13.fragment ] , [ undef , %bb68.fragment ] ; <i32> [#uses=1]
%meshStackVariable413.phi = phi i32 [ %Opq.sa.calc870 , %bb13.fragment ] , [ %Opq.sa.calc784 , %bb68.fragment ] ; <i32> [#uses=1]
%Opq.link.SV933.phi = phi i32 [ %Opq.sa.calc870 , %bb13.fragment ] , [ %Opq.link.mask722 , %bb68.fragment ] ; <i32> [#uses=1]
%Opq.link.SV936.phi = phi i32 [ %Opq.sa.calc866 , %bb13.fragment ] , [ %Opq.sa.calc784 , %bb68.fragment ] ; <i32> [#uses=1]
%Opq.link.mask938 = and i32 %Opq.link.SV936.phi , 4 ; <i32> [#uses=1]
%Opq.link.mask935 = and i32 %Opq.link.SV933.phi , 0 ; <i32> [#uses=1]
%Opq.sa.calc931 = sub i32 %Opq.link.mask935 , %Opq.link.mask938 ; <i32> [#uses=1]
%Opq.sa.calc932 = xor i32 %Opq.sa.calc931 , -51 ; <i32> [#uses=3]
%meshCmp415 = icmp eq i32 %meshStackVariable413.phi , 6 ; <i1> [#uses=1]
br i1 %meshCmp415 , label %bb74 , label %bb19
meshBB416: ; preds = %bb90.fragment, %bb77
%.SV38.phi1201 = phi i64 [ %.SV38.phi1191 , %bb90.fragment ] , [ %.SV38.phi1098 , %bb77 ] ; <i64> [#uses=2]
%.SV52.phi1200 = phi i32 * [ undef , %bb90.fragment ] , [ %.SV52.phi1097 , %bb77 ] ; <i32*> [#uses=1]
%.SV68.phi1199 = phi i32 [ %.SV68.phi1189 , %bb90.fragment ] , [ %.SV68.phi1096 , %bb77 ] ; <i32> [#uses=2]
%.SV70.phi1198 = phi i32 [ %.SV70.phi1188 , %bb90.fragment ] , [ %.SV70.phi1095 , %bb77 ] ; <i32> [#uses=2]
%.SV.phi1076 = phi i32 [ %214 , %bb90.fragment ] , [ undef , %bb77 ] ; <i32> [#uses=1]
%meshStackVariable417.phi = phi i32 [ %Opq.sa.calc773 , %bb90.fragment ] , [ %Opq.sa.calc643 , %bb77 ] ; <i32> [#uses=1]
%Opq.link.SV973.phi = phi i32 [ %Opq.sa.calc773 , %bb90.fragment ] , [ %Opq.sa.calc640 , %bb77 ] ; <i32> [#uses=1]
%Opq.link.mask975 = and i32 %Opq.link.SV973.phi , 10 ; <i32> [#uses=1]
%Opq.sa.calc972 = xor i32 %Opq.link.mask975 , 110 ; <i32> [#uses=1]
%Opq.sa.calc971 = add i32 %Opq.sa.calc972 , -19 ; <i32> [#uses=1]
%meshCmp419 = icmp eq i32 %meshStackVariable417.phi , 12 ; <i1> [#uses=1]
br i1 %meshCmp419 , label %bb78 , label %bb96
meshBB420: ; preds = %bb66, %bb26.fragment
%.SV38.phi1194 = phi i64 [ %.SV38.phi1098 , %bb66 ] , [ %.SV38.phi1167 , %bb26.fragment ] ; <i64> [#uses=2]
%.SV68.phi1193 = phi i32 [ %.SV68.phi1096 , %bb66 ] , [ %.SV68.phi1166 , %bb26.fragment ] ; <i32> [#uses=2]
%.SV70.phi1192 = phi i32 [ %.SV70.phi1095 , %bb66 ] , [ %.SV70.phi1165 , %bb26.fragment ] ; <i32> [#uses=2]
%.load61.SV.phi = phi i32 * [ %.SV52.phi1097 , %bb66 ] , [ undef , %bb26.fragment ] ; <i32*> [#uses=1]
%.SV270.phi = phi i32 [ %165 , %bb66 ] , [ undef , %bb26.fragment ] ; <i32> [#uses=1]
%.SV272.phi = phi i32 * [ %166 , %bb66 ] , [ undef , %bb26.fragment ] ; <i32*> [#uses=1]
%.SV.phi1044 = phi i32 [ undef , %bb66 ] , [ %.load123.SV.phi , %bb26.fragment ] ; <i32> [#uses=1]
%meshStackVariable421.phi = phi i32 [ %Opq.sa.calc621 , %bb66 ] , [ %Opq.sa.calc918 , %bb26.fragment ] ; <i32> [#uses=1]
%Opq.link.SV838.phi = phi i32 [ %Opq.sa.calc602 , %bb66 ] , [ %Opq.sa.calc918 , %bb26.fragment ] ; <i32> [#uses=1]
%Opq.link.mask840 = and i32 %Opq.link.SV838.phi , 9 ; <i32> [#uses=2]
%Opq.sa.calc837 = sub i32 %Opq.link.mask840 , -202 ; <i32> [#uses=2]
%Opq.sa.calc835 = sub i32 %Opq.sa.calc837 , %Opq.link.mask840 ; <i32> [#uses=1]
%Opq.sa.calc836 = xor i32 %Opq.sa.calc835 , 176 ; <i32> [#uses=0]
%meshCmp423 = icmp eq i32 %meshStackVariable421.phi , 9 ; <i1> [#uses=1]
br i1 %meshCmp423 , label %bb96 , label %bb66.fragment
meshBB424: ; preds = %bb86.fragment, %bb83
%.SV38.phi1197 = phi i64 [ %.SV38.phi1231 , %bb86.fragment ] , [ %.SV38.phi1098 , %bb83 ] ; <i64> [#uses=2]
%.SV68.phi1196 = phi i32 [ %.SV68.phi1229 , %bb86.fragment ] , [ %.SV68.phi1096 , %bb83 ] ; <i32> [#uses=2]
%.SV70.phi1195 = phi i32 [ %.SV70.phi1228 , %bb86.fragment ] , [ %.SV70.phi1095 , %bb83 ] ; <i32> [#uses=2]
%.SV.phi1072 = phi i32 [ %209 , %bb86.fragment ] , [ undef , %bb83 ] ; <i32> [#uses=1]
%meshStackVariable425.phi = phi i32 [ %Opq.sa.calc943 , %bb86.fragment ] , [ %Opq.sa.calc658 , %bb83 ] ; <i32> [#uses=1]
%Opq.link.SV951.phi = phi i32 [ %Opq.sa.calc943 , %bb86.fragment ] , [ %Opq.sa.calc1002 , %bb83 ] ; <i32> [#uses=1]
%Opq.link.mask953 = and i32 %Opq.link.SV951.phi , 12 ; <i32> [#uses=1]
%Opq.sa.calc950 = sub i32 %Opq.link.mask953 , -208 ; <i32> [#uses=0]
%meshCmp427 = icmp eq i32 %meshStackVariable425.phi , 4 ; <i1> [#uses=1]
br i1 %meshCmp427 , label %bb97 , label %bb96
meshBB428: ; preds = %bb70, %bb4
%.SV158.phi1090 = phi i32 [ %.SV158.phi , %bb70 ] , [ undef , %bb4 ] ; <i32> [#uses=1]
%.SV162.phi1089 = phi i32 * [ %.SV162.phi , %bb70 ] , [ undef , %bb4 ] ; <i32*> [#uses=1]
%.SV164.phi1088 = phi i32 [ %.SV164.phi , %bb70 ] , [ undef , %bb4 ] ; <i32> [#uses=1]
%.load165.SV.phi = phi i32 [ %.SV164.phi , %bb70 ] , [ undef , %bb4 ] ; <i32> [#uses=1]
%.SV278.phi = phi %struct.Macroblock * [ %176 , %bb70 ] , [ undef , %bb4 ] ; <%struct.Macroblock*> [#uses=1]
%.SV280.phi = phi i32 [ %177 , %bb70 ] , [ undef , %bb4 ] ; <i32> [#uses=1]
%meshStackVariable429.phi = phi i32 [ %Opq.sa.calc630 , %bb70 ] , [ %Opq.sa.calc467 , %bb4 ] ; <i32> [#uses=1]
%Opq.link.SV898.phi = phi i32 [ %Opq.sa.calc630 , %bb70 ] , [ %Opq.sa.calc462 , %bb4 ] ; <i32> [#uses=1]
%.SV70.phi1026 = phi i32 [ %.SV70.phi1188 , %bb70 ] , [ %12 , %bb4 ] ; <i32> [#uses=5]
%.SV52.phi = phi i32 * [ undef , %bb70 ] , [ %9 , %bb4 ] ; <i32*> [#uses=3]
%.SV68.phi1020 = phi i32 [ %.SV68.phi1189 , %bb70 ] , [ %10 , %bb4 ] ; <i32> [#uses=5]
%.SV38.phi1014 = phi i64 [ %.SV38.phi1191 , %bb70 ] , [ %4 , %bb4 ] ; <i64> [#uses=5]
%.SV43.phi = phi i32 [ undef , %bb70 ] , [ %8 , %bb4 ] ; <i32> [#uses=1]
%Opq.link.mask900 = and i32 %Opq.link.SV898.phi , 4 ; <i32> [#uses=1]
%Opq.sa.calc897 = xor i32 %Opq.link.mask900 , 193 ; <i32> [#uses=3]
%meshCmp431 = icmp eq i32 %meshStackVariable429.phi , 5 ; <i1> [#uses=1]
br i1 %meshCmp431 , label %bb5 , label %bb70.fragment
meshBB432: ; preds = %bb42, %bb23.fragment182
%.SV38.phi1179 = phi i64 [ %.SV38.phi1115 , %bb23.fragment182 ] , [ %.SV38.phi1231 , %bb42 ] ; <i64> [#uses=7]
%.SV43.phi1178 = phi i32 [ %.SV43.phi1015 , %bb23.fragment182 ] , [ %.SV43.phi1230 , %bb42 ] ; <i32> [#uses=3]
%.SV68.phi1177 = phi i32 [ %.SV68.phi1112 , %bb23.fragment182 ] , [ %.SV68.phi1229 , %bb42 ] ; <i32> [#uses=7]
%.SV70.phi1176 = phi i32 [ %.SV70.phi1111 , %bb23.fragment182 ] , [ %.SV70.phi1228 , %bb42 ] ; <i32> [#uses=7]
%.SV118.phi1040 = phi i32 [ %76 , %bb23.fragment182 ] , [ %.SV118.phi1125 , %bb42 ] ; <i32> [#uses=7]
%.SV135.phi1039 = phi i1 [ %78 , %bb23.fragment182 ] , [ undef , %bb42 ] ; <i1> [#uses=2]
%meshStackVariable433.phi = phi i32 [ %Opq.sa.calc744 , %bb23.fragment182 ] , [ %Opq.sa.calc560 , %bb42 ] ; <i32> [#uses=1]
%Opq.link.SV799.phi = phi i32 [ %Opq.sa.calc744 , %bb23.fragment182 ] , [ %Opq.sa.calc987 , %bb42 ] ; <i32> [#uses=1]
%.SV96.phi1038 = phi i1 [ %71 , %bb23.fragment182 ] , [ undef , %bb42 ] ; <i1> [#uses=1]
%.SV99.phi1037 = phi i32 * [ %72 , %bb23.fragment182 ] , [ undef , %bb42 ] ; <i32*> [#uses=2]
%.SV104.phi1036 = phi i32 [ %73 , %bb23.fragment182 ] , [ %.SV104.phi1127 , %bb42 ] ; <i32> [#uses=3]
%.SV111.phi1035 = phi i32 * [ %74 , %bb23.fragment182 ] , [ %.SV111.phi1126 , %bb42 ] ; <i32*> [#uses=3]
%Opq.link.mask801 = and i32 %Opq.link.SV799.phi , 6 ; <i32> [#uses=1]
%Opq.sa.calc798 = xor i32 %Opq.link.mask801 , 3 ; <i32> [#uses=5]
%meshCmp435 = icmp eq i32 %meshStackVariable433.phi , 1 ; <i1> [#uses=1]
br i1 %meshCmp435 , label %bb43 , label %bb39
meshBB436: ; preds = %bb71.fragment, %bb65
%.SV38.phi1147 = phi i64 [ %.SV38.phi1144 , %bb65 ] , [ %.SV38.phi1140 , %bb71.fragment ] ; <i64> [#uses=2]
%.SV68.phi1146 = phi i32 [ %.SV68.phi1142 , %bb65 ] , [ %.SV68.phi1139 , %bb71.fragment ] ; <i32> [#uses=2]
%.SV70.phi1145 = phi i32 [ %.SV70.phi1141 , %bb65 ] , [ %.SV70.phi1138 , %bb71.fragment ] ; <i32> [#uses=2]
%.SV.phi1067 = phi i32 [ undef , %bb65 ] , [ %.load166.SV.phi , %bb71.fragment ] ; <i32> [#uses=1]
%yM.0.SV.phi1066 = phi i32 [ undef , %bb65 ] , [ %183 , %bb71.fragment ] ; <i32> [#uses=1]
%.load62.SV.phi = phi i32 * [ %.SV52.phi1143 , %bb65 ] , [ undef , %bb71.fragment ] ; <i32*> [#uses=1]
%.SV268.phi = phi i32 [ %164 , %bb65 ] , [ undef , %bb71.fragment ] ; <i32> [#uses=2]
%meshStackVariable437.phi = phi i32 [ %Opq.sa.calc617 , %bb65 ] , [ %Opq.sa.calc809 , %bb71.fragment ] ; <i32> [#uses=1]
%Opq.link.SV704.phi = phi i32 [ %Opq.sa.calc617 , %bb65 ] , [ %Opq.sa.calc809 , %bb71.fragment ] ; <i32> [#uses=1]
%Opq.link.mask706 = and i32 %Opq.link.SV704.phi , 0 ; <i32> [#uses=2]
%Opq.sa.calc703 = add i32 %Opq.link.mask706 , 216 ; <i32> [#uses=0]
%meshCmp439 = icmp eq i32 %meshStackVariable437.phi , 2 ; <i1> [#uses=1]
br i1 %meshCmp439 , label %bb96 , label %bb65.fragment
meshBB440: ; preds = %bb85, %bb54.fragment
%.SV52.phi1235 = phi i32 * [ %.SV52.phi1213 , %bb85 ] , [ undef , %bb54.fragment ] ; <i32*> [#uses=2]
%.SV38.phi1210 = phi i64 [ %.SV38.phi1214 , %bb85 ] , [ %.SV38.phi1207 , %bb54.fragment ] ; <i64> [#uses=2]
%.SV68.phi1209 = phi i32 [ %.SV68.phi1212 , %bb85 ] , [ %.SV68.phi1206 , %bb54.fragment ] ; <i32> [#uses=2]
%.SV70.phi1208 = phi i32 [ %.SV70.phi1211 , %bb85 ] , [ %.SV70.phi1205 , %bb54.fragment ] ; <i32> [#uses=2]
%.SV.phi1056 = phi i32 [ undef , %bb85 ] , [ %.SV118.phi1122 , %bb54.fragment ] ; <i32> [#uses=1]
%meshStackVariable441.phi = phi i32 [ %Opq.sa.calc666 , %bb85 ] , [ %Opq.sa.calc883 , %bb54.fragment ] ; <i32> [#uses=1]
%Opq.link.SV991.phi = phi i32 [ %Opq.sa.calc665 , %bb85 ] , [ %Opq.sa.calc883 , %bb54.fragment ] ; <i32> [#uses=1]
%Opq.link.mask993 = and i32 %Opq.link.SV991.phi , 6 ; <i32> [#uses=1]
%Opq.sa.calc990 = xor i32 %Opq.link.mask993 , 139 ; <i32> [#uses=2]
%meshCmp443 = icmp eq i32 %meshStackVariable441.phi , 6 ; <i1> [#uses=1]
br i1 %meshCmp443 , label %bb96 , label %bb87
meshBB444: ; preds = %bb66.fragment, %bb40
%.SV38.phi1224 = phi i64 [ %.SV38.phi1194 , %bb66.fragment ] , [ %.SV38.phi1179 , %bb40 ] ; <i64> [#uses=2]
%.SV68.phi1223 = phi i32 [ %.SV68.phi1193 , %bb66.fragment ] , [ %.SV68.phi1177 , %bb40 ] ; <i32> [#uses=2]
%.SV70.phi1222 = phi i32 [ %.SV70.phi1192 , %bb66.fragment ] , [ %.SV70.phi1176 , %bb40 ] ; <i32> [#uses=2]
%.SV.phi1048 = phi i32 [ undef , %bb66.fragment ] , [ %.SV118.phi1040 , %bb40 ] ; <i32> [#uses=1]
%meshStackVariable445.phi = phi i32 [ %Opq.sa.calc794 , %bb66.fragment ] , [ %Opq.sa.calc554 , %bb40 ] ; <i32> [#uses=1]
%Opq.link.SV781.phi = phi i32 [ %Opq.sa.calc795 , %bb66.fragment ] , [ %Opq.sa.calc554 , %bb40 ] ; <i32> [#uses=1]
%Opq.link.mask783 = and i32 %Opq.link.SV781.phi , 10 ; <i32> [#uses=1]
%Opq.sa.calc780 = add i32 %Opq.link.mask783 , 1 ; <i32> [#uses=0]
%meshCmp447 = icmp eq i32 %meshStackVariable445.phi , 11 ; <i1> [#uses=1]
br i1 %meshCmp447 , label %bb96 , label %bb98
meshBB448: ; preds = %bb35, %entry.fragment181
%.SV70.phi1233 = phi i32 [ undef , %entry.fragment181 ] , [ %.SV70.phi1180 , %bb35 ] ; <i32> [#uses=1]
%.SV104.phi1157 = phi i32 [ undef , %entry.fragment181 ] , [ %.SV104.phi1084 , %bb35 ] ; <i32> [#uses=1]
%.SV111.phi1156 = phi i32 * [ undef , %entry.fragment181 ] , [ %.SV111.phi1083 , %bb35 ] ; <i32*> [#uses=1]
%.SV118.phi1155 = phi i32 [ undef , %entry.fragment181 ] , [ %.SV118.phi1082 , %bb35 ] ; <i32> [#uses=1]
%.SV68.phi1025 = phi i32 [ %10 , %entry.fragment181 ] , [ %.SV68.phi1181 , %bb35 ] ; <i32> [#uses=1]
%meshStackVariable449.phi = phi i32 [ %Opq.sa.calc863 , %entry.fragment181 ] , [ %Opq.sa.calc541 , %bb35 ] ; <i32> [#uses=1]
%Opq.link.SV959.phi = phi i32 [ %Opq.sa.calc863 , %entry.fragment181 ] , [ %Opq.sa.calc828 , %bb35 ] ; <i32> [#uses=1]
%.SV38.phi1019 = phi i64 [ %4 , %entry.fragment181 ] , [ %.SV38.phi1183 , %bb35 ] ; <i64> [#uses=1]
%.SV43.phi1018 = phi i32 [ %8 , %entry.fragment181 ] , [ %.SV43.phi1015 , %bb35 ] ; <i32> [#uses=2]
%Opq.link.mask961 = and i32 %Opq.link.SV959.phi , 1 ; <i32> [#uses=1]
%Opq.sa.calc958 = xor i32 %Opq.link.mask961 , 63 ; <i32> [#uses=3]
%Opq.sa.calc957 = xor i32 %Opq.sa.calc958 , 126 ; <i32> [#uses=1]
%meshCmp451 = icmp eq i32 %meshStackVariable449.phi , 5 ; <i1> [#uses=1]
br i1 %meshCmp451 , label %bb37 , label %return
meshBB452: ; preds = %bb70.fragment, %bb63
%.SV38.phi1110 = phi i64 [ %.SV38.phi1014 , %bb70.fragment ] , [ %.SV38.phi1098 , %bb63 ] ; <i64> [#uses=3]
%.SV52.phi1109 = phi i32 * [ undef , %bb70.fragment ] , [ %.SV52.phi1097 , %bb63 ] ; <i32*> [#uses=2]
%.SV68.phi1108 = phi i32 [ %.SV68.phi1020 , %bb70.fragment ] , [ %.SV68.phi1096 , %bb63 ] ; <i32> [#uses=3]
%.SV70.phi1107 = phi i32 [ %.SV70.phi1026 , %bb70.fragment ] , [ %.SV70.phi1095 , %bb63 ] ; <i32> [#uses=3]
%.SV158.phi1106 = phi i32 [ %.SV158.phi1090 , %bb70.fragment ] , [ undef , %bb63 ] ; <i32> [#uses=1]
%.SV162.phi1105 = phi i32 * [ %.SV162.phi1089 , %bb70.fragment ] , [ undef , %bb63 ] ; <i32*> [#uses=1]
%.SV164.phi1104 = phi i32 [ %.SV164.phi1088 , %bb70.fragment ] , [ undef , %bb63 ] ; <i32> [#uses=1]
%.SV264.phi = phi %struct.Macroblock * [ undef , %bb70.fragment ] , [ %157 , %bb63 ] ; <%struct.Macroblock*> [#uses=1]
%.SV266.phi = phi i32 [ undef , %bb70.fragment ] , [ %158 , %bb63 ] ; <i32> [#uses=1]
%meshStackVariable453.phi = phi i32 [ %Opq.sa.calc739 , %bb70.fragment ] , [ %Opq.sa.calc611 , %bb63 ] ; <i32> [#uses=1]
%Opq.link.SV821.phi = phi i32 [ %Opq.sa.calc897 , %bb70.fragment ] , [ %Opq.sa.calc611 , %bb63 ] ; <i32> [#uses=1]
%.SV150.phi1060 = phi i32 * [ undef , %bb70.fragment ] , [ %148 , %bb63 ] ; <i32*> [#uses=1]
%.SV152.phi1059 = phi i32 * [ undef , %bb70.fragment ] , [ %149 , %bb63 ] ; <i32*> [#uses=2]
%.SV148.phi1057 = phi i32 [ undef , %bb70.fragment ] , [ %147 , %bb63 ] ; <i32> [#uses=1]
%Opq.link.mask823 = and i32 %Opq.link.SV821.phi , 4 ; <i32> [#uses=2]
%Opq.sa.calc820 = sub i32 %Opq.link.mask823 , -97 ; <i32> [#uses=2]
%meshCmp455 = icmp eq i32 %meshStackVariable453.phi , 6 ; <i1> [#uses=1]
br i1 %meshCmp455 , label %bb63.fragment , label %bb71
meshBB456: ; preds = %bb79, %bb63.fragment
%.SV38.phi1137 = phi i64 [ %.SV38.phi1110 , %bb63.fragment ] , [ %.SV38.phi1098 , %bb79 ] ; <i64> [#uses=2]
%.SV52.phi1136 = phi i32 * [ %.SV52.phi1109 , %bb63.fragment ] , [ %.SV52.phi1097 , %bb79 ] ; <i32*> [#uses=2]
%.SV68.phi1135 = phi i32 [ %.SV68.phi1108 , %bb63.fragment ] , [ %.SV68.phi1096 , %bb79 ] ; <i32> [#uses=2]
%.SV70.phi1134 = phi i32 [ %.SV70.phi1107 , %bb63.fragment ] , [ %.SV70.phi1095 , %bb79 ] ; <i32> [#uses=2]
%.SV152.phi1133 = phi i32 * [ %.SV152.phi1059 , %bb63.fragment ] , [ undef , %bb79 ] ; <i32*> [#uses=1]
%meshStackVariable457.phi = phi i32 [ %Opq.sa.calc890 , %bb63.fragment ] , [ %Opq.sa.calc651 , %bb79 ] ; <i32> [#uses=1]
%Opq.link.SV817.phi = phi i32 [ %Opq.sa.calc891 , %bb63.fragment ] , [ %Opq.sa.calc651 , %bb79 ] ; <i32> [#uses=1]
%Opq.link.mask819 = and i32 %Opq.link.SV817.phi , 2 ; <i32> [#uses=1]
%Opq.sa.calc816 = add i32 %Opq.link.mask819 , 186 ; <i32> [#uses=2]
%meshCmp459 = icmp eq i32 %meshStackVariable457.phi , 10 ; <i1> [#uses=1]
br i1 %meshCmp459 , label %bb81 , label %bb65
}
