diff --git a/cranelift/Cargo.toml b/cranelift/Cargo.toml
index f5e066734c..490fc8cdc2 100644
--- a/cranelift/Cargo.toml
+++ b/cranelift/Cargo.toml
@@ -41,6 +41,7 @@ wabt = { version = "0.7.0", optional = true }
 target-lexicon = "0.4.0"
 pretty_env_logger = "0.3.0"
 file-per-thread-logger = "0.1.2"
+indicatif = "0.11.0"
 
 [features]
 default = ["disas", "wasm"]
diff --git a/cranelift/src/bugpoint.rs b/cranelift/src/bugpoint.rs
new file mode 100644
index 0000000000..fcac964aa3
--- /dev/null
+++ b/cranelift/src/bugpoint.rs
@@ -0,0 +1,850 @@
+//! CLI tool to reduce Cranelift IR files crashing during compilation.
+
+use crate::disasm::{PrintRelocs, PrintTraps};
+use crate::utils::{parse_sets_and_triple, read_to_string};
+use cranelift_codegen::ir::{
+    Ebb, FuncRef, Function, GlobalValueData, Inst, InstBuilder, InstructionData, StackSlots,
+    TrapCode,
+};
+use cranelift_codegen::isa::TargetIsa;
+use cranelift_codegen::Context;
+use cranelift_entity::PrimaryMap;
+use cranelift_reader::parse_test;
+use std::collections::HashMap;
+use std::path::Path;
+
+use indicatif::{ProgressBar, ProgressDrawTarget, ProgressStyle};
+
+pub fn run(
+    filename: &str,
+    flag_set: &[String],
+    flag_isa: &str,
+    verbose: bool,
+) -> Result<(), String> {
+    let parsed = parse_sets_and_triple(flag_set, flag_isa)?;
+    let fisa = parsed.as_fisa();
+
+    let path = Path::new(&filename).to_path_buf();
+
+    let buffer = read_to_string(&path).map_err(|e| format!("{}: {}", filename, e))?;
+    let test_file = parse_test(&buffer, None, None).map_err(|e| format!("{}: {}", filename, e))?;
+
+    // If we have an isa from the command-line, use that. Otherwise if the
+    // file contains a unique isa, use that.
+    let isa = if let Some(isa) = fisa.isa {
+        isa
+    } else if let Some(isa) = test_file.isa_spec.unique_isa() {
+        isa
+    } else {
+        return Err(String::from("compilation requires a target isa"));
+    };
+
+    std::env::set_var("RUST_BACKTRACE", "0"); // Disable backtraces to reduce verbosity
+
+    for (func, _) in test_file.functions {
+        let (orig_ebb_count, orig_inst_count) = (ebb_count(&func), inst_count(&func));
+
+        match reduce(isa, func, verbose) {
+            Ok((func, crash_msg)) => {
+                println!("Crash message: {}", crash_msg);
+
+                println!("\n{}", func);
+
+                println!(
+                    "{} ebbs {} insts -> {} ebbs {} insts",
+                    orig_ebb_count,
+                    orig_inst_count,
+                    ebb_count(&func),
+                    inst_count(&func)
+                );
+            }
+            Err(err) => println!("Warning: {}", err),
+        }
+    }
+
+    Ok(())
+}
+
+enum MutationKind {
+    /// The mutation reduced the amount of instructions or ebbs.
+    Shrinked,
+    /// The mutation only changed an instruction. Performing another round of mutations may only
+    /// reduce the test case if another mutation shrank the test case.
+    Changed,
+}
+
+trait Mutator {
+    fn name(&self) -> &'static str;
+
+    fn mutation_count(&self, func: &Function) -> Option<usize>;
+
+    fn mutate(&mut self, func: Function) -> Option<(Function, String, MutationKind)>;
+
+    fn reduce(
+        &mut self,
+        ccc: &mut CrashCheckContext,
+        mut func: Function,
+        progress_bar_prefix: String,
+        verbose: bool,
+        should_keep_reducing: &mut bool,
+    ) -> Function {
+        let progress = ProgressBar::with_draw_target(
+            self.mutation_count(&func).unwrap_or(0) as u64,
+            ProgressDrawTarget::stdout(),
+        );
+        progress.set_style(
+            ProgressStyle::default_bar().template("{bar:60} {prefix:40} {pos:>4}/{len:>4} {msg}"),
+        );
+
+        progress.set_prefix(&(progress_bar_prefix + &format!(" phase {}", self.name())));
+
+        for _ in 0..10000 {
+            progress.inc(1);
+
+            let (mutated_func, msg, mutation_kind) = match self.mutate(func.clone()) {
+                Some(res) => res,
+                None => {
+                    break;
+                }
+            };
+
+            progress.set_message(&msg);
+
+            match ccc.check_for_crash(&mutated_func) {
+                CheckResult::Succeed => {
+                    // Shrinking didn't hit the problem anymore, discard changes.
+                    continue;
+                }
+                CheckResult::Crash(_) => {
+                    // Panic remained while shrinking, make changes definitive.
+                    func = mutated_func;
+                    match mutation_kind {
+                        MutationKind::Shrinked => {
+                            *should_keep_reducing = true;
+                            if verbose {
+                                progress.println(format!("{}: shrink", msg));
+                            }
+                        }
+                        MutationKind::Changed => {
+                            if verbose {
+                                progress.println(format!("{}: changed", msg));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        progress.set_message("done");
+        progress.finish();
+
+        func
+    }
+}
+
+/// Try to remove instructions.
+struct RemoveInst {
+    ebb: Ebb,
+    inst: Inst,
+}
+
+impl RemoveInst {
+    fn new(func: &Function) -> Self {
+        let first_ebb = func.layout.entry_block().unwrap();
+        let first_inst = func.layout.first_inst(first_ebb).unwrap();
+        Self {
+            ebb: first_ebb,
+            inst: first_inst,
+        }
+    }
+}
+
+impl Mutator for RemoveInst {
+    fn name(&self) -> &'static str {
+        "remove inst"
+    }
+
+    fn mutation_count(&self, func: &Function) -> Option<usize> {
+        Some(inst_count(func))
+    }
+
+    fn mutate(&mut self, mut func: Function) -> Option<(Function, String, MutationKind)> {
+        if let Some((prev_ebb, prev_inst)) =
+            next_inst_ret_prev(&func, &mut self.ebb, &mut self.inst)
+        {
+            func.layout.remove_inst(prev_inst);
+            if func.layout.ebb_insts(prev_ebb).next().is_none() {
+                // Make sure empty ebbs are removed, as `next_inst_ret_prev` depends on non empty ebbs
+                func.layout.remove_ebb(prev_ebb);
+                Some((
+                    func,
+                    format!("Remove inst {} and empty ebb {}", prev_inst, prev_ebb),
+                    MutationKind::Shrinked,
+                ))
+            } else {
+                Some((
+                    func,
+                    format!("Remove inst {}", prev_inst),
+                    MutationKind::Shrinked,
+                ))
+            }
+        } else {
+            None
+        }
+    }
+}
+
+/// Try to replace instructions with `iconst`.
+struct ReplaceInstWithIconst {
+    ebb: Ebb,
+    inst: Inst,
+}
+
+impl ReplaceInstWithIconst {
+    fn new(func: &Function) -> Self {
+        let first_ebb = func.layout.entry_block().unwrap();
+        let first_inst = func.layout.first_inst(first_ebb).unwrap();
+        Self {
+            ebb: first_ebb,
+            inst: first_inst,
+        }
+    }
+}
+
+impl Mutator for ReplaceInstWithIconst {
+    fn name(&self) -> &'static str {
+        "replace inst with iconst"
+    }
+
+    fn mutation_count(&self, func: &Function) -> Option<usize> {
+        Some(inst_count(func))
+    }
+
+    fn mutate(&mut self, mut func: Function) -> Option<(Function, String, MutationKind)> {
+        if let Some((_prev_ebb, prev_inst)) =
+            next_inst_ret_prev(&func, &mut self.ebb, &mut self.inst)
+        {
+            let results = func.dfg.inst_results(prev_inst);
+            if results.len() == 1 {
+                let ty = func.dfg.value_type(results[0]);
+                func.dfg.replace(prev_inst).iconst(ty, 0);
+                Some((
+                    func,
+                    format!("Replace inst {} with iconst.{}", prev_inst, ty),
+                    MutationKind::Changed,
+                ))
+            } else {
+                Some((func, format!(""), MutationKind::Changed))
+            }
+        } else {
+            None
+        }
+    }
+}
+
+/// Try to replace instructions with `trap`.
+struct ReplaceInstWithTrap {
+    ebb: Ebb,
+    inst: Inst,
+}
+
+impl ReplaceInstWithTrap {
+    fn new(func: &Function) -> Self {
+        let first_ebb = func.layout.entry_block().unwrap();
+        let first_inst = func.layout.first_inst(first_ebb).unwrap();
+        Self {
+            ebb: first_ebb,
+            inst: first_inst,
+        }
+    }
+}
+
+impl Mutator for ReplaceInstWithTrap {
+    fn name(&self) -> &'static str {
+        "replace inst with trap"
+    }
+
+    fn mutation_count(&self, func: &Function) -> Option<usize> {
+        Some(inst_count(func))
+    }
+
+    fn mutate(&mut self, mut func: Function) -> Option<(Function, String, MutationKind)> {
+        if let Some((_prev_ebb, prev_inst)) =
+            next_inst_ret_prev(&func, &mut self.ebb, &mut self.inst)
+        {
+            func.dfg.replace(prev_inst).trap(TrapCode::User(0));
+            Some((
+                func,
+                format!("Replace inst {} with trap", prev_inst),
+                MutationKind::Changed,
+            ))
+        } else {
+            None
+        }
+    }
+}
+
+/// Try to remove an ebb.
+struct RemoveEbb {
+    ebb: Ebb,
+}
+
+impl RemoveEbb {
+    fn new(func: &Function) -> Self {
+        Self {
+            ebb: func.layout.entry_block().unwrap(),
+        }
+    }
+}
+
+impl Mutator for RemoveEbb {
+    fn name(&self) -> &'static str {
+        "remove ebb"
+    }
+
+    fn mutation_count(&self, func: &Function) -> Option<usize> {
+        Some(ebb_count(func))
+    }
+
+    fn mutate(&mut self, mut func: Function) -> Option<(Function, String, MutationKind)> {
+        if let Some(next_ebb) = func.layout.next_ebb(self.ebb) {
+            self.ebb = next_ebb;
+            while let Some(inst) = func.layout.last_inst(self.ebb) {
+                func.layout.remove_inst(inst);
+            }
+            func.layout.remove_ebb(self.ebb);
+            Some((
+                func,
+                format!("Remove ebb {}", next_ebb),
+                MutationKind::Shrinked,
+            ))
+        } else {
+            None
+        }
+    }
+}
+
+/// Try to remove unused entities.
+struct RemoveUnusedEntities {
+    kind: u32,
+}
+
+impl RemoveUnusedEntities {
+    fn new() -> Self {
+        Self { kind: 0 }
+    }
+}
+
+impl Mutator for RemoveUnusedEntities {
+    fn name(&self) -> &'static str {
+        "remove unused entities"
+    }
+
+    fn mutation_count(&self, _func: &Function) -> Option<usize> {
+        Some(4)
+    }
+
+    fn mutate(&mut self, mut func: Function) -> Option<(Function, String, MutationKind)> {
+        let name = match self.kind {
+            0 => {
+                let mut ext_func_usage_map = HashMap::new();
+                for ebb in func.layout.ebbs() {
+                    for inst in func.layout.ebb_insts(ebb) {
+                        match func.dfg[inst] {
+                            // Add new cases when there are new instruction formats taking a `FuncRef`.
+                            InstructionData::Call { func_ref, .. }
+                            | InstructionData::FuncAddr { func_ref, .. } => {
+                                ext_func_usage_map
+                                    .entry(func_ref)
+                                    .or_insert_with(Vec::new)
+                                    .push(inst);
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+
+                let mut ext_funcs = PrimaryMap::new();
+
+                for (func_ref, ext_func_data) in func.dfg.ext_funcs.clone().into_iter() {
+                    if let Some(func_ref_usage) = ext_func_usage_map.get(&func_ref) {
+                        let new_func_ref = ext_funcs.push(ext_func_data.clone());
+                        for &inst in func_ref_usage {
+                            match func.dfg[inst] {
+                                // Keep in sync with the above match.
+                                InstructionData::Call {
+                                    ref mut func_ref, ..
+                                }
+                                | InstructionData::FuncAddr {
+                                    ref mut func_ref, ..
+                                } => {
+                                    *func_ref = new_func_ref;
+                                }
+                                _ => unreachable!(),
+                            }
+                        }
+                    }
+                }
+
+                func.dfg.ext_funcs = ext_funcs;
+
+                "Remove unused ext funcs"
+            }
+            1 => {
+                #[derive(Copy, Clone)]
+                enum SigRefUser {
+                    Instruction(Inst),
+                    ExtFunc(FuncRef),
+                }
+
+                let mut signatures_usage_map = HashMap::new();
+                for ebb in func.layout.ebbs() {
+                    for inst in func.layout.ebb_insts(ebb) {
+                        match func.dfg[inst] {
+                            // Add new cases when there are new instruction formats taking a `SigRef`.
+                            InstructionData::CallIndirect { sig_ref, .. } => {
+                                signatures_usage_map
+                                    .entry(sig_ref)
+                                    .or_insert_with(Vec::new)
+                                    .push(SigRefUser::Instruction(inst));
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+                for (func_ref, ext_func_data) in func.dfg.ext_funcs.iter() {
+                    signatures_usage_map
+                        .entry(ext_func_data.signature)
+                        .or_insert_with(Vec::new)
+                        .push(SigRefUser::ExtFunc(func_ref));
+                }
+
+                let mut signatures = PrimaryMap::new();
+
+                for (sig_ref, sig_data) in func.dfg.signatures.clone().into_iter() {
+                    if let Some(sig_ref_usage) = signatures_usage_map.get(&sig_ref) {
+                        let new_sig_ref = signatures.push(sig_data.clone());
+                        for &sig_ref_user in sig_ref_usage {
+                            match sig_ref_user {
+                                SigRefUser::Instruction(inst) => match func.dfg[inst] {
+                                    // Keep in sync with the above match.
+                                    InstructionData::CallIndirect {
+                                        ref mut sig_ref, ..
+                                    } => {
+                                        *sig_ref = new_sig_ref;
+                                    }
+                                    _ => unreachable!(),
+                                },
+                                SigRefUser::ExtFunc(func_ref) => {
+                                    func.dfg.ext_funcs[func_ref].signature = new_sig_ref;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                func.dfg.signatures = signatures;
+
+                "Remove unused signatures"
+            }
+            2 => {
+                let mut stack_slot_usage_map = HashMap::new();
+                for ebb in func.layout.ebbs() {
+                    for inst in func.layout.ebb_insts(ebb) {
+                        match func.dfg[inst] {
+                            // Add new cases when there are new instruction formats taking a `StackSlot`.
+                            InstructionData::StackLoad { stack_slot, .. }
+                            | InstructionData::StackStore { stack_slot, .. } => {
+                                stack_slot_usage_map
+                                    .entry(stack_slot)
+                                    .or_insert_with(Vec::new)
+                                    .push(inst);
+                            }
+
+                            InstructionData::RegSpill { dst, .. } => {
+                                stack_slot_usage_map
+                                    .entry(dst)
+                                    .or_insert_with(Vec::new)
+                                    .push(inst);
+                            }
+                            InstructionData::RegFill { src, .. } => {
+                                stack_slot_usage_map
+                                    .entry(src)
+                                    .or_insert_with(Vec::new)
+                                    .push(inst);
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+
+                let mut stack_slots = StackSlots::new();
+
+                for (stack_slot, stack_slot_data) in func.stack_slots.clone().iter() {
+                    if let Some(stack_slot_usage) = stack_slot_usage_map.get(&stack_slot) {
+                        let new_stack_slot = stack_slots.push(stack_slot_data.clone());
+                        for &inst in stack_slot_usage {
+                            match &mut func.dfg[inst] {
+                                // Keep in sync with the above match.
+                                InstructionData::StackLoad { stack_slot, .. }
+                                | InstructionData::StackStore { stack_slot, .. } => {
+                                    *stack_slot = new_stack_slot;
+                                }
+                                InstructionData::RegSpill { dst, .. } => {
+                                    *dst = new_stack_slot;
+                                }
+                                InstructionData::RegFill { src, .. } => {
+                                    *src = new_stack_slot;
+                                }
+                                _ => unreachable!(),
+                            }
+                        }
+                    }
+                }
+
+                func.stack_slots = stack_slots;
+
+                "Remove unused stack slots"
+            }
+            3 => {
+                let mut global_value_usage_map = HashMap::new();
+                for ebb in func.layout.ebbs() {
+                    for inst in func.layout.ebb_insts(ebb) {
+                        match func.dfg[inst] {
+                            // Add new cases when there are new instruction formats taking a `GlobalValue`.
+                            InstructionData::UnaryGlobalValue { global_value, .. } => {
+                                global_value_usage_map
+                                    .entry(global_value)
+                                    .or_insert_with(Vec::new)
+                                    .push(inst);
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+
+                for (_global_value, global_value_data) in func.global_values.iter() {
+                    match *global_value_data {
+                        GlobalValueData::VMContext | GlobalValueData::Symbol { .. } => {}
+                        // These can create cyclic references, which cause complications. Just skip
+                        // the global value removal for now.
+                        // FIXME Handle them in a better way.
+                        GlobalValueData::Load { base: _, .. }
+                        | GlobalValueData::IAddImm { base: _, .. } => return None,
+                    }
+                }
+
+                let mut global_values = PrimaryMap::new();
+
+                for (global_value, global_value_data) in func.global_values.clone().into_iter() {
+                    if let Some(global_value_usage) = global_value_usage_map.get(&global_value) {
+                        let new_global_value = global_values.push(global_value_data.clone());
+                        for &inst in global_value_usage {
+                            match &mut func.dfg[inst] {
+                                // Keep in sync with the above match.
+                                InstructionData::UnaryGlobalValue { global_value, .. } => {
+                                    *global_value = new_global_value;
+                                }
+                                _ => unreachable!(),
+                            }
+                        }
+                    }
+                }
+
+                func.global_values = global_values;
+
+                "Remove unused global values"
+            }
+            _ => return None,
+        };
+        self.kind += 1;
+        Some((func, name.to_owned(), MutationKind::Changed))
+    }
+}
+
+fn next_inst_ret_prev(func: &Function, ebb: &mut Ebb, inst: &mut Inst) -> Option<(Ebb, Inst)> {
+    let prev = (*ebb, *inst);
+    if let Some(next_inst) = func.layout.next_inst(*inst) {
+        *inst = next_inst;
+        return Some(prev);
+    } else if let Some(next_ebb) = func.layout.next_ebb(*ebb) {
+        *ebb = next_ebb;
+        *inst = func.layout.first_inst(*ebb).expect("no inst");
+        return Some(prev);
+    } else {
+        return None;
+    }
+}
+
+fn ebb_count(func: &Function) -> usize {
+    func.layout.ebbs().count()
+}
+
+fn inst_count(func: &Function) -> usize {
+    func.layout
+        .ebbs()
+        .map(|ebb| func.layout.ebb_insts(ebb).count())
+        .sum()
+}
+
+fn resolve_aliases(func: &mut Function) {
+    for ebb in func.layout.ebbs() {
+        for inst in func.layout.ebb_insts(ebb) {
+            func.dfg.resolve_aliases_in_arguments(inst);
+        }
+    }
+}
+
+fn reduce(
+    isa: &TargetIsa,
+    mut func: Function,
+    verbose: bool,
+) -> Result<(Function, String), String> {
+    let mut ccc = CrashCheckContext::new(isa);
+
+    match ccc.check_for_crash(&func) {
+        CheckResult::Succeed => {
+            return Err(format!(
+                "Given function compiled successfully or gave an verifier error."
+            ));
+        }
+        CheckResult::Crash(_) => {}
+    }
+
+    resolve_aliases(&mut func);
+
+    for pass_idx in 0..100 {
+        let mut should_keep_reducing = false;
+        let mut phase = 0;
+
+        loop {
+            let mut mutator = match phase {
+                0 => Box::new(RemoveInst::new(&func)) as Box<dyn Mutator>,
+                1 => Box::new(ReplaceInstWithIconst::new(&func)) as Box<dyn Mutator>,
+                2 => Box::new(ReplaceInstWithTrap::new(&func)) as Box<dyn Mutator>,
+                3 => Box::new(RemoveEbb::new(&func)) as Box<dyn Mutator>,
+                4 => Box::new(RemoveUnusedEntities::new()) as Box<dyn Mutator>,
+                _ => break,
+            };
+
+            func = mutator.reduce(
+                &mut ccc,
+                func,
+                format!("pass {}", pass_idx),
+                verbose,
+                &mut should_keep_reducing,
+            );
+
+            phase += 1;
+        }
+
+        if !should_keep_reducing {
+            // No new shrinking opportunities have been found this pass. This means none will ever
+            // be found. Skip the rest of the passes over the function.
+            break;
+        }
+    }
+
+    let crash_msg = match ccc.check_for_crash(&func) {
+        CheckResult::Succeed => unreachable!("Used to crash, but doesn't anymore???"),
+        CheckResult::Crash(crash_msg) => crash_msg,
+    };
+
+    Ok((func, crash_msg))
+}
+
+struct CrashCheckContext<'a> {
+    /// Cached `Context`, to prevent repeated allocation.
+    context: Context,
+
+    /// The target isa to compile for.
+    isa: &'a TargetIsa,
+}
+
+fn get_panic_string(panic: Box<std::any::Any>) -> String {
+    let panic = match panic.downcast::<&'static str>() {
+        Ok(panic_msg) => panic_msg.to_owned(),
+        Err(panic) => panic,
+    };
+    match panic.downcast::<String>() {
+        Ok(panic_msg) => *panic_msg,
+        Err(_) => "Box<Any>".to_owned(),
+    }
+}
+
+enum CheckResult {
+    /// The function compiled fine, or the verifier noticed an error.
+    Succeed,
+
+    /// The compilation of the function panicked.
+    Crash(String),
+}
+
+impl<'a> CrashCheckContext<'a> {
+    fn new(isa: &'a TargetIsa) -> Self {
+        CrashCheckContext {
+            context: Context::new(),
+            isa,
+        }
+    }
+
+    #[cfg_attr(test, allow(unreachable_code))]
+    fn check_for_crash(&mut self, func: &Function) -> CheckResult {
+        self.context.clear();
+        self.context.func = func.clone();
+
+        use std::io::Write;
+        std::io::stdout().flush().unwrap(); // Flush stdout to sync with panic messages on stderr
+
+        match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            cranelift_codegen::verifier::verify_function(&func, self.isa).err()
+        })) {
+            Ok(Some(_)) => return CheckResult::Succeed,
+            Ok(None) => {}
+            // The verifier panicked. compiling it will probably give the same panic.
+            // We treat it as succeeding to make it possible to reduce for the actual error.
+            // FIXME prevent verifier panic on removing ebb1
+            Err(_) => return CheckResult::Succeed,
+        }
+
+        #[cfg(test)]
+        {
+            // For testing purposes we emulate a panic caused by the existence of
+            // a `call` instruction.
+            let contains_call = func.layout.ebbs().any(|ebb| {
+                func.layout.ebb_insts(ebb).any(|inst| match func.dfg[inst] {
+                    InstructionData::Call { .. } => true,
+                    _ => false,
+                })
+            });
+            if contains_call {
+                return CheckResult::Crash("test crash".to_string());
+            } else {
+                return CheckResult::Succeed;
+            }
+        }
+
+        let old_panic_hook = std::panic::take_hook();
+        std::panic::set_hook(Box::new(|_| {})); // silence panics
+
+        let res = match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            let mut relocs = PrintRelocs::new(false);
+            let mut traps = PrintTraps::new(false);
+            let mut mem = vec![];
+
+            let _ = self
+                .context
+                .compile_and_emit(self.isa, &mut mem, &mut relocs, &mut traps);
+        })) {
+            Ok(()) => CheckResult::Succeed,
+            Err(err) => CheckResult::Crash(get_panic_string(err)),
+        };
+
+        std::panic::set_hook(old_panic_hook);
+
+        res
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_reduce() {
+        const TEST: &'static str = include_str!("./bugpoint_test.clif");
+
+        let test_file = parse_test(TEST, None, None).unwrap();
+
+        // If we have an isa from the command-line, use that. Otherwise if the
+        // file contains a unique isa, use that.
+        let isa = test_file.isa_spec.unique_isa().expect("Unknown isa");
+
+        for (func, _) in test_file.functions {
+            let (func, crash_msg) = reduce(isa, func, false).expect("Couldn't reduce test case");
+
+            assert_eq!(crash_msg, "test crash");
+
+            assert_eq!(
+                format!("{}", func),
+                "function u0:0(i64, i64, i64) system_v {
+    sig0 = (i64, i64, i16, i64, i64, i64, i64, i64) system_v
+    fn0 = u0:95 sig0
+
+ebb0(v0: i64, v1: i64, v2: i64):
+    v113 -> v1
+    v124 -> v1
+    v136 -> v1
+    v148 -> v1
+    v160 -> v1
+    v185 -> v1
+    v222 -> v1
+    v237 -> v1
+    v241 -> v1
+    v256 -> v1
+    v262 -> v1
+    v105 = iconst.i64 0
+    trap user0
+
+ebb99(v804: i64, v1035: i64, v1037: i64, v1039: i64, v1044: i64, v1052: i16, v1057: i64):
+    v817 -> v1035
+    v830 -> v1037
+    v844 -> v1039
+    v857 -> v1039
+    v939 -> v1039
+    v1042 -> v1039
+    v1050 -> v1039
+    v908 -> v1044
+    v917 -> v1044
+    v921 -> v1044
+    v1043 -> v1044
+    v960 -> v1052
+    v990 -> v1052
+    v1051 -> v1052
+    v1055 -> v1052
+    v963 -> v1057
+    v1056 -> v1057
+    v1060 -> v1057
+    trap user0
+
+ebb101:
+    v829 = iconst.i64 0
+    v935 -> v829
+    v962 -> v829
+    v992 -> v829
+    v1036 -> v829
+    v1049 -> v829
+    trap user0
+
+ebb102:
+    v842 = iconst.i64 0
+    v976 -> v842
+    v989 -> v842
+    v1038 -> v842
+    v1061 -> v842
+    trap user0
+
+ebb105:
+    v883 = iconst.i64 0
+    v934 -> v883
+    v961 -> v883
+    v991 -> v883
+    v1005 -> v883
+    v1048 -> v883
+    trap user0
+
+ebb114:
+    v951 = iconst.i64 0
+    v988 -> v951
+    trap user0
+
+ebb117:
+    v987 = iconst.i64 0
+    call fn0(v0, v105, v1052, v883, v829, v987, v951, v842)
+    trap user0
+}
+"
+            );
+        }
+    }
+}
diff --git a/cranelift/src/bugpoint_test.clif b/cranelift/src/bugpoint_test.clif
new file mode 100644
index 0000000000..20c34e2351
--- /dev/null
+++ b/cranelift/src/bugpoint_test.clif
@@ -0,0 +1,1784 @@
+test compile
+set is_pic
+target x86_64-unknown-linux-gnu
+
+function u0:0(i64, i64, i64) system_v {
+
+
+    ss0 = explicit_slot 16
+    ss1 = explicit_slot 1     ss2 = explicit_slot 16     ss3 = explicit_slot 1     ss4 = explicit_slot 16     ss5 = explicit_slot 8     ss6 = explicit_slot 16     ss7 = explicit_slot 16     ss8 = explicit_slot 16     ss9 = explicit_slot 16     ss10 = explicit_slot 16     ss11 = explicit_slot 16     ss12 = explicit_slot 16     ss13 = explicit_slot 16     ss14 = explicit_slot 16     ss15 = explicit_slot 16     ss16 = explicit_slot 16     ss17 = explicit_slot 16     ss18 = explicit_slot 24     ss19 = explicit_slot 4     ss20 = explicit_slot 4     ss21 = explicit_slot 4     ss22 = explicit_slot 4     ss23 = explicit_slot 16     ss24 = explicit_slot 16     ss25 = explicit_slot 16     ss26 = explicit_slot 16     ss27 = explicit_slot 48     ss28 = explicit_slot 16     ss29 = explicit_slot 16     ss30 = explicit_slot 32     ss31 = explicit_slot 16     ss32 = explicit_slot 8     ss33 = explicit_slot 8     ss34 = explicit_slot 16     ss35 = explicit_slot 16     ss36 = explicit_slot 16     ss37 = explicit_slot 48     ss38 = explicit_slot 16     ss39 = explicit_slot 16     ss40 = explicit_slot 32     ss41 = explicit_slot 16     ss42 = explicit_slot 8     ss43 = explicit_slot 8     ss44 = explicit_slot 16     ss45 = explicit_slot 16     ss46 = explicit_slot 16     ss47 = explicit_slot 16     ss48 = explicit_slot 16     ss49 = explicit_slot 16     ss50 = explicit_slot 16     ss51 = explicit_slot 8     ss52 = explicit_slot 4     ss53 = explicit_slot 4     ss54 = explicit_slot 16     ss55 = explicit_slot 16     ss56 = explicit_slot 16     ss57 = explicit_slot 2     ss58 = explicit_slot 4     ss59 = explicit_slot 2     ss60 = explicit_slot 16     ss61 = explicit_slot 16     ss62 = explicit_slot 16     ss63 = explicit_slot 16     ss64 = explicit_slot 16     ss65 = explicit_slot 16     ss66 = explicit_slot 16     ss67 = explicit_slot 16     ss68 = explicit_slot 8     ss69 = explicit_slot 16     ss70 = explicit_slot 16     ss71 = explicit_slot 48     ss72 = explicit_slot 16     ss73 = explicit_slot 16     ss74 = explicit_slot 32     ss75 = explicit_slot 16     ss76 = explicit_slot 8     ss77 = explicit_slot 8     ss78 = explicit_slot 16     ss79 = explicit_slot 16     ss80 = explicit_slot 16     ss81 = explicit_slot 48     ss82 = explicit_slot 16     ss83 = explicit_slot 16     ss84 = explicit_slot 32     ss85 = explicit_slot 16     ss86 = explicit_slot 8     ss87 = explicit_slot 8     ss88 = explicit_slot 16     ss89 = explicit_slot 16     ss90 = explicit_slot 4     ss91 = explicit_slot 16     ss92 = explicit_slot 16     ss93 = explicit_slot 16     ss94 = explicit_slot 16     ss95 = explicit_slot 16     ss96 = explicit_slot 16     ss97 = explicit_slot 2     ss98 = explicit_slot 16     ss99 = explicit_slot 16     ss100 = explicit_slot 16     ss101 = explicit_slot 16     ss102 = explicit_slot 16     ss103 = explicit_slot 16     ss104 = explicit_slot 8     ss105 = explicit_slot 16     ss106 = explicit_slot 16     ss107 = explicit_slot 4     ss108 = explicit_slot 16
+    ss109 = explicit_slot 16
+    ss110 = explicit_slot 16
+    ss111 = explicit_slot 16
+    ss112 = explicit_slot 4
+    ss113 = explicit_slot 4
+    ss114 = explicit_slot 4
+    ss115 = explicit_slot 4
+    ss116 = explicit_slot 16
+    ss117 = explicit_slot 16
+    ss118 = explicit_slot 16
+    ss119 = explicit_slot 16
+    ss120 = explicit_slot 16
+    ss121 = explicit_slot 4
+    ss122 = explicit_slot 4
+    ss123 = explicit_slot 16
+    ss124 = explicit_slot 16
+    ss125 = explicit_slot 16
+    ss126 = explicit_slot 2
+    ss127 = explicit_slot 16
+    ss128 = explicit_slot 16
+    ss129 = explicit_slot 16
+    ss130 = explicit_slot 16
+    ss131 = explicit_slot 16
+    ss132 = explicit_slot 4
+    ss133 = explicit_slot 16
+    ss134 = explicit_slot 16
+    ss135 = explicit_slot 16
+    ss136 = explicit_slot 16
+    ss137 = explicit_slot 16
+    ss138 = explicit_slot 16
+    ss139 = explicit_slot 2
+    ss140 = explicit_slot 16
+    ss141 = explicit_slot 16
+    ss142 = explicit_slot 16
+    ss143 = explicit_slot 16
+    ss144 = explicit_slot 4
+    gv0 = symbol colocated u1:22
+    gv1 = symbol colocated u1:23
+    gv2 = symbol colocated u1:24
+    gv3 = symbol colocated u1:23
+    gv4 = symbol colocated u1:25
+    gv5 = symbol colocated u1:23
+    gv6 = symbol colocated u1:26
+    gv7 = symbol colocated u1:23
+    gv8 = symbol colocated u1:27
+    gv9 = symbol colocated u1:23
+    gv10 = symbol colocated u1:28
+    gv11 = symbol colocated u1:23
+    gv12 = symbol colocated u1:29
+    gv13 = symbol colocated u1:30
+    gv14 = symbol colocated u1:31
+    gv15 = symbol colocated u1:23
+    gv16 = symbol colocated u1:29
+    gv17 = symbol colocated u1:32
+    gv18 = symbol colocated u1:32
+    gv19 = symbol colocated u1:32
+    gv20 = symbol colocated u1:32
+    gv21 = symbol colocated u1:32
+    gv22 = symbol colocated u1:33
+    gv23 = symbol colocated u1:34
+    gv24 = symbol colocated u1:23
+    gv25 = symbol colocated u1:35
+    gv26 = symbol colocated u1:36
+    gv27 = symbol colocated u1:23
+    gv28 = symbol colocated u1:29
+    gv29 = symbol colocated u1:32
+    gv30 = symbol colocated u1:37
+    gv31 = symbol colocated u1:38
+    gv32 = symbol colocated u1:30
+    gv33 = symbol colocated u1:32
+    gv34 = symbol colocated u1:32
+    gv35 = symbol colocated u1:29
+    gv36 = symbol colocated u1:32
+    gv37 = symbol colocated u1:30
+    gv38 = symbol colocated u1:32
+    gv39 = symbol colocated u1:39
+    gv40 = symbol colocated u1:40
+    gv41 = symbol colocated u1:41
+    gv42 = symbol colocated u1:23
+    gv43 = symbol colocated u1:29
+    gv44 = symbol colocated u1:42
+    gv45 = symbol colocated u1:29
+    gv46 = symbol colocated u1:30
+    gv47 = symbol colocated u1:29
+    gv48 = symbol colocated u1:30
+    gv49 = symbol colocated u1:32
+    gv50 = symbol colocated u1:43
+    gv51 = symbol colocated u1:44
+    gv52 = symbol colocated u1:45
+    gv53 = symbol colocated u1:23
+    gv54 = symbol colocated u1:46
+    gv55 = symbol colocated u1:47
+    gv56 = symbol colocated u1:48
+    gv57 = symbol colocated u1:23
+    gv58 = symbol colocated u1:32
+    gv59 = symbol colocated u1:39
+    gv60 = symbol colocated u1:49
+    gv61 = symbol colocated u1:49
+    gv62 = symbol colocated u1:49
+    gv63 = symbol colocated u1:38
+    gv64 = symbol colocated u1:30
+    gv65 = symbol colocated u1:32
+    gv66 = symbol colocated u1:50
+    gv67 = symbol colocated u1:23
+    gv68 = symbol colocated u1:29
+    gv69 = symbol colocated u1:51
+    gv70 = symbol colocated u1:29
+    gv71 = symbol colocated u1:30
+    gv72 = symbol colocated u1:32
+    gv73 = symbol colocated u1:49
+    gv74 = symbol colocated u1:32
+    sig0 = (i64) system_v
+    sig1 = (i64) system_v
+    sig2 = (i64) system_v
+    sig3 = (i64) system_v
+    sig4 = (i64) system_v
+    sig5 = (i64) system_v
+    sig6 = (i64, i64, i64) system_v
+    sig7 = (i64) -> i8 system_v
+    sig8 = (i64) system_v
+    sig9 = (i64) system_v
+    sig10 = (i64, i64, i64) system_v
+    sig11 = (i64) -> i8 system_v
+    sig12 = (i64) system_v
+    sig13 = (i64) system_v
+    sig14 = (i64) -> i64 system_v
+    sig15 = (i64) system_v
+    sig16 = (i64) system_v
+    sig17 = (i64) system_v
+    sig18 = (i64) system_v
+    sig19 = (i64) system_v
+    sig20 = (i64) system_v
+    sig21 = (i64) system_v
+    sig22 = (i64, i64) system_v
+    sig23 = (i64) system_v
+    sig24 = (i64, i64, i16) system_v
+    sig25 = (i64, i64, i16) system_v
+    sig26 = (i64) system_v
+    sig27 = (i64) system_v
+    sig28 = (i64) system_v
+    sig29 = (i64) system_v
+    sig30 = (i64, i16, i16) system_v
+    sig31 = (i64, i64, i64) system_v
+    sig32 = (i64, i64, i64) system_v
+    sig33 = (i64, i64, i64) system_v
+    sig34 = (i64, i64) -> i8 system_v
+    sig35 = (i64, i64, i64) system_v
+    sig36 = (i64, i64) -> i8 system_v
+    sig37 = (i64, i64, i64) system_v
+    sig38 = (i64, i64, i64) system_v
+    sig39 = (i64, i64) system_v
+    sig40 = (i64) system_v
+    sig41 = (i64, i64) -> i8 system_v
+    sig42 = (i64, i64, i64) system_v
+    sig43 = (i64, i64) -> i8 system_v
+    sig44 = (i64, i64, i64) system_v
+    sig45 = (i64, i64, i64) system_v
+    sig46 = (i64, i64) system_v
+    sig47 = (i64) system_v
+    sig48 = (i64) system_v
+    sig49 = (i64) system_v
+    sig50 = (i64) system_v
+    sig51 = (i64) system_v
+    sig52 = (i64) system_v
+    sig53 = (i64) system_v
+    sig54 = (i64, i32) system_v
+    sig55 = (i64) system_v
+    sig56 = (i64) system_v
+    sig57 = (i64) system_v
+    sig58 = (i64) system_v
+    sig59 = (i64) system_v
+    sig60 = (i64) system_v
+    sig61 = (i64) system_v
+    sig62 = (i64) system_v
+    sig63 = (i64) system_v
+    sig64 = (i64) system_v
+    sig65 = (i64) system_v
+    sig66 = (i64) system_v
+    sig67 = (i64) system_v
+    sig68 = (i64) system_v
+    sig69 = (i64) system_v
+    sig70 = (i64, i64, i64) system_v
+    sig71 = (i64) system_v
+    sig72 = (i64, i64, i16, i64, i64, i64, i64, i64) system_v
+    sig73 = (i64, i64) -> i8 system_v
+    sig74 = (i64, i64, i64) system_v
+    sig75 = (i64, i64) -> i8 system_v
+    sig76 = (i64, i64, i64) system_v
+    sig77 = (i64, i64, i64) system_v
+    sig78 = (i64, i64) system_v
+    sig79 = (i64) system_v
+    sig80 = (i64, i64) -> i8 system_v
+    sig81 = (i64, i64, i64) system_v
+    sig82 = (i64, i64) -> i8 system_v
+    sig83 = (i64, i64, i64) system_v
+    sig84 = (i64, i64, i64) system_v
+    sig85 = (i64, i64) system_v
+    sig86 = (i64) system_v
+    sig87 = (i64) system_v
+    sig88 = (i64) system_v
+    sig89 = (i64) system_v
+    sig90 = (i64) system_v
+    sig91 = (i64) system_v
+    sig92 = (i64) system_v
+    sig93 = (i64) system_v
+    sig94 = (i64) system_v
+    sig95 = (i64) system_v
+    sig96 = (i64) system_v
+    sig97 = (i64) system_v
+    sig98 = (i64) system_v
+    sig99 = (i64) system_v
+    sig100 = (i64) system_v
+    sig101 = (i64, i64, i64) system_v
+    sig102 = (i64) system_v
+    sig103 = (i64) system_v
+    sig104 = (i64, i64, i16, i64, i64, i64, i64, i64) system_v
+    sig105 = (i64) system_v
+    fn0 = u0:83 sig0
+    fn1 = u0:13 sig1
+    fn2 = u0:83 sig2
+    fn3 = u0:13 sig3
+    fn4 = u0:83 sig4
+    fn5 = u0:13 sig5
+    fn6 = u0:84 sig6
+    fn7 = u0:85 sig7
+    fn8 = u0:83 sig8
+    fn9 = u0:13 sig9
+    fn10 = u0:86 sig10     fn11 = u0:85 sig11     fn12 = u0:83 sig12     fn13 = u0:13 sig13
+    fn14 = u0:16 sig14     fn15 = u0:83 sig15     fn16 = u0:13 sig16
+    fn17 = u0:13 sig17
+    fn18 = u0:13 sig18
+    fn19 = u0:83 sig19     fn20 = u0:13 sig20
+    fn21 = u0:13 sig21
+    fn22 = u0:87 sig22     fn23 = u0:13 sig23
+    fn24 = u0:88 sig24     fn25 = u0:88 sig25     fn26 = u0:13 sig26
+    fn27 = u0:13 sig27
+    fn28 = u0:13 sig28
+    fn29 = u0:13 sig29
+    fn30 = u0:89 sig30     fn31 = u0:90 sig31     fn32 = u0:90 sig32     fn33 = u0:90 sig33     fn34 = u0:91 sig34     fn35 = u0:92 sig35     fn36 = u0:91 sig36     fn37 = u0:92 sig37     fn38 = u0:11 sig38     fn39 = u0:12 sig39     fn40 = u0:13 sig40
+    fn41 = u0:91 sig41     fn42 = u0:92 sig42     fn43 = u0:91 sig43     fn44 = u0:92 sig44     fn45 = u0:11 sig45     fn46 = u0:12 sig46     fn47 = u0:13 sig47
+    fn48 = u0:13 sig48
+    fn49 = u0:13 sig49
+    fn50 = u0:13 sig50
+    fn51 = u0:13 sig51
+    fn52 = u0:13 sig52
+    fn53 = u0:13 sig53
+    fn54 = u0:93 sig54     fn55 = u0:13 sig55
+    fn56 = u0:13 sig56
+    fn57 = u0:13 sig57
+    fn58 = u0:13 sig58
+    fn59 = u0:13 sig59
+    fn60 = u0:13 sig60
+    fn61 = u0:13 sig61
+    fn62 = u0:83 sig62     fn63 = u0:13 sig63
+    fn64 = u0:13 sig64
+    fn65 = u0:13 sig65
+    fn66 = u0:13 sig66
+    fn67 = u0:13 sig67
+    fn68 = u0:13 sig68
+    fn69 = u0:13 sig69
+    fn70 = u0:94 sig70     fn71 = u0:13 sig71
+    fn72 = u0:95 sig72     fn73 = u0:96 sig73     fn74 = u0:97 sig74     fn75 = u0:96 sig75     fn76 = u0:97 sig76     fn77 = u0:11 sig77     fn78 = u0:12 sig78     fn79 = u0:13 sig79
+    fn80 = u0:91 sig80     fn81 = u0:92 sig81     fn82 = u0:91 sig82     fn83 = u0:92 sig83     fn84 = u0:11 sig84     fn85 = u0:12 sig85     fn86 = u0:13 sig86
+    fn87 = u0:13 sig87
+    fn88 = u0:13 sig88
+    fn89 = u0:13 sig89
+    fn90 = u0:13 sig90
+    fn91 = u0:13 sig91
+    fn92 = u0:13 sig92
+    fn93 = u0:13 sig93
+    fn94 = u0:13 sig94
+    fn95 = u0:83 sig95     fn96 = u0:13 sig96
+    fn97 = u0:13 sig97
+    fn98 = u0:13 sig98
+    fn99 = u0:13 sig99
+    fn100 = u0:13 sig100
+    fn101 = u0:94 sig101
+    fn102 = u0:13 sig102
+    fn103 = u0:13 sig103
+    fn104 = u0:95 sig104
+
+ebb0(v0: i64, v1: i64, v2: i64):
+    v113 -> v1
+    v124 -> v1
+    v136 -> v1
+    v148 -> v1
+    v160 -> v1
+    v185 -> v1
+    v222 -> v1
+    v237 -> v1
+    v241 -> v1
+    v256 -> v1
+    v262 -> v1
+    v3 = stack_addr.i64 ss0
+    v4 = load.i64 aligned v2
+    store aligned v4, v3
+    v5 = load.i64 aligned v2+8
+    store aligned v5, v3+8
+    v6 = stack_addr.i64 ss1
+    v7 = stack_addr.i64 ss2
+    v8 = stack_addr.i64 ss3
+    v9 = stack_addr.i64 ss4
+    v10 = stack_addr.i64 ss5
+    v11 = stack_addr.i64 ss6
+    v12 = stack_addr.i64 ss7
+    v13 = stack_addr.i64 ss8
+    v14 = stack_addr.i64 ss9
+    v15 = stack_addr.i64 ss10
+    v16 = stack_addr.i64 ss11
+    v17 = stack_addr.i64 ss12
+    v18 = stack_addr.i64 ss13
+    v19 = stack_addr.i64 ss14
+    v20 = stack_addr.i64 ss15
+    v21 = stack_addr.i64 ss16
+    v22 = stack_addr.i64 ss17
+    v23 = stack_addr.i64 ss18
+    v24 = stack_addr.i64 ss19
+    v25 = stack_addr.i64 ss20
+    v26 = stack_addr.i64 ss21
+    v27 = stack_addr.i64 ss22
+    v28 = stack_addr.i64 ss23
+    v29 = stack_addr.i64 ss24
+    v30 = stack_addr.i64 ss25
+    v31 = stack_addr.i64 ss26
+    v32 = stack_addr.i64 ss27
+    v33 = stack_addr.i64 ss28
+    v34 = stack_addr.i64 ss29
+    v35 = stack_addr.i64 ss30
+    v36 = stack_addr.i64 ss31
+    v37 = stack_addr.i64 ss32
+    v38 = stack_addr.i64 ss33
+    v39 = stack_addr.i64 ss34
+    v40 = stack_addr.i64 ss35
+    v41 = stack_addr.i64 ss36
+    v42 = stack_addr.i64 ss37
+    v43 = stack_addr.i64 ss38
+    v44 = stack_addr.i64 ss39
+    v45 = stack_addr.i64 ss40
+    v46 = stack_addr.i64 ss41
+    v47 = stack_addr.i64 ss42
+    v48 = stack_addr.i64 ss43
+    v49 = stack_addr.i64 ss44
+    v50 = stack_addr.i64 ss45
+    v51 = stack_addr.i64 ss46
+    v52 = stack_addr.i64 ss47
+    v53 = stack_addr.i64 ss48
+    v54 = stack_addr.i64 ss49
+    v55 = stack_addr.i64 ss50
+    v56 = stack_addr.i64 ss51
+    v57 = stack_addr.i64 ss52
+    v58 = stack_addr.i64 ss53
+    v59 = stack_addr.i64 ss54
+    v60 = stack_addr.i64 ss55
+    v61 = stack_addr.i64 ss56
+    v62 = stack_addr.i64 ss57
+    v63 = stack_addr.i64 ss58
+    v64 = stack_addr.i64 ss59
+    v65 = stack_addr.i64 ss60
+    v66 = stack_addr.i64 ss61
+    v67 = stack_addr.i64 ss62
+    v68 = stack_addr.i64 ss63
+    v69 = stack_addr.i64 ss64
+    v70 = stack_addr.i64 ss65
+    v71 = stack_addr.i64 ss66
+    v72 = stack_addr.i64 ss67
+    v73 = stack_addr.i64 ss68
+    v74 = stack_addr.i64 ss69
+    v75 = stack_addr.i64 ss70
+    v76 = stack_addr.i64 ss71
+    v77 = stack_addr.i64 ss72
+    v78 = stack_addr.i64 ss73
+    v79 = stack_addr.i64 ss74
+    v80 = stack_addr.i64 ss75
+    v81 = stack_addr.i64 ss76
+    v82 = stack_addr.i64 ss77
+    v83 = stack_addr.i64 ss78
+    v84 = stack_addr.i64 ss79
+    v85 = stack_addr.i64 ss80
+    v86 = stack_addr.i64 ss81
+    v87 = stack_addr.i64 ss82
+    v88 = stack_addr.i64 ss83
+    v89 = stack_addr.i64 ss84
+    v90 = stack_addr.i64 ss85
+    v91 = stack_addr.i64 ss86
+    v92 = stack_addr.i64 ss87
+    v93 = stack_addr.i64 ss88
+    v94 = stack_addr.i64 ss89
+    v95 = stack_addr.i64 ss90
+    v96 = stack_addr.i64 ss91
+    v97 = stack_addr.i64 ss92
+    v98 = stack_addr.i64 ss93
+    v99 = stack_addr.i64 ss94
+    v100 = stack_addr.i64 ss95
+    v101 = stack_addr.i64 ss96
+    v102 = stack_addr.i64 ss97
+    v103 = stack_addr.i64 ss98
+    v104 = stack_addr.i64 ss99
+    v105 = stack_addr.i64 ss100
+    v106 = stack_addr.i64 ss101
+    v107 = stack_addr.i64 ss102
+    v108 = stack_addr.i64 ss103
+    v109 = stack_addr.i64 ss104
+    v110 = stack_addr.i64 ss105
+    v111 = stack_addr.i64 ss106
+    v112 = stack_addr.i64 ss107
+    jump ebb1
+
+ebb1:
+    v114 = load.i64 v113
+    v115 = iconst.i64 0
+    v116 = icmp ugt v114, v115
+    v117 = bint.i8 v116
+    v118 = uextend.i32 v117
+    v119 = icmp_imm eq v118, 0
+    v120 = bint.i8 v119
+    v121 = uextend.i32 v120
+    brz v121, ebb3
+    jump ebb2
+
+ebb2:
+    v122 = global_value.i64 gv0
+    v123 = global_value.i64 gv1
+    trap user65535
+
+ebb3:
+    v125 = iadd_imm.i64 v124, 8
+    v126 = load.i64 v125
+    v127 = iconst.i64 0
+    v128 = icmp ugt v126, v127
+    v129 = bint.i8 v128
+    v130 = uextend.i32 v129
+    v131 = icmp_imm eq v130, 0
+    v132 = bint.i8 v131
+    v133 = uextend.i32 v132
+    brz v133, ebb5
+    jump ebb4
+
+ebb4:
+    v134 = global_value.i64 gv2
+    v135 = global_value.i64 gv3
+    trap user65535
+
+ebb5:
+    v137 = iadd_imm.i64 v136, 16
+    v138 = load.i64 v137+42
+    v139 = iconst.i64 0
+    v140 = icmp ugt v138, v139
+    v141 = bint.i8 v140
+    v142 = uextend.i32 v141
+    v143 = icmp_imm eq v142, 0
+    v144 = bint.i8 v143
+    v145 = uextend.i32 v144
+    brz v145, ebb7
+    jump ebb6
+
+ebb6:
+    v146 = global_value.i64 gv4
+    v147 = global_value.i64 gv5
+    trap user65535
+
+ebb7:
+    v149 = load.i64 v148
+    v150 = iadd_imm.i64 v148, 16
+    v151 = load.i64 v150
+    call fn6(v7, v149, v151)
+    jump ebb8
+
+ebb8:
+    v152 = call fn7(v7)
+    jump ebb9
+
+ebb9:
+    v153 = load.i8 v6
+    v154 = uextend.i32 v153
+    v155 = icmp_imm eq v154, 0
+    v156 = bint.i8 v155
+    v157 = uextend.i32 v156
+    brz v157, ebb11
+    jump ebb10
+
+ebb10:
+    v158 = global_value.i64 gv6
+    v159 = global_value.i64 gv7
+    trap user65535
+
+ebb11:
+    v161 = load.i64 v160
+    v162 = iadd_imm.i64 v160, 8
+    v163 = load.i64 v162
+    call fn10(v9, v161, v163)
+    jump ebb12
+
+ebb12:
+    v164 = call fn11(v9)
+    jump ebb13
+
+ebb13:
+    v165 = load.i8 v8
+    v166 = uextend.i32 v165
+    v167 = icmp_imm eq v166, 0
+    v168 = bint.i8 v167
+    v169 = uextend.i32 v168
+    brz v169, ebb15
+    jump ebb14
+
+ebb14:
+    v170 = global_value.i64 gv8
+    v171 = global_value.i64 gv9
+    trap user65535
+
+ebb15:
+    v172 = load.i64 aligned v3
+    v173 = load.i64 aligned v3+8
+    v174 = call fn14(v11)
+    jump ebb16
+
+ebb16:
+    v175 = iconst.i64 17
+    v176 = load.i64 v10
+    v177 = icmp uge v176, v175
+    v178 = bint.i8 v177
+    v179 = uextend.i32 v178
+    v180 = icmp_imm eq v179, 0
+    v181 = bint.i8 v180
+    v182 = uextend.i32 v181
+    brz v182, ebb18
+    jump ebb17
+
+ebb17:
+    v183 = global_value.i64 gv10
+    v184 = global_value.i64 gv11
+    trap user65535
+
+ebb18:
+    v186 = load.i64 v185
+    v187 = iadd_imm.i64 v185, 16
+    v188 = load.i64 v187
+    v189 = iadd v186, v188
+    v190 = iconst.i8 0
+    v191 = stack_addr.i64 ss108
+    v192 = stack_addr.i64 ss108
+    v193 = load.i64 aligned v192
+    v194 = load.i64 aligned v192+8
+    v195 = iadd_imm.i64 v12, 8
+    v196 = load.i8 v195
+    v197 = uextend.i32 v196
+    brz v197, ebb19
+    v198 = global_value.i64 gv12
+    trap user0
+
+ebb19:
+    v199 = load.i64 v12
+        v213 -> v199
+    v200 = iconst.i64 1
+    v201 = iconst.i32 61
+    v202 = ishl v200, v201
+    v203 = iconst.i8 0
+    v204 = stack_addr.i64 ss109
+    v205 = stack_addr.i64 ss109
+    v206 = load.i64 aligned v205
+    v207 = load.i64 aligned v205+8
+    v208 = iadd_imm.i64 v13, 8
+    v209 = load.i8 v208
+    v210 = uextend.i32 v209
+    brz v210, ebb20
+    v211 = global_value.i64 gv13
+    trap user0
+
+ebb20:
+    v212 = load.i64 v13
+    v214 = icmp.i64 ult v213, v212
+    v215 = bint.i8 v214
+    v216 = uextend.i32 v215
+    v217 = icmp_imm eq v216, 0
+    v218 = bint.i8 v217
+    v219 = uextend.i32 v218
+    brz v219, ebb22
+    jump ebb21
+
+ebb21:
+    v220 = global_value.i64 gv14
+    v221 = global_value.i64 gv15
+    trap user65535
+
+ebb22:
+    v223 = load.i64 v222
+    v224 = iadd_imm.i64 v222, 16
+    v225 = load.i64 v224
+    v226 = iadd v223, v225
+    v227 = iconst.i8 0
+    v228 = stack_addr.i64 ss110
+    v229 = stack_addr.i64 ss110
+    v230 = load.i64 aligned v229
+    v231 = load.i64 aligned v229+8
+    v232 = iadd_imm.i64 v16, 8
+    v233 = load.i8 v232
+    v234 = uextend.i32 v233
+    brz v234, ebb23
+    v235 = global_value.i64 gv16
+    trap user0
+
+ebb23:
+    v236 = load.i64 v16
+    v238 = iadd_imm.i64 v237, 24
+    v239 = load.i16 v238
+    v240 = iadd_imm.i64 v15, 8
+    call fn22(v14, v15)
+    jump ebb24
+
+ebb24:
+    v242 = load.i64 v241
+    v243 = iadd_imm.i64 v241, 8
+    v244 = load.i64 v243
+    v245 = isub v242, v244
+    v246 = iconst.i8 0
+    v247 = stack_addr.i64 ss111
+    v248 = stack_addr.i64 ss111
+    v249 = load.i64 aligned v248
+    v250 = load.i64 aligned v248+8
+    v251 = iadd_imm.i64 v19, 8
+    v252 = load.i8 v251
+    v253 = uextend.i32 v252
+    brz v253, ebb25
+    v254 = global_value.i64 gv17
+    trap user0
+
+ebb25:
+    v255 = load.i64 v19
+    v257 = iadd_imm.i64 v256, 24
+    v258 = load.i16 v257
+    v259 = iadd_imm.i64 v18, 8
+    v260 = iadd_imm.i64 v14, 8
+    v261 = load.i16 v260
+    call fn24(v17, v18, v261)
+    jump ebb26
+
+ebb26:
+    v263 = load.i64 v262
+    v264 = iadd_imm.i64 v262, 24
+    v265 = load.i16 v264
+    v266 = iadd_imm.i64 v21, 8
+    v267 = iadd_imm.i64 v14, 8
+    v268 = load.i16 v267
+    call fn25(v20, v21, v268)
+    jump ebb27
+
+ebb27:
+    v269 = iadd_imm.i64 v14, 8
+    v270 = load.i16 v269
+    v271 = iconst.i16 -60
+    v272 = isub v271, v270
+    v273 = iconst.i8 0
+    v274 = stack_addr.i64 ss112
+    v275 = stack_addr.i64 ss112
+    v276 = load.i32 aligned v275
+    v277 = iadd_imm.i64 v24, 2
+    v278 = load.i8 v277
+    v279 = uextend.i32 v278
+    brz v279, ebb28
+    v280 = global_value.i64 gv18
+    trap user0
+
+ebb28:
+    v281 = load.i16 v24
+    v282 = iconst.i16 64
+    v283 = isub v281, v282
+    v284 = iconst.i8 0
+    v285 = stack_addr.i64 ss113
+    v286 = stack_addr.i64 ss113
+    v287 = load.i32 aligned v286
+    v288 = iadd_imm.i64 v25, 2
+    v289 = load.i8 v288
+    v290 = uextend.i32 v289
+    brz v290, ebb29
+    v291 = global_value.i64 gv19
+    trap user0
+
+ebb29:
+    v292 = load.i16 v25
+        v317 -> v292
+    v293 = iadd_imm.i64 v14, 8
+    v294 = load.i16 v293
+    v295 = iconst.i16 -32
+    v296 = isub v295, v294
+    v297 = iconst.i8 0
+    v298 = stack_addr.i64 ss114
+    v299 = stack_addr.i64 ss114
+    v300 = load.i32 aligned v299
+    v301 = iadd_imm.i64 v26, 2
+    v302 = load.i8 v301
+    v303 = uextend.i32 v302
+    brz v303, ebb30
+    v304 = global_value.i64 gv20
+    trap user0
+
+ebb30:
+    v305 = load.i16 v26
+    v306 = iconst.i16 64
+    v307 = isub v305, v306
+    v308 = iconst.i8 0
+    v309 = stack_addr.i64 ss115
+    v310 = stack_addr.i64 ss115
+    v311 = load.i32 aligned v310
+    v312 = iadd_imm.i64 v27, 2
+    v313 = load.i8 v312
+    v314 = uextend.i32 v313
+    brz v314, ebb31
+    v315 = global_value.i64 gv21
+    trap user0
+
+ebb31:
+    v316 = load.i16 v27
+    call fn30(v23, v317, v316)
+    jump ebb32
+
+ebb32:
+    v318 = load.i16 v23
+        v1007 -> v318
+    v319 = iadd_imm.i64 v23, 8
+    v320 = load.i64 aligned v319
+    v321 = load.i64 aligned v319+8
+    call fn31(v28, v14, v22)
+    jump ebb33
+
+ebb33:
+    call fn32(v29, v17, v22)
+    jump ebb34
+
+ebb34:
+    call fn33(v30, v20, v22)
+    jump ebb35
+
+ebb35:
+    v322 = iconst.i8 1
+    v323 = uextend.i32 v322
+    brz v323, ebb42
+    jump ebb36
+
+ebb36:
+    v324 = iadd_imm.i64 v28, 8
+    v325 = iadd_imm.i64 v29, 8
+    v326 = iadd_imm.i64 v31, 8
+    v327 = load.i64 v31
+        v340 -> v327
+    v328 = iadd_imm.i64 v31, 8
+    v329 = load.i64 v328
+        v341 -> v329
+    v330 = load.i16 v327
+    v331 = load.i16 v329
+    v332 = icmp eq v330, v331
+    v333 = bint.i8 v332
+    v334 = uextend.i32 v333
+    v335 = icmp_imm eq v334, 0
+    v336 = bint.i8 v335
+    v337 = uextend.i32 v336
+    brz v337, ebb38
+    jump ebb37
+
+ebb37:
+    v338 = global_value.i64 gv22
+    v339 = iconst.i64 3
+    v342 = iadd_imm.i64 v36, 8
+    v343 = load.i64 v36
+    v344 = iadd_imm.i64 v36, 8
+    v345 = load.i64 v344
+        v347 -> v345
+    v346 = func_addr.i64 fn34
+    call fn35(v39, v343, v346)
+    jump ebb39
+
+ebb38:
+    jump ebb42
+
+ebb39:
+    v348 = func_addr.i64 fn36
+    call fn37(v40, v347, v348)
+    jump ebb40
+
+ebb40:
+    v349 = iconst.i64 0
+    v350 = imul_imm v349, 16
+    v351 = iadd.i64 v35, v350
+    v352 = load.i64 aligned v39
+    v353 = load.i64 aligned v39+8
+    v354 = iconst.i64 1
+    v355 = imul_imm v354, 16
+    v356 = iadd.i64 v35, v355
+    v357 = load.i64 aligned v40
+    v358 = load.i64 aligned v40+8
+    v359 = iconst.i64 2
+    call fn38(v32, v33, v34)
+    jump ebb41
+
+ebb41:
+    v360 = global_value.i64 gv23
+    call fn39(v32, v360)
+    v361 = global_value.i64 gv24
+    trap user65535
+
+ebb42:
+    v362 = iconst.i8 1
+    v363 = uextend.i32 v362
+    brz v363, ebb49(v1007)
+    jump ebb43
+
+ebb43:
+    v364 = iadd_imm.i64 v28, 8
+    v365 = iadd_imm.i64 v30, 8
+    v366 = iadd_imm.i64 v41, 8
+    v367 = load.i64 v41
+        v380 -> v367
+    v368 = iadd_imm.i64 v41, 8
+    v369 = load.i64 v368
+        v381 -> v369
+    v370 = load.i16 v367
+    v371 = load.i16 v369
+    v372 = icmp eq v370, v371
+    v373 = bint.i8 v372
+    v374 = uextend.i32 v373
+    v375 = icmp_imm eq v374, 0
+    v376 = bint.i8 v375
+    v377 = uextend.i32 v376
+    brz v377, ebb45
+    jump ebb44
+
+ebb44:
+    v378 = global_value.i64 gv25
+    v379 = iconst.i64 3
+    v382 = iadd_imm.i64 v46, 8
+    v383 = load.i64 v46
+    v384 = iadd_imm.i64 v46, 8
+    v385 = load.i64 v384
+        v387 -> v385
+    v386 = func_addr.i64 fn41
+    call fn42(v49, v383, v386)
+    jump ebb46
+
+ebb45:
+    jump ebb49(v1007)
+
+ebb46:
+    v388 = func_addr.i64 fn43
+    call fn44(v50, v387, v388)
+    jump ebb47
+
+ebb47:
+    v389 = iconst.i64 0
+    v390 = imul_imm v389, 16
+    v391 = iadd.i64 v45, v390
+    v392 = load.i64 aligned v49
+    v393 = load.i64 aligned v49+8
+    v394 = iconst.i64 1
+    v395 = imul_imm v394, 16
+    v396 = iadd.i64 v45, v395
+    v397 = load.i64 aligned v50
+    v398 = load.i64 aligned v50+8
+    v399 = iconst.i64 2
+    call fn45(v42, v43, v44)
+    jump ebb48
+
+ebb48:
+    v400 = global_value.i64 gv26
+    call fn46(v42, v400)
+    v401 = global_value.i64 gv27
+    trap user65535
+
+ebb49(v1006: i16):
+        v486 -> v1006
+    v402 = load.i64 v28
+    v403 = iconst.i64 1
+    v404 = iadd v402, v403
+    v405 = iconst.i8 0
+    v406 = stack_addr.i64 ss116
+    v407 = stack_addr.i64 ss116
+    v408 = load.i64 aligned v407
+    v409 = load.i64 aligned v407+8
+    v410 = iadd_imm.i64 v51, 8
+    v411 = load.i8 v410
+    v412 = uextend.i32 v411
+    brz v412, ebb50
+    v413 = global_value.i64 gv28
+    trap user0
+
+ebb50:
+    v414 = load.i64 v51
+        v439 -> v414
+        v452 -> v414
+        v478 -> v414
+        v508 -> v414
+    v415 = load.i64 v29
+    v416 = iconst.i64 1
+    v417 = isub v415, v416
+    v418 = iconst.i8 0
+    v419 = stack_addr.i64 ss117
+    v420 = stack_addr.i64 ss117
+    v421 = load.i64 aligned v420
+    v422 = load.i64 aligned v420+8
+    v423 = iadd_imm.i64 v52, 8
+    v424 = load.i8 v423
+    v425 = uextend.i32 v424
+    brz v425, ebb51
+    v426 = global_value.i64 gv29
+    trap user0
+
+ebb51:
+    v427 = load.i64 v52
+        v509 -> v427
+    v428 = iadd_imm.i64 v28, 8
+    v429 = load.i16 v428
+        v435 -> v429
+    v430 = iconst.i16 0xffff_ffff_ffff_8000
+    v431 = icmp eq v429, v430
+    v432 = bint.i8 v431
+    v433 = uextend.i32 v432
+    brz v433, ebb52
+    v434 = global_value.i64 gv30
+    trap user0
+
+ebb52:
+    v436 = iconst.i16 0
+    v437 = isub v436, v435
+    v438 = sextend.i64 v437
+        v453 -> v438
+        v521 -> v438
+    v440 = ushr.i64 v439, v438
+    v441 = iconst.i8 0
+    v442 = stack_addr.i64 ss118
+    v443 = stack_addr.i64 ss118
+    v444 = load.i64 aligned v443
+    v445 = load.i64 aligned v443+8
+    v446 = iadd_imm.i64 v53, 8
+    v447 = load.i8 v446
+    v448 = uextend.i32 v447
+    brz v448, ebb53
+    v449 = global_value.i64 gv31
+    trap user0
+
+ebb53:
+    v450 = load.i64 v53
+    v451 = ireduce.i32 v450
+        v480 -> v451
+        v551 -> v451
+    v454 = iconst.i64 1
+    v455 = ishl v454, v453
+    v456 = iconst.i8 0
+    v457 = stack_addr.i64 ss119
+    v458 = stack_addr.i64 ss119
+    v459 = load.i64 aligned v458
+    v460 = load.i64 aligned v458+8
+    v461 = iadd_imm.i64 v54, 8
+    v462 = load.i8 v461
+    v463 = uextend.i32 v462
+    brz v463, ebb54
+    v464 = global_value.i64 gv32
+    trap user0
+
+ebb54:
+    v465 = load.i64 v54
+    v466 = iconst.i64 1
+    v467 = isub v465, v466
+    v468 = iconst.i8 0
+    v469 = stack_addr.i64 ss120
+    v470 = stack_addr.i64 ss120
+    v471 = load.i64 aligned v470
+    v472 = load.i64 aligned v470+8
+    v473 = iadd_imm.i64 v55, 8
+    v474 = load.i8 v473
+    v475 = uextend.i32 v474
+    brz v475, ebb55
+    v476 = global_value.i64 gv33
+    trap user0
+
+ebb55:
+    v477 = load.i64 v55
+    v479 = band.i64 v478, v477
+    call fn54(v56, v480)
+    jump ebb56
+
+ebb56:
+    v481 = load.i8 v56
+        v548 -> v481
+    v482 = iadd_imm.i64 v56, 4
+    v483 = load.i32 v482
+        v550 -> v483
+    v484 = iconst.i64 0
+    v485 = uextend.i16 v481
+    v487 = isub v485, v486
+    v488 = iconst.i8 0
+    v489 = stack_addr.i64 ss121
+    v490 = stack_addr.i64 ss121
+    v491 = load.i32 aligned v490
+    v492 = iadd_imm.i64 v57, 2
+    v493 = load.i8 v492
+    v494 = uextend.i32 v493
+    brz v494, ebb57
+    v495 = global_value.i64 gv34
+    trap user0
+
+ebb57:
+    v496 = load.i16 v57
+    v497 = iconst.i16 1
+    v498 = iadd v496, v497
+    v499 = iconst.i8 0
+    v500 = stack_addr.i64 ss122
+    v501 = stack_addr.i64 ss122
+    v502 = load.i32 aligned v501
+    v503 = iadd_imm.i64 v58, 2
+    v504 = load.i8 v503
+    v505 = uextend.i32 v504
+    brz v505, ebb58
+    v506 = global_value.i64 gv35
+    trap user0
+
+ebb58:
+    v507 = load.i16 v58
+    v510 = isub.i64 v508, v509
+    v511 = iconst.i8 0
+    v512 = stack_addr.i64 ss123
+    v513 = stack_addr.i64 ss123
+    v514 = load.i64 aligned v513
+    v515 = load.i64 aligned v513+8
+    v516 = iadd_imm.i64 v59, 8
+    v517 = load.i8 v516
+    v518 = uextend.i32 v517
+    brz v518, ebb59
+    v519 = global_value.i64 gv36
+    trap user0
+
+ebb59:
+    v520 = load.i64 v59
+        v546 -> v520
+    v522 = iconst.i64 1
+    v523 = ishl v522, v521
+    v524 = iconst.i8 0
+    v525 = stack_addr.i64 ss124
+    v526 = stack_addr.i64 ss124
+    v527 = load.i64 aligned v526
+    v528 = load.i64 aligned v526+8
+    v529 = iadd_imm.i64 v60, 8
+    v530 = load.i8 v529
+    v531 = uextend.i32 v530
+    brz v531, ebb60
+    v532 = global_value.i64 gv37
+    trap user0
+
+ebb60:
+    v533 = load.i64 v60
+    v534 = iconst.i64 1
+    v535 = isub v533, v534
+    v536 = iconst.i8 0
+    v537 = stack_addr.i64 ss125
+    v538 = stack_addr.i64 ss125
+    v539 = load.i64 aligned v538
+    v540 = load.i64 aligned v538+8
+    v541 = iadd_imm.i64 v61, 8
+    v542 = load.i8 v541
+    v543 = uextend.i32 v542
+    brz v543, ebb61
+    v544 = global_value.i64 gv38
+    trap user0
+
+ebb61:
+    v545 = load.i64 v61
+    v547 = band.i64 v546, v545
+    v549 = uextend.i16 v548
+    jump ebb62(v551, v484, v521, v479, v520, v507, v508, v548, v547)
+
+ebb62(v552: i32, v1009: i64, v1013: i64, v1016: i64, v1019: i64, v1022: i16, v1025: i64, v1028: i8, v1033: i64):
+        v559 -> v552
+        v562 -> v552
+        v569 -> v552
+        v596 -> v1009
+        v605 -> v1009
+        v609 -> v1009
+        v1008 -> v1009
+        v624 -> v1013
+        v654 -> v1013
+        v1012 -> v1013
+        v1014 -> v1013
+        v1041 -> v1013
+        v636 -> v1016
+        v1015 -> v1016
+        v1017 -> v1016
+        v1030 -> v1016
+        v648 -> v1019
+        v676 -> v1019
+        v693 -> v1019
+        v1018 -> v1019
+        v1020 -> v1019
+        v674 -> v1022
+        v691 -> v1022
+        v1021 -> v1022
+        v1023 -> v1022
+        v1054 -> v1022
+        v677 -> v1025
+        v1024 -> v1025
+        v1026 -> v1025
+        v1059 -> v1025
+        v696 -> v1028
+        v1027 -> v1028
+        v1029 -> v1028
+        v1031 -> v1033
+        v1032 -> v1033
+        v1034 -> v1033
+    v553 = load.i32 v63
+        v560 -> v553
+    v554 = iconst.i32 0
+    v555 = icmp eq v553, v554
+    v556 = bint.i8 v555
+    v557 = uextend.i32 v556
+    brz v557, ebb63
+    v558 = global_value.i64 gv39
+    trap user0
+
+ebb63:
+    v561 = udiv.i32 v559, v560
+        v574 -> v561
+    v563 = load.i32 v63
+        v570 -> v563
+    v564 = iconst.i32 0
+    v565 = icmp eq v563, v564
+    v566 = bint.i8 v565
+    v567 = uextend.i32 v566
+    brz v567, ebb64
+    v568 = global_value.i64 gv40
+    trap user0
+
+ebb64:
+    v571 = urem.i32 v569, v570
+        v622 -> v571
+        v803 -> v571
+        v1011 -> v571
+    v572 = iconst.i8 1
+    v573 = uextend.i32 v572
+    brz v573, ebb68(v561)
+    jump ebb65
+
+ebb65:
+    v575 = iconst.i32 10
+    v576 = icmp.i32 ult v574, v575
+    v577 = bint.i8 v576
+    v578 = uextend.i32 v577
+    v579 = icmp_imm eq v578, 0
+    v580 = bint.i8 v579
+    v581 = uextend.i32 v580
+    brz v581, ebb67
+    jump ebb66
+
+ebb66:
+    v582 = global_value.i64 gv41
+    v583 = global_value.i64 gv42
+    trap user65535
+
+ebb67:
+    jump ebb68(v574)
+
+ebb68(v584: i32):
+    v585 = ireduce.i8 v584
+    v586 = iconst.i8 48
+    v587 = iadd v586, v585
+    v588 = iconst.i8 0
+    v589 = stack_addr.i64 ss126
+    v590 = stack_addr.i64 ss126
+    v591 = load.i16 aligned v590
+    v592 = iadd_imm.i64 v64, 1
+    v593 = load.i8 v592
+    v594 = uextend.i32 v593
+    brz v594, ebb69
+    v595 = global_value.i64 gv43
+    trap user0
+
+ebb69:
+    v597 = load.i64 v3
+    v598 = load.i64 v3+8
+    v599 = icmp.i64 ult v596, v598
+    v600 = bint.i8 v599
+    v601 = uextend.i32 v600
+    brnz v601, ebb70
+    v602 = global_value.i64 gv44
+    trap user0
+
+ebb70:
+    v603 = load.i64 v3
+    v604 = load.i64 v3+8
+    v606 = imul_imm.i64 v605, 1
+    v607 = iadd v603, v606
+    v608 = load.i8 aligned v64
+    v610 = iconst.i64 1
+    v611 = iadd.i64 v609, v610
+    v612 = iconst.i8 0
+    v613 = stack_addr.i64 ss127
+    v614 = stack_addr.i64 ss127
+    v615 = load.i64 aligned v614
+    v616 = load.i64 aligned v614+8
+    v617 = iadd_imm.i64 v65, 8
+    v618 = load.i8 v617
+    v619 = uextend.i32 v618
+    brz v619, ebb71
+    v620 = global_value.i64 gv45
+    trap user0
+
+ebb71:
+    v621 = load.i64 v65
+        v668 -> v621
+        v695 -> v621
+        v1010 -> v621
+        v1046 -> v621
+    v623 = uextend.i64 v622
+    v625 = ishl v623, v624
+    v626 = iconst.i8 0
+    v627 = stack_addr.i64 ss128
+    v628 = stack_addr.i64 ss128
+    v629 = load.i64 aligned v628
+    v630 = load.i64 aligned v628+8
+    v631 = iadd_imm.i64 v66, 8
+    v632 = load.i8 v631
+    v633 = uextend.i32 v632
+    brz v633, ebb72
+    v634 = global_value.i64 gv46
+    trap user0
+
+ebb72:
+    v635 = load.i64 v66
+    v637 = iadd v635, v636
+    v638 = iconst.i8 0
+    v639 = stack_addr.i64 ss129
+    v640 = stack_addr.i64 ss129
+    v641 = load.i64 aligned v640
+    v642 = load.i64 aligned v640+8
+    v643 = iadd_imm.i64 v67, 8
+    v644 = load.i8 v643
+    v645 = uextend.i32 v644
+    brz v645, ebb73
+    v646 = global_value.i64 gv47
+    trap user0
+
+ebb73:
+    v647 = load.i64 v67
+        v675 -> v647
+        v692 -> v647
+    v649 = icmp ult v647, v648
+    v650 = bint.i8 v649
+    v651 = uextend.i32 v650
+    brz v651, ebb80
+    jump ebb74
+
+ebb74:
+    v652 = load.i32 v63
+    v653 = uextend.i64 v652
+    v655 = ishl v653, v654
+    v656 = iconst.i8 0
+    v657 = stack_addr.i64 ss130
+    v658 = stack_addr.i64 ss130
+    v659 = load.i64 aligned v658
+    v660 = load.i64 aligned v658+8
+    v661 = iadd_imm.i64 v68, 8
+    v662 = load.i8 v661
+    v663 = uextend.i32 v662
+    brz v663, ebb75
+    v664 = global_value.i64 gv48
+    trap user0
+
+ebb75:
+    v665 = load.i64 v68
+        v690 -> v665
+    v666 = load.i64 aligned v3
+    v667 = load.i64 aligned v3+8
+    v669 = load.i64 v73
+    call fn70(v71, v72, v669)
+    jump ebb76
+
+ebb76:
+    v670 = load.i64 aligned v71
+    v671 = load.i64 aligned v71+8
+    v672 = load.i64 aligned v70
+    v673 = load.i64 aligned v70+8
+    v678 = load.i64 v30
+    v679 = isub.i64 v677, v678
+    v680 = iconst.i8 0
+    v681 = stack_addr.i64 ss131
+    v682 = stack_addr.i64 ss131
+    v683 = load.i64 aligned v682
+    v684 = load.i64 aligned v682+8
+    v685 = iadd_imm.i64 v74, 8
+    v686 = load.i8 v685
+    v687 = uextend.i32 v686
+    brz v687, ebb77
+    v688 = global_value.i64 gv49
+    trap user0
+
+ebb77:
+    v689 = load.i64 v74
+    v694 = iconst.i64 1
+    call fn72(v0, v69, v691, v692, v693, v689, v690, v694)
+    jump ebb78
+
+ebb78:
+    jump ebb79
+
+ebb79:
+    return
+
+ebb80:
+    v697 = uextend.i64 v696
+    v698 = icmp.i64 ugt v695, v697
+    v699 = bint.i8 v698
+    v700 = uextend.i32 v699
+    brz v700, ebb96
+    jump ebb81
+
+ebb81:
+    v701 = iconst.i8 1
+    v702 = uextend.i32 v701
+    brz v702, ebb88
+    jump ebb82
+
+ebb82:
+    v703 = global_value.i64 gv50
+    v704 = iadd_imm.i64 v75, 8
+    v705 = load.i64 v75
+        v718 -> v705
+    v706 = iadd_imm.i64 v75, 8
+    v707 = load.i64 v706
+        v719 -> v707
+    v708 = load.i32 v705
+    v709 = load.i32 v707
+    v710 = icmp eq v708, v709
+    v711 = bint.i8 v710
+    v712 = uextend.i32 v711
+    v713 = icmp_imm eq v712, 0
+    v714 = bint.i8 v713
+    v715 = uextend.i32 v714
+    brz v715, ebb84
+    jump ebb83
+
+ebb83:
+    v716 = global_value.i64 gv51
+    v717 = iconst.i64 3
+    v720 = iadd_imm.i64 v80, 8
+    v721 = load.i64 v80
+    v722 = iadd_imm.i64 v80, 8
+    v723 = load.i64 v722
+        v725 -> v723
+    v724 = func_addr.i64 fn73
+    call fn74(v83, v721, v724)
+    jump ebb85
+
+ebb84:
+    jump ebb88
+
+ebb85:
+    v726 = func_addr.i64 fn75
+    call fn76(v84, v725, v726)
+    jump ebb86
+
+ebb86:
+    v727 = iconst.i64 0
+    v728 = imul_imm v727, 16
+    v729 = iadd.i64 v79, v728
+    v730 = load.i64 aligned v83
+    v731 = load.i64 aligned v83+8
+    v732 = iconst.i64 1
+    v733 = imul_imm v732, 16
+    v734 = iadd.i64 v79, v733
+    v735 = load.i64 aligned v84
+    v736 = load.i64 aligned v84+8
+    v737 = iconst.i64 2
+    call fn77(v76, v77, v78)
+    jump ebb87
+
+ebb87:
+    v738 = global_value.i64 gv52
+    call fn78(v76, v738)
+    v739 = global_value.i64 gv53
+    trap user65535
+
+ebb88:
+    v740 = iconst.i8 1
+    v741 = uextend.i32 v740
+    brz v741, ebb95(v1030, v1031, v1041, v1046, v1054, v1059)
+    jump ebb89
+
+ebb89:
+    v742 = global_value.i64 gv54
+    v743 = iadd_imm.i64 v85, 8
+    v744 = load.i64 v85
+        v757 -> v744
+    v745 = iadd_imm.i64 v85, 8
+    v746 = load.i64 v745
+        v758 -> v746
+    v747 = load.i16 v744
+    v748 = load.i16 v746
+    v749 = icmp eq v747, v748
+    v750 = bint.i8 v749
+    v751 = uextend.i32 v750
+    v752 = icmp_imm eq v751, 0
+    v753 = bint.i8 v752
+    v754 = uextend.i32 v753
+    brz v754, ebb91
+    jump ebb90
+
+ebb90:
+    v755 = global_value.i64 gv55
+    v756 = iconst.i64 3
+    v759 = iadd_imm.i64 v90, 8
+    v760 = load.i64 v90
+    v761 = iadd_imm.i64 v90, 8
+    v762 = load.i64 v761
+        v764 -> v762
+    v763 = func_addr.i64 fn80
+    call fn81(v93, v760, v763)
+    jump ebb92
+
+ebb91:
+    jump ebb95(v1030, v1031, v1041, v1046, v1054, v1059)
+
+ebb92:
+    v765 = func_addr.i64 fn82
+    call fn83(v94, v764, v765)
+    jump ebb93
+
+ebb93:
+    v766 = iconst.i64 0
+    v767 = imul_imm v766, 16
+    v768 = iadd.i64 v89, v767
+    v769 = load.i64 aligned v93
+    v770 = load.i64 aligned v93+8
+    v771 = iconst.i64 1
+    v772 = imul_imm v771, 16
+    v773 = iadd.i64 v89, v772
+    v774 = load.i64 aligned v94
+    v775 = load.i64 aligned v94+8
+    v776 = iconst.i64 2
+    call fn84(v86, v87, v88)
+    jump ebb94
+
+ebb94:
+    v777 = global_value.i64 gv56
+    call fn85(v86, v777)
+    v778 = global_value.i64 gv57
+    trap user65535
+
+ebb95(v779: i64, v780: i64, v1040: i64, v1045: i64, v1053: i16, v1058: i64):
+    v781 = iconst.i64 1
+    jump ebb99(v779, v780, v781, v1040, v1045, v1053, v1058)
+
+ebb96:
+    v782 = iconst.i16 1
+    v783 = load.i16 v62
+    v784 = isub v783, v782
+    v785 = iconst.i8 0
+    v786 = stack_addr.i64 ss132
+    v787 = stack_addr.i64 ss132
+    v788 = load.i32 aligned v787
+    v789 = iadd_imm.i64 v95, 2
+    v790 = load.i8 v789
+    v791 = uextend.i32 v790
+    brz v791, ebb97
+    v792 = global_value.i64 gv58
+    trap user0
+
+ebb97:
+    v793 = load.i16 aligned v95
+    v794 = iconst.i32 10
+    v795 = iconst.i32 0
+    v796 = icmp eq v794, v795
+    v797 = bint.i8 v796
+    v798 = uextend.i32 v797
+    brz v798, ebb98
+    v799 = global_value.i64 gv59
+    trap user0
+
+ebb98:
+    v800 = iconst.i32 10
+    v801 = load.i32 v63
+    v802 = udiv v801, v800
+    jump ebb62(v803, v1010, v1014, v1017, v1020, v1023, v1026, v1029, v1034)
+
+ebb99(v804: i64, v1035: i64, v1037: i64, v1039: i64, v1044: i64, v1052: i16, v1057: i64):
+        v817 -> v1035
+        v830 -> v1037
+        v844 -> v1039
+        v857 -> v1039
+        v939 -> v1039
+        v1042 -> v1039
+        v1050 -> v1039
+        v908 -> v1044
+        v917 -> v1044
+        v921 -> v1044
+        v1043 -> v1044
+        v960 -> v1052
+        v990 -> v1052
+        v1051 -> v1052
+        v1055 -> v1052
+        v963 -> v1057
+        v1056 -> v1057
+        v1060 -> v1057
+    v805 = iconst.i64 10
+    v806 = imul v804, v805
+    v807 = iconst.i8 0
+    v808 = stack_addr.i64 ss133
+    v809 = stack_addr.i64 ss133
+    v810 = load.i64 aligned v809
+    v811 = load.i64 aligned v809+8
+    v812 = iadd_imm.i64 v96, 8
+    v813 = load.i8 v812
+    v814 = uextend.i32 v813
+    brz v814, ebb100
+    v815 = global_value.i64 gv60
+    trap user0
+
+ebb100:
+    v816 = load.i64 v96
+        v843 -> v816
+        v856 -> v816
+        v882 -> v816
+    v818 = iconst.i64 10
+    v819 = imul.i64 v817, v818
+    v820 = iconst.i8 0
+    v821 = stack_addr.i64 ss134
+    v822 = stack_addr.i64 ss134
+    v823 = load.i64 aligned v822
+    v824 = load.i64 aligned v822+8
+    v825 = iadd_imm.i64 v97, 8
+    v826 = load.i8 v825
+    v827 = uextend.i32 v826
+    brz v827, ebb101
+    v828 = global_value.i64 gv61
+    trap user0
+
+ebb101:
+    v829 = load.i64 v97
+        v935 -> v829
+        v962 -> v829
+        v992 -> v829
+        v1036 -> v829
+        v1049 -> v829
+    v831 = iconst.i64 10
+    v832 = imul.i64 v830, v831
+    v833 = iconst.i8 0
+    v834 = stack_addr.i64 ss135
+    v835 = stack_addr.i64 ss135
+    v836 = load.i64 aligned v835
+    v837 = load.i64 aligned v835+8
+    v838 = iadd_imm.i64 v98, 8
+    v839 = load.i8 v838
+    v840 = uextend.i32 v839
+    brz v840, ebb102
+    v841 = global_value.i64 gv62
+    trap user0
+
+ebb102:
+    v842 = load.i64 v98
+        v976 -> v842
+        v989 -> v842
+        v1038 -> v842
+        v1061 -> v842
+    v845 = ushr.i64 v843, v844
+    v846 = iconst.i8 0
+    v847 = stack_addr.i64 ss136
+    v848 = stack_addr.i64 ss136
+    v849 = load.i64 aligned v848
+    v850 = load.i64 aligned v848+8
+    v851 = iadd_imm.i64 v99, 8
+    v852 = load.i8 v851
+    v853 = uextend.i32 v852
+    brz v853, ebb103
+    v854 = global_value.i64 gv63
+    trap user0
+
+ebb103:
+    v855 = load.i64 v99
+        v886 -> v855
+    v858 = iconst.i64 1
+    v859 = ishl v858, v857
+    v860 = iconst.i8 0
+    v861 = stack_addr.i64 ss137
+    v862 = stack_addr.i64 ss137
+    v863 = load.i64 aligned v862
+    v864 = load.i64 aligned v862+8
+    v865 = iadd_imm.i64 v100, 8
+    v866 = load.i8 v865
+    v867 = uextend.i32 v866
+    brz v867, ebb104
+    v868 = global_value.i64 gv64
+    trap user0
+
+ebb104:
+    v869 = load.i64 v100
+    v870 = iconst.i64 1
+    v871 = isub v869, v870
+    v872 = iconst.i8 0
+    v873 = stack_addr.i64 ss138
+    v874 = stack_addr.i64 ss138
+    v875 = load.i64 aligned v874
+    v876 = load.i64 aligned v874+8
+    v877 = iadd_imm.i64 v101, 8
+    v878 = load.i8 v877
+    v879 = uextend.i32 v878
+    brz v879, ebb105
+    v880 = global_value.i64 gv65
+    trap user0
+
+ebb105:
+    v881 = load.i64 v101
+    v883 = band.i64 v882, v881
+        v934 -> v883
+        v961 -> v883
+        v991 -> v883
+        v1005 -> v883
+        v1048 -> v883
+    v884 = iconst.i8 1
+    v885 = uextend.i32 v884
+    brz v885, ebb109(v855)
+    jump ebb106
+
+ebb106:
+    v887 = iconst.i64 10
+    v888 = icmp.i64 ult v886, v887
+    v889 = bint.i8 v888
+    v890 = uextend.i32 v889
+    v891 = icmp_imm eq v890, 0
+    v892 = bint.i8 v891
+    v893 = uextend.i32 v892
+    brz v893, ebb108
+    jump ebb107
+
+ebb107:
+    v894 = global_value.i64 gv66
+    v895 = global_value.i64 gv67
+    trap user65535
+
+ebb108:
+    jump ebb109(v886)
+
+ebb109(v896: i64):
+    v897 = ireduce.i8 v896
+    v898 = iconst.i8 48
+    v899 = iadd v898, v897
+    v900 = iconst.i8 0
+    v901 = stack_addr.i64 ss139
+    v902 = stack_addr.i64 ss139
+    v903 = load.i16 aligned v902
+    v904 = iadd_imm.i64 v102, 1
+    v905 = load.i8 v904
+    v906 = uextend.i32 v905
+    brz v906, ebb110
+    v907 = global_value.i64 gv68
+    trap user0
+
+ebb110:
+    v909 = load.i64 v3
+    v910 = load.i64 v3+8
+    v911 = icmp.i64 ult v908, v910
+    v912 = bint.i8 v911
+    v913 = uextend.i32 v912
+    brnz v913, ebb111
+    v914 = global_value.i64 gv69
+    trap user0
+
+ebb111:
+    v915 = load.i64 v3
+    v916 = load.i64 v3+8
+    v918 = imul_imm.i64 v917, 1
+    v919 = iadd v915, v918
+    v920 = load.i8 aligned v102
+    v922 = iconst.i64 1
+    v923 = iadd.i64 v921, v922
+    v924 = iconst.i8 0
+    v925 = stack_addr.i64 ss140
+    v926 = stack_addr.i64 ss140
+    v927 = load.i64 aligned v926
+    v928 = load.i64 aligned v926+8
+    v929 = iadd_imm.i64 v103, 8
+    v930 = load.i8 v929
+    v931 = uextend.i32 v930
+    brz v931, ebb112
+    v932 = global_value.i64 gv70
+    trap user0
+
+ebb112:
+    v933 = load.i64 v103
+        v954 -> v933
+        v1047 -> v933
+    v936 = icmp.i64 ult v934, v935
+    v937 = bint.i8 v936
+    v938 = uextend.i32 v937
+    brz v938, ebb119
+    jump ebb113
+
+ebb113:
+    v940 = iconst.i64 1
+    v941 = ishl v940, v939
+    v942 = iconst.i8 0
+    v943 = stack_addr.i64 ss141
+    v944 = stack_addr.i64 ss141
+    v945 = load.i64 aligned v944
+    v946 = load.i64 aligned v944+8
+    v947 = iadd_imm.i64 v104, 8
+    v948 = load.i8 v947
+    v949 = uextend.i32 v948
+    brz v949, ebb114
+    v950 = global_value.i64 gv71
+    trap user0
+
+ebb114:
+    v951 = load.i64 v104
+        v988 -> v951
+    v952 = load.i64 aligned v3
+    v953 = load.i64 aligned v3+8
+    v955 = load.i64 v109
+    call fn101(v107, v108, v955)
+    jump ebb115
+
+ebb115:
+    v956 = load.i64 aligned v107
+    v957 = load.i64 aligned v107+8
+    v958 = load.i64 aligned v106
+    v959 = load.i64 aligned v106+8
+    v964 = load.i64 v30
+    v965 = isub.i64 v963, v964
+    v966 = iconst.i8 0
+    v967 = stack_addr.i64 ss142
+    v968 = stack_addr.i64 ss142
+    v969 = load.i64 aligned v968
+    v970 = load.i64 aligned v968+8
+    v971 = iadd_imm.i64 v110, 8
+    v972 = load.i8 v971
+    v973 = uextend.i32 v972
+    brz v973, ebb116
+    v974 = global_value.i64 gv72
+    trap user0
+
+ebb116:
+    v975 = load.i64 v110
+    v977 = imul v975, v976
+    v978 = iconst.i8 0
+    v979 = stack_addr.i64 ss143
+    v980 = stack_addr.i64 ss143
+    v981 = load.i64 aligned v980
+    v982 = load.i64 aligned v980+8
+    v983 = iadd_imm.i64 v111, 8
+    v984 = load.i8 v983
+    v985 = uextend.i32 v984
+    brz v985, ebb117
+    v986 = global_value.i64 gv73
+    trap user0
+
+ebb117:
+    v987 = load.i64 v111
+    call fn104(v0, v105, v990, v991, v992, v987, v988, v989)
+    jump ebb118
+
+ebb118:
+    jump ebb79
+
+ebb119:
+    v993 = iconst.i16 1
+    v994 = load.i16 v62
+    v995 = isub v994, v993
+    v996 = iconst.i8 0
+    v997 = stack_addr.i64 ss144
+    v998 = stack_addr.i64 ss144
+    v999 = load.i32 aligned v998
+    v1000 = iadd_imm.i64 v112, 2
+    v1001 = load.i8 v1000
+    v1002 = uextend.i32 v1001
+    brz v1002, ebb120
+    v1003 = global_value.i64 gv74
+    trap user0
+
+ebb120:
+    v1004 = load.i16 aligned v112
+    jump ebb99(v1005, v1036, v1038, v1042, v1047, v1055, v1060)
+}
diff --git a/cranelift/src/clif-util.rs b/cranelift/src/clif-util.rs
index a2b248b0df..a182889059 100755
--- a/cranelift/src/clif-util.rs
+++ b/cranelift/src/clif-util.rs
@@ -28,6 +28,7 @@ use std::io::{self, Write};
 use std::option::Option;
 use std::process;
 
+mod bugpoint;
 mod cat;
 mod compile;
 mod disasm;
@@ -199,6 +200,14 @@ fn main() {
                 .arg(add_pass_arg())
                 .arg(add_debug_flag())
                 .arg(add_time_flag()),
+        )
+        .subcommand(
+            SubCommand::with_name("bugpoint")
+                .about("Reduce size of clif file causing panic during compilation.")
+                .arg(add_single_input_file_arg())
+                .arg(add_set_flag())
+                .arg(add_target_flag())
+                .arg(add_verbose_flag()),
         );
 
     let res_util = match app_cmds.get_matches().subcommand() {
@@ -284,6 +293,19 @@ fn main() {
 
             result
         }
+        ("bugpoint", Some(rest_cmd)) => {
+            let mut target_val: &str = "";
+            if let Some(clap_target) = rest_cmd.value_of("target") {
+                target_val = clap_target;
+            }
+
+            bugpoint::run(
+                rest_cmd.value_of("single-file").unwrap(),
+                &get_vec(rest_cmd.values_of("set")),
+                target_val,
+                rest_cmd.is_present("verbose"),
+            )
+        }
         _ => Err("Invalid subcommand.".to_owned()),
     };