Function load_function_def

language/move-binary-format/src/deserializer.rs:1251–1323

Deserializes a `FunctionDefinition`.

(cursor: &mut VersionedCursor)

/// Deserializes a `FunctionDefinition`.
fn load_function_def(cursor: &mut VersionedCursor) -> BinaryLoaderResult<FunctionDefinition> {
    let function = load_function_handle_index(cursor)?;

    let mut flags = cursor.read_u8().map_err(|_| {
        PartialVMError::new(StatusCode::MALFORMED).with_message("Unexpected EOF".to_string())
    })?;

    // NOTE: changes compared with VERSION_1
    // - in VERSION_1: the flags is a byte compositing both the visibility info and whether
    //                 the function is a native function
    // - in VERSION_2 onwards: the flags only represent the visibility info and we need to
    //                 advance the cursor to read up the next byte as flags
    // - in VERSION_5 onwards: script visibility has been deprecated for an entry function flag
    let (visibility, is_entry, mut extra_flags) = if cursor.version() == VERSION_1 {
        let vis = if (flags & FunctionDefinition::DEPRECATED_PUBLIC_BIT) != 0 {
            flags ^= FunctionDefinition::DEPRECATED_PUBLIC_BIT;
            Visibility::Public
        } else {
            Visibility::Private
        };
        (vis, false, flags)
    } else if cursor.version() < VERSION_5 {
        let (vis, is_entry) = if flags == Visibility::DEPRECATED_SCRIPT {
            (Visibility::Public, true)
        } else {
            let vis = flags.try_into().map_err(|_| {
                PartialVMError::new(StatusCode::MALFORMED)
                    .with_message("Invalid visibility byte".to_string())
            })?;
            (vis, false)
        };
        let extra_flags = cursor.read_u8().map_err(|_| {
            PartialVMError::new(StatusCode::MALFORMED).with_message("Unexpected EOF".to_string())
        })?;
        (vis, is_entry, extra_flags)
    } else {
        let vis = flags.try_into().map_err(|_| {
            PartialVMError::new(StatusCode::MALFORMED)
                .with_message("Invalid visibility byte".to_string())
        })?;

        let mut extra_flags = cursor.read_u8().map_err(|_| {
            PartialVMError::new(StatusCode::MALFORMED).with_message("Unexpected EOF".to_string())
        })?;
        let is_entry = (extra_flags & FunctionDefinition::ENTRY) != 0;
        if is_entry {
            extra_flags ^= FunctionDefinition::ENTRY;
        }
        (vis, is_entry, extra_flags)
    };

    let acquires_global_resources = load_struct_definition_indices(cursor)?;
    let code_unit = if (extra_flags & FunctionDefinition::NATIVE) != 0 {
        extra_flags ^= FunctionDefinition::NATIVE;
        None
    } else {
        Some(load_code_unit(cursor)?)
    };