//! A SSA-building API that handles incomplete CFGs.
//!
//! The algorithm is based upon Braun M., Buchwald S., Hack S., Leißa R., Mallon C.,
//! Zwinkau A. (2013) Simple and Efficient Construction of Static Single Assignment Form.
//! In: Jhala R., De Bosschere K. (eds) Compiler Construction. CC 2013.
//! Lecture Notes in Computer Science, vol 7791. Springer, Berlin, Heidelberg

use cretonne_codegen::cursor::{Cursor, FuncCursor};
use cretonne_codegen::entity::{EntityMap, EntityRef, PrimaryMap};
use cretonne_codegen::ir::immediates::{Ieee32, Ieee64};
use cretonne_codegen::ir::instructions::BranchInfo;
use cretonne_codegen::ir::types::{F32, F64};
use cretonne_codegen::ir::{Ebb, Function, Inst, InstBuilder, Type, Value};
use cretonne_codegen::packed_option::PackedOption;
use cretonne_codegen::packed_option::ReservedValue;
use std::mem;
use std::u32;
use std::vec::Vec;

/// Structure containing the data relevant the construction of SSA for a given function.
///
/// The parameter struct `Variable` corresponds to the way variables are represented in the
/// non-SSA language you're translating from.
///
/// The SSA building relies on information about the variables used and defined, as well as
/// their position relative to basic blocks which are stricter than extended basic blocks since
/// they don't allow branching in the middle of them.
///
/// This SSA building module allows you to def and use variables on the fly while you are
/// constructing the CFG, no need for a separate SSA pass after the CFG is completed.
///
/// A basic block is said _filled_ if all the instruction that it contains have been translated,
/// and it is said _sealed_ if all of its predecessors have been declared. Only filled predecessors
/// can be declared.
pub struct SSABuilder<Variable>
where
    Variable: EntityRef,
{
    // Records for every variable and for every relevant block, the last definition of
    // the variable in the block.
    variables: EntityMap<Variable, EntityMap<Block, PackedOption<Value>>>,
    // Records the position of the basic blocks and the list of values used but not defined in the
    // block.
    blocks: PrimaryMap<Block, BlockData<Variable>>,
    // Records the basic blocks at the beginning of the `Ebb`s.
    ebb_headers: EntityMap<Ebb, PackedOption<Block>>,

    // Call and result stacks for use in the `use_var`/`predecessors_lookup` state machine.
    calls: Vec<Call>,
    results: Vec<Value>,
    // Side effects accumulated in the `use_var`/`predecessors_lookup` state machine.
    side_effects: SideEffects,
}

/// Side effects of a `use_var` or a `seal_ebb_header_block` method call.
pub struct SideEffects {
    /// When we want to append jump arguments to a `br_table` instruction, the critical edge is
    /// splitted and the newly created `Ebb`s are signaled here.
    pub split_ebbs_created: Vec<Ebb>,
    /// When a variable is used but has never been defined before (this happens in the case of
    /// unreachable code), a placeholder `iconst` or `fconst` value is added to the right `Ebb`.
    /// This field signals if it is the case and return the `Ebb` to which the initialization has
    /// been added.
    pub instructions_added_to_ebbs: Vec<Ebb>,
}

impl SideEffects {
    fn new() -> Self {
        Self {
            split_ebbs_created: Vec::new(),
            instructions_added_to_ebbs: Vec::new(),
        }
    }

    fn is_empty(&self) -> bool {
        self.split_ebbs_created.is_empty() && self.instructions_added_to_ebbs.is_empty()
    }
}

/// Describes the current position of a basic block in the control flow graph.
enum BlockData<Variable> {
    /// A block at the top of an `Ebb`.
    EbbHeader(EbbHeaderBlockData<Variable>),
    /// A block inside an `Ebb` with an unique other block as its predecessor.
    /// The block is implicitly sealed at creation.
    EbbBody { predecessor: Block },
}

impl<Variable> BlockData<Variable> {
    fn add_predecessor(&mut self, pred: Block, inst: Inst) {
        match *self {
            BlockData::EbbBody { .. } => panic!("you can't add a predecessor to a body block"),
            BlockData::EbbHeader(ref mut data) => {
                debug_assert!(!data.sealed, "sealed blocks cannot accept new predecessors");
                data.predecessors.push((pred, inst));
            }
        }
    }
    fn remove_predecessor(&mut self, inst: Inst) -> Block {
        match *self {
            BlockData::EbbBody { .. } => panic!("should not happen"),
            BlockData::EbbHeader(ref mut data) => {
                // This a linear complexity operation but the number of predecessors is low
                // in all non-pathological cases
                let pred: usize = data.predecessors
                    .iter()
                    .position(|pair| pair.1 == inst)
                    .expect("the predecessor you are trying to remove is not declared");
                data.predecessors.swap_remove(pred).0
            }
        }
    }
}

struct EbbHeaderBlockData<Variable> {
    // The predecessors of the Ebb header block, with the block and branch instruction.
    predecessors: Vec<(Block, Inst)>,
    // A ebb header block is sealed if all of its predecessors have been declared.
    sealed: bool,
    // The ebb which this block is part of.
    ebb: Ebb,
    // List of current Ebb arguments for which an earlier def has not been found yet.
    undef_variables: Vec<(Variable, Value)>,
}

/// A opaque reference to a basic block.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub struct Block(u32);
impl EntityRef for Block {
    fn new(index: usize) -> Self {
        debug_assert!(index < (u32::MAX as usize));
        Block(index as u32)
    }

    fn index(self) -> usize {
        self.0 as usize
    }
}

impl ReservedValue for Block {
    fn reserved_value() -> Self {
        Block(u32::MAX)
    }
}

impl<Variable> SSABuilder<Variable>
where
    Variable: EntityRef,
{
    /// Allocate a new blank SSA builder struct. Use the API function to interact with the struct.
    pub fn new() -> Self {
        Self {
            variables: EntityMap::with_default(EntityMap::new()),
            blocks: PrimaryMap::new(),
            ebb_headers: EntityMap::new(),
            calls: Vec::new(),
            results: Vec::new(),
            side_effects: SideEffects::new(),
        }
    }

    /// Clears a `SSABuilder` from all its data, letting it in a pristine state without
    /// deallocating memory.
    pub fn clear(&mut self) {
        self.variables.clear();
        self.blocks.clear();
        self.ebb_headers.clear();
        debug_assert!(self.calls.is_empty());
        debug_assert!(self.results.is_empty());
        debug_assert!(self.side_effects.is_empty());
    }

    /// Tests whether an `SSABuilder` is in a cleared state.
    pub fn is_empty(&self) -> bool {
        self.variables.is_empty() && self.blocks.is_empty() && self.ebb_headers.is_empty()
            && self.calls.is_empty() && self.results.is_empty()
            && self.side_effects.is_empty()
    }
}

/// Small enum used for clarity in some functions.
#[derive(Debug)]
enum ZeroOneOrMore<T> {
    Zero(),
    One(T),
    More(),
}

#[derive(Debug)]
enum UseVarCases {
    Unsealed(Value),
    SealedOnePredecessor(Block),
    SealedMultiplePredecessors(Value, Ebb),
}

/// States for the `use_var`/`predecessors_lookup` state machine.
enum Call {
    UseVar(Block),
    FinishSealedOnePredecessor(Block),
    FinishPredecessorsLookup(Value, Ebb),
}

/// Emit instructions to produce a zero value in the given type.
fn emit_zero(ty: Type, mut cur: FuncCursor) -> Value {
    if ty.is_int() {
        cur.ins().iconst(ty, 0)
    } else if ty.is_bool() {
        cur.ins().bconst(ty, false)
    } else if ty == F32 {
        cur.ins().f32const(Ieee32::with_bits(0))
    } else if ty == F64 {
        cur.ins().f64const(Ieee64::with_bits(0))
    } else if ty.is_vector() {
        let scalar_ty = ty.lane_type();
        if scalar_ty.is_int() {
            cur.ins().iconst(ty, 0)
        } else if scalar_ty.is_bool() {
            cur.ins().bconst(ty, false)
        } else if scalar_ty == F32 {
            let scalar = cur.ins().f32const(Ieee32::with_bits(0));
            cur.ins().splat(ty, scalar)
        } else if scalar_ty == F64 {
            let scalar = cur.ins().f64const(Ieee64::with_bits(0));
            cur.ins().splat(ty, scalar)
        } else {
            panic!("unimplemented scalar type: {:?}", ty)
        }
    } else {
        panic!("unimplemented type: {:?}", ty)
    }
}
/// The following methods are the API of the SSA builder. Here is how it should be used when
/// translating to Cretonne IR:
///
/// - for each sequence of contiguous instructions (with no branches), create a corresponding
///   basic block with `declare_ebb_body_block` or `declare_ebb_header_block` depending on the
///   position of the basic block;
///
/// - while traversing a basic block and translating instruction, use `def_var` and `use_var`
///   to record definitions and uses of variables, these methods will give you the corresponding
///   SSA values;
///
/// - when all the instructions in a basic block have translated, the block is said _filled_ and
///   only then you can add it as a predecessor to other blocks with `declare_ebb_predecessor`;
///
/// - when you have constructed all the predecessor to a basic block at the beginning of an `Ebb`,
///   call `seal_ebb_header_block` on it with the `Function` that you are building.
///
/// This API will give you the correct SSA values to use as arguments of your instructions,
/// as well as modify the jump instruction and `Ebb` headers parameters to account for the SSA
/// Phi functions.
///
impl<Variable> SSABuilder<Variable>
where
    Variable: EntityRef,
{
    /// Declares a new definition of a variable in a given basic block.
    /// The SSA value is passed as an argument because it should be created with
    /// `ir::DataFlowGraph::append_result`.
    pub fn def_var(&mut self, var: Variable, val: Value, block: Block) {
        self.variables[var][block] = PackedOption::from(val);
    }

    /// Declares a use of a variable in a given basic block. Returns the SSA value corresponding
    /// to the current SSA definition of this variable and a list of newly created Ebbs that
    /// are the results of critical edge splitting for `br_table` with arguments.
    ///
    /// If the variable has never been defined in this blocks or recursively in its predecessors,
    /// this method will silently create an initializer with `iconst` or `fconst`. You are
    /// responsible for making sure that you initialize your variables.
    pub fn use_var(
        &mut self,
        func: &mut Function,
        var: Variable,
        ty: Type,
        block: Block,
    ) -> (Value, SideEffects) {
        // First we lookup for the current definition of the variable in this block
        if let Some(var_defs) = self.variables.get(var) {
            if let Some(val) = var_defs[block].expand() {
                return (val, SideEffects::new());
            }
        }

        // Otherwise, we have to do a non-local lookup.
        debug_assert!(self.calls.is_empty());
        debug_assert!(self.results.is_empty());
        debug_assert!(self.side_effects.is_empty());
        self.use_var_nonlocal(func, var, ty, block);
        (
            self.run_state_machine(func, var, ty),
            mem::replace(&mut self.side_effects, SideEffects::new()),
        )
    }

    /// Resolve a use of `var` in `block` in the case where there's no prior def
    /// in `block`.
    fn use_var_nonlocal(&mut self, func: &mut Function, var: Variable, ty: Type, block: Block) {
        let case = match self.blocks[block] {
            BlockData::EbbHeader(ref mut data) => {
                // The block has multiple predecessors so we append an Ebb parameter that
                // will serve as a value.
                if data.sealed {
                    if data.predecessors.len() == 1 {
                        // Only one predecessor, straightforward case
                        UseVarCases::SealedOnePredecessor(data.predecessors[0].0)
                    } else {
                        let val = func.dfg.append_ebb_param(data.ebb, ty);
                        UseVarCases::SealedMultiplePredecessors(val, data.ebb)
                    }
                } else {
                    let val = func.dfg.append_ebb_param(data.ebb, ty);
                    data.undef_variables.push((var, val));
                    UseVarCases::Unsealed(val)
                }
            }
            BlockData::EbbBody { predecessor: pred } => UseVarCases::SealedOnePredecessor(pred),
        };
        match case {
            // The block has a single predecessor, we look into it.
            UseVarCases::SealedOnePredecessor(pred) => {
                self.calls.push(Call::FinishSealedOnePredecessor(block));
                self.calls.push(Call::UseVar(pred));
            }
            // The block has multiple predecessors, we register the EBB parameter as the current
            // definition for the variable.
            UseVarCases::Unsealed(val) => {
                self.def_var(var, val, block);
                self.results.push(val);
            }
            UseVarCases::SealedMultiplePredecessors(val, ebb) => {
                // If multiple predecessor we look up a use_var in each of them:
                // if they all yield the same value no need for an EBB parameter
                self.def_var(var, val, block);
                self.begin_predecessors_lookup(val, ebb);
            }
        }
    }

    /// For blocks with a single predecessor, once we've determined the value,
    /// record a local def for it for future queries to find.
    fn finish_sealed_one_predecessor(&mut self, var: Variable, block: Block) {
        let val = *self.results.last().unwrap();
        self.def_var(var, val, block);
    }

    /// Declares a new basic block belonging to the body of a certain `Ebb` and having `pred`
    /// as a predecessor. `pred` is the only predecessor of the block and the block is sealed
    /// at creation.
    ///
    /// To declare a `Ebb` header block, see `declare_ebb_header_block`.
    pub fn declare_ebb_body_block(&mut self, pred: Block) -> Block {
        self.blocks.push(BlockData::EbbBody { predecessor: pred })
    }

    /// Declares a new basic block at the beginning of an `Ebb`. No predecessors are declared
    /// here and the block is not sealed.
    /// Predecessors have to be added with `declare_ebb_predecessor`.
    pub fn declare_ebb_header_block(&mut self, ebb: Ebb) -> Block {
        let block = self.blocks.push(BlockData::EbbHeader(EbbHeaderBlockData {
            predecessors: Vec::new(),
            sealed: false,
            ebb,
            undef_variables: Vec::new(),
        }));
        self.ebb_headers[ebb] = block.into();
        block
    }
    /// Gets the header block corresponding to an Ebb, panics if the Ebb or the header block
    /// isn't declared.
    pub fn header_block(&self, ebb: Ebb) -> Block {
        self.ebb_headers
            .get(ebb)
            .expect("the ebb has not been declared")
            .expand()
            .expect("the header block has not been defined")
    }

    /// Declares a new predecessor for an `Ebb` header block and record the branch instruction
    /// of the predecessor that leads to it.
    ///
    /// Note that the predecessor is a `Block` and not an `Ebb`. This `Block` must be filled
    /// before added as predecessor. Note that you must provide no jump arguments to the branch
    /// instruction when you create it since `SSABuilder` will fill them for you.
    ///
    /// Callers are expected to avoid adding the same predecessor more than once in the case
    /// of a jump table.
    pub fn declare_ebb_predecessor(&mut self, ebb: Ebb, pred: Block, inst: Inst) {
        debug_assert!(!self.is_sealed(ebb));
        let header_block = self.header_block(ebb);
        self.blocks[header_block].add_predecessor(pred, inst)
    }

    /// Remove a previously declared Ebb predecessor by giving a reference to the jump
    /// instruction. Returns the basic block containing the instruction.
    ///
    /// Note: use only when you know what you are doing, this might break the SSA building problem
    pub fn remove_ebb_predecessor(&mut self, ebb: Ebb, inst: Inst) -> Block {
        debug_assert!(!self.is_sealed(ebb));
        let header_block = self.header_block(ebb);
        self.blocks[header_block].remove_predecessor(inst)
    }

    /// Completes the global value numbering for an `Ebb`, all of its predecessors having been
    /// already sealed.
    ///
    /// This method modifies the function's `Layout` by adding arguments to the `Ebb`s to
    /// take into account the Phi function placed by the SSA algorithm.
    ///
    /// Returns the list of newly created ebbs for critical edge splitting.
    pub fn seal_ebb_header_block(&mut self, ebb: Ebb, func: &mut Function) -> SideEffects {
        self.seal_one_ebb_header_block(ebb, func);
        mem::replace(&mut self.side_effects, SideEffects::new())
    }

    /// Completes the global value numbering for all `Ebb`s in `func`.
    ///
    /// It's more efficient to seal `Ebb`s as soon as possible, during
    /// translation, but for frontends where this is impractical to do, this
    /// function can be used at the end of translating all blocks to ensure
    /// that everything is sealed.
    pub fn seal_all_ebb_header_blocks(&mut self, func: &mut Function) -> SideEffects {
        // Seal all `Ebb`s currently in the function. This can entail splitting
        // and creation of new blocks, however such new blocks are sealed on
        // the fly, so we don't need to account for them here.
        for ebb in self.ebb_headers.keys() {
            self.seal_one_ebb_header_block(ebb, func);
        }
        mem::replace(&mut self.side_effects, SideEffects::new())
    }

    /// Helper function for `seal_ebb_header_block` and
    /// `seal_all_ebb_header_blocks`.
    fn seal_one_ebb_header_block(&mut self, ebb: Ebb, func: &mut Function) {
        let block = self.header_block(ebb);

        let (undef_vars, ebb): (Vec<(Variable, Value)>, Ebb) = match self.blocks[block] {
            BlockData::EbbBody { .. } => panic!("this should not happen"),
            BlockData::EbbHeader(ref mut data) => {
                debug_assert!(!data.sealed);
                // Extract the undef_variables data from the block so that we
                // can iterate over it without borrowing the whole builder.
                let undef_variables = mem::replace(&mut data.undef_variables, Vec::new());
                (undef_variables, data.ebb)
            }
        };

        // For each undef var we look up values in the predecessors and create an EBB parameter
        // only if necessary.
        for (var, val) in undef_vars {
            let ty = func.dfg.value_type(val);
            self.predecessors_lookup(func, val, var, ty, ebb);
        }
        self.mark_ebb_header_block_sealed(block);
    }

    /// Set the `sealed` flag for `block`.
    fn mark_ebb_header_block_sealed(&mut self, block: Block) {
        // Then we mark the block as sealed.
        match self.blocks[block] {
            BlockData::EbbBody { .. } => panic!("this should not happen"),
            BlockData::EbbHeader(ref mut data) => {
                debug_assert!(!data.sealed);
                debug_assert!(data.undef_variables.is_empty());
                data.sealed = true;
                // We could call data.predecessors.shrink_to_fit() here, if
                // important, because no further predecessors will be added
                // to this block.
            }
        }
    }

    /// Look up in the predecessors of an Ebb the def for a value an decides whether or not
    /// to keep the eeb arg, and act accordingly. Returns the chosen value and optionally a
    /// list of Ebb that are the middle of newly created critical edges splits.
    fn predecessors_lookup(
        &mut self,
        func: &mut Function,
        temp_arg_val: Value,
        temp_arg_var: Variable,
        ty: Type,
        dest_ebb: Ebb,
    ) -> Value {
        debug_assert!(self.calls.is_empty());
        debug_assert!(self.results.is_empty());
        // self.side_effects may be non-empty here so that callers can
        // accumulate side effects over multiple calls.
        self.begin_predecessors_lookup(temp_arg_val, dest_ebb);
        self.run_state_machine(func, temp_arg_var, ty)
    }

    /// Initiate use lookups in all predecessors of `dest_ebb`, and arrange for a call
    /// to `finish_predecessors_lookup` once they complete.
    fn begin_predecessors_lookup(&mut self, temp_arg_val: Value, dest_ebb: Ebb) {
        self.calls
            .push(Call::FinishPredecessorsLookup(temp_arg_val, dest_ebb));
        // Iterate over the predecessors.
        let mut calls = mem::replace(&mut self.calls, Vec::new());
        calls.extend(
            self.predecessors(dest_ebb)
                .iter()
                .rev()
                .map(|&(pred, _)| Call::UseVar(pred)),
        );
        self.calls = calls;
    }

    /// Examine the values from the predecessors and compute a result value, creating
    /// block parameters as needed.
    fn finish_predecessors_lookup(
        &mut self,
        func: &mut Function,
        temp_arg_val: Value,
        temp_arg_var: Variable,
        dest_ebb: Ebb,
    ) {
        let mut pred_values: ZeroOneOrMore<Value> = ZeroOneOrMore::Zero();

        // Iterate over the predecessors.
        for _ in 0..self.predecessors(dest_ebb).len() {
            // For each predecessor, we query what is the local SSA value corresponding
            // to var and we put it as an argument of the branch instruction.
            let pred_val = self.results.pop().unwrap();
            match pred_values {
                ZeroOneOrMore::Zero() => {
                    if pred_val != temp_arg_val {
                        pred_values = ZeroOneOrMore::One(pred_val);
                    }
                }
                ZeroOneOrMore::One(old_val) => {
                    if pred_val != temp_arg_val && pred_val != old_val {
                        pred_values = ZeroOneOrMore::More();
                    }
                }
                ZeroOneOrMore::More() => {}
            }
        }
        let result_val = match pred_values {
            ZeroOneOrMore::Zero() => {
                // The variable is used but never defined before. This is an irregularity in the
                // code, but rather than throwing an error we silently initialize the variable to
                // 0. This will have no effect since this situation happens in unreachable code.
                if !func.layout.is_ebb_inserted(dest_ebb) {
                    func.layout.append_ebb(dest_ebb);
                }
                self.side_effects.instructions_added_to_ebbs.push(dest_ebb);
                let zero = emit_zero(
                    func.dfg.value_type(temp_arg_val),
                    FuncCursor::new(func).at_first_insertion_point(dest_ebb),
                );
                func.dfg.remove_ebb_param(temp_arg_val);
                func.dfg.change_to_alias(temp_arg_val, zero);
                zero
            }
            ZeroOneOrMore::One(pred_val) => {
                // Here all the predecessors use a single value to represent our variable
                // so we don't need to have it as an ebb argument.
                // We need to replace all the occurrences of val with pred_val but since
                // we can't afford a re-writing pass right now we just declare an alias.
                // Resolve aliases eagerly so that we can check for cyclic aliasing,
                // which can occur in unreachable code.
                let mut resolved = func.dfg.resolve_aliases(pred_val);
                if temp_arg_val == resolved {
                    // Cycle detected. Break it by creating a zero value.
                    resolved = emit_zero(
                        func.dfg.value_type(temp_arg_val),
                        FuncCursor::new(func).at_first_insertion_point(dest_ebb),
                    );
                }
                func.dfg.remove_ebb_param(temp_arg_val);
                func.dfg.change_to_alias(temp_arg_val, resolved);
                resolved
            }
            ZeroOneOrMore::More() => {
                // There is disagreement in the predecessors on which value to use so we have
                // to keep the ebb argument. To avoid borrowing `self` for the whole loop,
                // temporarily detach the predecessors list and replace it with an empty list.
                let mut preds = mem::replace(self.predecessors_mut(dest_ebb), Vec::new());
                for &mut (ref mut pred_block, ref mut last_inst) in &mut preds {
                    // We already did a full `use_var` above, so we can do just the fast path.
                    let pred_val = self.variables
                        .get(temp_arg_var)
                        .unwrap()
                        .get(*pred_block)
                        .unwrap()
                        .unwrap();
                    let jump_arg = self.append_jump_argument(
                        func,
                        *last_inst,
                        *pred_block,
                        dest_ebb,
                        pred_val,
                        temp_arg_var,
                    );
                    if let Some((middle_ebb, middle_block, middle_jump_inst)) = jump_arg {
                        *pred_block = middle_block;
                        *last_inst = middle_jump_inst;
                        self.side_effects.split_ebbs_created.push(middle_ebb);
                    }
                }
                // Now that we're done, move the predecessors list back.
                debug_assert!(self.predecessors(dest_ebb).is_empty());
                *self.predecessors_mut(dest_ebb) = preds;

                temp_arg_val
            }
        };

        self.results.push(result_val);
    }

    /// Appends a jump argument to a jump instruction, returns ebb created in case of
    /// critical edge splitting.
    fn append_jump_argument(
        &mut self,
        func: &mut Function,
        jump_inst: Inst,
        jump_inst_block: Block,
        dest_ebb: Ebb,
        val: Value,
        var: Variable,
    ) -> Option<(Ebb, Block, Inst)> {
        match func.dfg.analyze_branch(jump_inst) {
            BranchInfo::NotABranch => {
                panic!("you have declared a non-branch instruction as a predecessor to an ebb");
            }
            // For a single destination appending a jump argument to the instruction
            // is sufficient.
            BranchInfo::SingleDest(_, _) => {
                func.dfg.append_inst_arg(jump_inst, val);
                None
            }
            BranchInfo::Table(jt) => {
                // In the case of a jump table, the situation is tricky because br_table doesn't
                // support arguments.
                // We have to split the critical edge
                let middle_ebb = func.dfg.make_ebb();
                func.layout.append_ebb(middle_ebb);
                let middle_block = self.declare_ebb_header_block(middle_ebb);
                self.blocks[middle_block].add_predecessor(jump_inst_block, jump_inst);
                self.mark_ebb_header_block_sealed(middle_block);
                for old_dest in func.jump_tables[jt].as_mut_slice() {
                    if old_dest.unwrap() == dest_ebb {
                        *old_dest = PackedOption::from(middle_ebb);
                    }
                }
                let mut cur = FuncCursor::new(func).at_bottom(middle_ebb);
                let middle_jump_inst = cur.ins().jump(dest_ebb, &[val]);
                self.def_var(var, val, middle_block);
                Some((middle_ebb, middle_block, middle_jump_inst))
            }
        }
    }

    /// Returns the list of `Ebb`s that have been declared as predecessors of the argument.
    pub fn predecessors(&self, ebb: Ebb) -> &[(Block, Inst)] {
        let block = self.header_block(ebb);
        match self.blocks[block] {
            BlockData::EbbBody { .. } => panic!("should not happen"),
            BlockData::EbbHeader(ref data) => &data.predecessors,
        }
    }

    /// Same as predecessors, but for &mut.
    pub fn predecessors_mut(&mut self, ebb: Ebb) -> &mut Vec<(Block, Inst)> {
        let block = self.header_block(ebb);
        match self.blocks[block] {
            BlockData::EbbBody { .. } => panic!("should not happen"),
            BlockData::EbbHeader(ref mut data) => &mut data.predecessors,
        }
    }

    /// Returns `true` if and only if `seal_ebb_header_block` has been called on the argument.
    pub fn is_sealed(&self, ebb: Ebb) -> bool {
        match self.blocks[self.header_block(ebb)] {
            BlockData::EbbBody { .. } => panic!("should not happen"),
            BlockData::EbbHeader(ref data) => data.sealed,
        }
    }

    /// The main algorithm is naturally recursive: when there's a `use_var` in a
    /// block with no corresponding local defs, it recurses and performs a
    /// `use_var` in each predecessor. To avoid risking running out of callstack
    /// space, we keep an explicit stack and use a small state machine rather
    /// than literal recursion.
    fn run_state_machine(&mut self, func: &mut Function, var: Variable, ty: Type) -> Value {
        // Process the calls scheduled in `self.calls` until it is empty.
        while let Some(call) = self.calls.pop() {
            match call {
                Call::UseVar(block) => {
                    // First we lookup for the current definition of the variable in this block
                    if let Some(var_defs) = self.variables.get(var) {
                        if let Some(val) = var_defs[block].expand() {
                            self.results.push(val);
                            continue;
                        }
                    }
                    self.use_var_nonlocal(func, var, ty, block);
                }
                Call::FinishSealedOnePredecessor(block) => {
                    self.finish_sealed_one_predecessor(var, block);
                }
                Call::FinishPredecessorsLookup(temp_arg_val, dest_ebb) => {
                    self.finish_predecessors_lookup(func, temp_arg_val, var, dest_ebb);
                }
            }
        }
        debug_assert_eq!(self.results.len(), 1);
        self.results.pop().unwrap()
    }
}

#[cfg(test)]
mod tests {
    use cretonne_codegen::cursor::{Cursor, FuncCursor};
    use cretonne_codegen::entity::EntityRef;
    use cretonne_codegen::ir::instructions::BranchInfo;
    use cretonne_codegen::ir::types::*;
    use cretonne_codegen::ir::{Function, Inst, InstBuilder, JumpTableData, Opcode};
    use cretonne_codegen::settings;
    use cretonne_codegen::verify_function;
    use ssa::SSABuilder;
    use Variable;

    #[test]
    fn simple_block() {
        let mut func = Function::new();
        let mut ssa: SSABuilder<Variable> = SSABuilder::new();
        let ebb0 = func.dfg.make_ebb();
        // Here is the pseudo-program we want to translate:
        // x = 1;
        // y = 2;
        // z = x + y;
        // z = x + z;

        let block = ssa.declare_ebb_header_block(ebb0);
        let x_var = Variable::new(0);
        let x_ssa = {
            let mut cur = FuncCursor::new(&mut func);
            cur.insert_ebb(ebb0);
            cur.ins().iconst(I32, 1)
        };
        ssa.def_var(x_var, x_ssa, block);
        let y_var = Variable::new(1);
        let y_ssa = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb0);
            cur.ins().iconst(I32, 2)
        };
        ssa.def_var(y_var, y_ssa, block);

        assert_eq!(ssa.use_var(&mut func, x_var, I32, block).0, x_ssa);
        assert_eq!(ssa.use_var(&mut func, y_var, I32, block).0, y_ssa);
        let z_var = Variable::new(2);
        let x_use1 = ssa.use_var(&mut func, x_var, I32, block).0;
        let y_use1 = ssa.use_var(&mut func, y_var, I32, block).0;
        let z1_ssa = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb0);
            cur.ins().iadd(x_use1, y_use1)
        };
        ssa.def_var(z_var, z1_ssa, block);
        assert_eq!(ssa.use_var(&mut func, z_var, I32, block).0, z1_ssa);
        let x_use2 = ssa.use_var(&mut func, x_var, I32, block).0;
        let z_use1 = ssa.use_var(&mut func, z_var, I32, block).0;
        let z2_ssa = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb0);
            cur.ins().iadd(x_use2, z_use1)
        };
        ssa.def_var(z_var, z2_ssa, block);
        assert_eq!(ssa.use_var(&mut func, z_var, I32, block).0, z2_ssa);
    }

    #[test]
    fn sequence_of_blocks() {
        let mut func = Function::new();
        let mut ssa: SSABuilder<Variable> = SSABuilder::new();
        let ebb0 = func.dfg.make_ebb();
        let ebb1 = func.dfg.make_ebb();
        // Here is the pseudo-program we want to translate:
        // ebb0:
        //    x = 1;
        //    y = 2;
        //    z = x + y;
        //    brnz y, ebb1;
        //    z = x + z;
        // ebb1:
        //    y = x + y;

        let block0 = ssa.declare_ebb_header_block(ebb0);
        let x_var = Variable::new(0);
        let x_ssa = {
            let mut cur = FuncCursor::new(&mut func);
            cur.insert_ebb(ebb0);
            cur.insert_ebb(ebb1);
            cur.goto_bottom(ebb0);
            cur.ins().iconst(I32, 1)
        };
        ssa.def_var(x_var, x_ssa, block0);
        let y_var = Variable::new(1);
        let y_ssa = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb0);
            cur.ins().iconst(I32, 2)
        };
        ssa.def_var(y_var, y_ssa, block0);
        assert_eq!(ssa.use_var(&mut func, x_var, I32, block0).0, x_ssa);
        assert_eq!(ssa.use_var(&mut func, y_var, I32, block0).0, y_ssa);
        let z_var = Variable::new(2);
        let x_use1 = ssa.use_var(&mut func, x_var, I32, block0).0;
        let y_use1 = ssa.use_var(&mut func, y_var, I32, block0).0;
        let z1_ssa = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb0);
            cur.ins().iadd(x_use1, y_use1)
        };
        ssa.def_var(z_var, z1_ssa, block0);
        assert_eq!(ssa.use_var(&mut func, z_var, I32, block0).0, z1_ssa);
        let y_use2 = ssa.use_var(&mut func, y_var, I32, block0).0;
        let jump_inst: Inst = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb0);
            cur.ins().brnz(y_use2, ebb1, &[])
        };
        let block1 = ssa.declare_ebb_body_block(block0);
        let x_use2 = ssa.use_var(&mut func, x_var, I32, block1).0;
        assert_eq!(x_use2, x_ssa);
        let z_use1 = ssa.use_var(&mut func, z_var, I32, block1).0;
        assert_eq!(z_use1, z1_ssa);
        let z2_ssa = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb0);
            cur.ins().iadd(x_use2, z_use1)
        };
        ssa.def_var(z_var, z2_ssa, block1);
        assert_eq!(ssa.use_var(&mut func, z_var, I32, block1).0, z2_ssa);
        ssa.seal_ebb_header_block(ebb0, &mut func);
        let block2 = ssa.declare_ebb_header_block(ebb1);
        ssa.declare_ebb_predecessor(ebb1, block0, jump_inst);
        ssa.seal_ebb_header_block(ebb1, &mut func);
        let x_use3 = ssa.use_var(&mut func, x_var, I32, block2).0;
        assert_eq!(x_ssa, x_use3);
        let y_use3 = ssa.use_var(&mut func, y_var, I32, block2).0;
        assert_eq!(y_ssa, y_use3);
        let y2_ssa = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb0);
            cur.ins().iadd(x_use3, y_use3)
        };
        ssa.def_var(y_var, y2_ssa, block2);
        match func.dfg.analyze_branch(jump_inst) {
            BranchInfo::SingleDest(dest, jump_args) => {
                assert_eq!(dest, ebb1);
                assert_eq!(jump_args.len(), 0);
            }
            _ => assert!(false),
        };
    }

    #[test]
    fn program_with_loop() {
        let mut func = Function::new();
        let mut ssa: SSABuilder<Variable> = SSABuilder::new();
        let ebb0 = func.dfg.make_ebb();
        let ebb1 = func.dfg.make_ebb();
        let ebb2 = func.dfg.make_ebb();
        // Here is the pseudo-program we want to translate:
        // ebb0:
        //    x = 1;
        //    y = 2;
        //    z = x + y;
        //    jump ebb1
        // ebb1:
        //    z = z + y;
        //    brnz y, ebb1;
        //    z = z - x;
        //    return y
        // ebb2:
        //    y = y - x
        //    jump ebb1

        let block0 = ssa.declare_ebb_header_block(ebb0);
        ssa.seal_ebb_header_block(ebb0, &mut func);
        let x_var = Variable::new(0);
        let x1 = {
            let mut cur = FuncCursor::new(&mut func);
            cur.insert_ebb(ebb0);
            cur.insert_ebb(ebb1);
            cur.insert_ebb(ebb2);
            cur.goto_bottom(ebb0);
            cur.ins().iconst(I32, 1)
        };
        ssa.def_var(x_var, x1, block0);
        assert_eq!(ssa.use_var(&mut func, x_var, I32, block0).0, x1);
        let y_var = Variable::new(1);
        let y1 = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb0);
            cur.ins().iconst(I32, 2)
        };
        ssa.def_var(y_var, y1, block0);
        assert_eq!(ssa.use_var(&mut func, y_var, I32, block0).0, y1);
        let z_var = Variable::new(2);
        let x2 = ssa.use_var(&mut func, x_var, I32, block0).0;
        assert_eq!(x2, x1);
        let y2 = ssa.use_var(&mut func, y_var, I32, block0).0;
        assert_eq!(y2, y1);
        let z1 = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb0);
            cur.ins().iadd(x2, y2)
        };
        ssa.def_var(z_var, z1, block0);
        let jump_ebb0_ebb1 = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb0);
            cur.ins().jump(ebb1, &[])
        };
        let block1 = ssa.declare_ebb_header_block(ebb1);
        ssa.declare_ebb_predecessor(ebb1, block0, jump_ebb0_ebb1);
        let z2 = ssa.use_var(&mut func, z_var, I32, block1).0;
        let y3 = ssa.use_var(&mut func, y_var, I32, block1).0;
        let z3 = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb1);
            cur.ins().iadd(z2, y3)
        };
        ssa.def_var(z_var, z3, block1);
        let y4 = ssa.use_var(&mut func, y_var, I32, block1).0;
        assert_eq!(y4, y3);
        let jump_ebb1_ebb2 = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb1);
            cur.ins().brnz(y4, ebb2, &[])
        };
        let block2 = ssa.declare_ebb_body_block(block1);
        let z4 = ssa.use_var(&mut func, z_var, I32, block2).0;
        assert_eq!(z4, z3);
        let x3 = ssa.use_var(&mut func, x_var, I32, block2).0;
        let z5 = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb1);
            cur.ins().isub(z4, x3)
        };
        ssa.def_var(z_var, z5, block2);
        let y5 = ssa.use_var(&mut func, y_var, I32, block2).0;
        assert_eq!(y5, y3);
        {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb1);
            cur.ins().return_(&[y5])
        };

        let block3 = ssa.declare_ebb_header_block(ebb2);
        ssa.declare_ebb_predecessor(ebb2, block1, jump_ebb1_ebb2);
        ssa.seal_ebb_header_block(ebb2, &mut func);
        let y6 = ssa.use_var(&mut func, y_var, I32, block3).0;
        assert_eq!(y6, y3);
        let x4 = ssa.use_var(&mut func, x_var, I32, block3).0;
        assert_eq!(x4, x3);
        let y7 = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb2);
            cur.ins().isub(y6, x4)
        };
        ssa.def_var(y_var, y7, block3);
        let jump_ebb2_ebb1 = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb2);
            cur.ins().jump(ebb1, &[])
        };

        ssa.declare_ebb_predecessor(ebb1, block3, jump_ebb2_ebb1);
        ssa.seal_ebb_header_block(ebb1, &mut func);
        assert_eq!(func.dfg.ebb_params(ebb1)[0], z2);
        assert_eq!(func.dfg.ebb_params(ebb1)[1], y3);
        assert_eq!(func.dfg.resolve_aliases(x3), x1);
    }

    #[test]
    fn br_table_with_args() {
        // This tests the on-demand splitting of critical edges for br_table with jump arguments
        let mut func = Function::new();
        let mut ssa: SSABuilder<Variable> = SSABuilder::new();
        let ebb0 = func.dfg.make_ebb();
        let ebb1 = func.dfg.make_ebb();
        // Here is the pseudo-program we want to translate:
        // ebb0:
        //    x = 0;
        //    br_table x ebb1
        //    x = 1
        //    jump ebb1
        // ebb1:
        //    x = x + 1
        //    return
        //
        let block0 = ssa.declare_ebb_header_block(ebb0);
        ssa.seal_ebb_header_block(ebb0, &mut func);
        let x_var = Variable::new(0);
        let x1 = {
            let mut cur = FuncCursor::new(&mut func);
            cur.insert_ebb(ebb0);
            cur.insert_ebb(ebb1);
            cur.goto_bottom(ebb0);
            cur.ins().iconst(I32, 1)
        };
        ssa.def_var(x_var, x1, block0);
        let mut data = JumpTableData::new();
        data.push_entry(ebb1);
        let jt = func.create_jump_table(data);
        ssa.use_var(&mut func, x_var, I32, block0).0;
        let br_table = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb0);
            cur.ins().br_table(x1, jt)
        };
        let block1 = ssa.declare_ebb_body_block(block0);
        let x3 = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb0);
            cur.ins().iconst(I32, 2)
        };
        ssa.def_var(x_var, x3, block1);
        let jump_inst = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb0);
            cur.ins().jump(ebb1, &[])
        };
        let block2 = ssa.declare_ebb_header_block(ebb1);
        ssa.declare_ebb_predecessor(ebb1, block1, jump_inst);
        ssa.declare_ebb_predecessor(ebb1, block0, br_table);
        ssa.seal_ebb_header_block(ebb1, &mut func);
        let x4 = ssa.use_var(&mut func, x_var, I32, block2).0;
        {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb1);
            cur.ins().iadd_imm(x4, 1)
        };
        {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb1);
            cur.ins().return_(&[])
        };
        let flags = settings::Flags::new(settings::builder());
        match verify_function(&func, &flags) {
            Ok(()) => {}
            Err(_err) => {
                #[cfg(feature = "std")]
                panic!(_err.message);
                #[cfg(not(feature = "std"))]
                panic!("function failed to verify");
            }
        }
    }

    #[test]
    fn undef_values_reordering() {
        let mut func = Function::new();
        let mut ssa: SSABuilder<Variable> = SSABuilder::new();
        let ebb0 = func.dfg.make_ebb();
        let ebb1 = func.dfg.make_ebb();
        // Here is the pseudo-program we want to translate:
        // ebb0:
        //    x = 0
        //    y = 1
        //    z = 2
        //    jump ebb1
        // ebb1:
        //    x = z + x
        //    y = y - x
        //    jump ebb1
        //
        let block0 = ssa.declare_ebb_header_block(ebb0);
        let x_var = Variable::new(0);
        let y_var = Variable::new(1);
        let z_var = Variable::new(2);
        ssa.seal_ebb_header_block(ebb0, &mut func);
        let x1 = {
            let mut cur = FuncCursor::new(&mut func);
            cur.insert_ebb(ebb0);
            cur.insert_ebb(ebb1);
            cur.goto_bottom(ebb0);
            cur.ins().iconst(I32, 0)
        };
        ssa.def_var(x_var, x1, block0);
        let y1 = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb0);
            cur.ins().iconst(I32, 1)
        };
        ssa.def_var(y_var, y1, block0);
        let z1 = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb0);
            cur.ins().iconst(I32, 2)
        };
        ssa.def_var(z_var, z1, block0);
        let jump_inst = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb0);
            cur.ins().jump(ebb1, &[])
        };
        let block1 = ssa.declare_ebb_header_block(ebb1);
        ssa.declare_ebb_predecessor(ebb1, block0, jump_inst);
        let z2 = ssa.use_var(&mut func, z_var, I32, block1).0;
        assert_eq!(func.dfg.ebb_params(ebb1)[0], z2);
        let x2 = ssa.use_var(&mut func, x_var, I32, block1).0;
        assert_eq!(func.dfg.ebb_params(ebb1)[1], x2);
        let x3 = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb1);
            cur.ins().iadd(x2, z2)
        };
        ssa.def_var(x_var, x3, block1);
        let x4 = ssa.use_var(&mut func, x_var, I32, block1).0;
        let y3 = ssa.use_var(&mut func, y_var, I32, block1).0;
        assert_eq!(func.dfg.ebb_params(ebb1)[2], y3);
        let y4 = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb1);
            cur.ins().isub(y3, x4)
        };
        ssa.def_var(y_var, y4, block1);
        let jump_inst = {
            let mut cur = FuncCursor::new(&mut func).at_bottom(ebb1);
            cur.ins().jump(ebb1, &[])
        };
        ssa.declare_ebb_predecessor(ebb1, block1, jump_inst);
        ssa.seal_ebb_header_block(ebb1, &mut func);
        // At sealing the "z" argument disappear but the remaining "x" and "y" args have to be
        // in the right order.
        assert_eq!(func.dfg.ebb_params(ebb1)[1], y3);
        assert_eq!(func.dfg.ebb_params(ebb1)[0], x2);
    }

    #[test]
    fn undef() {
        // Use vars of various types which have not been defined.
        let mut func = Function::new();
        let mut ssa: SSABuilder<Variable> = SSABuilder::new();
        let ebb0 = func.dfg.make_ebb();
        let block = ssa.declare_ebb_header_block(ebb0);
        ssa.seal_ebb_header_block(ebb0, &mut func);
        let i32_var = Variable::new(0);
        let f32_var = Variable::new(1);
        let f64_var = Variable::new(2);
        let b1_var = Variable::new(3);
        let f32x4_var = Variable::new(4);
        ssa.use_var(&mut func, i32_var, I32, block);
        ssa.use_var(&mut func, f32_var, F32, block);
        ssa.use_var(&mut func, f64_var, F64, block);
        ssa.use_var(&mut func, b1_var, B1, block);
        ssa.use_var(&mut func, f32x4_var, F32X4, block);
        assert_eq!(func.dfg.num_ebb_params(ebb0), 0);
    }

    #[test]
    fn undef_in_entry() {
        // Use a var which has not been defined. The search should hit the
        // top of the entry block, and then fall back to inserting an iconst.
        let mut func = Function::new();
        let mut ssa: SSABuilder<Variable> = SSABuilder::new();
        let ebb0 = func.dfg.make_ebb();
        let block = ssa.declare_ebb_header_block(ebb0);
        ssa.seal_ebb_header_block(ebb0, &mut func);
        let x_var = Variable::new(0);
        assert_eq!(func.dfg.num_ebb_params(ebb0), 0);
        ssa.use_var(&mut func, x_var, I32, block);
        assert_eq!(func.dfg.num_ebb_params(ebb0), 0);
        assert_eq!(
            func.dfg[func.layout.first_inst(ebb0).unwrap()].opcode(),
            Opcode::Iconst
        );
    }

    #[test]
    fn undef_in_entry_sealed_after() {
        // Use a var which has not been defined, but the block is not sealed
        // until afterward. Before sealing, the SSA builder should insert an
        // ebb param; after sealing, it should be removed.
        let mut func = Function::new();
        let mut ssa: SSABuilder<Variable> = SSABuilder::new();
        let ebb0 = func.dfg.make_ebb();
        let block = ssa.declare_ebb_header_block(ebb0);
        let x_var = Variable::new(0);
        assert_eq!(func.dfg.num_ebb_params(ebb0), 0);
        ssa.use_var(&mut func, x_var, I32, block);
        assert_eq!(func.dfg.num_ebb_params(ebb0), 1);
        ssa.seal_ebb_header_block(ebb0, &mut func);
        assert_eq!(func.dfg.num_ebb_params(ebb0), 0);
        assert_eq!(
            func.dfg[func.layout.first_inst(ebb0).unwrap()].opcode(),
            Opcode::Iconst
        );
    }

    #[test]
    fn unreachable_use() {
        let mut func = Function::new();
        let mut ssa: SSABuilder<Variable> = SSABuilder::new();
        let ebb0 = func.dfg.make_ebb();
        let ebb1 = func.dfg.make_ebb();
        // Here is the pseudo-program we want to translate:
        // ebb0:
        //    return
        // ebb1:
        //    brz v1, ebb1
        //    jump ebb1
        let _block0 = ssa.declare_ebb_header_block(ebb0);
        ssa.seal_ebb_header_block(ebb0, &mut func);
        let block1 = ssa.declare_ebb_header_block(ebb1);
        let block2 = ssa.declare_ebb_body_block(block1);
        {
            let mut cur = FuncCursor::new(&mut func);
            cur.insert_ebb(ebb0);
            cur.insert_ebb(ebb1);
            cur.goto_bottom(ebb0);
            cur.ins().return_(&[]);
            let x_var = Variable::new(0);
            cur.goto_bottom(ebb1);
            let val = ssa.use_var(&mut cur.func, x_var, I32, block1).0;
            let brz = cur.ins().brz(val, ebb1, &[]);
            ssa.declare_ebb_predecessor(ebb1, block1, brz);
            let j = cur.ins().jump(ebb1, &[]);
            ssa.declare_ebb_predecessor(ebb1, block2, j);
        }
        ssa.seal_ebb_header_block(ebb1, &mut func);
        let flags = settings::Flags::new(settings::builder());
        match verify_function(&func, &flags) {
            Ok(()) => {}
            Err(_err) => {
                #[cfg(feature = "std")]
                panic!(_err.message);
                #[cfg(not(feature = "std"))]
                panic!("function failed to verify");
            }
        }
    }

    #[test]
    fn unreachable_use_with_multiple_preds() {
        let mut func = Function::new();
        let mut ssa: SSABuilder<Variable> = SSABuilder::new();
        let ebb0 = func.dfg.make_ebb();
        let ebb1 = func.dfg.make_ebb();
        let ebb2 = func.dfg.make_ebb();
        // Here is the pseudo-program we want to translate:
        // ebb0:
        //    return
        // ebb1:
        //    brz v1, ebb2
        //    jump ebb1
        // ebb2:
        //    jump ebb1
        let _block0 = ssa.declare_ebb_header_block(ebb0);
        ssa.seal_ebb_header_block(ebb0, &mut func);
        let block1 = ssa.declare_ebb_header_block(ebb1);
        let block2 = ssa.declare_ebb_header_block(ebb2);
        {
            let mut cur = FuncCursor::new(&mut func);
            let x_var = Variable::new(0);
            cur.insert_ebb(ebb0);
            cur.insert_ebb(ebb1);
            cur.insert_ebb(ebb2);
            cur.goto_bottom(ebb0);
            cur.ins().return_(&[]);
            cur.goto_bottom(ebb1);
            let v = ssa.use_var(&mut cur.func, x_var, I32, block1).0;
            let brz = cur.ins().brz(v, ebb2, &[]);
            let j0 = cur.ins().jump(ebb1, &[]);
            cur.goto_bottom(ebb2);
            let j1 = cur.ins().jump(ebb1, &[]);
            ssa.declare_ebb_predecessor(ebb1, block2, brz);
            ssa.declare_ebb_predecessor(ebb1, block1, j0);
            ssa.declare_ebb_predecessor(ebb2, block1, j1);
        }
        ssa.seal_ebb_header_block(ebb1, &mut func);
        ssa.seal_ebb_header_block(ebb2, &mut func);
        let flags = settings::Flags::new(settings::builder());
        match verify_function(&func, &flags) {
            Ok(()) => {}
            Err(_err) => {
                #[cfg(feature = "std")]
                panic!(_err.message);
                #[cfg(not(feature = "std"))]
                panic!("function failed to verify");
            }
        }
    }
}