[llvm] r215054 - Add a vector shuffle fuzzer.
Chandler Carruth
chandlerc at gmail.com
Wed Aug 6 21:13:51 PDT 2014
Author: chandlerc
Date: Wed Aug 6 23:13:51 2014
New Revision: 215054
URL: http://llvm.org/viewvc/llvm-project?rev=215054&view=rev
Log:
Add a vector shuffle fuzzer.
This is a python script which for a given seed generates a random
sequence of random shuffles of a random vector width. It embeds this
into a function and emits a main function which calls the test routine
and checks that the results (where defined) match the obvious results.
I'll be using this to drive out miscompiles from the new vector shuffle
logic now that it is clean of any crashes I can find with llvm-stress.
Note, my python skills are very poor. Sorry if this is terrible code,
and feel free to tell me how I should write this or just patch it as
necessary.
The tests generated try to be very portable and use boring C routines.
It technically will mis-declare the C routines and pass 32-bit integers
to parametrs that expect 64-bit integers. If someone wants to fix this
and has less terrible ideas of how to do it, I'm all ears. Fortunately,
this "just works" for x86. =]
Added:
llvm/trunk/utils/shuffle_fuzz.py (with props)
Added: llvm/trunk/utils/shuffle_fuzz.py
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/shuffle_fuzz.py?rev=215054&view=auto
==============================================================================
--- llvm/trunk/utils/shuffle_fuzz.py (added)
+++ llvm/trunk/utils/shuffle_fuzz.py Wed Aug 6 23:13:51 2014
@@ -0,0 +1,170 @@
+#!/usr/bin/env python
+
+"""A shuffle vector fuzz tester.
+
+This is a python program to fuzz test the LLVM shufflevector instruction. It
+generates a function with a random sequnece of shufflevectors, maintaining the
+element mapping accumulated across the function. It then generates a main
+function which calls it with a different value in each element and checks that
+the result matches the expected mapping.
+
+Take the output IR printed to stdout, compile it to an executable using whatever
+set of transforms you want to test, and run the program. If it crashes, it found
+a bug.
+"""
+
+import argparse
+import itertools
+import random
+import sys
+
+def main():
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument('seed',
+ help='A string used to seed the RNG')
+ parser.add_argument('-v', '--verbose', action='store_true',
+ help='Show verbose output')
+ parser.add_argument('--fixed-num-shuffles', type=int,
+ help='Specify a fixed number of shuffles to test')
+ parser.add_argument('--triple',
+ help='Specify a triple string to include in the IR')
+ args = parser.parse_args()
+
+ random.seed(args.seed)
+
+ width = random.choice([2, 4, 8, 16, 32, 64])
+ element_type = random.choice(['i8', 'i16', 'i32', 'i64', 'f32', 'f64'])
+
+ # FIXME: Support blends.
+ shuffle_indices = [-1] + range(width)
+
+ if args.fixed_num_shuffles is not None:
+ num_shuffles = args.fixed_num_shuffles
+ else:
+ num_shuffles = random.randint(0, 16)
+
+ shuffles = [[random.choice(shuffle_indices)
+ for _ in itertools.repeat(None, width)]
+ for _ in itertools.repeat(None, num_shuffles)]
+
+ if args.verbose:
+ # Print out the shuffle sequence in a compact form.
+ print >>sys.stderr, 'Testing shuffle sequence:'
+ for s in shuffles:
+ print >>sys.stderr, ' v%d%s: %s' % (width, element_type, s)
+ print >>sys.stderr, ''
+
+ # Compute a round-trip of the shuffle.
+ result = range(1, width + 1)
+ for s in shuffles:
+ result = [result[i] if i != -1 else -1 for i in s]
+
+ if args.verbose:
+ print >>sys.stderr, 'Which transforms:'
+ print >>sys.stderr, ' from: %s' % (range(1, width + 1),)
+ print >>sys.stderr, ' into: %s' % (result,)
+ print >>sys.stderr, ''
+
+ # The IR uses silly names for floating point types. We also need a same-size
+ # integer type.
+ integral_element_type = element_type
+ if element_type == 'f32':
+ integral_element_type = 'i32'
+ element_type = 'float'
+ elif element_type == 'f64':
+ integral_element_type = 'i64'
+ element_type = 'double'
+
+ # Now we need to generate IR for the shuffle function.
+ subst = {'N': width, 'T': element_type, 'IT': integral_element_type}
+ print """
+define internal <%(N)d x %(T)s> @test(<%(N)d x %(T)s> %%v) noinline nounwind {
+entry:""" % subst
+
+ for i, s in enumerate(shuffles):
+ print """
+ %%s%(i)d = shufflevector <%(N)d x %(T)s> %(I)s, <%(N)d x %(T)s> undef, <%(N)d x i32> <%(S)s>
+""".strip() % dict(subst,
+ i=i,
+ I=('%%s%d' % (i - 1)) if i != 0 else '%v',
+ S=', '.join(['i32 %s' % (str(si) if si != -1 else 'undef',)
+ for si in s]))
+
+ print """
+ ret <%(N)d x %(T)s> %%s%(i)d
+}
+""" % dict(subst, i=len(shuffles) - 1)
+
+ # Generate some string constants that we can use to report errors.
+ for i, r in enumerate(result):
+ if r != -1:
+ s = ('FAIL(%(seed)s): lane %(lane)d, expected %(result)d, found %%d\\0A' %
+ {'seed': args.seed, 'lane': i, 'result': r})
+ s += ''.join(['\\00' for _ in itertools.repeat(None, 64 - len(s) + 2)])
+ print """
+ at error.%(i)d = private unnamed_addr global [64 x i8] c"%(s)s"
+""".strip() % {'i': i, 's': s}
+
+ # Finally, generate a main function which will trap if any lanes are mapped
+ # incorrectly (in an observable way).
+ print """
+define i32 @main() optnone noinline {
+entry:
+ ; Create a scratch space to print error messages.
+ %%str = alloca [64 x i8]
+ %%str.ptr = getelementptr inbounds [64 x i8]* %%str, i32 0, i32 0
+
+ ; Build the input vector and call the test function.
+ %%input = bitcast <%(N)d x %(IT)s> <%(input)s> to <%(N)d x %(T)s>
+ %%v = call <%(N)d x %(T)s> @test(<%(N)d x %(T)s> %%input)
+ ; We need to cast this back to an integer type vector to easily check the
+ ; result.
+ %%v.cast = bitcast <%(N)d x %(T)s> %%v to <%(N)d x %(IT)s>
+ br label %%test.0
+""" % dict(subst,
+ input=', '.join(['%(IT)s %(i)s' % dict(subst, i=i)
+ for i in xrange(1, width + 1)]),
+ result=', '.join(['%(IT)s %(i)s' % dict(subst,
+ i=i if i != -1 else 'undef')
+ for i in result]))
+
+ # Test that each non-undef result lane contains the expected value.
+ for i, r in enumerate(result):
+ if r == -1:
+ print """
+test.%(i)d:
+ ; Skip this lane, its value is undef.
+ br label %%test.%(next_i)d
+""" % dict(subst, i=i, next_i=i + 1)
+ else:
+ print """
+test.%(i)d:
+ %%v.%(i)d = extractelement <%(N)d x %(IT)s> %%v.cast, i32 %(i)d
+ %%cmp.%(i)d = icmp ne %(IT)s %%v.%(i)d, %(r)d
+ br i1 %%cmp.%(i)d, label %%die.%(i)d, label %%test.%(next_i)d
+
+die.%(i)d:
+ ; Capture the actual value and print an error message.
+ %%tmp.%(i)d = zext %(IT)s %%v.%(i)d to i2048
+ %%bad.%(i)d = trunc i2048 %%tmp.%(i)d to i32
+ call i32 (i8*, i8*, ...)* @sprintf(i8* %%str.ptr, i8* getelementptr inbounds ([64 x i8]* @error.%(i)d, i32 0, i32 0), i32 %%bad.%(i)d)
+ %%length.%(i)d = call i32 @strlen(i8* %%str.ptr)
+ %%size.%(i)d = add i32 %%length.%(i)d, 1
+ call i32 @write(i32 2, i8* %%str.ptr, i32 %%size.%(i)d)
+ call void @llvm.trap()
+ unreachable
+""" % dict(subst, i=i, next_i=i + 1, r=r)
+
+ print """
+test.%d:
+ ret i32 0
+}
+
+declare i32 @strlen(i8*)
+declare i32 @write(i32, i8*, i32)
+declare i32 @sprintf(i8*, i8*, ...)
+declare void @llvm.trap() noreturn nounwind
+""" % (len(result),)
+
+if __name__ == '__main__':
+ main()
Propchange: llvm/trunk/utils/shuffle_fuzz.py
------------------------------------------------------------------------------
svn:executable = *
More information about the llvm-commits
mailing list