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
|
package wasm
import (
"github.com/tetratelabs/wazero/api"
"github.com/tetratelabs/wazero/internal/internalapi"
)
// ImportedMemories implements the same method as documented on wazero.CompiledModule.
func (m *Module) ImportedMemories() (ret []api.MemoryDefinition) {
for i := range m.MemoryDefinitionSection {
d := &m.MemoryDefinitionSection[i]
if d.importDesc != nil {
ret = append(ret, d)
}
}
return
}
// ExportedMemories implements the same method as documented on wazero.CompiledModule.
func (m *Module) ExportedMemories() map[string]api.MemoryDefinition {
ret := map[string]api.MemoryDefinition{}
for i := range m.MemoryDefinitionSection {
d := &m.MemoryDefinitionSection[i]
for _, e := range d.exportNames {
ret[e] = d
}
}
return ret
}
// BuildMemoryDefinitions generates memory metadata that can be parsed from
// the module. This must be called after all validation.
//
// Note: This is exported for wazero.Runtime `CompileModule`.
func (m *Module) BuildMemoryDefinitions() {
var moduleName string
if m.NameSection != nil {
moduleName = m.NameSection.ModuleName
}
memoryCount := m.ImportMemoryCount
if m.MemorySection != nil {
memoryCount++
}
if memoryCount == 0 {
return
}
m.MemoryDefinitionSection = make([]MemoryDefinition, 0, memoryCount)
importMemIdx := Index(0)
for i := range m.ImportSection {
imp := &m.ImportSection[i]
if imp.Type != ExternTypeMemory {
continue
}
m.MemoryDefinitionSection = append(m.MemoryDefinitionSection, MemoryDefinition{
importDesc: &[2]string{imp.Module, imp.Name},
index: importMemIdx,
memory: imp.DescMem,
})
importMemIdx++
}
if m.MemorySection != nil {
m.MemoryDefinitionSection = append(m.MemoryDefinitionSection, MemoryDefinition{
index: importMemIdx,
memory: m.MemorySection,
})
}
for i := range m.MemoryDefinitionSection {
d := &m.MemoryDefinitionSection[i]
d.moduleName = moduleName
for i := range m.ExportSection {
e := &m.ExportSection[i]
if e.Type == ExternTypeMemory && e.Index == d.index {
d.exportNames = append(d.exportNames, e.Name)
}
}
}
}
// MemoryDefinition implements api.MemoryDefinition
type MemoryDefinition struct {
internalapi.WazeroOnlyType
moduleName string
index Index
importDesc *[2]string
exportNames []string
memory *Memory
}
// ModuleName implements the same method as documented on api.MemoryDefinition.
func (f *MemoryDefinition) ModuleName() string {
return f.moduleName
}
// Index implements the same method as documented on api.MemoryDefinition.
func (f *MemoryDefinition) Index() uint32 {
return f.index
}
// Import implements the same method as documented on api.MemoryDefinition.
func (f *MemoryDefinition) Import() (moduleName, name string, isImport bool) {
if importDesc := f.importDesc; importDesc != nil {
moduleName, name, isImport = importDesc[0], importDesc[1], true
}
return
}
// ExportNames implements the same method as documented on api.MemoryDefinition.
func (f *MemoryDefinition) ExportNames() []string {
return f.exportNames
}
// Min implements the same method as documented on api.MemoryDefinition.
func (f *MemoryDefinition) Min() uint32 {
return f.memory.Min
}
// Max implements the same method as documented on api.MemoryDefinition.
func (f *MemoryDefinition) Max() (max uint32, encoded bool) {
max = f.memory.Max
encoded = f.memory.IsMaxEncoded
return
}
|
