Method check_code

language/move-binary-format/src/check_bounds.rs:346–522

(
        &self,
        code_unit: &CodeUnit,
        type_parameters: &[AbilitySet],
        parameters: &Signature,
    )

    }

    fn check_code(
        &self,
        code_unit: &CodeUnit,
        type_parameters: &[AbilitySet],
        parameters: &Signature,
    ) -> PartialVMResult<()> {
        check_bounds_impl(self.view.signatures(), code_unit.locals)?;

        let locals = self.get_locals(code_unit)?;
        let locals_count = locals.len() + parameters.len();

        // if there are locals check that the type parameters in local signature are in bounds.
        let type_param_count = type_parameters.len();
        for local in locals {
            self.check_type_parameter(local, type_param_count)?
        }

        // check bytecodes
        let code_len = code_unit.code.len();
        for (bytecode_offset, bytecode) in code_unit.code.iter().enumerate() {
            use self::Bytecode::*;

            match bytecode {
                LdConst(idx) => self.check_code_unit_bounds_impl(
                    self.view.constant_pool(),
                    *idx,
                    bytecode_offset,
                )?,
                MutBorrowField(idx) | ImmBorrowField(idx) => self.check_code_unit_bounds_impl_opt(
                    &self.view.field_handles(),
                    *idx,
                    bytecode_offset,
                )?,
                MutBorrowFieldGeneric(idx) | ImmBorrowFieldGeneric(idx) => {
                    self.check_code_unit_bounds_impl_opt(
                        &self.view.field_instantiations(),
                        *idx,
                        bytecode_offset,
                    )?;
                    // check type parameters in borrow are bound to the function type parameters
                    if let Some(field_inst) = self
                        .view
                        .field_instantiations()
                        .and_then(|f| f.get(idx.into_index()))
                    {
                        if let Some(sig) = self
                            .view
                            .signatures()
                            .get(field_inst.type_parameters.into_index())
                        {
                            for ty in &sig.0 {
                                self.check_type_parameter(ty, type_param_count)?
                            }
                        }
                    }
                }
                Call(idx) => self.check_code_unit_bounds_impl(
                    self.view.function_handles(),