gear-core 1.10.0

Gear core library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

// This file is part of Gear.

// Copyright (C) 2024-2025 Gear Technologies Inc.
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.

//! Module for instrumented code.

use crate::code::Code;
use alloc::vec::Vec;
use scale_decode::DecodeAsType;
use scale_encode::EncodeAsType;
use scale_info::{
    TypeInfo,
    scale::{Decode, Encode},
};

/// Instantiated section sizes for charging during module instantiation.
/// By "instantiated sections sizes" we mean the size of the section representation in the executor
/// during module instantiation.
#[derive(
    Clone, Debug, PartialEq, Eq, Decode, DecodeAsType, Encode, EncodeAsType, TypeInfo, Hash,
)]
pub struct InstantiatedSectionSizes {
    /// Code section size in bytes.
    code_section: u32,
    /// Data section size in bytes based on the number of heuristic memory pages
    /// used during data section instantiation (see `GENERIC_OS_PAGE_SIZE`).
    data_section: u32,
    /// Global section size in bytes.
    global_section: u32,
    /// Table section size in bytes.
    table_section: u32,
    /// Element section size in bytes.
    element_section: u32,
    /// Type section size in bytes.
    type_section: u32,
}

impl InstantiatedSectionSizes {
    /// Creates a new instance of the section sizes.
    pub fn new(
        code_section: u32,
        data_section: u32,
        global_section: u32,
        table_section: u32,
        element_section: u32,
        type_section: u32,
    ) -> Self {
        Self {
            code_section,
            data_section,
            global_section,
            table_section,
            element_section,
            type_section,
        }
    }

    /// Returns the code section size in bytes.
    pub fn code_section(&self) -> u32 {
        self.code_section
    }

    /// Returns the data section size in bytes.
    pub fn data_section(&self) -> u32 {
        self.data_section
    }

    /// Returns the global section size in bytes.
    pub fn global_section(&self) -> u32 {
        self.global_section
    }

    /// Returns the table section size in bytes.
    pub fn table_section(&self) -> u32 {
        self.table_section
    }

    /// Returns the element section size in bytes.
    pub fn element_section(&self) -> u32 {
        self.element_section
    }

    /// Returns the type section size in bytes.
    pub fn type_section(&self) -> u32 {
        self.type_section
    }
}

/// The newtype contains the instrumented code and the corresponding id (hash).
#[derive(
    Clone, Debug, Decode, DecodeAsType, Encode, EncodeAsType, TypeInfo, PartialEq, Eq, Hash,
)]
pub struct InstrumentedCode {
    /// Code instrumented with the latest schedule.
    bytes: Vec<u8>,
    /// Instantiated section sizes used for charging during module instantiation.
    instantiated_section_sizes: InstantiatedSectionSizes,
}

impl InstrumentedCode {
    /// Creates a new instance of the instrumented code.
    pub fn new(bytes: Vec<u8>, instantiated_section_sizes: InstantiatedSectionSizes) -> Self {
        Self {
            bytes,
            instantiated_section_sizes,
        }
    }

    /// Returns reference to the instrumented binary code.
    pub fn bytes(&self) -> &[u8] {
        &self.bytes
    }

    /// Returns instantiated section sizes used for charging during module instantiation.
    pub fn instantiated_section_sizes(&self) -> &InstantiatedSectionSizes {
        &self.instantiated_section_sizes
    }

    /// Consumes the instance and returns the instrumented code.
    pub fn into_bytes(self) -> Vec<u8> {
        self.bytes
    }
}

impl From<Code> for InstrumentedCode {
    fn from(code: Code) -> Self {
        code.into_parts().1
    }
}