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
|
;; Check all the valid custom page sizes.
(module (memory 1 (pagesize 1)))
(module (memory 1 (pagesize 65536)))
;; Check them all again with maximums specified.
(module (memory 1 2 (pagesize 1)))
(module (memory 1 2 (pagesize 65536)))
;; Check the behavior of memories with page size 1.
(module
(memory 0 (pagesize 1))
(func (export "size") (result i32)
memory.size
)
(func (export "grow") (param i32) (result i32)
(memory.grow (local.get 0))
)
(func (export "load") (param i32) (result i32)
(i32.load8_u (local.get 0))
)
(func (export "store") (param i32 i32)
(i32.store8 (local.get 0) (local.get 1))
)
)
(assert_return (invoke "size") (i32.const 0))
(assert_trap (invoke "load" (i32.const 0)) "out of bounds memory access")
(assert_return (invoke "grow" (i32.const 65536)) (i32.const 0))
(assert_return (invoke "size") (i32.const 65536))
(assert_return (invoke "load" (i32.const 65535)) (i32.const 0))
(assert_return (invoke "store" (i32.const 65535) (i32.const 1)))
(assert_return (invoke "load" (i32.const 65535)) (i32.const 1))
(assert_trap (invoke "load" (i32.const 65536)) "out of bounds memory access")
(assert_return (invoke "grow" (i32.const 65536)) (i32.const 65536))
(assert_return (invoke "size") (i32.const 131072))
(assert_return (invoke "load" (i32.const 131071)) (i32.const 0))
(assert_return (invoke "store" (i32.const 131071) (i32.const 1)))
(assert_return (invoke "load" (i32.const 131071)) (i32.const 1))
(assert_trap (invoke "load" (i32.const 131072)) "out of bounds memory access")
;; Although smaller page sizes let us get to memories larger than 2**16 pages,
;; we can't do that with the default page size, even if we explicitly state it
;; as a custom page size.
(module
(memory 0 (pagesize 65536))
(func (export "size") (result i32)
memory.size
)
(func (export "grow") (param i32) (result i32)
(memory.grow (local.get 0))
)
)
(assert_return (invoke "size") (i32.const 0))
(assert_return (invoke "grow" (i32.const 65537)) (i32.const -1))
(assert_return (invoke "size") (i32.const 0))
;; Can copy between memories of different page sizes.
(module
(memory $small 10 (pagesize 1))
(memory $large 1 (pagesize 65536))
(data (memory $small) (i32.const 0) "\11\22\33\44")
(data (memory $large) (i32.const 0) "\55\66\77\88")
(func (export "copy-small-to-large") (param i32 i32 i32)
(memory.copy $large $small (local.get 0) (local.get 1) (local.get 2))
)
(func (export "copy-large-to-small") (param i32 i32 i32)
(memory.copy $small $large (local.get 0) (local.get 1) (local.get 2))
)
(func (export "load8-small") (param i32) (result i32)
(i32.load8_u $small (local.get 0))
)
(func (export "load8-large") (param i32) (result i32)
(i32.load8_u $large (local.get 0))
)
)
(assert_return (invoke "copy-small-to-large" (i32.const 6) (i32.const 0) (i32.const 2)))
(assert_return (invoke "load8-large" (i32.const 6)) (i32.const 0x11))
(assert_return (invoke "load8-large" (i32.const 7)) (i32.const 0x22))
(assert_return (invoke "copy-large-to-small" (i32.const 4) (i32.const 1) (i32.const 3)))
(assert_return (invoke "load8-small" (i32.const 4)) (i32.const 0x66))
(assert_return (invoke "load8-small" (i32.const 5)) (i32.const 0x77))
(assert_return (invoke "load8-small" (i32.const 6)) (i32.const 0x88))
;; Can link together modules that export and import memories with custom page
;; sizes.
(module $m
(memory (export "small-pages-memory") 0 (pagesize 1))
(memory (export "large-pages-memory") 0 (pagesize 65536))
)
(register "m" $m)
(module
(memory (import "m" "small-pages-memory") 0 (pagesize 1))
)
(module
(memory (import "m" "large-pages-memory") 0 (pagesize 65536))
)
|
