@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 06:00 UTC

main
inc 207 lines 6.63 KB
Raw
1 /*
2 * Copyright 2018 WebAssembly Community Group participants
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 // This file is used as a template to generate code for regular memories or for
18 // shared memories. For this, the file must be included after defining either
19 // WASM_RT_MEM_OPS or WASM_RT_MEM_OPS_SHARED.
20
21 #if defined(WASM_RT_MEM_OPS) && defined(WASM_RT_MEM_OPS_SHARED)
22 #error \
23 "Expected only one of { WASM_RT_MEM_OPS, WASM_RT_MEM_OPS_SHARED } to be defined"
24 #elif !defined(WASM_RT_MEM_OPS) && !defined(WASM_RT_MEM_OPS_SHARED)
25 #error \
26 "Expected one of { WASM_RT_MEM_OPS, WASM_RT_MEM_OPS_SHARED } to be defined"
27 #endif
28
29 // Shared memory operations are defined only if we have C11
30 #if defined(WASM_RT_MEM_OPS) || \
31 (defined(WASM_RT_MEM_OPS_SHARED) && defined(WASM_RT_C11_AVAILABLE))
32
33 #ifdef WASM_RT_MEM_OPS
34
35 // Memory operations on wasm_rt_memory_t
36 #define MEMORY_TYPE wasm_rt_memory_t
37 #define MEMORY_API_NAME(name) name
38 #define MEMORY_CELL_TYPE uint8_t*
39 #define MEMORY_LOCK_VAR_INIT(name)
40 #define MEMORY_LOCK_AQUIRE(name)
41 #define MEMORY_LOCK_RELEASE(name)
42
43 #else
44
45 // Memory operations on wasm_rt_shared_memory_t
46 #define MEMORY_TYPE wasm_rt_shared_memory_t
47 #define MEMORY_API_NAME(name) name##_shared
48 #define MEMORY_CELL_TYPE _Atomic volatile uint8_t*
49
50 #if WASM_RT_USE_CRITICALSECTION
51 #define MEMORY_LOCK_VAR_INIT(name) WIN_MEMORY_LOCK_VAR_INIT(name)
52 #define MEMORY_LOCK_AQUIRE(name) WIN_MEMORY_LOCK_AQUIRE(name)
53 #define MEMORY_LOCK_RELEASE(name) WIN_MEMORY_LOCK_RELEASE(name)
54 #elif WASM_RT_USE_PTHREADS
55 #define MEMORY_LOCK_VAR_INIT(name) PTHREAD_MEMORY_LOCK_VAR_INIT(name)
56 #define MEMORY_LOCK_AQUIRE(name) PTHREAD_MEMORY_LOCK_AQUIRE(name)
57 #define MEMORY_LOCK_RELEASE(name) PTHREAD_MEMORY_LOCK_RELEASE(name)
58 #endif
59
60 #endif
61
62 bool MEMORY_API_NAME(wasm_rt_memory_is_default32)(const MEMORY_TYPE* memory) {
63 return memory->page_size == WASM_DEFAULT_PAGE_SIZE && !memory->is64;
64 }
65
66 void MEMORY_API_NAME(wasm_rt_allocate_memory)(MEMORY_TYPE* memory,
67 uint64_t initial_pages,
68 uint64_t max_pages,
69 bool is64,
70 uint32_t page_size) {
71 uint64_t byte_length;
72 if (u64_mult_overflow(initial_pages, page_size, &byte_length)) {
73 abort();
74 }
75 memory->size = byte_length;
76 memory->pages = initial_pages;
77 memory->max_pages = max_pages;
78 memory->is64 = is64;
79 memory->page_size = page_size;
80 MEMORY_LOCK_VAR_INIT(memory->mem_lock);
81
82 #if WASM_RT_USE_MMAP
83 if (MEMORY_API_NAME(wasm_rt_memory_is_default32)(memory)) {
84 const uint64_t mmap_size =
85 get_alloc_size_for_mmap_default32(memory->max_pages);
86 uint8_t* addr = os_mmap(mmap_size);
87 if (!addr) {
88 os_print_last_error("os_mmap failed.");
89 abort();
90 }
91 uint8_t* data_end = addr + mmap_size;
92 #if !WABT_BIG_ENDIAN
93 int ret = os_mprotect(addr, byte_length);
94 #else
95 int ret = os_mprotect(data_end - byte_length, byte_length);
96 #endif
97 if (ret != 0) {
98 os_print_last_error("os_mprotect failed.");
99 abort();
100 }
101 memory->data = (MEMORY_CELL_TYPE)addr;
102 memory->data_end = (MEMORY_CELL_TYPE)data_end;
103 return;
104 }
105 #endif
106
107 memory->data = (MEMORY_CELL_TYPE)calloc(byte_length, 1);
108 if (byte_length != 0 && !memory->data) {
109 abort();
110 }
111 memory->data_end = memory->data + byte_length;
112 }
113
114 // Returns 0 on success
115 static int MEMORY_API_NAME(expand_data_allocation)(MEMORY_TYPE* memory,
116 uint64_t old_size,
117 uint64_t new_size,
118 uint64_t delta_size) {
119 #if WASM_RT_USE_MMAP
120 if (MEMORY_API_NAME(wasm_rt_memory_is_default32)(memory)) {
121 #if !WABT_BIG_ENDIAN
122 return os_mprotect((void*)(memory->data + old_size), delta_size);
123 #else
124 return os_mprotect((void*)(memory->data_end - old_size - delta_size),
125 delta_size);
126 #endif
127 }
128 #endif
129
130 uint8_t* new_data = realloc((void*)memory->data, new_size);
131 if (new_data == NULL) {
132 return -1;
133 }
134 #if !WABT_BIG_ENDIAN
135 memset((void*)(new_data + old_size), 0, delta_size);
136 #else
137 memmove((void*)(new_data + new_size - old_size), (void*)new_data, old_size);
138 memset((void*)new_data, 0, delta_size);
139 #endif
140
141 memory->data = (MEMORY_CELL_TYPE)new_data;
142 memory->data_end = memory->data + new_size;
143 return 0;
144 }
145
146 static uint64_t MEMORY_API_NAME(grow_memory_impl)(MEMORY_TYPE* memory,
147 uint64_t delta) {
148 uint64_t old_pages = memory->pages;
149 uint64_t new_pages = memory->pages + delta;
150 if (delta == 0) {
151 return old_pages;
152 }
153 if (new_pages < old_pages || new_pages > memory->max_pages) {
154 return (uint64_t)-1;
155 }
156
157 uint64_t old_size, new_size, delta_size;
158 if (u64_mult_overflow(old_pages, memory->page_size, &old_size) ||
159 u64_mult_overflow(new_pages, memory->page_size, &new_size) ||
160 u64_mult_overflow(delta, memory->page_size, &delta_size)) {
161 return (uint64_t)-1;
162 }
163
164 int err = MEMORY_API_NAME(expand_data_allocation)(memory, old_size, new_size,
165 delta_size);
166 if (err != 0) {
167 return (uint64_t)-1;
168 }
169
170 memory->pages = new_pages;
171 memory->size = new_size;
172 return old_pages;
173 }
174
175 uint64_t MEMORY_API_NAME(wasm_rt_grow_memory)(MEMORY_TYPE* memory,
176 uint64_t delta) {
177 MEMORY_LOCK_AQUIRE(memory->mem_lock);
178 uint64_t ret = MEMORY_API_NAME(grow_memory_impl)(memory, delta);
179 MEMORY_LOCK_RELEASE(memory->mem_lock);
180 #ifdef WASM_RT_GROW_FAILED_HANDLER
181 if (ret == (uint64_t)-1) {
182 WASM_RT_GROW_FAILED_HANDLER();
183 }
184 #endif
185 return ret;
186 }
187
188 void MEMORY_API_NAME(wasm_rt_free_memory)(MEMORY_TYPE* memory) {
189 #if WASM_RT_USE_MMAP
190 if (MEMORY_API_NAME(wasm_rt_memory_is_default32)(memory)) {
191 const uint64_t mmap_size =
192 get_alloc_size_for_mmap_default32(memory->max_pages);
193 os_munmap((void*)memory->data, mmap_size); // ignore error
194 return;
195 }
196 #endif
197 free((void*)memory->data);
198 }
199
200 #undef MEMORY_LOCK_RELEASE
201 #undef MEMORY_LOCK_AQUIRE
202 #undef MEMORY_LOCK_VAR_INIT
203 #undef MEMORY_CELL_TYPE
204 #undef MEMORY_API_NAME
205 #undef MEMORY_TYPE
206
207 #endif