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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
|
// extern "C" {
// #include <iwasm/include/wasm_c_api.h>
// #include <iwasm/include/wasm_export.h>
// #include <iwasm/include/lib_export.h>
// #include <iwasm/interpreter/wasm_runtime.h>
// #include <stdint.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <sys/stat.h>
// #include <dirent.h>
// }
// #include <fstream>
// #include <iostream>
// #include <vector>
// #include <filesystem>
// #include <functional>
// #include <main.h>
// #include <code_80091750.h>
// #include <common_data.h>
// #include <data_segment2.h>
// #include <render_objects.h>
// struct mod_instance {
// wasm_exec_env_t exec_env;
// char* name;
// };
// std::vector<mod_instance> mods_instance = {};
// std::vector<std::function<void()>> render_hook = {};
// void hook_render(wasm_exec_env_t exec_env, uint32 func1) {
// render_hook.push_back([exec_env, func1]() { wasm_runtime_call_indirect(exec_env, func1, 0, NULL); });
// }
// extern "C" void call_render_hook() {
// for (auto f : render_hook) {
// f();
// }
// }
// bool CreateDirectoryRecursive(std::string const& dirName, std::error_code& err) {
// err.clear();
// if (!std::filesystem::create_directories(dirName, err)) {
// if (std::filesystem::exists(dirName)) {
// // The folder already exists:
// err.clear();
// return true;
// }
// return false;
// }
// return true;
// }
// void load_mod_wasm_file(char* mod_name, char* buffer, size_t size) {
// char error_buf[128];
// wasm_module_t module;
// wasm_module_inst_t module_inst;
// wasm_exec_env_t exec_env;
// uint32_t stack_size = 8092 * 8092, heap_size = 8092 * 8;
// /* parse the WASM file from buffer and create a WASM module */
// module = wasm_runtime_load((uint8_t*) buffer, size, error_buf, sizeof(error_buf));
// printf("error? %s\n", error_buf);
// if (module == NULL) {
// printf("%s\n", error_buf);
// exit(-1);
// }
// /* create an instance of the WASM module (WASM linear memory is ready) */
// module_inst = wasm_runtime_instantiate(module, stack_size, heap_size, error_buf, sizeof(error_buf));
// if (module_inst == NULL) {
// printf("%s\n", error_buf);
// exit(-1);
// }
// /* lookup a WASM function by its name
// The function signature can NULL here */
// /* creat an execution environment to execute the WASM functions */
// exec_env = wasm_runtime_create_exec_env(module_inst, stack_size);
// mods_instance.push_back({ exec_env, mod_name });
// }
// mod_instance* find_mod(char* name) {
// for (size_t i = 0; i < mods_instance.size(); i++) {
// if (strcmp(mods_instance[i].name, name) == 0) {
// return &mods_instance[i];
// }
// }
// return NULL;
// }
// wasm_module_inst_t get_mods_instance(char* mod_name) {
// return wasm_exec_env_get_module_inst(find_mod(mod_name)->exec_env);
// }
// wasm_function_inst_t mod_lookup_function(char* mod_name, char* function_name) {
// return wasm_runtime_lookup_function(get_mods_instance(mod_name), function_name);
// }
// bool mod_call_function_wasm(char* mod_name, char* function_name, uint32 argc, uint32 argv[]) {
// wasm_function_inst_t func = mod_lookup_function(mod_name, function_name);
// if (func == NULL) {
// printf("error to find the function\n");
// return false;
// }
// return wasm_runtime_call_wasm(find_mod(mod_name)->exec_env, func, 1, argv);
// }
// void mod_print_exception(char* mod_name) {
// printf("%s\n", wasm_runtime_get_exception(get_mods_instance(mod_name)));
// }
// uint32 call_extern_function(wasm_exec_env_t exec_env, char* mod_name, char* function_name, uint32 argc,
// uint32 argv_offset) {
// if (!wasm_runtime_validate_app_addr(wasm_exec_env_get_module_inst(exec_env), (uint64) argv_offset,
// (uint64) argc * 4)) {
// return false;
// }
// uint32* argv =
// (uint32*) wasm_runtime_addr_app_to_native(wasm_exec_env_get_module_inst(exec_env), (uint64) argv_offset);
// return mod_call_function_wasm(mod_name, function_name, argc, argv);
// }
// void post_debug_print(wasm_exec_env_t exec_env) {
// gSPDisplayList(gDisplayListHead++, (Gfx*) D_0D007EB8);
// gSPDisplayList(gDisplayListHead++, (Gfx*) D_020076E0);
// func_80093C98(1);
// }
// void load_debug_font_wrapper(wasm_exec_env_t exec_env) {
// load_debug_font();
// }
// void debug_print_str2_wrapper(wasm_exec_env_t exec_env, uint32 x, uint32 y, char* str) {
// debug_print_str2(x, y, str);
// }
// /* the native functions that will be exported to WASM app */
// static NativeSymbol native_symbols[] = {
// EXPORT_WASM_API_WITH_SIG(call_extern_function, "($$ii)i"), EXPORT_WASM_API_WITH_SIG(hook_render, "(i)"),
// EXPORT_WASM_API_WITH_SIG(post_debug_print, "()"), EXPORT_WASM_API_WITH_SIG2(load_debug_font, "()"),
// EXPORT_WASM_API_WITH_SIG2(debug_print_str2, "(ii$)"),
// // EXPORT_WASM_API_WITH_SIG(display_input_read, "(*)i"),
// // EXPORT_WASM_API_WITH_SIG(display_flush, "(iiii*)")
// };
// /* all the runtime memory allocations are retricted in the global_heap_buf array */
// static char global_heap_buf[512 * 1024];
// char* read_wasm_binary_to_buffer(char* path, uint32_t* size) {
// std::ifstream file;
// file.open(path, std::ios::binary);
// if (!file.is_open()) {
// perror(path);
// return NULL;
// }
// file.seekg(0, std::ios::end);
// *size = file.tellg();
// file.seekg(0);
// char* c_buffer = (char*) malloc(*size);
// file.read(c_buffer, *size);
// return c_buffer;
// }
// extern "C" void load_wasm() {
// printf("load wasm\n");
// char* buffer;
// /* initialize the wasm runtime by default configurations */
// wasm_runtime_init();
// RuntimeInitArgs init_args;
// memset(&init_args, 0, sizeof(RuntimeInitArgs));
// /* configure the memory allocator for the runtime */
// init_args.mem_alloc_type = Alloc_With_Pool;
// init_args.mem_alloc_option.pool.heap_buf = global_heap_buf;
// init_args.mem_alloc_option.pool.heap_size = sizeof(global_heap_buf);
// /* set maximum thread number if needed when multi-thread is enabled,
// the default value is 4 */
// init_args.max_thread_num = 4;
// /* initialize runtime environment with user configurations*/
// if (!wasm_runtime_full_init(&init_args)) {
// exit(-1);
// }
// int n_native_symbols = sizeof(native_symbols) / sizeof(NativeSymbol);
// if (!wasm_runtime_register_natives("env", native_symbols, n_native_symbols)) {
// exit(-1);
// }
// uint32_t size;
// std::error_code err;
// if (!CreateDirectoryRecursive("mods", err)) {
// // Report the error:
// std::cout << "CreateDirectoryRecursive FAILED, err: " << err.message() << std::endl;
// }
// /* read WASM file into a memory buffer */
// for (const auto& entry : std::filesystem::directory_iterator("mods")) {
// if (std::filesystem::is_regular_file(entry) && entry.path().extension() == ".wasm") {
// std::string path = entry.path().string();
// std::string name = entry.path().stem().string();
// printf("found %s\n", name.c_str());
// buffer = read_wasm_binary_to_buffer((char*) path.c_str(), &size);
// if (buffer == NULL) {
// printf("error read binary\n");
// }
// load_mod_wasm_file((char*) name.c_str(), buffer, size);
// mod_call_function_wasm((char*) name.c_str(), "init", 0, NULL);
// }
// }
// // buffer = read_wasm_binary_to_buffer("test.wasm", &size);
// // if (buffer == NULL) {
// // printf("error read binary\n");
// // exit(-1);
// // }
// // load_mod_wasm_file("test", buffer, size);
// // uint32_t argv[2];
// // /* arguments are always transferred in 32-bit element */
// // argv[0] = 8;
// // printf("run fib function\n");
// // /* call the WASM function */
// // if (mod_call_function_wasm("test", "fib", 1, argv)) {
// // /* the return value is stored in argv[0] */
// // printf("fib function return: %d\n", argv[0]);
// // } else {
// // /* exception is thrown if call fails */
// // // wasm_runtime_dump_call_stack(exec_env);
// // mod_print_exception("test");
// // }
// // mod_call_function_wasm("test", "init", 0, NULL);
// // exit(-1);
// }
|
