#!/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()