| #!/usr/bin/env python |
| |
| """A shuffle-select vector fuzz tester. |
| |
| This is a python program to fuzz test the LLVM shufflevector and select |
| instructions. It generates a function with a random sequnece of shufflevectors |
| while optionally attaching it with a select instruction (regular or zero merge), |
| 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 (an error message with the expected and actual result is printed). |
| """ |
| from __future__ import print_function |
| |
| import random |
| import uuid |
| import argparse |
| |
| # Possibility of one undef index in generated mask for shufflevector instruction |
| SHUF_UNDEF_POS = 0.15 |
| |
| # Possibility of one undef index in generated mask for select instruction |
| SEL_UNDEF_POS = 0.15 |
| |
| # Possibility of adding a select instruction to the result of a shufflevector |
| ADD_SEL_POS = 0.4 |
| |
| # If we are adding a select instruction, this is the possibility of a |
| # merge-select instruction (1 - MERGE_SEL_POS = possibility of zero-merge-select |
| # instruction. |
| MERGE_SEL_POS = 0.5 |
| |
| |
| test_template = r''' |
| define internal fastcc {ty} @test({inputs}) noinline nounwind {{ |
| entry: |
| {instructions} |
| ret {ty} {last_name} |
| }} |
| ''' |
| |
| error_template = r'''@error.{lane} = private unnamed_addr global [64 x i8] c"FAIL: lane {lane}, expected {exp}, found %d\0A{padding}"''' |
| |
| main_template = r''' |
| define i32 @main() {{ |
| entry: |
| ; Create a scratch space to print error messages. |
| %str = alloca [64 x i8] |
| %str.ptr = getelementptr inbounds [64 x i8], [64 x i8]* %str, i32 0, i32 0 |
| |
| ; Build the input vector and call the test function. |
| %v = call fastcc {ty} @test({inputs}) |
| br label %test.0 |
| |
| {check_die} |
| }} |
| |
| declare i32 @strlen(i8*) |
| declare i32 @write(i32, i8*, i32) |
| declare i32 @sprintf(i8*, i8*, ...) |
| declare void @llvm.trap() noreturn nounwind |
| ''' |
| |
| check_template = r''' |
| test.{lane}: |
| %v.{lane} = extractelement {ty} %v, i32 {lane} |
| %cmp.{lane} = {i_f}cmp {ordered}ne {scalar_ty} %v.{lane}, {exp} |
| br i1 %cmp.{lane}, label %die.{lane}, label %test.{n_lane} |
| ''' |
| |
| undef_check_template = r''' |
| test.{lane}: |
| ; Skip this lane, its value is undef. |
| br label %test.{n_lane} |
| ''' |
| |
| die_template = r''' |
| die.{lane}: |
| ; Capture the actual value and print an error message. |
| call i32 (i8*, i8*, ...) @sprintf(i8* %str.ptr, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @error.{lane}, i32 0, i32 0), {scalar_ty} %v.{lane}) |
| %length.{lane} = call i32 @strlen(i8* %str.ptr) |
| call i32 @write(i32 2, i8* %str.ptr, i32 %length.{lane}) |
| call void @llvm.trap() |
| unreachable |
| ''' |
| |
| class Type: |
| def __init__(self, is_float, elt_width, elt_num): |
| self.is_float = is_float # Boolean |
| self.elt_width = elt_width # Integer |
| self.elt_num = elt_num # Integer |
| |
| def dump(self): |
| if self.is_float: |
| str_elt = 'float' if self.elt_width == 32 else 'double' |
| else: |
| str_elt = 'i' + str(self.elt_width) |
| |
| if self.elt_num == 1: |
| return str_elt |
| else: |
| return '<' + str(self.elt_num) + ' x ' + str_elt + '>' |
| |
| def get_scalar_type(self): |
| return Type(self.is_float, self.elt_width, 1) |
| |
| |
| |
| # Class to represent any value (variable) that can be used. |
| class Value: |
| def __init__(self, name, ty, value = None): |
| self.ty = ty # Type |
| self.name = name # String |
| self.value = value # list of integers or floating points |
| |
| |
| # Class to represent an IR instruction (shuffle/select). |
| class Instruction(Value): |
| def __init__(self, name, ty, op0, op1, mask): |
| Value.__init__(self, name, ty) |
| self.op0 = op0 # Value |
| self.op1 = op1 # Value |
| self.mask = mask # list of integers |
| |
| def dump(self): pass |
| |
| def calc_value(self): pass |
| |
| |
| # Class to represent an IR shuffle instruction |
| class ShufInstr(Instruction): |
| |
| shuf_template = ' {name} = shufflevector {ty} {op0}, {ty} {op1}, <{num} x i32> {mask}\n' |
| |
| def __init__(self, name, ty, op0, op1, mask): |
| Instruction.__init__(self, '%shuf' + name, ty, op0, op1, mask) |
| |
| def dump(self): |
| str_mask = [('i32 ' + str(idx)) if idx != -1 else 'i32 undef' for idx in self.mask] |
| str_mask = '<' + (', ').join(str_mask) + '>' |
| return self.shuf_template.format(name = self.name, ty = self.ty.dump(), op0 = self.op0.name, |
| op1 = self.op1.name, num = self.ty.elt_num, mask = str_mask) |
| |
| def calc_value(self): |
| if self.value != None: |
| print('Trying to calculate the value of a shuffle instruction twice') |
| exit(1) |
| |
| result = [] |
| for i in range(len(self.mask)): |
| index = self.mask[i] |
| |
| if index < self.ty.elt_num and index >= 0: |
| result.append(self.op0.value[index]) |
| elif index >= self.ty.elt_num: |
| index = index % self.ty.elt_num |
| result.append(self.op1.value[index]) |
| else: # -1 => undef |
| result.append(-1) |
| |
| self.value = result |
| |
| |
| # Class to represent an IR select instruction |
| class SelectInstr(Instruction): |
| |
| sel_template = ' {name} = select <{num} x i1> {mask}, {ty} {op0}, {ty} {op1}\n' |
| |
| def __init__(self, name, ty, op0, op1, mask): |
| Instruction.__init__(self, '%sel' + name, ty, op0, op1, mask) |
| |
| def dump(self): |
| str_mask = [('i1 ' + str(idx)) if idx != -1 else 'i1 undef' for idx in self.mask] |
| str_mask = '<' + (', ').join(str_mask) + '>' |
| return self.sel_template.format(name = self.name, ty = self.ty.dump(), op0 = self.op0.name, |
| op1 = self.op1.name, num = self.ty.elt_num, mask = str_mask) |
| |
| def calc_value(self): |
| if self.value != None: |
| print('Trying to calculate the value of a select instruction twice') |
| exit(1) |
| |
| result = [] |
| for i in range(len(self.mask)): |
| index = self.mask[i] |
| |
| if index == 1: |
| result.append(self.op0.value[i]) |
| elif index == 0: |
| result.append(self.op1.value[i]) |
| else: # -1 => undef |
| result.append(-1) |
| |
| self.value = result |
| |
| |
| # Returns a list of Values initialized with actual numbers according to the |
| # provided type |
| def gen_inputs(ty, num): |
| inputs = [] |
| for i in range(num): |
| inp = [] |
| for j in range(ty.elt_num): |
| if ty.is_float: |
| inp.append(float(i*ty.elt_num + j)) |
| else: |
| inp.append((i*ty.elt_num + j) % (1 << ty.elt_width)) |
| inputs.append(Value('%inp' + str(i), ty, inp)) |
| |
| return inputs |
| |
| |
| # Returns a random vector type to be tested |
| # In case one of the dimensions (scalar type/number of elements) is provided, |
| # fill the blank dimension and return appropriate Type object. |
| def get_random_type(ty, num_elts): |
| if ty != None: |
| if ty == 'i8': |
| is_float = False |
| width = 8 |
| elif ty == 'i16': |
| is_float = False |
| width = 16 |
| elif ty == 'i32': |
| is_float = False |
| width = 32 |
| elif ty == 'i64': |
| is_float = False |
| width = 64 |
| elif ty == 'f32': |
| is_float = True |
| width = 32 |
| elif ty == 'f64': |
| is_float = True |
| width = 64 |
| |
| int_elt_widths = [8, 16, 32, 64] |
| float_elt_widths = [32, 64] |
| |
| if num_elts == None: |
| num_elts = random.choice(range(2, 65)) |
| |
| if ty == None: |
| # 1 for integer type, 0 for floating-point |
| if random.randint(0,1): |
| is_float = False |
| width = random.choice(int_elt_widths) |
| else: |
| is_float = True |
| width = random.choice(float_elt_widths) |
| |
| return Type(is_float, width, num_elts) |
| |
| |
| # Generate mask for shufflevector IR instruction, with SHUF_UNDEF_POS possibility |
| # of one undef index. |
| def gen_shuf_mask(ty): |
| mask = [] |
| for i in range(ty.elt_num): |
| if SHUF_UNDEF_POS/ty.elt_num > random.random(): |
| mask.append(-1) |
| else: |
| mask.append(random.randint(0, ty.elt_num*2 - 1)) |
| |
| return mask |
| |
| |
| # Generate mask for select IR instruction, with SEL_UNDEF_POS possibility |
| # of one undef index. |
| def gen_sel_mask(ty): |
| mask = [] |
| for i in range(ty.elt_num): |
| if SEL_UNDEF_POS/ty.elt_num > random.random(): |
| mask.append(-1) |
| else: |
| mask.append(random.randint(0, 1)) |
| |
| return mask |
| |
| # Generate shuffle instructions with optional select instruction after. |
| def gen_insts(inputs, ty): |
| int_zero_init = Value('zeroinitializer', ty, [0]*ty.elt_num) |
| float_zero_init = Value('zeroinitializer', ty, [0.0]*ty.elt_num) |
| |
| insts = [] |
| name_idx = 0 |
| while len(inputs) > 1: |
| # Choose 2 available Values - remove them from inputs list. |
| [idx0, idx1] = sorted(random.sample(range(len(inputs)), 2)) |
| op0 = inputs[idx0] |
| op1 = inputs[idx1] |
| |
| # Create the shuffle instruction. |
| shuf_mask = gen_shuf_mask(ty) |
| shuf_inst = ShufInstr(str(name_idx), ty, op0, op1, shuf_mask) |
| shuf_inst.calc_value() |
| |
| # Add the new shuffle instruction to the list of instructions. |
| insts.append(shuf_inst) |
| |
| # Optionally, add select instruction with the result of the previous shuffle. |
| if random.random() < ADD_SEL_POS: |
| # Either blending with a random Value or with an all-zero vector. |
| if random.random() < MERGE_SEL_POS: |
| op2 = random.choice(inputs) |
| else: |
| op2 = float_zero_init if ty.is_float else int_zero_init |
| |
| select_mask = gen_sel_mask(ty) |
| select_inst = SelectInstr(str(name_idx), ty, shuf_inst, op2, select_mask) |
| select_inst.calc_value() |
| |
| # Add the select instructions to the list of instructions and to the available Values. |
| insts.append(select_inst) |
| inputs.append(select_inst) |
| else: |
| # If the shuffle instruction is not followed by select, add it to the available Values. |
| inputs.append(shuf_inst) |
| |
| del inputs[idx1] |
| del inputs[idx0] |
| name_idx += 1 |
| |
| return insts |
| |
| |
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('--seed', default=str(uuid.uuid4()), |
| help='A string used to seed the RNG') |
| parser.add_argument('--max-num-inputs', type=int, default=20, |
| help='Specify the maximum number of vector inputs for the test. (default: 20)') |
| parser.add_argument('--min-num-inputs', type=int, default=10, |
| help='Specify the minimum number of vector inputs for the test. (default: 10)') |
| parser.add_argument('--type', default=None, |
| help=''' |
| Choose specific type to be tested. |
| i8, i16, i32, i64, f32 or f64. |
| (default: random)''') |
| parser.add_argument('--num-elts', default=None, type=int, |
| help='Choose specific number of vector elements to be tested. (default: random)') |
| args = parser.parse_args() |
| |
| print('; The seed used for this test is ' + args.seed) |
| |
| assert args.min_num_inputs < args.max_num_inputs , "Minimum value greater than maximum." |
| assert args.type in [None, 'i8', 'i16', 'i32', 'i64', 'f32', 'f64'], "Illegal type." |
| assert args.num_elts == None or args.num_elts > 0, "num_elts must be a positive integer." |
| |
| random.seed(args.seed) |
| ty = get_random_type(args.type, args.num_elts) |
| inputs = gen_inputs(ty, random.randint(args.min_num_inputs, args.max_num_inputs)) |
| inputs_str = (', ').join([inp.ty.dump() + ' ' + inp.name for inp in inputs]) |
| inputs_values = [inp.value for inp in inputs] |
| |
| insts = gen_insts(inputs, ty) |
| |
| assert len(inputs) == 1, "Only one value should be left after generating phase" |
| res = inputs[0] |
| |
| # print the actual test function by dumping the generated instructions. |
| insts_str = ''.join([inst.dump() for inst in insts]) |
| print(test_template.format(ty = ty.dump(), inputs = inputs_str, |
| instructions = insts_str, last_name = res.name)) |
| |
| # Print the error message templates as global strings |
| for i in range(len(res.value)): |
| pad = ''.join(['\\00']*(31 - len(str(i)) - len(str(res.value[i])))) |
| print(error_template.format(lane = str(i), exp = str(res.value[i]), |
| padding = pad)) |
| |
| # Prepare the runtime checks and failure handlers. |
| scalar_ty = ty.get_scalar_type() |
| check_die = '' |
| i_f = 'f' if ty.is_float else 'i' |
| ordered = 'o' if ty.is_float else '' |
| for i in range(len(res.value)): |
| if res.value[i] != -1: |
| # Emit runtime check for each non-undef expected value. |
| check_die += check_template.format(lane = str(i), n_lane = str(i+1), |
| ty = ty.dump(), i_f = i_f, scalar_ty = scalar_ty.dump(), |
| exp = str(res.value[i]), ordered = ordered) |
| # Emit failure handler for each runtime check with proper error message |
| check_die += die_template.format(lane = str(i), scalar_ty = scalar_ty.dump()) |
| else: |
| # Ignore lanes with undef result |
| check_die += undef_check_template.format(lane = str(i), n_lane = str(i+1)) |
| |
| check_die += '\ntest.' + str(len(res.value)) + ':\n' |
| check_die += ' ret i32 0' |
| |
| # Prepare the input values passed to the test function. |
| inputs_values = [', '.join([scalar_ty.dump() + ' ' + str(i) for i in inp]) for inp in inputs_values] |
| inputs = ', '.join([ty.dump() + ' <' + inp + '>' for inp in inputs_values]) |
| |
| print(main_template.format(ty = ty.dump(), inputs = inputs, check_die = check_die)) |
| |
| |
| if __name__ == '__main__': |
| main() |
| |
| |