register_allocator/src/fuzzing.rs

   1 use crate::{
   2     function::{Block, FnFields, SSAVal, SSAValDef},
   3     index::{BlockIdx, SSAValIdx},
   4     loc::Ty,
   5 };
   6 use arbitrary::{Arbitrary, Error, Unstructured};
   7
   8 struct FnBuilder<'a, 'b> {
   9     u: &'a mut Unstructured<'b>,
  10     func: FnFields,
  11 }
  12
  13 impl FnBuilder<'_, '_> {
  14     fn new_ssa_val(&mut self, ty: Ty, def: SSAValDef) -> SSAValIdx {
  15         let retval = SSAValIdx::new(self.func.ssa_vals.len());
  16         self.func.ssa_vals.push(SSAVal {
  17             ty,
  18             def,
  19             operand_uses: Default::default(),
  20             branch_succ_param_uses: Default::default(),
  21         });
  22         retval
  23     }
  24     fn run(&mut self) -> Result<(), Error> {
  25         for block_idx in 0..self.u.int_in_range(1..=10)? {
  26             let block_idx = BlockIdx::new(block_idx);
  27             let mut params = Vec::new();
  28             for param_idx in 0..self.u.int_in_range(0..=10)? {
  29                 let ty = self.u.arbitrary()?;
  30                 params.push(self.new_ssa_val(
  31                     ty,
  32                     SSAValDef::BlockParam {
  33                         block: block_idx,
  34                         param_idx,
  35                     },
  36                 ));
  37             }
  38             let insts = todo!();
  39             self.func.blocks.push(Block {
  40                 params,
  41                 insts,
  42                 preds: Default::default(),
  43                 immediate_dominator: Default::default(),
  44             });
  45         }
  46         Ok(())
  47     }
  48 }
  49
  50 impl<'a> Arbitrary<'a> for FnFields {
  51     fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self, Error> {
  52         let mut builder = FnBuilder {
  53             u,
  54             func: Self {
  55                 ssa_vals: Vec::new(),
  56                 insts: Vec::new(),
  57                 blocks: Vec::new(),
  58                 start_inst_to_block_map: Default::default(),
  59             },
  60         };
  61         builder.run()?;
  62         Ok(builder.func)
  63     }
  64 }