You've already forked linux-packaging-mono
Imported Upstream version 5.18.0.207
Former-commit-id: 3b152f462918d427ce18620a2cbe4f8b79650449
This commit is contained in:
Xamarin Public Jenkins (auto-signing)
parent
8e12397d70
commit
eb85e2fc17
@ -1,108 +0,0 @@
|
||||
# Test normal conditional branches in cases where the sheer number of
|
||||
# instructions causes some branches to be out of range.
|
||||
# RUN: python %s | llc -mtriple=s390x-linux-gnu | FileCheck %s
|
||||
|
||||
# Construct:
|
||||
#
|
||||
# before0:
|
||||
# conditional branch to after0
|
||||
# ...
|
||||
# beforeN:
|
||||
# conditional branch to after0
|
||||
# main:
|
||||
# 0xffd8 bytes, from MVIY instructions
|
||||
# conditional branch to main
|
||||
# after0:
|
||||
# ...
|
||||
# conditional branch to main
|
||||
# afterN:
|
||||
#
|
||||
# Each conditional branch sequence occupies 8 bytes if it uses a short branch
|
||||
# and 10 if it uses a long one. The ones before "main:" have to take the branch
|
||||
# length into account -- which is 4 bytes for short branches -- so the final
|
||||
# (0x28 - 4) / 8 == 4 blocks can use short branches. The ones after "main:"
|
||||
# do not, so the first 0x28 / 8 == 5 can use short branches. However,
|
||||
# the conservative algorithm we use makes one branch unnecessarily long
|
||||
# on each side.
|
||||
#
|
||||
# CHECK: c %r4, 0(%r3)
|
||||
# CHECK: jge [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: c %r4, 4(%r3)
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: c %r4, 8(%r3)
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: c %r4, 12(%r3)
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: c %r4, 16(%r3)
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: c %r4, 20(%r3)
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: c %r4, 24(%r3)
|
||||
# CHECK: j{{g?}}e [[LABEL]]
|
||||
# CHECK: c %r4, 28(%r3)
|
||||
# CHECK: je [[LABEL]]
|
||||
# CHECK: c %r4, 32(%r3)
|
||||
# CHECK: je [[LABEL]]
|
||||
# CHECK: c %r4, 36(%r3)
|
||||
# CHECK: je [[LABEL]]
|
||||
# ...main goes here...
|
||||
# CHECK: c %r4, 100(%r3)
|
||||
# CHECK: je [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: c %r4, 104(%r3)
|
||||
# CHECK: je [[LABEL]]
|
||||
# CHECK: c %r4, 108(%r3)
|
||||
# CHECK: je [[LABEL]]
|
||||
# CHECK: c %r4, 112(%r3)
|
||||
# CHECK: je [[LABEL]]
|
||||
# CHECK: c %r4, 116(%r3)
|
||||
# CHECK: j{{g?}}e [[LABEL]]
|
||||
# CHECK: c %r4, 120(%r3)
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: c %r4, 124(%r3)
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: c %r4, 128(%r3)
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: c %r4, 132(%r3)
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: c %r4, 136(%r3)
|
||||
# CHECK: jge [[LABEL]]
|
||||
|
||||
branch_blocks = 10
|
||||
main_size = 0xffd8
|
||||
|
||||
print '@global = global i32 0'
|
||||
|
||||
print 'define void @f1(i8 *%base, i32 *%stop, i32 %limit) {'
|
||||
print 'entry:'
|
||||
print ' br label %before0'
|
||||
print ''
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
next = 'before%d' % (i + 1) if i + 1 < branch_blocks else 'main'
|
||||
print 'before%d:' % i
|
||||
print ' %%bstop%d = getelementptr i32, i32 *%%stop, i64 %d' % (i, i)
|
||||
print ' %%bcur%d = load i32 , i32 *%%bstop%d' % (i, i)
|
||||
print ' %%btest%d = icmp eq i32 %%limit, %%bcur%d' % (i, i)
|
||||
print ' br i1 %%btest%d, label %%after0, label %%%s' % (i, next)
|
||||
print ''
|
||||
|
||||
print '%s:' % next
|
||||
a, b = 1, 1
|
||||
for i in xrange(0, main_size, 6):
|
||||
a, b = b, a + b
|
||||
offset = 4096 + b % 500000
|
||||
value = a % 256
|
||||
print ' %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
|
||||
print ' store volatile i8 %d, i8 *%%ptr%d' % (value, i)
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
print ' %%astop%d = getelementptr i32, i32 *%%stop, i64 %d' % (i, i + 25)
|
||||
print ' %%acur%d = load i32 , i32 *%%astop%d' % (i, i)
|
||||
print ' %%atest%d = icmp eq i32 %%limit, %%acur%d' % (i, i)
|
||||
print ' br i1 %%atest%d, label %%main, label %%after%d' % (i, i)
|
||||
print ''
|
||||
print 'after%d:' % i
|
||||
|
||||
print ' %dummy = load volatile i32, i32 *@global'
|
||||
print ' ret void'
|
||||
print '}'
|
||||
@ -1,82 +0,0 @@
|
||||
# Test normal conditional branches in cases where block alignments cause
|
||||
# some branches to be out of range.
|
||||
# RUN: python %s | llc -mtriple=s390x-linux-gnu -align-all-blocks=8 | FileCheck %s
|
||||
|
||||
# Construct:
|
||||
#
|
||||
# b0:
|
||||
# conditional branch to end
|
||||
# ...
|
||||
# b<N>:
|
||||
# conditional branch to end
|
||||
# b<N+1>:
|
||||
# conditional branch to b0
|
||||
# ...
|
||||
# b<2*N>:
|
||||
# conditional branch to b0
|
||||
# end:
|
||||
#
|
||||
# with N == 256 + 4. The -align-all-blocks=8 option ensures that all blocks
|
||||
# are 256 bytes in size. The first 4 blocks and the last 4 blocks are then
|
||||
# out of range.
|
||||
#
|
||||
# CHECK: c %r4, 0(%r3)
|
||||
# CHECK: jge [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: c %r4, 4(%r3)
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: c %r4, 8(%r3)
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: c %r4, 12(%r3)
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: c %r4, 16(%r3)
|
||||
# CHECK: je [[LABEL]]
|
||||
# CHECK: c %r4, 20(%r3)
|
||||
# CHECK: je [[LABEL]]
|
||||
# CHECK: c %r4, 24(%r3)
|
||||
# CHECK: je [[LABEL]]
|
||||
# CHECK: c %r4, 28(%r3)
|
||||
# CHECK: je [[LABEL]]
|
||||
# ...lots of other blocks...
|
||||
# CHECK: c %r4, 1004(%r3)
|
||||
# CHECK: je [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: c %r4, 1008(%r3)
|
||||
# CHECK: je [[LABEL]]
|
||||
# CHECK: c %r4, 1012(%r3)
|
||||
# CHECK: je [[LABEL]]
|
||||
# CHECK: c %r4, 1016(%r3)
|
||||
# CHECK: je [[LABEL]]
|
||||
# CHECK: c %r4, 1020(%r3)
|
||||
# CHECK: je [[LABEL]]
|
||||
# CHECK: c %r4, 1024(%r3)
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: c %r4, 1028(%r3)
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: c %r4, 1032(%r3)
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: c %r4, 1036(%r3)
|
||||
# CHECK: jge [[LABEL]]
|
||||
|
||||
blocks = 256 + 4
|
||||
|
||||
print 'define void @f1(i8 *%base, i32 *%stop, i32 %limit) {'
|
||||
print 'entry:'
|
||||
print ' br label %b0'
|
||||
print ''
|
||||
|
||||
a, b = 1, 1
|
||||
for i in xrange(blocks):
|
||||
a, b = b, a + b
|
||||
value = a % 256
|
||||
next = 'b%d' % (i + 1) if i + 1 < blocks else 'end'
|
||||
other = 'end' if 2 * i < blocks else 'b0'
|
||||
print 'b%d:' % i
|
||||
print ' store volatile i8 %d, i8 *%%base' % value
|
||||
print ' %%astop%d = getelementptr i32, i32 *%%stop, i64 %d' % (i, i)
|
||||
print ' %%acur%d = load i32 , i32 *%%astop%d' % (i, i)
|
||||
print ' %%atest%d = icmp eq i32 %%limit, %%acur%d' % (i, i)
|
||||
print ' br i1 %%atest%d, label %%%s, label %%%s' % (i, other, next)
|
||||
|
||||
print ''
|
||||
print '%s:' % next
|
||||
print ' ret void'
|
||||
print '}'
|
||||
@ -1,110 +0,0 @@
|
||||
# Test 32-bit COMPARE AND BRANCH in cases where the sheer number of
|
||||
# instructions causes some branches to be out of range.
|
||||
# RUN: python %s | llc -mtriple=s390x-linux-gnu | FileCheck %s
|
||||
|
||||
# Construct:
|
||||
#
|
||||
# before0:
|
||||
# conditional branch to after0
|
||||
# ...
|
||||
# beforeN:
|
||||
# conditional branch to after0
|
||||
# main:
|
||||
# 0xffcc bytes, from MVIY instructions
|
||||
# conditional branch to main
|
||||
# after0:
|
||||
# ...
|
||||
# conditional branch to main
|
||||
# afterN:
|
||||
#
|
||||
# Each conditional branch sequence occupies 12 bytes if it uses a short
|
||||
# branch and 14 if it uses a long one. The ones before "main:" have to
|
||||
# take the branch length into account, which is 6 for short branches,
|
||||
# so the final (0x34 - 6) / 12 == 3 blocks can use short branches.
|
||||
# The ones after "main:" do not, so the first 0x34 / 12 == 4 blocks
|
||||
# can use short branches.
|
||||
#
|
||||
# CHECK: lb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cr %r4, [[REG]]
|
||||
# CHECK: jge [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 1(%r3)
|
||||
# CHECK: cr %r4, [[REG]]
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 2(%r3)
|
||||
# CHECK: cr %r4, [[REG]]
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 3(%r3)
|
||||
# CHECK: cr %r4, [[REG]]
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 4(%r3)
|
||||
# CHECK: cr %r4, [[REG]]
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 5(%r3)
|
||||
# CHECK: crje %r4, [[REG]], [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 6(%r3)
|
||||
# CHECK: crje %r4, [[REG]], [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 7(%r3)
|
||||
# CHECK: crje %r4, [[REG]], [[LABEL]]
|
||||
# ...main goes here...
|
||||
# CHECK: lb [[REG:%r[0-5]]], 25(%r3)
|
||||
# CHECK: crje %r4, [[REG]], [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 26(%r3)
|
||||
# CHECK: crje %r4, [[REG]], [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 27(%r3)
|
||||
# CHECK: crje %r4, [[REG]], [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 28(%r3)
|
||||
# CHECK: crje %r4, [[REG]], [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 29(%r3)
|
||||
# CHECK: cr %r4, [[REG]]
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 30(%r3)
|
||||
# CHECK: cr %r4, [[REG]]
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 31(%r3)
|
||||
# CHECK: cr %r4, [[REG]]
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 32(%r3)
|
||||
# CHECK: cr %r4, [[REG]]
|
||||
# CHECK: jge [[LABEL]]
|
||||
|
||||
branch_blocks = 8
|
||||
main_size = 0xffcc
|
||||
|
||||
print '@global = global i32 0'
|
||||
|
||||
print 'define void @f1(i8 *%base, i8 *%stop, i32 %limit) {'
|
||||
print 'entry:'
|
||||
print ' br label %before0'
|
||||
print ''
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
next = 'before%d' % (i + 1) if i + 1 < branch_blocks else 'main'
|
||||
print 'before%d:' % i
|
||||
print ' %%bstop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i)
|
||||
print ' %%bcur%d = load i8 , i8 *%%bstop%d' % (i, i)
|
||||
print ' %%bext%d = sext i8 %%bcur%d to i32' % (i, i)
|
||||
print ' %%btest%d = icmp eq i32 %%limit, %%bext%d' % (i, i)
|
||||
print ' br i1 %%btest%d, label %%after0, label %%%s' % (i, next)
|
||||
print ''
|
||||
|
||||
print '%s:' % next
|
||||
a, b = 1, 1
|
||||
for i in xrange(0, main_size, 6):
|
||||
a, b = b, a + b
|
||||
offset = 4096 + b % 500000
|
||||
value = a % 256
|
||||
print ' %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
|
||||
print ' store volatile i8 %d, i8 *%%ptr%d' % (value, i)
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
print ' %%astop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i + 25)
|
||||
print ' %%acur%d = load i8 , i8 *%%astop%d' % (i, i)
|
||||
print ' %%aext%d = sext i8 %%acur%d to i32' % (i, i)
|
||||
print ' %%atest%d = icmp eq i32 %%limit, %%aext%d' % (i, i)
|
||||
print ' br i1 %%atest%d, label %%main, label %%after%d' % (i, i)
|
||||
print ''
|
||||
print 'after%d:' % i
|
||||
|
||||
print ' %dummy = load volatile i32, i32 *@global'
|
||||
print ' ret void'
|
||||
print '}'
|
||||
@ -1,114 +0,0 @@
|
||||
# Test 64-bit COMPARE AND BRANCH in cases where the sheer number of
|
||||
# instructions causes some branches to be out of range.
|
||||
# RUN: python %s | llc -mtriple=s390x-linux-gnu | FileCheck %s
|
||||
|
||||
# Construct:
|
||||
#
|
||||
# before0:
|
||||
# conditional branch to after0
|
||||
# ...
|
||||
# beforeN:
|
||||
# conditional branch to after0
|
||||
# main:
|
||||
# 0xffcc bytes, from MVIY instructions
|
||||
# conditional branch to main
|
||||
# after0:
|
||||
# ...
|
||||
# conditional branch to main
|
||||
# afterN:
|
||||
#
|
||||
# Each conditional branch sequence occupies 12 bytes if it uses a short
|
||||
# branch and 16 if it uses a long one. The ones before "main:" have to
|
||||
# take the branch length into account, which is 6 for short branches,
|
||||
# so the final (0x34 - 6) / 12 == 3 blocks can use short branches.
|
||||
# The ones after "main:" do not, so the first 0x34 / 12 == 4 blocks
|
||||
# can use short branches. The conservative algorithm we use makes
|
||||
# one of the forward branches unnecessarily long, as noted in the
|
||||
# check output below.
|
||||
#
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cgr %r4, [[REG]]
|
||||
# CHECK: jge [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 1(%r3)
|
||||
# CHECK: cgr %r4, [[REG]]
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 2(%r3)
|
||||
# CHECK: cgr %r4, [[REG]]
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 3(%r3)
|
||||
# CHECK: cgr %r4, [[REG]]
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 4(%r3)
|
||||
# CHECK: cgr %r4, [[REG]]
|
||||
# CHECK: jge [[LABEL]]
|
||||
# ...as mentioned above, the next one could be a CGRJE instead...
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 5(%r3)
|
||||
# CHECK: cgr %r4, [[REG]]
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 6(%r3)
|
||||
# CHECK: cgrje %r4, [[REG]], [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 7(%r3)
|
||||
# CHECK: cgrje %r4, [[REG]], [[LABEL]]
|
||||
# ...main goes here...
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 25(%r3)
|
||||
# CHECK: cgrje %r4, [[REG]], [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 26(%r3)
|
||||
# CHECK: cgrje %r4, [[REG]], [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 27(%r3)
|
||||
# CHECK: cgrje %r4, [[REG]], [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 28(%r3)
|
||||
# CHECK: cgrje %r4, [[REG]], [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 29(%r3)
|
||||
# CHECK: cgr %r4, [[REG]]
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 30(%r3)
|
||||
# CHECK: cgr %r4, [[REG]]
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 31(%r3)
|
||||
# CHECK: cgr %r4, [[REG]]
|
||||
# CHECK: jge [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 32(%r3)
|
||||
# CHECK: cgr %r4, [[REG]]
|
||||
# CHECK: jge [[LABEL]]
|
||||
|
||||
branch_blocks = 8
|
||||
main_size = 0xffcc
|
||||
|
||||
print '@global = global i32 0'
|
||||
|
||||
print 'define void @f1(i8 *%base, i8 *%stop, i64 %limit) {'
|
||||
print 'entry:'
|
||||
print ' br label %before0'
|
||||
print ''
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
next = 'before%d' % (i + 1) if i + 1 < branch_blocks else 'main'
|
||||
print 'before%d:' % i
|
||||
print ' %%bstop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i)
|
||||
print ' %%bcur%d = load i8 , i8 *%%bstop%d' % (i, i)
|
||||
print ' %%bext%d = sext i8 %%bcur%d to i64' % (i, i)
|
||||
print ' %%btest%d = icmp eq i64 %%limit, %%bext%d' % (i, i)
|
||||
print ' br i1 %%btest%d, label %%after0, label %%%s' % (i, next)
|
||||
print ''
|
||||
|
||||
print '%s:' % next
|
||||
a, b = 1, 1
|
||||
for i in xrange(0, main_size, 6):
|
||||
a, b = b, a + b
|
||||
offset = 4096 + b % 500000
|
||||
value = a % 256
|
||||
print ' %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
|
||||
print ' store volatile i8 %d, i8 *%%ptr%d' % (value, i)
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
print ' %%astop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i + 25)
|
||||
print ' %%acur%d = load i8 , i8 *%%astop%d' % (i, i)
|
||||
print ' %%aext%d = sext i8 %%acur%d to i64' % (i, i)
|
||||
print ' %%atest%d = icmp eq i64 %%limit, %%aext%d' % (i, i)
|
||||
print ' br i1 %%atest%d, label %%main, label %%after%d' % (i, i)
|
||||
print ''
|
||||
print 'after%d:' % i
|
||||
|
||||
print ' %dummy = load volatile i32, i32 *@global'
|
||||
print ' ret void'
|
||||
print '}'
|
||||
@ -1,112 +0,0 @@
|
||||
# Test 32-bit COMPARE IMMEDIATE AND BRANCH in cases where the sheer number of
|
||||
# instructions causes some branches to be out of range.
|
||||
# RUN: python %s | llc -mtriple=s390x-linux-gnu | FileCheck %s
|
||||
|
||||
# Construct:
|
||||
#
|
||||
# before0:
|
||||
# conditional branch to after0
|
||||
# ...
|
||||
# beforeN:
|
||||
# conditional branch to after0
|
||||
# main:
|
||||
# 0xffcc bytes, from MVIY instructions
|
||||
# conditional branch to main
|
||||
# after0:
|
||||
# ...
|
||||
# conditional branch to main
|
||||
# afterN:
|
||||
#
|
||||
# Each conditional branch sequence occupies 12 bytes if it uses a short
|
||||
# branch and 16 if it uses a long one. The ones before "main:" have to
|
||||
# take the branch length into account, which is 6 for short branches,
|
||||
# so the final (0x34 - 6) / 12 == 3 blocks can use short branches.
|
||||
# The ones after "main:" do not, so the first 0x34 / 12 == 4 blocks
|
||||
# can use short branches. The conservative algorithm we use makes
|
||||
# one of the forward branches unnecessarily long, as noted in the
|
||||
# check output below.
|
||||
#
|
||||
# CHECK: lb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: chi [[REG]], 50
|
||||
# CHECK: jgl [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: chi [[REG]], 51
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: chi [[REG]], 52
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: chi [[REG]], 53
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: chi [[REG]], 54
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# ...as mentioned above, the next one could be a CIJL instead...
|
||||
# CHECK: lb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: chi [[REG]], 55
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cijl [[REG]], 56, [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cijl [[REG]], 57, [[LABEL]]
|
||||
# ...main goes here...
|
||||
# CHECK: lb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cijl [[REG]], 100, [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cijl [[REG]], 101, [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cijl [[REG]], 102, [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cijl [[REG]], 103, [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: chi [[REG]], 104
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: chi [[REG]], 105
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: chi [[REG]], 106
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: chi [[REG]], 107
|
||||
# CHECK: jgl [[LABEL]]
|
||||
|
||||
branch_blocks = 8
|
||||
main_size = 0xffcc
|
||||
|
||||
print '@global = global i32 0'
|
||||
|
||||
print 'define void @f1(i8 *%base, i8 *%stop) {'
|
||||
print 'entry:'
|
||||
print ' br label %before0'
|
||||
print ''
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
next = 'before%d' % (i + 1) if i + 1 < branch_blocks else 'main'
|
||||
print 'before%d:' % i
|
||||
print ' %%bcur%d = load i8 , i8 *%%stop' % i
|
||||
print ' %%bext%d = sext i8 %%bcur%d to i32' % (i, i)
|
||||
print ' %%btest%d = icmp slt i32 %%bext%d, %d' % (i, i, i + 50)
|
||||
print ' br i1 %%btest%d, label %%after0, label %%%s' % (i, next)
|
||||
print ''
|
||||
|
||||
print '%s:' % next
|
||||
a, b = 1, 1
|
||||
for i in xrange(0, main_size, 6):
|
||||
a, b = b, a + b
|
||||
offset = 4096 + b % 500000
|
||||
value = a % 256
|
||||
print ' %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
|
||||
print ' store volatile i8 %d, i8 *%%ptr%d' % (value, i)
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
print ' %%acur%d = load i8 , i8 *%%stop' % i
|
||||
print ' %%aext%d = sext i8 %%acur%d to i32' % (i, i)
|
||||
print ' %%atest%d = icmp slt i32 %%aext%d, %d' % (i, i, i + 100)
|
||||
print ' br i1 %%atest%d, label %%main, label %%after%d' % (i, i)
|
||||
print ''
|
||||
print 'after%d:' % i
|
||||
|
||||
print ' %dummy = load volatile i32, i32 *@global'
|
||||
print ' ret void'
|
||||
print '}'
|
||||
@ -1,112 +0,0 @@
|
||||
# Test 64-bit COMPARE IMMEDIATE AND BRANCH in cases where the sheer number of
|
||||
# instructions causes some branches to be out of range.
|
||||
# RUN: python %s | llc -mtriple=s390x-linux-gnu | FileCheck %s
|
||||
|
||||
# Construct:
|
||||
#
|
||||
# before0:
|
||||
# conditional branch to after0
|
||||
# ...
|
||||
# beforeN:
|
||||
# conditional branch to after0
|
||||
# main:
|
||||
# 0xffcc bytes, from MVIY instructions
|
||||
# conditional branch to main
|
||||
# after0:
|
||||
# ...
|
||||
# conditional branch to main
|
||||
# afterN:
|
||||
#
|
||||
# Each conditional branch sequence occupies 12 bytes if it uses a short
|
||||
# branch and 16 if it uses a long one. The ones before "main:" have to
|
||||
# take the branch length into account, which is 6 for short branches,
|
||||
# so the final (0x34 - 6) / 12 == 3 blocks can use short branches.
|
||||
# The ones after "main:" do not, so the first 0x34 / 12 == 4 blocks
|
||||
# can use short branches. The conservative algorithm we use makes
|
||||
# one of the forward branches unnecessarily long, as noted in the
|
||||
# check output below.
|
||||
#
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cghi [[REG]], 50
|
||||
# CHECK: jgl [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cghi [[REG]], 51
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cghi [[REG]], 52
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cghi [[REG]], 53
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cghi [[REG]], 54
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# ...as mentioned above, the next one could be a CGIJL instead...
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cghi [[REG]], 55
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cgijl [[REG]], 56, [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cgijl [[REG]], 57, [[LABEL]]
|
||||
# ...main goes here...
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cgijl [[REG]], 100, [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cgijl [[REG]], 101, [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cgijl [[REG]], 102, [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cgijl [[REG]], 103, [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cghi [[REG]], 104
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cghi [[REG]], 105
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cghi [[REG]], 106
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: cghi [[REG]], 107
|
||||
# CHECK: jgl [[LABEL]]
|
||||
|
||||
branch_blocks = 8
|
||||
main_size = 0xffcc
|
||||
|
||||
print '@global = global i32 0'
|
||||
|
||||
print 'define void @f1(i8 *%base, i8 *%stop) {'
|
||||
print 'entry:'
|
||||
print ' br label %before0'
|
||||
print ''
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
next = 'before%d' % (i + 1) if i + 1 < branch_blocks else 'main'
|
||||
print 'before%d:' % i
|
||||
print ' %%bcur%d = load i8 , i8 *%%stop' % i
|
||||
print ' %%bext%d = sext i8 %%bcur%d to i64' % (i, i)
|
||||
print ' %%btest%d = icmp slt i64 %%bext%d, %d' % (i, i, i + 50)
|
||||
print ' br i1 %%btest%d, label %%after0, label %%%s' % (i, next)
|
||||
print ''
|
||||
|
||||
print '%s:' % next
|
||||
a, b = 1, 1
|
||||
for i in xrange(0, main_size, 6):
|
||||
a, b = b, a + b
|
||||
offset = 4096 + b % 500000
|
||||
value = a % 256
|
||||
print ' %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
|
||||
print ' store volatile i8 %d, i8 *%%ptr%d' % (value, i)
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
print ' %%acur%d = load i8 , i8 *%%stop' % i
|
||||
print ' %%aext%d = sext i8 %%acur%d to i64' % (i, i)
|
||||
print ' %%atest%d = icmp slt i64 %%aext%d, %d' % (i, i, i + 100)
|
||||
print ' br i1 %%atest%d, label %%main, label %%after%d' % (i, i)
|
||||
print ''
|
||||
print 'after%d:' % i
|
||||
|
||||
print ' %dummy = load volatile i32, i32 *@global'
|
||||
print ' ret void'
|
||||
print '}'
|
||||
@ -1,68 +0,0 @@
|
||||
# Test 32-bit BRANCH RELATIVE ON COUNT in cases where some branches are out
|
||||
# of range.
|
||||
# RUN: python %s | llc -mtriple=s390x-linux-gnu | FileCheck %s
|
||||
|
||||
# Construct:
|
||||
#
|
||||
# loopN:
|
||||
# load of countN
|
||||
# ...
|
||||
# loop0:
|
||||
# 0xffd8 bytes, from MVIY instructions
|
||||
# conditional branch to main
|
||||
# after0:
|
||||
# ...
|
||||
# decrement of countN
|
||||
# conditional branch to loopN
|
||||
# afterN:
|
||||
#
|
||||
# Each load occupies 4 bytes. Each decrement and branch occupies 4
|
||||
# bytes if BRCT can be used, otherwise it occupies 10 bytes (AHI + BRCL).
|
||||
# This means that loop 6 contains 5 * 4 + 0xffd8 + 5 * 4 == 0x10000 bytes
|
||||
# and is therefore (just) in range. Loop 7 is out of range.
|
||||
#
|
||||
# CHECK: brct {{%r[0-9]+}}
|
||||
# CHECK: brct {{%r[0-9]+}}
|
||||
# CHECK: brct {{%r[0-9]+}}
|
||||
# CHECK: brct {{%r[0-9]+}}
|
||||
# CHECK: brct {{%r[0-9]+}}
|
||||
# CHECK: brct {{%r[0-9]+}}
|
||||
# CHECK: ahi {{%r[0-9]+}}, -1
|
||||
# CHECK: jglh
|
||||
# CHECK: ahi {{%r[0-9]+}}, -1
|
||||
# CHECK: jglh
|
||||
|
||||
branch_blocks = 8
|
||||
main_size = 0xffd8
|
||||
|
||||
print 'define void @f1(i8 *%base, i32 *%counts) {'
|
||||
print 'entry:'
|
||||
|
||||
for i in xrange(branch_blocks - 1, -1, -1):
|
||||
print ' %%countptr%d = getelementptr i32, i32 *%%counts, i64 %d' % (i, i)
|
||||
print ' %%initcount%d = load i32 , i32 *%%countptr%d' % (i, i)
|
||||
print ' br label %%loop%d' % i
|
||||
|
||||
print 'loop%d:' % i
|
||||
block1 = 'entry' if i == branch_blocks - 1 else 'loop%d' % (i + 1)
|
||||
block2 = 'loop0' if i == 0 else 'after%d' % (i - 1)
|
||||
print (' %%count%d = phi i32 [ %%initcount%d, %%%s ],'
|
||||
' [ %%nextcount%d, %%%s ]' % (i, i, block1, i, block2))
|
||||
|
||||
a, b = 1, 1
|
||||
for i in xrange(0, main_size, 6):
|
||||
a, b = b, a + b
|
||||
offset = 4096 + b % 500000
|
||||
value = a % 256
|
||||
print ' %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
|
||||
print ' store volatile i8 %d, i8 *%%ptr%d' % (value, i)
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
print ' %%nextcount%d = add i32 %%count%d, -1' % (i, i)
|
||||
print ' %%test%d = icmp ne i32 %%nextcount%d, 0' % (i, i)
|
||||
print ' br i1 %%test%d, label %%loop%d, label %%after%d' % (i, i, i)
|
||||
print ''
|
||||
print 'after%d:' % i
|
||||
|
||||
print ' ret void'
|
||||
print '}'
|
||||
@ -1,69 +0,0 @@
|
||||
# Test 64-bit BRANCH RELATIVE ON COUNT in cases where some branches are out
|
||||
# of range.
|
||||
# RUN: python %s | llc -mtriple=s390x-linux-gnu | FileCheck %s
|
||||
|
||||
# Construct:
|
||||
#
|
||||
# loopN:
|
||||
# load of countN
|
||||
# ...
|
||||
# loop0:
|
||||
# 0xffd8 bytes, from MVIY instructions
|
||||
# conditional branch to main
|
||||
# after0:
|
||||
# ...
|
||||
# decrement of countN
|
||||
# conditional branch to loopN
|
||||
# afterN:
|
||||
#
|
||||
# Each load occupies 6 bytes. Each decrement and branch occupies 4
|
||||
# bytes if BRCTG can be used, otherwise it occupies 10 bytes (AGHI + BRCL).
|
||||
# This means that loop 5 contains 4 * 6 + 0xffd8 + 4 * 4 == 0x10000 bytes
|
||||
# and is therefore (just) in range. Loop 6 is out of range.
|
||||
#
|
||||
# CHECK: brctg {{%r[0-9]+}}
|
||||
# CHECK: brctg {{%r[0-9]+}}
|
||||
# CHECK: brctg {{%r[0-9]+}}
|
||||
# CHECK: brctg {{%r[0-9]+}}
|
||||
# CHECK: brctg {{%r[0-9]+}}
|
||||
# CHECK: aghi {{%r[0-9]+}}, -1
|
||||
# CHECK: jglh
|
||||
# CHECK: aghi {{%r[0-9]+}}, -1
|
||||
# CHECK: jglh
|
||||
# CHECK: aghi {{%r[0-9]+}}, -1
|
||||
# CHECK: jglh
|
||||
|
||||
branch_blocks = 8
|
||||
main_size = 0xffd8
|
||||
|
||||
print 'define void @f1(i8 *%base, i64 *%counts) {'
|
||||
print 'entry:'
|
||||
|
||||
for i in xrange(branch_blocks - 1, -1, -1):
|
||||
print ' %%countptr%d = getelementptr i64, i64 *%%counts, i64 %d' % (i, i)
|
||||
print ' %%initcount%d = load i64 , i64 *%%countptr%d' % (i, i)
|
||||
print ' br label %%loop%d' % i
|
||||
|
||||
print 'loop%d:' % i
|
||||
block1 = 'entry' if i == branch_blocks - 1 else 'loop%d' % (i + 1)
|
||||
block2 = 'loop0' if i == 0 else 'after%d' % (i - 1)
|
||||
print (' %%count%d = phi i64 [ %%initcount%d, %%%s ],'
|
||||
' [ %%nextcount%d, %%%s ]' % (i, i, block1, i, block2))
|
||||
|
||||
a, b = 1, 1
|
||||
for i in xrange(0, main_size, 6):
|
||||
a, b = b, a + b
|
||||
offset = 4096 + b % 500000
|
||||
value = a % 256
|
||||
print ' %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
|
||||
print ' store volatile i8 %d, i8 *%%ptr%d' % (value, i)
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
print ' %%nextcount%d = add i64 %%count%d, -1' % (i, i)
|
||||
print ' %%test%d = icmp ne i64 %%nextcount%d, 0' % (i, i)
|
||||
print ' br i1 %%test%d, label %%loop%d, label %%after%d' % (i, i, i)
|
||||
print ''
|
||||
print 'after%d:' % i
|
||||
|
||||
print ' ret void'
|
||||
print '}'
|
||||
@ -1,110 +0,0 @@
|
||||
# Test 32-bit COMPARE LOGICAL AND BRANCH in cases where the sheer number of
|
||||
# instructions causes some branches to be out of range.
|
||||
# RUN: python %s | llc -mtriple=s390x-linux-gnu | FileCheck %s
|
||||
|
||||
# Construct:
|
||||
#
|
||||
# before0:
|
||||
# conditional branch to after0
|
||||
# ...
|
||||
# beforeN:
|
||||
# conditional branch to after0
|
||||
# main:
|
||||
# 0xffcc bytes, from MVIY instructions
|
||||
# conditional branch to main
|
||||
# after0:
|
||||
# ...
|
||||
# conditional branch to main
|
||||
# afterN:
|
||||
#
|
||||
# Each conditional branch sequence occupies 12 bytes if it uses a short
|
||||
# branch and 14 if it uses a long one. The ones before "main:" have to
|
||||
# take the branch length into account, which is 6 for short branches,
|
||||
# so the final (0x34 - 6) / 12 == 3 blocks can use short branches.
|
||||
# The ones after "main:" do not, so the first 0x34 / 12 == 4 blocks
|
||||
# can use short branches.
|
||||
#
|
||||
# CHECK: lb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: clr %r4, [[REG]]
|
||||
# CHECK: jgl [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 1(%r3)
|
||||
# CHECK: clr %r4, [[REG]]
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 2(%r3)
|
||||
# CHECK: clr %r4, [[REG]]
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 3(%r3)
|
||||
# CHECK: clr %r4, [[REG]]
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 4(%r3)
|
||||
# CHECK: clr %r4, [[REG]]
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 5(%r3)
|
||||
# CHECK: clrjl %r4, [[REG]], [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 6(%r3)
|
||||
# CHECK: clrjl %r4, [[REG]], [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 7(%r3)
|
||||
# CHECK: clrjl %r4, [[REG]], [[LABEL]]
|
||||
# ...main goes here...
|
||||
# CHECK: lb [[REG:%r[0-5]]], 25(%r3)
|
||||
# CHECK: clrjl %r4, [[REG]], [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 26(%r3)
|
||||
# CHECK: clrjl %r4, [[REG]], [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 27(%r3)
|
||||
# CHECK: clrjl %r4, [[REG]], [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 28(%r3)
|
||||
# CHECK: clrjl %r4, [[REG]], [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 29(%r3)
|
||||
# CHECK: clr %r4, [[REG]]
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 30(%r3)
|
||||
# CHECK: clr %r4, [[REG]]
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 31(%r3)
|
||||
# CHECK: clr %r4, [[REG]]
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lb [[REG:%r[0-5]]], 32(%r3)
|
||||
# CHECK: clr %r4, [[REG]]
|
||||
# CHECK: jgl [[LABEL]]
|
||||
|
||||
branch_blocks = 8
|
||||
main_size = 0xffcc
|
||||
|
||||
print '@global = global i32 0'
|
||||
|
||||
print 'define void @f1(i8 *%base, i8 *%stop, i32 %limit) {'
|
||||
print 'entry:'
|
||||
print ' br label %before0'
|
||||
print ''
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
next = 'before%d' % (i + 1) if i + 1 < branch_blocks else 'main'
|
||||
print 'before%d:' % i
|
||||
print ' %%bstop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i)
|
||||
print ' %%bcur%d = load i8 , i8 *%%bstop%d' % (i, i)
|
||||
print ' %%bext%d = sext i8 %%bcur%d to i32' % (i, i)
|
||||
print ' %%btest%d = icmp ult i32 %%limit, %%bext%d' % (i, i)
|
||||
print ' br i1 %%btest%d, label %%after0, label %%%s' % (i, next)
|
||||
print ''
|
||||
|
||||
print '%s:' % next
|
||||
a, b = 1, 1
|
||||
for i in xrange(0, main_size, 6):
|
||||
a, b = b, a + b
|
||||
offset = 4096 + b % 500000
|
||||
value = a % 256
|
||||
print ' %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
|
||||
print ' store volatile i8 %d, i8 *%%ptr%d' % (value, i)
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
print ' %%astop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i + 25)
|
||||
print ' %%acur%d = load i8 , i8 *%%astop%d' % (i, i)
|
||||
print ' %%aext%d = sext i8 %%acur%d to i32' % (i, i)
|
||||
print ' %%atest%d = icmp ult i32 %%limit, %%aext%d' % (i, i)
|
||||
print ' br i1 %%atest%d, label %%main, label %%after%d' % (i, i)
|
||||
print ''
|
||||
print 'after%d:' % i
|
||||
|
||||
print ' %dummy = load volatile i32, i32 *@global'
|
||||
print ' ret void'
|
||||
print '}'
|
||||
@ -1,114 +0,0 @@
|
||||
# Test 64-bit COMPARE LOGICAL AND BRANCH in cases where the sheer number of
|
||||
# instructions causes some branches to be out of range.
|
||||
# RUN: python %s | llc -mtriple=s390x-linux-gnu | FileCheck %s
|
||||
|
||||
# Construct:
|
||||
#
|
||||
# before0:
|
||||
# conditional branch to after0
|
||||
# ...
|
||||
# beforeN:
|
||||
# conditional branch to after0
|
||||
# main:
|
||||
# 0xffcc bytes, from MVIY instructions
|
||||
# conditional branch to main
|
||||
# after0:
|
||||
# ...
|
||||
# conditional branch to main
|
||||
# afterN:
|
||||
#
|
||||
# Each conditional branch sequence occupies 12 bytes if it uses a short
|
||||
# branch and 16 if it uses a long one. The ones before "main:" have to
|
||||
# take the branch length into account, which is 6 for short branches,
|
||||
# so the final (0x34 - 6) / 12 == 3 blocks can use short branches.
|
||||
# The ones after "main:" do not, so the first 0x34 / 12 == 4 blocks
|
||||
# can use short branches. The conservative algorithm we use makes
|
||||
# one of the forward branches unnecessarily long, as noted in the
|
||||
# check output below.
|
||||
#
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: clgr %r4, [[REG]]
|
||||
# CHECK: jgl [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 1(%r3)
|
||||
# CHECK: clgr %r4, [[REG]]
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 2(%r3)
|
||||
# CHECK: clgr %r4, [[REG]]
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 3(%r3)
|
||||
# CHECK: clgr %r4, [[REG]]
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 4(%r3)
|
||||
# CHECK: clgr %r4, [[REG]]
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# ...as mentioned above, the next one could be a CLGRJL instead...
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 5(%r3)
|
||||
# CHECK: clgr %r4, [[REG]]
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 6(%r3)
|
||||
# CHECK: clgrjl %r4, [[REG]], [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 7(%r3)
|
||||
# CHECK: clgrjl %r4, [[REG]], [[LABEL]]
|
||||
# ...main goes here...
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 25(%r3)
|
||||
# CHECK: clgrjl %r4, [[REG]], [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 26(%r3)
|
||||
# CHECK: clgrjl %r4, [[REG]], [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 27(%r3)
|
||||
# CHECK: clgrjl %r4, [[REG]], [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 28(%r3)
|
||||
# CHECK: clgrjl %r4, [[REG]], [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 29(%r3)
|
||||
# CHECK: clgr %r4, [[REG]]
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 30(%r3)
|
||||
# CHECK: clgr %r4, [[REG]]
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 31(%r3)
|
||||
# CHECK: clgr %r4, [[REG]]
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lgb [[REG:%r[0-5]]], 32(%r3)
|
||||
# CHECK: clgr %r4, [[REG]]
|
||||
# CHECK: jgl [[LABEL]]
|
||||
|
||||
branch_blocks = 8
|
||||
main_size = 0xffcc
|
||||
|
||||
print '@global = global i32 0'
|
||||
|
||||
print 'define void @f1(i8 *%base, i8 *%stop, i64 %limit) {'
|
||||
print 'entry:'
|
||||
print ' br label %before0'
|
||||
print ''
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
next = 'before%d' % (i + 1) if i + 1 < branch_blocks else 'main'
|
||||
print 'before%d:' % i
|
||||
print ' %%bstop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i)
|
||||
print ' %%bcur%d = load i8 , i8 *%%bstop%d' % (i, i)
|
||||
print ' %%bext%d = sext i8 %%bcur%d to i64' % (i, i)
|
||||
print ' %%btest%d = icmp ult i64 %%limit, %%bext%d' % (i, i)
|
||||
print ' br i1 %%btest%d, label %%after0, label %%%s' % (i, next)
|
||||
print ''
|
||||
|
||||
print '%s:' % next
|
||||
a, b = 1, 1
|
||||
for i in xrange(0, main_size, 6):
|
||||
a, b = b, a + b
|
||||
offset = 4096 + b % 500000
|
||||
value = a % 256
|
||||
print ' %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
|
||||
print ' store volatile i8 %d, i8 *%%ptr%d' % (value, i)
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
print ' %%astop%d = getelementptr i8, i8 *%%stop, i64 %d' % (i, i + 25)
|
||||
print ' %%acur%d = load i8 , i8 *%%astop%d' % (i, i)
|
||||
print ' %%aext%d = sext i8 %%acur%d to i64' % (i, i)
|
||||
print ' %%atest%d = icmp ult i64 %%limit, %%aext%d' % (i, i)
|
||||
print ' br i1 %%atest%d, label %%main, label %%after%d' % (i, i)
|
||||
print ''
|
||||
print 'after%d:' % i
|
||||
|
||||
print ' %dummy = load volatile i32, i32 *@global'
|
||||
print ' ret void'
|
||||
print '}'
|
||||
@ -1,130 +0,0 @@
|
||||
# Test 32-bit COMPARE LOGICAL IMMEDIATE AND BRANCH in cases where the sheer
|
||||
# number of instructions causes some branches to be out of range.
|
||||
# RUN: python %s | llc -mtriple=s390x-linux-gnu | FileCheck %s
|
||||
|
||||
# Construct:
|
||||
#
|
||||
# before0:
|
||||
# conditional branch to after0
|
||||
# ...
|
||||
# beforeN:
|
||||
# conditional branch to after0
|
||||
# main:
|
||||
# 0xffc6 bytes, from MVIY instructions
|
||||
# conditional branch to main
|
||||
# after0:
|
||||
# ...
|
||||
# conditional branch to main
|
||||
# afterN:
|
||||
#
|
||||
# Each conditional branch sequence occupies 14 bytes if it uses a short
|
||||
# branch and 20 if it uses a long one. The ones before "main:" have to
|
||||
# take the branch length into account, which is 6 for short branches,
|
||||
# so the final (0x3a - 6) / 14 == 3 blocks can use short branches.
|
||||
# The ones after "main:" do not, so the first 0x3a / 14 == 4 blocks
|
||||
# can use short branches. The conservative algorithm we use makes
|
||||
# one of the forward branches unnecessarily long, as noted in the
|
||||
# check output below.
|
||||
#
|
||||
# CHECK: l [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: s [[REG]], 0(%r4)
|
||||
# CHECK: clfi [[REG]], 50
|
||||
# CHECK: jgl [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: l [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: s [[REG]], 0(%r4)
|
||||
# CHECK: clfi [[REG]], 51
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: l [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: s [[REG]], 0(%r4)
|
||||
# CHECK: clfi [[REG]], 52
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: l [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: s [[REG]], 0(%r4)
|
||||
# CHECK: clfi [[REG]], 53
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: l [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: s [[REG]], 0(%r4)
|
||||
# CHECK: clfi [[REG]], 54
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# ...as mentioned above, the next one could be a CLIJL instead...
|
||||
# CHECK: l [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: s [[REG]], 0(%r4)
|
||||
# CHECK: clfi [[REG]], 55
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: l [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: s [[REG]], 0(%r4)
|
||||
# CHECK: clijl [[REG]], 56, [[LABEL]]
|
||||
# CHECK: l [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: s [[REG]], 0(%r4)
|
||||
# CHECK: clijl [[REG]], 57, [[LABEL]]
|
||||
# ...main goes here...
|
||||
# CHECK: l [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: s [[REG]], 0(%r4)
|
||||
# CHECK: clijl [[REG]], 100, [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: l [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: s [[REG]], 0(%r4)
|
||||
# CHECK: clijl [[REG]], 101, [[LABEL]]
|
||||
# CHECK: l [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: s [[REG]], 0(%r4)
|
||||
# CHECK: clijl [[REG]], 102, [[LABEL]]
|
||||
# CHECK: l [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: s [[REG]], 0(%r4)
|
||||
# CHECK: clijl [[REG]], 103, [[LABEL]]
|
||||
# CHECK: l [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: s [[REG]], 0(%r4)
|
||||
# CHECK: clfi [[REG]], 104
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: l [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: s [[REG]], 0(%r4)
|
||||
# CHECK: clfi [[REG]], 105
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: l [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: s [[REG]], 0(%r4)
|
||||
# CHECK: clfi [[REG]], 106
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: l [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: s [[REG]], 0(%r4)
|
||||
# CHECK: clfi [[REG]], 107
|
||||
# CHECK: jgl [[LABEL]]
|
||||
|
||||
branch_blocks = 8
|
||||
main_size = 0xffc6
|
||||
|
||||
print '@global = global i32 0'
|
||||
|
||||
print 'define void @f1(i8 *%base, i32 *%stopa, i32 *%stopb) {'
|
||||
print 'entry:'
|
||||
print ' br label %before0'
|
||||
print ''
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
next = 'before%d' % (i + 1) if i + 1 < branch_blocks else 'main'
|
||||
print 'before%d:' % i
|
||||
print ' %%bcur%da = load i32 , i32 *%%stopa' % i
|
||||
print ' %%bcur%db = load i32 , i32 *%%stopb' % i
|
||||
print ' %%bsub%d = sub i32 %%bcur%da, %%bcur%db' % (i, i, i)
|
||||
print ' %%btest%d = icmp ult i32 %%bsub%d, %d' % (i, i, i + 50)
|
||||
print ' br i1 %%btest%d, label %%after0, label %%%s' % (i, next)
|
||||
print ''
|
||||
|
||||
print '%s:' % next
|
||||
a, b = 1, 1
|
||||
for i in xrange(0, main_size, 6):
|
||||
a, b = b, a + b
|
||||
offset = 4096 + b % 500000
|
||||
value = a % 256
|
||||
print ' %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
|
||||
print ' store volatile i8 %d, i8 *%%ptr%d' % (value, i)
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
print ' %%acur%da = load i32 , i32 *%%stopa' % i
|
||||
print ' %%acur%db = load i32 , i32 *%%stopb' % i
|
||||
print ' %%asub%d = sub i32 %%acur%da, %%acur%db' % (i, i, i)
|
||||
print ' %%atest%d = icmp ult i32 %%asub%d, %d' % (i, i, i + 100)
|
||||
print ' br i1 %%atest%d, label %%main, label %%after%d' % (i, i)
|
||||
print ''
|
||||
print 'after%d:' % i
|
||||
|
||||
print ' %dummy = load volatile i32, i32 *@global'
|
||||
print ' ret void'
|
||||
print '}'
|
||||
@ -1,130 +0,0 @@
|
||||
# Test 64-bit COMPARE LOGICAL IMMEDIATE AND BRANCH in cases where the sheer
|
||||
# number of instructions causes some branches to be out of range.
|
||||
# RUN: python %s | llc -mtriple=s390x-linux-gnu | FileCheck %s
|
||||
|
||||
# Construct:
|
||||
#
|
||||
# before0:
|
||||
# conditional branch to after0
|
||||
# ...
|
||||
# beforeN:
|
||||
# conditional branch to after0
|
||||
# main:
|
||||
# 0xffb4 bytes, from MVIY instructions
|
||||
# conditional branch to main
|
||||
# after0:
|
||||
# ...
|
||||
# conditional branch to main
|
||||
# afterN:
|
||||
#
|
||||
# Each conditional branch sequence occupies 18 bytes if it uses a short
|
||||
# branch and 24 if it uses a long one. The ones before "main:" have to
|
||||
# take the branch length into account, which is 6 for short branches,
|
||||
# so the final (0x4c - 6) / 18 == 3 blocks can use short branches.
|
||||
# The ones after "main:" do not, so the first 0x4c / 18 == 4 blocks
|
||||
# can use short branches. The conservative algorithm we use makes
|
||||
# one of the forward branches unnecessarily long, as noted in the
|
||||
# check output below.
|
||||
#
|
||||
# CHECK: lg [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: sg [[REG]], 0(%r4)
|
||||
# CHECK: clgfi [[REG]], 50
|
||||
# CHECK: jgl [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: lg [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: sg [[REG]], 0(%r4)
|
||||
# CHECK: clgfi [[REG]], 51
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lg [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: sg [[REG]], 0(%r4)
|
||||
# CHECK: clgfi [[REG]], 52
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lg [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: sg [[REG]], 0(%r4)
|
||||
# CHECK: clgfi [[REG]], 53
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lg [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: sg [[REG]], 0(%r4)
|
||||
# CHECK: clgfi [[REG]], 54
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# ...as mentioned above, the next one could be a CLGIJL instead...
|
||||
# CHECK: lg [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: sg [[REG]], 0(%r4)
|
||||
# CHECK: clgfi [[REG]], 55
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lg [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: sg [[REG]], 0(%r4)
|
||||
# CHECK: clgijl [[REG]], 56, [[LABEL]]
|
||||
# CHECK: lg [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: sg [[REG]], 0(%r4)
|
||||
# CHECK: clgijl [[REG]], 57, [[LABEL]]
|
||||
# ...main goes here...
|
||||
# CHECK: lg [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: sg [[REG]], 0(%r4)
|
||||
# CHECK: clgijl [[REG]], 100, [[LABEL:\.L[^ ]*]]
|
||||
# CHECK: lg [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: sg [[REG]], 0(%r4)
|
||||
# CHECK: clgijl [[REG]], 101, [[LABEL]]
|
||||
# CHECK: lg [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: sg [[REG]], 0(%r4)
|
||||
# CHECK: clgijl [[REG]], 102, [[LABEL]]
|
||||
# CHECK: lg [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: sg [[REG]], 0(%r4)
|
||||
# CHECK: clgijl [[REG]], 103, [[LABEL]]
|
||||
# CHECK: lg [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: sg [[REG]], 0(%r4)
|
||||
# CHECK: clgfi [[REG]], 104
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lg [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: sg [[REG]], 0(%r4)
|
||||
# CHECK: clgfi [[REG]], 105
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lg [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: sg [[REG]], 0(%r4)
|
||||
# CHECK: clgfi [[REG]], 106
|
||||
# CHECK: jgl [[LABEL]]
|
||||
# CHECK: lg [[REG:%r[0-5]]], 0(%r3)
|
||||
# CHECK: sg [[REG]], 0(%r4)
|
||||
# CHECK: clgfi [[REG]], 107
|
||||
# CHECK: jgl [[LABEL]]
|
||||
|
||||
branch_blocks = 8
|
||||
main_size = 0xffb4
|
||||
|
||||
print '@global = global i32 0'
|
||||
|
||||
print 'define void @f1(i8 *%base, i64 *%stopa, i64 *%stopb) {'
|
||||
print 'entry:'
|
||||
print ' br label %before0'
|
||||
print ''
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
next = 'before%d' % (i + 1) if i + 1 < branch_blocks else 'main'
|
||||
print 'before%d:' % i
|
||||
print ' %%bcur%da = load i64 , i64 *%%stopa' % i
|
||||
print ' %%bcur%db = load i64 , i64 *%%stopb' % i
|
||||
print ' %%bsub%d = sub i64 %%bcur%da, %%bcur%db' % (i, i, i)
|
||||
print ' %%btest%d = icmp ult i64 %%bsub%d, %d' % (i, i, i + 50)
|
||||
print ' br i1 %%btest%d, label %%after0, label %%%s' % (i, next)
|
||||
print ''
|
||||
|
||||
print '%s:' % next
|
||||
a, b = 1, 1
|
||||
for i in xrange(0, main_size, 6):
|
||||
a, b = b, a + b
|
||||
offset = 4096 + b % 500000
|
||||
value = a % 256
|
||||
print ' %%ptr%d = getelementptr i8, i8 *%%base, i64 %d' % (i, offset)
|
||||
print ' store volatile i8 %d, i8 *%%ptr%d' % (value, i)
|
||||
|
||||
for i in xrange(branch_blocks):
|
||||
print ' %%acur%da = load i64 , i64 *%%stopa' % i
|
||||
print ' %%acur%db = load i64 , i64 *%%stopb' % i
|
||||
print ' %%asub%d = sub i64 %%acur%da, %%acur%db' % (i, i, i)
|
||||
print ' %%atest%d = icmp ult i64 %%asub%d, %d' % (i, i, i + 100)
|
||||
print ' br i1 %%atest%d, label %%main, label %%after%d' % (i, i)
|
||||
print ''
|
||||
print 'after%d:' % i
|
||||
|
||||
print ' %dummy = load volatile i32, i32 *@global'
|
||||
print ' ret void'
|
||||
print '}'
|
||||
@ -1,9 +0,0 @@
|
||||
config.suffixes = ['.py']
|
||||
|
||||
# These tests take on the order of seconds to run, so skip them unless
|
||||
# we're running long tests.
|
||||
if 'long_tests' not in config.available_features:
|
||||
config.unsupported = True
|
||||
|
||||
if not 'SystemZ' in config.root.targets:
|
||||
config.unsupported = True
|
||||
@ -1,40 +0,0 @@
|
||||
# Test cases where MVC is used for spill slots that end up being out of range.
|
||||
# RUN: python %s | llc -mtriple=s390x-linux-gnu | FileCheck %s
|
||||
|
||||
# There are 8 usable call-saved GPRs, two of which are needed for the base
|
||||
# registers. The first 160 bytes of the frame are needed for the ABI
|
||||
# call frame, and a further 8 bytes are needed for the emergency spill slot.
|
||||
# That means we will have at least one out-of-range slot if:
|
||||
#
|
||||
# count == (4096 - 168) / 8 + 6 + 1 == 498
|
||||
#
|
||||
# Add in some extra room and check both %r15+4096 (the first out-of-range slot)
|
||||
# and %r15+4104.
|
||||
#
|
||||
# CHECK: f1:
|
||||
# CHECK: lay [[REG:%r[0-5]]], 4096(%r15)
|
||||
# CHECK: mvc 0(8,[[REG]]), {{[0-9]+}}({{%r[0-9]+}})
|
||||
# CHECK: brasl %r14, foo@PLT
|
||||
# CHECK: lay [[REG:%r[0-5]]], 4096(%r15)
|
||||
# CHECK: mvc {{[0-9]+}}(8,{{%r[0-9]+}}), 8([[REG]])
|
||||
# CHECK: br %r14
|
||||
count = 500
|
||||
|
||||
print 'declare void @foo()'
|
||||
print ''
|
||||
print 'define void @f1(i64 *%base0, i64 *%base1) {'
|
||||
|
||||
for i in range(count):
|
||||
print ' %%ptr%d = getelementptr i64, i64 *%%base%d, i64 %d' % (i, i % 2, i / 2)
|
||||
print ' %%val%d = load i64 , i64 *%%ptr%d' % (i, i)
|
||||
print ''
|
||||
|
||||
print ' call void @foo()'
|
||||
print ''
|
||||
|
||||
for i in range(count):
|
||||
print ' store i64 %%val%d, i64 *%%ptr%d' % (i, i)
|
||||
|
||||
print ''
|
||||
print ' ret void'
|
||||
print '}'
|
||||
@ -1,73 +0,0 @@
|
||||
# Test cases where we spill from one frame index to another, both of which
|
||||
# are out of range of MVC, and both of which need emergency spill slots.
|
||||
# RUN: python %s | llc -mtriple=s390x-linux-gnu | FileCheck %s
|
||||
|
||||
# CHECK: f1:
|
||||
# CHECK: %fallthru
|
||||
# CHECK-DAG: stg [[REG1:%r[0-9]+]], 8168(%r15)
|
||||
# CHECK-DAG: stg [[REG2:%r[0-9]+]], 8176(%r15)
|
||||
# CHECK-DAG: lay [[REG3:%r[0-9]+]], 8192(%r15)
|
||||
# CHECK-DAG: lay [[REG4:%r[0-9]+]], 4096(%r15)
|
||||
# CHECK: mvc 0(8,[[REG3]]), 4088([[REG4]])
|
||||
# CHECK-DAG: lg [[REG1]], 8168(%r15)
|
||||
# CHECK-DAG: lg [[REG2]], 8176(%r15)
|
||||
# CHECK: %skip
|
||||
# CHECK: br %r14
|
||||
|
||||
# Arrange for %foo's spill slot to be at 8184(%r15) and the alloca area to be at
|
||||
# 8192(%r15). The two emergency spill slots live below that, so this requires
|
||||
# the first 8168 bytes to be used for the call. 160 of these bytes are
|
||||
# allocated for the ABI frame. There are also 5 argument registers, one of
|
||||
# which is used as a base pointer.
|
||||
args = (8168 - 160) / 8 + (5 - 1)
|
||||
|
||||
print 'declare i64 *@foo(i64 *%s)' % (', i64' * args)
|
||||
print 'declare void @bar(i64 *)'
|
||||
print ''
|
||||
print 'define i64 @f1(i64 %foo) {'
|
||||
print 'entry:'
|
||||
|
||||
# Make the allocation big, so that it goes at the top of the frame.
|
||||
print ' %array = alloca [1000 x i64]'
|
||||
print ' %area = getelementptr [1000 x i64], [1000 x i64] *%array, i64 0, i64 0'
|
||||
print ' %%base = call i64 *@foo(i64 *%%area%s)' % (', i64 0' * args)
|
||||
print ''
|
||||
|
||||
# Make sure all GPRs are used. One is needed for the stack pointer and
|
||||
# another for %base, so we need 14 live values.
|
||||
count = 14
|
||||
for i in range(count):
|
||||
print ' %%ptr%d = getelementptr i64, i64 *%%base, i64 %d' % (i, i / 2)
|
||||
print ' %%val%d = load volatile i64 , i64 *%%ptr%d' % (i, i)
|
||||
print ''
|
||||
|
||||
# Encourage the register allocator to give preference to these %vals
|
||||
# by using them several times.
|
||||
for j in range(4):
|
||||
for i in range(count):
|
||||
print ' store volatile i64 %%val%d, i64 *%%ptr%d' % (i, i)
|
||||
print ''
|
||||
|
||||
# Copy the incoming argument, which we expect to be spilled, to the frame
|
||||
# index for the alloca area. Also throw in a volatile store, so that this
|
||||
# block cannot be reordered with the surrounding code.
|
||||
print ' %cond = icmp eq i64 %val0, %val1'
|
||||
print ' br i1 %cond, label %skip, label %fallthru'
|
||||
print ''
|
||||
print 'fallthru:'
|
||||
print ' store i64 %foo, i64 *%area'
|
||||
print ' store volatile i64 %val0, i64 *%ptr0'
|
||||
print ' br label %skip'
|
||||
print ''
|
||||
print 'skip:'
|
||||
|
||||
# Use each %val a few more times to emphasise the point, and to make sure
|
||||
# that they are live across the store of %foo.
|
||||
for j in range(4):
|
||||
for i in range(count):
|
||||
print ' store volatile i64 %%val%d, i64 *%%ptr%d' % (i, i)
|
||||
print ''
|
||||
|
||||
print ' call void @bar(i64 *%area)'
|
||||
print ' ret i64 0'
|
||||
print '}'
|
||||
Reference in New Issue
Block a user