//! An ISA-independent constant pool.

use cranelift_codegen::{

    MachBuffer, VCodeConstant, VCodeConstantData, VCodeConstants, VCodeInst, ir,

};

pub(crate) struct ConstantPool {

    inner: ir::ConstantPool,

    constants: VCodeConstants,

}

impl ConstantPool {

    pub fn new() -> Self {

        Self {

            inner: ir::ConstantPool::new(),

            constants: Default::default(),

        }

    }

    /// Register a constant and return a handle, ready for emission.

    pub fn register<I: VCodeInst>(

        &mut self,

        data: &[u8],

        buffer: &mut MachBuffer<I>,

    ) -> VCodeConstant {

        let constant_handle = self.inner.insert(data.into());

        let constant_data = self.inner.get(constant_handle);

        // NB: The insertion will only happen if the pool doesn't already use the constant data.

        // The reason why the order of operations is apparently inversed is to be sure to insert

        // the `VCodeConstantData` in the `MachBuffer` only once, as no deduplication happens at

        // such layer.

        let vcode_constant_data = VCodeConstantData::Pool(constant_handle, constant_data.clone());

        let must_register = !self.constants.pool_uses(&vcode_constant_data);

        let vcode_constant = self.constants.insert(VCodeConstantData::Pool(

            constant_handle,

            constant_data.clone(),

        ));

        if must_register {

            buffer.register_constant(&vcode_constant, &vcode_constant_data);

        }

        vcode_constant

    }

    /// Get the finalized constants.

    pub fn constants(self) -> VCodeConstants {

        self.constants

    }

}