hmn
/
orca
5
Fork 2
Code Issues 21 Pull Requests 1 Packages Projects Releases Wiki Activity

bugfixes to bindgen_bb.py

This commit is contained in:
Reuben Dunnington 2023-08-01 22:44:42 -07:00
parent 3f2ed41bfc
commit f76817c1ed
Signed by: rdunnington
GPG Key ID: 4EC5290E704FD482
6 changed files with 233 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
build.bat
View File

@ -56,7 +56,7 @@ if %target% == orca (
::compile orca
set INCLUDES=/I src /I sdk /I ext\bytebox\include /I milepost\src /I milepost\ext
set LIBS=/LIBPATH:bin milepost.dll.lib ext\bytebox\lib\bytebox.lib
set LIBS=/LIBPATH:bin milepost.dll.lib ext\bytebox\lib\bytebox.lib ntdll.lib
cl /Zi /Zc:preprocessor /std:c11 /experimental:c11atomics %INCLUDES% src\main.c /link %LIBS% /out:bin\orca.exe
cl /Zi /Zc:preprocessor /std:c11 /experimental:c11atomics %INCLUDES% src\main.c /link %LIBS% /STACK:8388608,8388608 /out:bin\orca.exe
)

59
ext/bytebox/include/bytebox.h
View File

@ -17,6 +17,8 @@ enum bb_error
BB_ERROR_OUTOFMEMORY,
BB_ERROR_INVALIDPARAM,
BB_ERROR_UNKNOWNEXPORT,
BB_ERROR_UNKNOWNIMPORT,
BB_ERROR_INCOMPATIBLEIMPORT,
};
typedef enum bb_error bb_error;
@ -47,44 +49,18 @@ struct bb_module_definition_init_opts
};
typedef struct bb_module_definition_init_opts bb_module_definition_init_opts;
struct bb_module_definition
{
void* module;
};
typedef struct bb_module_definition bb_module_definition;
// struct bb_import_function
// {
// const char* name;
// bb_host_function* func;
// bb_valtype* params;
// size_t num_params;
// bb_valtype* returns;
// size_t num_returns;
// void* userdata;
// };
// typedef struct bb_import_function bb_import_function;
struct bb_import_package
{
void* package;
};
typedef struct bb_module_instance bb_module_instance;
typedef struct bb_import_package bb_import_package;
struct bb_module_instance_instantiate_opts
{
bb_import_package* packages;
bb_import_package** packages;
size_t num_packages;
bool enable_debug;
};
typedef struct bb_module_instance_instantiate_opts bb_module_instance_instantiate_opts;
struct bb_module_instance
{
void* module;
};
typedef struct bb_module_instance bb_module_instance;
struct bb_module_instance_invoke_opts
{
bool trap_on_start;
@ -116,6 +92,21 @@ typedef enum bb_debug_trap_mode bb_debug_trap_mode;
typedef void bb_host_function(void* userdata, bb_module_instance* module, const bb_val* params, bb_val* returns);
enum bb_global_mut
{
BB_GLOBAL_MUT_IMMUTABLE,
BB_GLOBAL_MUT_MUTABLE,
};
typedef enum bb_global_mut bb_global_mut;
struct bb_global
{
bb_val* value;
bb_valtype type;
bb_global_mut mut;
};
typedef struct bb_global bb_global;
// typedef void* bb_malloc_func(size_t size, void* userdata);
// typedef void* bb_realloc_func(void* mem, size_t size, void* userdata);
// typedef void bb_free_func(void* mem, void* userdata);
@ -124,20 +115,19 @@ typedef void bb_host_function(void* userdata, bb_module_instance* module, const
const char* bb_error_str(bb_error err);
bb_module_definition bb_module_definition_init(bb_module_definition_init_opts opts);
bb_module_definition* bb_module_definition_init(bb_module_definition_init_opts opts);
void bb_module_definition_deinit(bb_module_definition* definition);
bb_error bb_module_definition_decode(bb_module_definition* definition, const char* data, size_t length);
bb_slice bb_module_definition_get_custom_section(const bb_module_definition* definition, const char* name);
bb_import_package bb_import_package_init(const char* name);
bb_import_package* bb_import_package_init(const char* name);
void bb_import_package_deinit(bb_import_package* package); // only deinit when all module_instances using the package have been deinited
void* bb_import_package_userdata(const bb_import_package* package);
bb_error bb_import_package_add_function(bb_import_package* package, bb_host_function* func, const char* export_name, bb_valtype* params, size_t num_params, bb_valtype* returns, size_t num_returns, void* userdata);
bb_module_instance bb_module_instance_init(bb_module_definition* definition);
bb_module_instance* bb_module_instance_init(bb_module_definition* definition);
void bb_module_instance_deinit(bb_module_instance* instance);
bb_error bb_module_instance_instantiate(bb_module_instance* instance, bb_module_instance_instantiate_opts opts);
bb_func_handle bb_module_instance_find_func(bb_module_instance* instance, const char* func_name);
bb_error bb_module_instance_find_func(bb_module_instance* instance, const char* func_name, bb_func_handle* out_handle);
bb_func_info bb_module_instance_func_info(bb_module_instance* instance, bb_func_handle handle);
bb_error bb_module_instance_invoke(bb_module_instance* instance, bb_func_handle, const bb_val* params, size_t num_params, bb_val* returns, size_t num_returns, bb_module_instance_invoke_opts opts);
bb_error bb_module_instance_resume(bb_module_instance* instance, bb_val* returns, size_t num_returns);
@ -145,3 +135,6 @@ bb_error bb_module_instance_step(bb_module_instance* instance, bb_val* returns,
bb_error bb_module_instance_debug_set_trap(bb_module_instance* instance, uint32_t address, bb_debug_trap_mode trap_mode);
void* bb_module_instance_mem(bb_module_instance* instance, size_t offset, size_t length);
bb_slice bb_module_instance_mem_all(bb_module_instance* instance);
bb_global bb_module_instance_find_global(bb_module_instance* instance, const char* global_name);
bool bb_func_handle_isvalid(bb_func_handle handle);

17
scripts/bindgen_bb.py
View File

@ -196,12 +196,9 @@ for decl in data:
paramTypes = []
numParams = 0
if retTag == 'S':
retType = 'BB_VALTYPE_I32' # unused, but we need something to put in the the returns array since 0-size arrays are illegal in C
paramTypes.append('BB_VALTYPE_I32')
elif retTag == 'v': #no returns
retType = 'BB_VALTYPE_I32' #unused but we need a dummy value
numReturns = 0
else:
numParams += 1
elif retTag != 'v': #no returns
retType = translateTag(retTag)
numReturns = 1
@ -212,16 +209,20 @@ for decl in data:
paramTypes.append(translateTag(tag))
numParams += 1
# dummy values to avoid 0-length arrays in C
if numReturns == 0:
retType = 'BB_VALTYPE_I32'
if numParams == 0:
paramTypes.append('BB_VALTYPE_I32') # unused but need a dummy value to avoid 0-length array
paramTypes.append('BB_VALTYPE_I32')
s += '\t{\n'
s += '\t\tbb_valtype params[] = {' + ', '.join(paramTypes) + '};\n'
s += '\t\tsize_t num_params = ' + str(len(paramTypes)) + ';\n'
s += '\t\tbb_valtype returns[] = {' + retType + '};\n'
s += '\t\tbb_valtype return_type = ' + retType + ';\n'
s += '\t\tsize_t num_returns = ' + str(numReturns) + ';\n'
s += '\t\tbb_error err = bb_import_package_add_function(package, ' + cname + '_stub, "' + name + '", params, num_params, returns, num_returns, NULL);\n'
s += '\t\tbb_error err = bb_import_package_add_function(package, ' + cname + '_stub, "' + name + '", params, num_params, &return_type, num_returns, NULL);\n'
s += '\t\tif(err != BB_ERROR_OK) { log_error("error: %s\\n", bb_error_str(err)); return(-1); }\n'
s += '\t}\n'

246
src/main.c
View File

@ -288,6 +288,20 @@ void log_entry_ui(orca_debug_overlay* overlay, log_entry* entry)
// }
// }
bool tag_to_valtype(char tag, bb_valtype* out)
{
switch (tag)
{
case 'i': *out = BB_VALTYPE_I32; return true;
case 'I': *out = BB_VALTYPE_I64; return true;
case 'f': *out = BB_VALTYPE_F32; return true;
case 'F': *out = BB_VALTYPE_F64; return true;
case 'd': *out = BB_VALTYPE_F64; return true;
}
return false;
}
void orca_runtime_init(orca_runtime* runtime)
{
memset(runtime, 0, sizeof(orca_runtime));
@ -305,19 +319,21 @@ void orca_runtime_init(orca_runtime* runtime)
#include"gles_api_bind_gen.c"
#include"manual_gles_api.c"
void* quit_on_wasm_init_failure(const char* stage, bb_error err)
i32 quit_on_wasm_init_failure(const char* stage, bb_error err)
{
const char* errStr = bb_error_str(err);
log_error("wasm error at init stage '%s': %s\n", errStr);
log_error("wasm error at init stage '%s': %s\n", stage, errStr);
str8 msg = str8_pushf(mem_scratch(), "The application couldn't load: encountered fatal error at stage '%s': %s", stage, errStr);
const char* options[] = {"OK"};
mp_alert_popup("Error",
"The application couldn't load: encountered fatal error at stage '%s': %s",
stage,
errStr);
msg.ptr,
1,
options);
mp_request_quit();
return((void*)-1);
return(-1);
}
i32 orca_runloop(void* user)
@ -357,7 +373,7 @@ i32 orca_runloop(void* user)
bb_error wasm_init_err;
bb_module_definition_init_opts module_def_init_opts = { .debug_name = bundleNameCString };
app->runtime.bbModuleDef = bb_module_definition_init(module_def_init_opts);
wasm_init_err = bb_module_definition_decode(&app->runtime.bbModuleDef, app->runtime.wasmBytecode.ptr, app->runtime.wasmBytecode.len);
wasm_init_err = bb_module_definition_decode(app->runtime.bbModuleDef, app->runtime.wasmBytecode.ptr, app->runtime.wasmBytecode.len);
if (wasm_init_err != BB_ERROR_OK)
{
return quit_on_wasm_init_failure("wasm decode", wasm_init_err);
@ -381,13 +397,13 @@ i32 orca_runloop(void* user)
mem_arena_clear(mem_scratch());
//NOTE: bind orca APIs
bb_import_package module_imports = bb_import_package_init("*");
bindgen_link_core_api(&module_imports);
bindgen_link_canvas_api(&module_imports);
bindgen_link_clock_api(&module_imports);
bindgen_link_io_api(&module_imports);
bindgen_link_gles_api(&module_imports);
manual_link_gles_api(&module_imports);
bb_import_package* module_imports = bb_import_package_init("*");
bindgen_link_core_api(module_imports);
bindgen_link_canvas_api(module_imports);
bindgen_link_clock_api(module_imports);
bindgen_link_io_api(module_imports);
bindgen_link_gles_api(module_imports);
manual_link_gles_api(module_imports);
//NOTE: compile
// M3Result res = m3_CompileModule(app->runtime.m3Module);
@ -407,16 +423,16 @@ i32 orca_runloop(void* user)
// return(-1);
// }
app->runtime.bbModuleInst = bb_module_instance_init(&app->runtime.bbModuleDef);
app->runtime.bbModuleInst = bb_module_instance_init(app->runtime.bbModuleDef);
bb_module_instance_instantiate_opts module_inst_instantiate_opts = { .packages = &module_imports, .num_packages = 1, .enable_debug = false, };
wasm_init_err = bb_module_instance_instantiate(&app->runtime.bbModuleInst, bb_module_instance_instantiate_opts opts);
wasm_init_err = bb_module_instance_instantiate(app->runtime.bbModuleInst, module_inst_instantiate_opts);
if (wasm_init_err != BB_ERROR_OK)
{
return quit_on_wasm_init_failure("wasm instantiate", wasm_init_err);
}
bb_import_package_deinit(&module_imports); // safe to deinit this now that the module has been instantiated
bb_import_package_deinit(module_imports); // safe to deinit this now that the module has been instantiated
// TODO up next: expose a cached handle to functions to invoke instead of a string search
@ -426,47 +442,67 @@ i32 orca_runloop(void* user)
const g_export_desc* desc = &G_EXPORT_DESC[i];
bb_func_handle handler;
bb_module_instance_find_func(&app->runtime.bbModuleInst, desc->name.ptr);
const bb_error find_func_err = bb_module_instance_find_func(app->runtime.bbModuleInst, desc->name.ptr, &handler);
// IM3Function handler = 0;
// m3_FindFunction(&handler, app->runtime.m3Runtime, desc->name.ptr);
if(handler)
if(find_func_err == BB_ERROR_OK)
{
bool checked = false;
//NOTE: check function signature
int retCount = m3_GetRetCount(handler);
int argCount = m3_GetArgCount(handler);
if(retCount == desc->retTags.len && argCount == desc->argTags.len)
bb_func_info func_info = bb_module_instance_func_info(app->runtime.bbModuleInst, handler);
bool checked = func_info.num_returns == desc->retTags.len && func_info.num_params == desc->argTags.len;
for(int retIndex = 0; checked && retIndex < func_info.num_returns; retIndex++)
{
checked = true;
for(int retIndex = 0; retIndex < retCount; retIndex++)
bb_valtype valtype;
if(tag_to_valtype(desc->retTags.ptr[retIndex], &valtype) && valtype != func_info.returns[retIndex])
{
M3ValueType m3Type = m3_GetRetType(handler, retIndex);
char tag = m3_type_to_tag(m3Type);
if(tag != desc->retTags.ptr[retIndex])
{
checked = false;
break;
}
}
if(checked)
{
for(int argIndex = 0; argIndex < argCount; argIndex++)
{
M3ValueType m3Type = m3_GetArgType(handler, argIndex);
char tag = m3_type_to_tag(m3Type);
if(tag != desc->argTags.ptr[argIndex])
{
checked = false;
break;
}
}
checked = false;
}
}
for(int argIndex = 0; checked && argIndex < func_info.num_params; argIndex++)
{
bb_valtype valtype;
if(tag_to_valtype(desc->argTags.ptr[argIndex], &valtype) && valtype != func_info.params[argIndex])
{
checked = false;
}
}
// int retCount = m3_GetRetCount(handler);
// int argCount = m3_GetArgCount(handler);
// if(retCount == desc->retTags.len && argCount == desc->argTags.len)
// {
// checked = true;
// for(int retIndex = 0; retIndex < retCount; retIndex++)
// {
// M3ValueType m3Type = m3_GetRetType(handler, retIndex);
// char tag = m3_type_to_tag(m3Type);
// if(tag != desc->retTags.ptr[retIndex])
// {
// checked = false;
// break;
// }
// }
// if(checked)
// {
// for(int argIndex = 0; argIndex < argCount; argIndex++)
// {
// M3ValueType m3Type = m3_GetArgType(handler, argIndex);
// char tag = m3_type_to_tag(m3Type);
// if(tag != desc->argTags.ptr[argIndex])
// {
// checked = false;
// break;
// }
// }
// }
// }
if(checked)
{
app->runtime.exports[i] = handler;
@ -479,8 +515,10 @@ i32 orca_runloop(void* user)
}
//NOTE: get location of the raw event slot
IM3Global rawEventGlobal = m3_FindGlobal(app->runtime.m3Module, "_OrcaRawEvent");
app->runtime.rawEventOffset = (u32)rawEventGlobal->intValue;
// IM3Global rawEventGlobal = m3_FindGlobal(app->runtime.m3Module, "_OrcaRawEvent");
// app->runtime.rawEventOffset = (u32)rawEventGlobal->intValue;
bb_global rawEventGlobal = bb_module_instance_find_global(app->runtime.bbModuleInst, "_OrcaRawEvent");
app->runtime.rawEventOffset = (u32)rawEventGlobal.value->i32_val;
//NOTE: preopen the app local root dir
{
@ -497,17 +535,22 @@ i32 orca_runloop(void* user)
//NOTE: prepare GL surface
mg_surface_prepare(app->surface);
IM3Function* exports = app->runtime.exports;
// IM3Function* exports = app->runtime.exports;
bb_func_handle* exports = app->runtime.exports;
//NOTE: call init handler
if(exports[G_EXPORT_ON_INIT])
if(bb_func_handle_isvalid(exports[G_EXPORT_ON_INIT]))
{
M3Result err = m3_Call(exports[G_EXPORT_ON_INIT], 0, 0);
if(err != NULL)
{
log_error("runtime error: %s\n", err);
bb_error err = bb_module_instance_invoke(app->runtime.bbModuleInst, exports[G_EXPORT_ON_INIT], 0, 0, 0, 0, (bb_module_instance_invoke_opts){0});
str8 msg = str8_pushf(mem_scratch(), "Runtime error: %s\n", err);
// M3Result err = m3_Call(exports[G_EXPORT_ON_INIT], 0, 0);
// if(err != NULL)
if(err != BB_ERROR_OK)
{
const char* errStr = bb_error_str(err);
log_error("runtime error: %s\n", errStr);
str8 msg = str8_pushf(mem_scratch(), "Runtime error: %s\n", errStr);
const char* options[] = {"OK"};
mp_alert_popup("Error",
msg.ptr,
@ -519,13 +562,14 @@ i32 orca_runloop(void* user)
}
}
if(exports[G_EXPORT_FRAME_RESIZE])
if(bb_func_handle_isvalid(exports[G_EXPORT_FRAME_RESIZE]))
{
mp_rect content = mp_window_get_content_rect(app->window);
u32 width = (u32)content.w;
u32 height = (u32)content.h;
const void* args[2] = {&width, &height};
m3_Call(exports[G_EXPORT_FRAME_RESIZE], 2, args);
const bb_val args[2] = {
{ .i32_val = (i32)content.w },
{ .i32_val = (i32)content.h },
};
bb_module_instance_invoke(app->runtime.bbModuleInst, exports[G_EXPORT_FRAME_RESIZE], args, 2, 0, 0, (bb_module_instance_invoke_opts){0});
}
ui_set_context(&app->debugOverlay.ui);
@ -541,14 +585,14 @@ i32 orca_runloop(void* user)
ui_process_event(event);
}
if(exports[G_EXPORT_RAW_EVENT])
if(bb_func_handle_isvalid(exports[G_EXPORT_RAW_EVENT]))
{
#ifndef M3_BIG_ENDIAN
mp_event* eventPtr = (mp_event*)wasm_memory_offset_to_ptr(&app->runtime.wasmMemory, app->runtime.rawEventOffset);
memcpy(eventPtr, event, sizeof(*event));
const void* args[1] = {&app->runtime.rawEventOffset};
m3_Call(exports[G_EXPORT_RAW_EVENT], 1, args);
bb_val args[1];
args[0].i32_val = app->runtime.rawEventOffset;
bb_module_instance_invoke(app->runtime.bbModuleInst, exports[G_EXPORT_RAW_EVENT], args, 1, 0, 0, (bb_module_instance_invoke_opts){0});
#else
log_error("OnRawEvent() is not supported on big endian platforms");
#endif
@ -565,12 +609,18 @@ i32 orca_runloop(void* user)
{
mp_rect frame = {0, 0, event->move.frame.w, event->move.frame.h};
if(exports[G_EXPORT_FRAME_RESIZE])
if(bb_func_handle_isvalid(exports[G_EXPORT_FRAME_RESIZE]))
{
u32 width = (u32)event->move.content.w;
u32 height = (u32)event->move.content.h;
const void* args[2] = {&width, &height};
m3_Call(exports[G_EXPORT_FRAME_RESIZE], 2, args);
const bb_val args[2] = {
{ .i32_val = (i32)(u32)event->move.content.w },
{ .i32_val = (i32)(u32)event->move.content.h },
};
bb_module_instance_invoke(app->runtime.bbModuleInst, exports[G_EXPORT_FRAME_RESIZE], args, 2, 0, 0, (bb_module_instance_invoke_opts){0});
// u32 width = (u32)event->move.content.w;
// u32 height = (u32)event->move.content.h;
// const void* args[2] = {&width, &height};
// m3_Call(exports[G_EXPORT_FRAME_RESIZE], 2, args);
}
} break;
@ -578,30 +628,41 @@ i32 orca_runloop(void* user)
{
if(event->key.action == MP_KEY_PRESS)
{
if(exports[G_EXPORT_MOUSE_DOWN])
if(bb_func_handle_isvalid(exports[G_EXPORT_MOUSE_DOWN]))
{
int key = event->key.code;
const void* args[1] = {&key};
m3_Call(exports[G_EXPORT_MOUSE_DOWN], 1, args);
const bb_val key = {.i32_val = event->key.code };
// int key = event->key.code;
// const void* args[1] = {&key};
// m3_Call(exports[G_EXPORT_MOUSE_DOWN], 1, args);
bb_module_instance_invoke(app->runtime.bbModuleInst, exports[G_EXPORT_MOUSE_DOWN], &key, 1, 0, 0, (bb_module_instance_invoke_opts){0});
}
}
else
{
if(exports[G_EXPORT_MOUSE_UP])
if(bb_func_handle_isvalid(exports[G_EXPORT_MOUSE_UP]))
{
int key = event->key.code;
const void* args[1] = {&key};
m3_Call(exports[G_EXPORT_MOUSE_UP], 1, args);
const bb_val key = {.i32_val = event->key.code };
// int key = event->key.code;
// const void* args[1] = {&key};
// m3_Call(exports[G_EXPORT_MOUSE_UP], 1, args);
bb_module_instance_invoke(app->runtime.bbModuleInst, exports[G_EXPORT_MOUSE_UP], &key, 1, 0, 0, (bb_module_instance_invoke_opts){0});
}
}
} break;
case MP_EVENT_MOUSE_MOVE:
{
if(exports[G_EXPORT_MOUSE_MOVE])
if(bb_func_handle_isvalid(exports[G_EXPORT_MOUSE_MOVE]))
{
const void* args[4] = {&event->mouse.x, &event->mouse.y, &event->mouse.deltaX, &event->mouse.deltaY};
m3_Call(exports[G_EXPORT_MOUSE_MOVE], 4, args);
const bb_val args[4] = {
{ .f32_val = event->mouse.x },
{ .f32_val = event->mouse.y },
{ .f32_val = event->mouse.deltaX },
{ .f32_val = event->mouse.deltaY },
};
// const void* args[4] = {&event->mouse.x, &event->mouse.y, &event->mouse.deltaX, &event->mouse.deltaY};
// m3_Call(exports[G_EXPORT_MOUSE_MOVE], 4, args);
bb_module_instance_invoke(app->runtime.bbModuleInst, exports[G_EXPORT_MOUSE_MOVE], args, 4, 0, 0, (bb_module_instance_invoke_opts){0});
}
} break;
@ -616,18 +677,22 @@ i32 orca_runloop(void* user)
#endif
}
if(exports[G_EXPORT_KEY_DOWN])
if(bb_func_handle_isvalid(exports[G_EXPORT_KEY_DOWN]))
{
const void* args[1] = {&event->key.code};
m3_Call(exports[G_EXPORT_KEY_DOWN], 1, args);
const bb_val key = {.i32_val = event->key.code };
// const void* args[1] = {&event->key.code};
// m3_Call(exports[G_EXPORT_KEY_DOWN], 1, args);
bb_module_instance_invoke(app->runtime.bbModuleInst, exports[G_EXPORT_KEY_DOWN], &key, 1, 0, 0, (bb_module_instance_invoke_opts){0});
}
}
else if(event->key.action == MP_KEY_RELEASE)
{
if(exports[G_EXPORT_KEY_UP])
if(bb_func_handle_isvalid(exports[G_EXPORT_KEY_UP]))
{
const void* args[1] = {&event->key.code};
m3_Call(exports[G_EXPORT_KEY_UP], 1, args);
const bb_val key = {.i32_val = event->key.code };
// const void* args[1] = {&event->key.code};
// m3_Call(exports[G_EXPORT_KEY_UP], 1, args);
bb_module_instance_invoke(app->runtime.bbModuleInst, exports[G_EXPORT_KEY_UP], &key, 1, 0, 0, (bb_module_instance_invoke_opts){0});
}
}
} break;
@ -773,10 +838,11 @@ i32 orca_runloop(void* user)
mg_render(app->debugOverlay.surface, app->debugOverlay.canvas);
}
if(exports[G_EXPORT_FRAME_REFRESH])
if(bb_func_handle_isvalid(exports[G_EXPORT_FRAME_REFRESH]))
{
mg_surface_prepare(app->surface);
m3_Call(exports[G_EXPORT_FRAME_REFRESH], 0, 0);
// m3_Call(exports[G_EXPORT_FRAME_REFRESH], 0, 0);
bb_module_instance_invoke(app->runtime.bbModuleInst, exports[G_EXPORT_FRAME_REFRESH], 0, 0, 0, 0, (bb_module_instance_invoke_opts){0});
}
if(app->debugOverlay.show)

71
src/memory_impl.c
View File

@ -10,62 +10,61 @@
void* wasm_memory_resize_callback(void* p, unsigned long size, void* userData)
{
// wasm_memory* memory = (wasm_memory*)userData;
wasm_memory* memory = (wasm_memory*)userData;
// if(memory->committed >= size)
// {
// return(memory->ptr);
// }
// else if(memory->committed < memory->reserved)
// {
// u32 commitSize = size - memory->committed;
if(memory->committed >= size)
{
return(memory->ptr);
}
else if(memory->committed < memory->reserved)
{
u32 commitSize = size - memory->committed;
// mem_base_allocator* allocator = mem_base_allocator_default();
// mem_base_commit(allocator, memory->ptr + memory->committed, commitSize);
// memory->committed += commitSize;
// return(memory->ptr);
// }
// else
// {
// DEBUG_ASSERT(0, "Out of memory");
// return(0);
// }
mem_base_allocator* allocator = mem_base_allocator_default();
mem_base_commit(allocator, memory->ptr + memory->committed, commitSize);
memory->committed += commitSize;
return(memory->ptr);
}
else
{
DEBUG_ASSERT(0, "Out of memory");
return(0);
}
return NULL;
}
void wasm_memory_free_callback(void* p, void* userData)
{
// wasm_memory* memory = (wasm_memory*)userData;
wasm_memory* memory = (wasm_memory*)userData;
// mem_base_allocator* allocator = mem_base_allocator_default();
// mem_base_release(allocator, memory->ptr, memory->reserved);
// memset(memory, 0, sizeof(wasm_memory));
mem_base_allocator* allocator = mem_base_allocator_default();
mem_base_release(allocator, memory->ptr, memory->reserved);
memset(memory, 0, sizeof(wasm_memory));
}
extern u32 orca_mem_grow(u64 size)
{
return 0;
// const size_t PAGE_SIZE = 65536;
const size_t PAGE_SIZE = 65536;
// orca_runtime* runtime = orca_runtime_get();
// wasm_memory* memory = &runtime->wasmMemory;
orca_runtime* runtime = orca_runtime_get();
wasm_memory* memory = &runtime->wasmMemory;
// size = AlignUpOnPow2(size, PAGE_SIZE);
// u64 totalSize = size + m3_GetMemorySize(runtime->m3Runtime);
size = AlignUpOnPow2(size, PAGE_SIZE);
u64 totalSize = size + m3_GetMemorySize(runtime->m3Runtime);
// u32 addr = memory->committed;
u32 addr = memory->committed;
// //NOTE: call resize memory, which will call our custom resize callback... this is a bit involved because
// // wasm3 doesn't allow resizing the memory directly
// M3Result res = ResizeMemory(runtime->m3Runtime, totalSize/PAGE_SIZE);
//NOTE: call resize memory, which will call our custom resize callback... this is a bit involved because
// wasm3 doesn't allow resizing the memory directly
M3Result res = ResizeMemory(runtime->m3Runtime, totalSize/PAGE_SIZE);
// return(addr);
return(addr);
}
void* wasm_memory_offset_to_ptr(wasm_memory* memory, u32 offset)
{
// M3MemoryHeader* header = (M3MemoryHeader*)(memory->ptr);
// DEBUG_ASSERT(offset < header->length, "Wasm offset exceeds memory length")
// return memory->ptr + sizeof(M3MemoryHeader) + offset;
M3MemoryHeader* header = (M3MemoryHeader*)(memory->ptr);
DEBUG_ASSERT(offset < header->length, "Wasm offset exceeds memory length")
return memory->ptr + sizeof(M3MemoryHeader) + offset;
return NULL;
}

8
src/orca_app.h
View File

@ -68,9 +68,11 @@ typedef struct orca_runtime
wasm_memory wasmMemory;
// bytebox data
bb_module_definition bbModuleDef;
bb_module_instance bbModuleInst;
bb_module_definition* bbModuleDef;
bb_module_instance* bbModuleInst;
bb_func_handle exports[G_EXPORT_COUNT];
u32 rawEventOffset;
// wasm3 data
// IM3Environment m3Env;
// IM3Runtime m3Runtime;