3 """A shuffle vector fuzz tester.
5 This is a python program to fuzz test the LLVM shufflevector instruction. It
6 generates a function with a random sequnece of shufflevectors, maintaining the
7 element mapping accumulated across the function. It then generates a main
8 function which calls it with a different value in each element and checks that
9 the result matches the expected mapping.
11 Take the output IR printed to stdout, compile it to an executable using whatever
12 set of transforms you want to test, and run the program. If it crashes, it found
23 parser = argparse.ArgumentParser(description=__doc__)
24 parser.add_argument('-v', '--verbose', action='store_true',
25 help='Show verbose output')
26 parser.add_argument('--seed', default=str(uuid.uuid4()),
27 help='A string used to seed the RNG')
28 parser.add_argument('--max-shuffle-height', type=int, default=16,
29 help='Specify a fixed height of shuffle tree to test')
30 parser.add_argument('--no-blends', dest='blends', action='store_false',
31 help='Include blends of two input vectors')
32 parser.add_argument('--fixed-bit-width', type=int, choices=[128, 256],
33 help='Specify a fixed bit width of vector to test')
34 parser.add_argument('--triple',
35 help='Specify a triple string to include in the IR')
36 args = parser.parse_args()
38 random.seed(args.seed)
40 if args.fixed_bit_width is not None:
41 if args.fixed_bit_width == 128:
42 (width, element_type) = random.choice(
43 [(2, 'i64'), (4, 'i32'), (8, 'i16'), (16, 'i8'),
44 (2, 'f64'), (4, 'f32')])
45 elif args.fixed_bit_width == 256:
46 (width, element_type) = random.choice([
47 (4, 'i64'), (8, 'i32'), (16, 'i16'), (32, 'i8'),
48 (4, 'f64'), (8, 'f32')])
50 sys.exit(1) # Checked above by argument parsing.
52 width = random.choice([2, 4, 8, 16, 32, 64])
53 element_type = random.choice(['i8', 'i16', 'i32', 'i64', 'f32', 'f64'])
56 'i8': 1 << 8, 'i16': 1 << 16, 'i32': 1 << 32, 'i64': 1 << 64,
57 'f32': 1 << 32, 'f64': 1 << 64}[element_type]
59 shuffle_range = (2 * width) if args.blends else width
60 shuffle_indices = [-1] + range(shuffle_range)
62 shuffle_tree = [[[random.choice(shuffle_indices)
63 for _ in itertools.repeat(None, width)]
64 for _ in itertools.repeat(None, args.max_shuffle_height - i)]
65 for i in xrange(args.max_shuffle_height)]
68 # Print out the shuffle sequence in a compact form.
69 print >>sys.stderr, ('Testing shuffle sequence "%s" (v%d%s):' %
70 (args.seed, width, element_type))
71 for i, shuffles in enumerate(shuffle_tree):
72 print >>sys.stderr, ' tree level %d:' % (i,)
73 for j, s in enumerate(shuffles):
74 print >>sys.stderr, ' shuffle %d: %s' % (j, s)
75 print >>sys.stderr, ''
77 # Symbolically evaluate the shuffle tree.
78 inputs = [[int(j % element_modulus)
79 for j in xrange(i * width + 1, (i + 1) * width + 1)]
80 for i in xrange(args.max_shuffle_height + 1)]
82 for shuffles in shuffle_tree:
83 results = [[((results[i] if j < width else results[i + 1])[j % width]
86 for i, s in enumerate(shuffles)]
88 print >>sys.stderr, 'ERROR: Bad results: %s' % (results,)
93 print >>sys.stderr, 'Which transforms:'
94 print >>sys.stderr, ' from: %s' % (inputs,)
95 print >>sys.stderr, ' into: %s' % (result,)
96 print >>sys.stderr, ''
98 # The IR uses silly names for floating point types. We also need a same-size
100 integral_element_type = element_type
101 if element_type == 'f32':
102 integral_element_type = 'i32'
103 element_type = 'float'
104 elif element_type == 'f64':
105 integral_element_type = 'i64'
106 element_type = 'double'
108 # Now we need to generate IR for the shuffle function.
109 subst = {'N': width, 'T': element_type, 'IT': integral_element_type}
111 define internal fastcc <%(N)d x %(T)s> @test(%(arguments)s) noinline nounwind {
112 entry:""" % dict(subst,
114 ['<%(N)d x %(T)s> %%s.0.%(i)d' % dict(subst, i=i)
115 for i in xrange(args.max_shuffle_height + 1)]))
117 for i, shuffles in enumerate(shuffle_tree):
118 for j, s in enumerate(shuffles):
120 %%s.%(next_i)d.%(j)d = shufflevector <%(N)d x %(T)s> %%s.%(i)d.%(j)d, <%(N)d x %(T)s> %%s.%(i)d.%(next_j)d, <%(N)d x i32> <%(S)s>
121 """.strip('\n') % dict(subst, i=i, next_i=i + 1, j=j, next_j=j + 1,
122 S=', '.join(['i32 ' + (str(si) if si != -1 else 'undef')
126 ret <%(N)d x %(T)s> %%s.%(i)d.0
128 """ % dict(subst, i=len(shuffle_tree))
130 # Generate some string constants that we can use to report errors.
131 for i, r in enumerate(result):
133 s = ('FAIL(%(seed)s): lane %(lane)d, expected %(result)d, found %%d\\0A' %
134 {'seed': args.seed, 'lane': i, 'result': r})
135 s += ''.join(['\\00' for _ in itertools.repeat(None, 128 - len(s) + 2)])
137 @error.%(i)d = private unnamed_addr global [128 x i8] c"%(s)s"
138 """.strip() % {'i': i, 's': s}
140 # Define a wrapper function which is marked 'optnone' to prevent
141 # interprocedural optimizations from deleting the test.
143 define internal fastcc <%(N)d x %(T)s> @test_wrapper(%(arguments)s) optnone noinline {
144 %%result = call fastcc <%(N)d x %(T)s> @test(%(arguments)s)
145 ret <%(N)d x %(T)s> %%result
148 arguments=', '.join(['<%(N)d x %(T)s> %%s.%(i)d' % dict(subst, i=i)
149 for i in xrange(args.max_shuffle_height + 1)]))
151 # Finally, generate a main function which will trap if any lanes are mapped
152 # incorrectly (in an observable way).
156 ; Create a scratch space to print error messages.
157 %%str = alloca [128 x i8]
158 %%str.ptr = getelementptr inbounds [128 x i8]* %%str, i32 0, i32 0
160 ; Build the input vector and call the test function.
161 %%v = call fastcc <%(N)d x %(T)s> @test_wrapper(%(inputs)s)
162 ; We need to cast this back to an integer type vector to easily check the
164 %%v.cast = bitcast <%(N)d x %(T)s> %%v to <%(N)d x %(IT)s>
168 [('<%(N)d x %(T)s> bitcast '
169 '(<%(N)d x %(IT)s> <%(input)s> to <%(N)d x %(T)s>)' %
170 dict(subst, input=', '.join(['%(IT)s %(i)d' % dict(subst, i=i)
172 for input in inputs]))
174 # Test that each non-undef result lane contains the expected value.
175 for i, r in enumerate(result):
179 ; Skip this lane, its value is undef.
180 br label %%test.%(next_i)d
181 """ % dict(subst, i=i, next_i=i + 1)
185 %%v.%(i)d = extractelement <%(N)d x %(IT)s> %%v.cast, i32 %(i)d
186 %%cmp.%(i)d = icmp ne %(IT)s %%v.%(i)d, %(r)d
187 br i1 %%cmp.%(i)d, label %%die.%(i)d, label %%test.%(next_i)d
190 ; Capture the actual value and print an error message.
191 %%tmp.%(i)d = zext %(IT)s %%v.%(i)d to i2048
192 %%bad.%(i)d = trunc i2048 %%tmp.%(i)d to i32
193 call i32 (i8*, i8*, ...)* @sprintf(i8* %%str.ptr, i8* getelementptr inbounds ([128 x i8]* @error.%(i)d, i32 0, i32 0), i32 %%bad.%(i)d)
194 %%length.%(i)d = call i32 @strlen(i8* %%str.ptr)
195 %%size.%(i)d = add i32 %%length.%(i)d, 1
196 call i32 @write(i32 2, i8* %%str.ptr, i32 %%size.%(i)d)
197 call void @llvm.trap()
199 """ % dict(subst, i=i, next_i=i + 1, r=r)
206 declare i32 @strlen(i8*)
207 declare i32 @write(i32, i8*, i32)
208 declare i32 @sprintf(i8*, i8*, ...)
209 declare void @llvm.trap() noreturn nounwind
212 if __name__ == '__main__':