| #!/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. |
| """ |
| |
| from __future__ import print_function |
| |
| import argparse |
| import itertools |
| import random |
| import sys |
| import uuid |
| |
| def main(): |
| element_types=['i8', 'i16', 'i32', 'i64', 'f32', 'f64'] |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('-v', '--verbose', action='store_true', |
| help='Show verbose output') |
| parser.add_argument('--seed', default=str(uuid.uuid4()), |
| help='A string used to seed the RNG') |
| parser.add_argument('--max-shuffle-height', type=int, default=16, |
| help='Specify a fixed height of shuffle tree to test') |
| parser.add_argument('--no-blends', dest='blends', action='store_false', |
| help='Include blends of two input vectors') |
| parser.add_argument('--fixed-bit-width', type=int, choices=[128, 256], |
| help='Specify a fixed bit width of vector to test') |
| parser.add_argument('--fixed-element-type', choices=element_types, |
| help='Specify a fixed element type to test') |
| parser.add_argument('--triple', |
| help='Specify a triple string to include in the IR') |
| args = parser.parse_args() |
| |
| random.seed(args.seed) |
| |
| if args.fixed_element_type is not None: |
| element_types=[args.fixed_element_type] |
| |
| if args.fixed_bit_width is not None: |
| if args.fixed_bit_width == 128: |
| width_map={'i64': 2, 'i32': 4, 'i16': 8, 'i8': 16, 'f64': 2, 'f32': 4} |
| (width, element_type) = random.choice( |
| [(width_map[t], t) for t in element_types]) |
| elif args.fixed_bit_width == 256: |
| width_map={'i64': 4, 'i32': 8, 'i16': 16, 'i8': 32, 'f64': 4, 'f32': 8} |
| (width, element_type) = random.choice( |
| [(width_map[t], t) for t in element_types]) |
| else: |
| sys.exit(1) # Checked above by argument parsing. |
| else: |
| width = random.choice([2, 4, 8, 16, 32, 64]) |
| element_type = random.choice(element_types) |
| |
| element_modulus = { |
| 'i8': 1 << 8, 'i16': 1 << 16, 'i32': 1 << 32, 'i64': 1 << 64, |
| 'f32': 1 << 32, 'f64': 1 << 64}[element_type] |
| |
| shuffle_range = (2 * width) if args.blends else width |
| |
| # Because undef (-1) saturates and is indistinguishable when testing the |
| # correctness of a shuffle, we want to bias our fuzz toward having a decent |
| # mixture of non-undef lanes in the end. With a deep shuffle tree, the |
| # probabilies aren't good so we need to bias things. The math here is that if |
| # we uniformly select between -1 and the other inputs, each element of the |
| # result will have the following probability of being undef: |
| # |
| # 1 - (shuffle_range/(shuffle_range+1))^max_shuffle_height |
| # |
| # More generally, for any probability P of selecting a defined element in |
| # a single shuffle, the end result is: |
| # |
| # 1 - P^max_shuffle_height |
| # |
| # The power of the shuffle height is the real problem, as we want: |
| # |
| # 1 - shuffle_range/(shuffle_range+1) |
| # |
| # So we bias the selection of undef at any given node based on the tree |
| # height. Below, let 'A' be 'len(shuffle_range)', 'C' be 'max_shuffle_height', |
| # and 'B' be the bias we use to compensate for |
| # C '((A+1)*A^(1/C))/(A*(A+1)^(1/C))': |
| # |
| # 1 - (B * A)/(A + 1)^C = 1 - A/(A + 1) |
| # |
| # So at each node we use: |
| # |
| # 1 - (B * A)/(A + 1) |
| # = 1 - ((A + 1) * A * A^(1/C))/(A * (A + 1) * (A + 1)^(1/C)) |
| # = 1 - ((A + 1) * A^((C + 1)/C))/(A * (A + 1)^((C + 1)/C)) |
| # |
| # This is the formula we use to select undef lanes in the shuffle. |
| A = float(shuffle_range) |
| C = float(args.max_shuffle_height) |
| undef_prob = 1.0 - (((A + 1.0) * pow(A, (C + 1.0)/C)) / |
| (A * pow(A + 1.0, (C + 1.0)/C))) |
| |
| shuffle_tree = [[[-1 if random.random() <= undef_prob |
| else random.choice(range(shuffle_range)) |
| for _ in itertools.repeat(None, width)] |
| for _ in itertools.repeat(None, args.max_shuffle_height - i)] |
| for i in range(args.max_shuffle_height)] |
| |
| if args.verbose: |
| # Print out the shuffle sequence in a compact form. |
| print(('Testing shuffle sequence "%s" (v%d%s):' % |
| (args.seed, width, element_type)), file=sys.stderr) |
| for i, shuffles in enumerate(shuffle_tree): |
| print(' tree level %d:' % (i,), file=sys.stderr) |
| for j, s in enumerate(shuffles): |
| print(' shuffle %d: %s' % (j, s), file=sys.stderr) |
| print('', file=sys.stderr) |
| |
| # Symbolically evaluate the shuffle tree. |
| inputs = [[int(j % element_modulus) |
| for j in range(i * width + 1, (i + 1) * width + 1)] |
| for i in range(args.max_shuffle_height + 1)] |
| results = inputs |
| for shuffles in shuffle_tree: |
| results = [[((results[i] if j < width else results[i + 1])[j % width] |
| if j != -1 else -1) |
| for j in s] |
| for i, s in enumerate(shuffles)] |
| if len(results) != 1: |
| print('ERROR: Bad results: %s' % (results,), file=sys.stderr) |
| sys.exit(1) |
| result = results[0] |
| |
| if args.verbose: |
| print('Which transforms:', file=sys.stderr) |
| print(' from: %s' % (inputs,), file=sys.stderr) |
| print(' into: %s' % (result,), file=sys.stderr) |
| print('', file=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 fastcc <%(N)d x %(T)s> @test(%(arguments)s) noinline nounwind { |
| entry:""" % dict(subst, |
| arguments=', '.join( |
| ['<%(N)d x %(T)s> %%s.0.%(i)d' % dict(subst, i=i) |
| for i in range(args.max_shuffle_height + 1)]))) |
| |
| for i, shuffles in enumerate(shuffle_tree): |
| for j, s in enumerate(shuffles): |
| print(""" |
| %%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> |
| """.strip('\n') % dict(subst, i=i, next_i=i + 1, j=j, next_j=j + 1, |
| S=', '.join(['i32 ' + (str(si) if si != -1 else 'undef') |
| for si in s]))) |
| |
| print(""" |
| ret <%(N)d x %(T)s> %%s.%(i)d.0 |
| } |
| """ % dict(subst, i=len(shuffle_tree))) |
| |
| # 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\n\\0A' % |
| {'seed': args.seed, 'lane': i, 'result': r}) |
| s += ''.join(['\\00' for _ in itertools.repeat(None, 128 - len(s) + 2)]) |
| print(""" |
| @error.%(i)d = private unnamed_addr global [128 x i8] c"%(s)s" |
| """.strip() % {'i': i, 's': s}) |
| |
| # Define a wrapper function which is marked 'optnone' to prevent |
| # interprocedural optimizations from deleting the test. |
| print(""" |
| define internal fastcc <%(N)d x %(T)s> @test_wrapper(%(arguments)s) optnone noinline { |
| %%result = call fastcc <%(N)d x %(T)s> @test(%(arguments)s) |
| ret <%(N)d x %(T)s> %%result |
| } |
| """ % dict(subst, |
| arguments=', '.join(['<%(N)d x %(T)s> %%s.%(i)d' % dict(subst, i=i) |
| for i in range(args.max_shuffle_height + 1)]))) |
| |
| # Finally, generate a main function which will trap if any lanes are mapped |
| # incorrectly (in an observable way). |
| print(""" |
| define i32 @main() { |
| entry: |
| ; Create a scratch space to print error messages. |
| %%str = alloca [128 x i8] |
| %%str.ptr = getelementptr inbounds [128 x i8], [128 x i8]* %%str, i32 0, i32 0 |
| |
| ; Build the input vector and call the test function. |
| %%v = call fastcc <%(N)d x %(T)s> @test_wrapper(%(inputs)s) |
| ; 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, |
| inputs=', '.join( |
| [('<%(N)d x %(T)s> bitcast ' |
| '(<%(N)d x %(IT)s> <%(input)s> to <%(N)d x %(T)s>)' % |
| dict(subst, input=', '.join(['%(IT)s %(i)d' % dict(subst, i=i) |
| for i in input]))) |
| for input in inputs]))) |
| |
| # 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 ([128 x i8], [128 x i8]* @error.%(i)d, i32 0, i32 0), i32 %%bad.%(i)d) |
| %%length.%(i)d = call i32 @strlen(i8* %%str.ptr) |
| call i32 @write(i32 2, i8* %%str.ptr, i32 %%length.%(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() |
