fluencelabs/wasmer
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasmer synced 2024-12-13 06:15:33 +00:00
Code Issues Projects Releases Wiki Activity

Run clang-format-8 over the C++ code. No functionality change.

Browse Source
This commit is contained in:
Nick Lewycky 2019-08-01 17:12:46 -07:00
parent a224d53c93
commit ac49e57c2d
2 changed files with 343 additions and 372 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

341
lib/llvm-backend/cpp/object_loader.cpp
View File

@ -7,201 +7,214 @@ extern "C" void __deregister_frame(uint8_t *);
struct MemoryManager : llvm::RuntimeDyld::MemoryManager { struct MemoryManager : llvm::RuntimeDyld::MemoryManager {
public: public:
MemoryManager(callbacks_t callbacks) : callbacks(callbacks) {} MemoryManager(callbacks_t callbacks) : callbacks(callbacks) {}
virtual ~MemoryManager() override { virtual ~MemoryManager() override {
deregisterEHFrames(); deregisterEHFrames();
// Deallocate all of the allocated memory. // Deallocate all of the allocated memory.
callbacks.dealloc_memory(code_section.base, code_section.size); callbacks.dealloc_memory(code_section.base, code_section.size);
callbacks.dealloc_memory(read_section.base, read_section.size); callbacks.dealloc_memory(read_section.base, read_section.size);
callbacks.dealloc_memory(readwrite_section.base, readwrite_section.size); callbacks.dealloc_memory(readwrite_section.base, readwrite_section.size);
}
virtual uint8_t *allocateCodeSection(uintptr_t size, unsigned alignment,
unsigned section_id,
llvm::StringRef section_name) override {
return allocate_bump(code_section, code_bump_ptr, size, alignment);
}
virtual uint8_t *allocateDataSection(uintptr_t size, unsigned alignment,
unsigned section_id,
llvm::StringRef section_name,
bool read_only) override {
// Allocate from the read-only section or the read-write section, depending
// on if this allocation should be read-only or not.
if (read_only) {
return allocate_bump(read_section, read_bump_ptr, size, alignment);
} else {
return allocate_bump(readwrite_section, readwrite_bump_ptr, size,
alignment);
} }
}
virtual uint8_t* allocateCodeSection(uintptr_t size, unsigned alignment, unsigned section_id, llvm::StringRef section_name) override { virtual void reserveAllocationSpace(uintptr_t code_size, uint32_t code_align,
return allocate_bump(code_section, code_bump_ptr, size, alignment); uintptr_t read_data_size,
} uint32_t read_data_align,
uintptr_t read_write_data_size,
virtual uint8_t* allocateDataSection(uintptr_t size, unsigned alignment, unsigned section_id, llvm::StringRef section_name, bool read_only) override { uint32_t read_write_data_align) override {
// Allocate from the read-only section or the read-write section, depending on if this allocation auto aligner = [](uintptr_t ptr, size_t align) {
// should be read-only or not. if (ptr == 0) {
if (read_only) { return align;
return allocate_bump(read_section, read_bump_ptr, size, alignment); }
} else { return (ptr + align - 1) & ~(align - 1);
return allocate_bump(readwrite_section, readwrite_bump_ptr, size, alignment);
}
}
virtual void reserveAllocationSpace(
uintptr_t code_size,
uint32_t code_align,
uintptr_t read_data_size,
uint32_t read_data_align,
uintptr_t read_write_data_size,
uint32_t read_write_data_align
) override {
auto aligner = [](uintptr_t ptr, size_t align) {
if (ptr == 0) {
return align;
}
return (ptr + align - 1) & ~(align - 1);
};
uint8_t *code_ptr_out = nullptr;
size_t code_size_out = 0;
auto code_result = callbacks.alloc_memory(aligner(code_size, 4096), PROTECT_READ_WRITE, &code_ptr_out, &code_size_out);
assert(code_result == RESULT_OK);
code_section = Section { code_ptr_out, code_size_out };
code_bump_ptr = (uintptr_t)code_ptr_out;
uint8_t *read_ptr_out = nullptr;
size_t read_size_out = 0;
auto read_result = callbacks.alloc_memory(aligner(read_data_size, 4096), PROTECT_READ_WRITE, &read_ptr_out, &read_size_out);
assert(read_result == RESULT_OK);
read_section = Section { read_ptr_out, read_size_out };
read_bump_ptr = (uintptr_t)read_ptr_out;
uint8_t *readwrite_ptr_out = nullptr;
size_t readwrite_size_out = 0;
auto readwrite_result = callbacks.alloc_memory(aligner(read_write_data_size, 4096), PROTECT_READ_WRITE, &readwrite_ptr_out, &readwrite_size_out);
assert(readwrite_result == RESULT_OK);
readwrite_section = Section { readwrite_ptr_out, readwrite_size_out };
readwrite_bump_ptr = (uintptr_t)readwrite_ptr_out;
}
/* Turn on the `reserveAllocationSpace` callback. */
virtual bool needsToReserveAllocationSpace() override {
return true;
}
virtual void registerEHFrames(uint8_t* addr, uint64_t LoadAddr, size_t size) override {
// We don't know yet how to do this on Windows, so we hide this on compilation
// so we can compile and pass spectests on unix systems
#ifndef _WIN32
eh_frame_ptr = addr;
eh_frame_size = size;
eh_frames_registered = true;
callbacks.visit_fde(addr, size, __register_frame);
#endif
}
virtual void deregisterEHFrames() override {
// We don't know yet how to do this on Windows, so we hide this on compilation
// so we can compile and pass spectests on unix systems
#ifndef _WIN32
if (eh_frames_registered) {
callbacks.visit_fde(eh_frame_ptr, eh_frame_size, __deregister_frame);
}
#endif
}
virtual bool finalizeMemory(std::string *ErrMsg = nullptr) override {
auto code_result = callbacks.protect_memory(code_section.base, code_section.size, mem_protect_t::PROTECT_READ_EXECUTE);
if (code_result != RESULT_OK) {
return false;
}
auto read_result = callbacks.protect_memory(read_section.base, read_section.size, mem_protect_t::PROTECT_READ);
if (read_result != RESULT_OK) {
return false;
}
// The readwrite section is already mapped as read-write.
return false;
}
virtual void notifyObjectLoaded(llvm::RuntimeDyld &RTDyld, const llvm::object::ObjectFile &Obj) override {}
private:
struct Section {
uint8_t* base;
size_t size;
}; };
uint8_t* allocate_bump(Section& section, uintptr_t& bump_ptr, size_t size, size_t align) { uint8_t *code_ptr_out = nullptr;
auto aligner = [](uintptr_t& ptr, size_t align) { size_t code_size_out = 0;
ptr = (ptr + align - 1) & ~(align - 1); auto code_result =
}; callbacks.alloc_memory(aligner(code_size, 4096), PROTECT_READ_WRITE,
&code_ptr_out, &code_size_out);
assert(code_result == RESULT_OK);
code_section = Section{code_ptr_out, code_size_out};
code_bump_ptr = (uintptr_t)code_ptr_out;
// Align the bump pointer to the requires alignment. uint8_t *read_ptr_out = nullptr;
aligner(bump_ptr, align); size_t read_size_out = 0;
auto read_result = callbacks.alloc_memory(aligner(read_data_size, 4096),
PROTECT_READ_WRITE, &read_ptr_out,
&read_size_out);
assert(read_result == RESULT_OK);
read_section = Section{read_ptr_out, read_size_out};
read_bump_ptr = (uintptr_t)read_ptr_out;
auto ret_ptr = bump_ptr; uint8_t *readwrite_ptr_out = nullptr;
bump_ptr += size; size_t readwrite_size_out = 0;
auto readwrite_result = callbacks.alloc_memory(
aligner(read_write_data_size, 4096), PROTECT_READ_WRITE,
&readwrite_ptr_out, &readwrite_size_out);
assert(readwrite_result == RESULT_OK);
readwrite_section = Section{readwrite_ptr_out, readwrite_size_out};
readwrite_bump_ptr = (uintptr_t)readwrite_ptr_out;
}
assert(bump_ptr <= (uintptr_t)section.base + section.size); /* Turn on the `reserveAllocationSpace` callback. */
virtual bool needsToReserveAllocationSpace() override { return true; }
return (uint8_t*)ret_ptr; virtual void registerEHFrames(uint8_t *addr, uint64_t LoadAddr,
size_t size) override {
// We don't know yet how to do this on Windows, so we hide this on compilation
// so we can compile and pass spectests on unix systems
#ifndef _WIN32
eh_frame_ptr = addr;
eh_frame_size = size;
eh_frames_registered = true;
callbacks.visit_fde(addr, size, __register_frame);
#endif
}
virtual void deregisterEHFrames() override {
// We don't know yet how to do this on Windows, so we hide this on compilation
// so we can compile and pass spectests on unix systems
#ifndef _WIN32
if (eh_frames_registered) {
callbacks.visit_fde(eh_frame_ptr, eh_frame_size, __deregister_frame);
}
#endif
}
virtual bool finalizeMemory(std::string *ErrMsg = nullptr) override {
auto code_result =
callbacks.protect_memory(code_section.base, code_section.size,
mem_protect_t::PROTECT_READ_EXECUTE);
if (code_result != RESULT_OK) {
return false;
} }
Section code_section, read_section, readwrite_section; auto read_result = callbacks.protect_memory(
uintptr_t code_bump_ptr, read_bump_ptr, readwrite_bump_ptr; read_section.base, read_section.size, mem_protect_t::PROTECT_READ);
uint8_t* eh_frame_ptr; if (read_result != RESULT_OK) {
size_t eh_frame_size; return false;
bool eh_frames_registered = false; }
callbacks_t callbacks; // The readwrite section is already mapped as read-write.
return false;
}
virtual void
notifyObjectLoaded(llvm::RuntimeDyld &RTDyld,
const llvm::object::ObjectFile &Obj) override {}
private:
struct Section {
uint8_t *base;
size_t size;
};
uint8_t *allocate_bump(Section &section, uintptr_t &bump_ptr, size_t size,
size_t align) {
auto aligner = [](uintptr_t &ptr, size_t align) {
ptr = (ptr + align - 1) & ~(align - 1);
};
// Align the bump pointer to the requires alignment.
aligner(bump_ptr, align);
auto ret_ptr = bump_ptr;
bump_ptr += size;
assert(bump_ptr <= (uintptr_t)section.base + section.size);
return (uint8_t *)ret_ptr;
}
Section code_section, read_section, readwrite_section;
uintptr_t code_bump_ptr, read_bump_ptr, readwrite_bump_ptr;
uint8_t *eh_frame_ptr;
size_t eh_frame_size;
bool eh_frames_registered = false;
callbacks_t callbacks;
}; };
struct SymbolLookup : llvm::JITSymbolResolver { struct SymbolLookup : llvm::JITSymbolResolver {
public: public:
SymbolLookup(callbacks_t callbacks) : callbacks(callbacks) {} SymbolLookup(callbacks_t callbacks) : callbacks(callbacks) {}
void lookup(const LookupSet& symbols, OnResolvedFunction OnResolved) { void lookup(const LookupSet &symbols, OnResolvedFunction OnResolved) {
LookupResult result; LookupResult result;
for (auto symbol : symbols) { for (auto symbol : symbols) {
result.emplace(symbol, symbol_lookup(symbol)); result.emplace(symbol, symbol_lookup(symbol));
}
OnResolved(result);
} }
llvm::Expected<LookupSet> getResponsibilitySet(const LookupSet &Symbols) { OnResolved(result);
const std::set<llvm::StringRef> empty; }
return empty;
} llvm::Expected<LookupSet> getResponsibilitySet(const LookupSet &Symbols) {
const std::set<llvm::StringRef> empty;
return empty;
}
private: private:
llvm::JITEvaluatedSymbol symbol_lookup(llvm::StringRef name) { llvm::JITEvaluatedSymbol symbol_lookup(llvm::StringRef name) {
uint64_t addr = callbacks.lookup_vm_symbol(name.data(), name.size()); uint64_t addr = callbacks.lookup_vm_symbol(name.data(), name.size());
return llvm::JITEvaluatedSymbol(addr, llvm::JITSymbolFlags::None); return llvm::JITEvaluatedSymbol(addr, llvm::JITSymbolFlags::None);
} }
callbacks_t callbacks; callbacks_t callbacks;
}; };
WasmModule::WasmModule( WasmModule::WasmModule(const uint8_t *object_start, size_t object_size,
const uint8_t *object_start, callbacks_t callbacks)
size_t object_size, : memory_manager(
callbacks_t callbacks std::unique_ptr<MemoryManager>(new MemoryManager(callbacks))) {
) : memory_manager(std::unique_ptr<MemoryManager>(new MemoryManager(callbacks)))
{
if (auto created_object_file =
llvm::object::ObjectFile::createObjectFile(llvm::MemoryBufferRef(
llvm::StringRef((const char *)object_start, object_size),
"object"))) {
object_file = cantFail(std::move(created_object_file));
SymbolLookup symbol_resolver(callbacks);
runtime_dyld = std::unique_ptr<llvm::RuntimeDyld>(
new llvm::RuntimeDyld(*memory_manager, symbol_resolver));
if (auto created_object_file = llvm::object::ObjectFile::createObjectFile(llvm::MemoryBufferRef( runtime_dyld->setProcessAllSections(true);
llvm::StringRef((const char *)object_start, object_size), "object"
))) {
object_file = cantFail(std::move(created_object_file));
SymbolLookup symbol_resolver(callbacks);
runtime_dyld = std::unique_ptr<llvm::RuntimeDyld>(new llvm::RuntimeDyld(*memory_manager, symbol_resolver));
runtime_dyld->setProcessAllSections(true); runtime_dyld->loadObject(*object_file);
runtime_dyld->finalizeWithMemoryManagerLocking();
runtime_dyld->loadObject(*object_file); if (runtime_dyld->hasError()) {
runtime_dyld->finalizeWithMemoryManagerLocking(); _init_failed = true;
return;
if (runtime_dyld->hasError()) {
_init_failed = true;
return;
}
} else {
_init_failed = true;
} }
} else {
_init_failed = true;
}
} }
void* WasmModule::get_func(llvm::StringRef name) const { void *WasmModule::get_func(llvm::StringRef name) const {
auto symbol = runtime_dyld->getSymbol(name); auto symbol = runtime_dyld->getSymbol(name);
return (void*)symbol.getAddress(); return (void *)symbol.getAddress();
} }

374
lib/llvm-backend/cpp/object_loader.hh
View File

@ -6,257 +6,215 @@
#include <llvm/ExecutionEngine/RuntimeDyld.h> #include <llvm/ExecutionEngine/RuntimeDyld.h>
typedef enum typedef enum {
{ PROTECT_NONE,
PROTECT_NONE, PROTECT_READ,
PROTECT_READ, PROTECT_READ_WRITE,
PROTECT_READ_WRITE, PROTECT_READ_EXECUTE,
PROTECT_READ_EXECUTE,
} mem_protect_t; } mem_protect_t;
typedef enum typedef enum {
{ RESULT_OK,
RESULT_OK, RESULT_ALLOCATE_FAILURE,
RESULT_ALLOCATE_FAILURE, RESULT_PROTECT_FAILURE,
RESULT_PROTECT_FAILURE, RESULT_DEALLOC_FAILURE,
RESULT_DEALLOC_FAILURE, RESULT_OBJECT_LOAD_FAILURE,
RESULT_OBJECT_LOAD_FAILURE,
} result_t; } result_t;
typedef result_t (*alloc_memory_t)(size_t size, mem_protect_t protect, uint8_t **ptr_out, size_t *size_out); typedef result_t (*alloc_memory_t)(size_t size, mem_protect_t protect,
typedef result_t (*protect_memory_t)(uint8_t *ptr, size_t size, mem_protect_t protect); uint8_t **ptr_out, size_t *size_out);
typedef result_t (*protect_memory_t)(uint8_t *ptr, size_t size,
mem_protect_t protect);
typedef result_t (*dealloc_memory_t)(uint8_t *ptr, size_t size); typedef result_t (*dealloc_memory_t)(uint8_t *ptr, size_t size);
typedef uintptr_t (*lookup_vm_symbol_t)(const char *name_ptr, size_t length); typedef uintptr_t (*lookup_vm_symbol_t)(const char *name_ptr, size_t length);
typedef void (*fde_visitor_t)(uint8_t *fde); typedef void (*fde_visitor_t)(uint8_t *fde);
typedef result_t (*visit_fde_t)(uint8_t *fde, size_t size, fde_visitor_t visitor); typedef result_t (*visit_fde_t)(uint8_t *fde, size_t size,
fde_visitor_t visitor);
typedef void (*trampoline_t)(void *, void *, void *, void *); typedef void (*trampoline_t)(void *, void *, void *, void *);
typedef struct typedef struct {
{ /* Memory management. */
/* Memory management. */ alloc_memory_t alloc_memory;
alloc_memory_t alloc_memory; protect_memory_t protect_memory;
protect_memory_t protect_memory; dealloc_memory_t dealloc_memory;
dealloc_memory_t dealloc_memory;
lookup_vm_symbol_t lookup_vm_symbol; lookup_vm_symbol_t lookup_vm_symbol;
visit_fde_t visit_fde; visit_fde_t visit_fde;
} callbacks_t; } callbacks_t;
typedef struct typedef struct {
{ size_t data, vtable;
size_t data, vtable;
} box_any_t; } box_any_t;
struct WasmException struct WasmException {
{ public:
public: virtual std::string description() const noexcept = 0;
virtual std::string description() const noexcept = 0;
}; };
struct UncatchableException : WasmException struct UncatchableException : WasmException {
{ public:
public: virtual std::string description() const noexcept override {
virtual std::string description() const noexcept override return "Uncatchable exception";
{ }
return "Uncatchable exception";
}
}; };
struct UserException : UncatchableException struct UserException : UncatchableException {
{ public:
public: UserException(size_t data, size_t vtable) : error_data({data, vtable}) {}
UserException(size_t data, size_t vtable) : error_data({ data, vtable }) {}
virtual std::string description() const noexcept override virtual std::string description() const noexcept override {
{ return "user exception";
return "user exception"; }
}
// The parts of a `Box<dyn Any>`. // The parts of a `Box<dyn Any>`.
box_any_t error_data; box_any_t error_data;
}; };
struct BreakpointException : UncatchableException struct BreakpointException : UncatchableException {
{ public:
public: BreakpointException(uintptr_t callback) : callback(callback) {}
BreakpointException(uintptr_t callback) : callback(callback) {}
virtual std::string description() const noexcept override virtual std::string description() const noexcept override {
{ return "breakpoint exception";
return "breakpoint exception"; }
}
uintptr_t callback; uintptr_t callback;
}; };
struct WasmTrap : UncatchableException struct WasmTrap : UncatchableException {
{ public:
public: enum Type {
enum Type Unreachable = 0,
{ IncorrectCallIndirectSignature = 1,
Unreachable = 0, MemoryOutOfBounds = 2,
IncorrectCallIndirectSignature = 1, CallIndirectOOB = 3,
MemoryOutOfBounds = 2, IllegalArithmetic = 4,
CallIndirectOOB = 3, Unknown,
IllegalArithmetic = 4, };
Unknown,
};
WasmTrap(Type type) : type(type) {} WasmTrap(Type type) : type(type) {}
virtual std::string description() const noexcept override virtual std::string description() const noexcept override {
{ std::ostringstream ss;
std::ostringstream ss; ss << "WebAssembly trap:" << '\n' << " - type: " << type << '\n';
ss
<< "WebAssembly trap:" << '\n'
<< " - type: " << type << '\n';
return ss.str(); return ss.str();
} }
Type type; Type type;
private: private:
friend std::ostream &operator<<(std::ostream &out, const Type &ty) friend std::ostream &operator<<(std::ostream &out, const Type &ty) {
{ switch (ty) {
switch (ty) case Type::Unreachable:
{ out << "unreachable";
case Type::Unreachable: break;
out << "unreachable"; case Type::IncorrectCallIndirectSignature:
break; out << "incorrect call_indirect signature";
case Type::IncorrectCallIndirectSignature: break;
out << "incorrect call_indirect signature"; case Type::MemoryOutOfBounds:
break; out << "memory access out-of-bounds";
case Type::MemoryOutOfBounds: break;
out << "memory access out-of-bounds"; case Type::CallIndirectOOB:
break; out << "call_indirect out-of-bounds";
case Type::CallIndirectOOB: break;
out << "call_indirect out-of-bounds"; case Type::IllegalArithmetic:
break; out << "illegal arithmetic operation";
case Type::IllegalArithmetic: break;
out << "illegal arithmetic operation"; case Type::Unknown:
break; default:
case Type::Unknown: out << "unknown";
default: break;
out << "unknown";
break;
}
return out;
} }
return out;
}
}; };
struct CatchableException : WasmException struct CatchableException : WasmException {
{ public:
public: CatchableException(uint32_t type_id, uint32_t value_num)
CatchableException(uint32_t type_id, uint32_t value_num) : type_id(type_id), value_num(value_num) {} : type_id(type_id), value_num(value_num) {}
virtual std::string description() const noexcept override virtual std::string description() const noexcept override {
{ return "catchable exception";
return "catchable exception"; }
}
uint32_t type_id, value_num; uint32_t type_id, value_num;
uint64_t values[1]; uint64_t values[1];
}; };
struct WasmModule struct WasmModule {
{ public:
public: WasmModule(const uint8_t *object_start, size_t object_size,
WasmModule( callbacks_t callbacks);
const uint8_t *object_start,
size_t object_size,
callbacks_t callbacks);
void *get_func(llvm::StringRef name) const; void *get_func(llvm::StringRef name) const;
bool _init_failed = false; bool _init_failed = false;
private:
std::unique_ptr<llvm::RuntimeDyld::MemoryManager> memory_manager; private:
std::unique_ptr<llvm::object::ObjectFile> object_file; std::unique_ptr<llvm::RuntimeDyld::MemoryManager> memory_manager;
std::unique_ptr<llvm::RuntimeDyld> runtime_dyld; std::unique_ptr<llvm::object::ObjectFile> object_file;
std::unique_ptr<llvm::RuntimeDyld> runtime_dyld;
}; };
extern "C" extern "C" {
{ void callback_trampoline(void *, void *);
void callback_trampoline(void *, void *);
result_t module_load(const uint8_t *mem_ptr, size_t mem_size, callbacks_t callbacks, WasmModule **module_out) result_t module_load(const uint8_t *mem_ptr, size_t mem_size,
{ callbacks_t callbacks, WasmModule **module_out) {
*module_out = new WasmModule(mem_ptr, mem_size, callbacks); *module_out = new WasmModule(mem_ptr, mem_size, callbacks);
if ((*module_out)->_init_failed) { if ((*module_out)->_init_failed) {
return RESULT_OBJECT_LOAD_FAILURE; return RESULT_OBJECT_LOAD_FAILURE;
} }
return RESULT_OK; return RESULT_OK;
} }
[[noreturn]] void throw_trap(WasmTrap::Type ty) { [[noreturn]] void throw_trap(WasmTrap::Type ty) { throw WasmTrap(ty); }
throw WasmTrap(ty);
} void module_delete(WasmModule *module) { delete module; }
void module_delete(WasmModule *module) // Throw a fat pointer that's assumed to be `*mut dyn Any` on the rust
{ // side.
delete module; [[noreturn]] void throw_any(size_t data, size_t vtable) {
} throw UserException(data, vtable);
}
// Throw a fat pointer that's assumed to be `*mut dyn Any` on the rust
// side. // Throw a pointer that's assumed to be codegen::BreakpointHandler on the
[[noreturn]] void throw_any(size_t data, size_t vtable) { // rust side.
throw UserException(data, vtable); [[noreturn]] void throw_breakpoint(uintptr_t callback) {
} throw BreakpointException(callback);
}
// Throw a pointer that's assumed to be codegen::BreakpointHandler on the
// rust side. bool invoke_trampoline(trampoline_t trampoline, void *ctx, void *func,
[[noreturn]] void throw_breakpoint(uintptr_t callback) { void *params, void *results, WasmTrap::Type *trap_out,
throw BreakpointException(callback); box_any_t *user_error, void *invoke_env) throw() {
} try {
trampoline(ctx, func, params, results);
bool invoke_trampoline( return true;
trampoline_t trampoline, } catch (const WasmTrap &e) {
void *ctx, *trap_out = e.type;
void *func, return false;
void *params, } catch (const UserException &e) {
void *results, *user_error = e.error_data;
WasmTrap::Type *trap_out, return false;
box_any_t *user_error, } catch (const BreakpointException &e) {
void *invoke_env) throw() callback_trampoline(user_error, (void *)e.callback);
{ return false;
try } catch (const WasmException &e) {
{ *trap_out = WasmTrap::Type::Unknown;
trampoline(ctx, func, params, results); return false;
return true; } catch (...) {
} *trap_out = WasmTrap::Type::Unknown;
catch (const WasmTrap &e) return false;
{ }
*trap_out = e.type; }
return false;
} void *get_func_symbol(WasmModule *module, const char *name) {
catch (const UserException &e) return module->get_func(llvm::StringRef(name));
{ }
*user_error = e.error_data;
return false;
}
catch (const BreakpointException &e) {
callback_trampoline(user_error, (void *)e.callback);
return false;
}
catch (const WasmException &e)
{
*trap_out = WasmTrap::Type::Unknown;
return false;
}
catch (...)
{
*trap_out = WasmTrap::Type::Unknown;
return false;
}
}
void *get_func_symbol(WasmModule *module, const char *name)
{
return module->get_func(llvm::StringRef(name));
}
} }