mii/wasmer
1
0
Fork 0
mirror of https://github.com/mii443/wasmer.git synced 2025-12-16 17:18:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Port C API to new Context API

Browse Source
This commit is contained in:
Manos Pitsidianakis
2022-06-23 13:51:26 +03:00
parent 0417111ada
commit 34a6511e16
31 changed files with 647 additions and 413 deletions
Download Patch File Download Diff File Expand all files Collapse all files

138
lib/c-api/tests/wasm-c-api/include/wasm.hh
View File

@@ -128,7 +128,7 @@ public:
return v;
}
// TODO: This can't be used for e.g. vec<Val>
// TODO: This can't be used for e.g. vec<Value>
auto deep_copy() const -> vec {
auto v = vec(size_);
if (v) for (size_t i = 0; i < size_; ++i) v.data_[i] = data_[i]->copy();
@@ -246,25 +246,25 @@ struct Limits {
// Value Types
enum class ValKind : uint8_t {
enum class ValueKind : uint8_t {
I32, I64, F32, F64,
ANYREF = 128, FUNCREF,
};
inline bool is_num(ValKind k) { return k < ValKind::ANYREF; }
inline bool is_ref(ValKind k) { return k >= ValKind::ANYREF; }
inline bool is_num(ValueKind k) { return k < ValueKind::ANYREF; }
inline bool is_ref(ValueKind k) { return k >= ValueKind::ANYREF; }
class WASM_API_EXTERN ValType {
class WASM_API_EXTERN ValueType {
public:
ValType() = delete;
~ValType();
ValueType() = delete;
~ValueType();
void operator delete(void*);
static auto make(ValKind) -> own<ValType>;
auto copy() const -> own<ValType>;
static auto make(ValueKind) -> own<ValueType>;
auto copy() const -> own<ValueType>;
auto kind() const -> ValKind;
auto kind() const -> ValueKind;
auto is_num() const -> bool { return wasm::is_num(kind()); }
auto is_ref() const -> bool { return wasm::is_ref(kind()); }
};
@@ -311,14 +311,14 @@ public:
~FuncType();
static auto make(
ownvec<ValType>&& params = ownvec<ValType>::make(),
ownvec<ValType>&& results = ownvec<ValType>::make()
ownvec<ValueType>&& params = ownvec<ValueType>::make(),
ownvec<ValueType>&& results = ownvec<ValueType>::make()
) -> own<FuncType>;
auto copy() const -> own<FuncType>;
auto params() const -> const ownvec<ValType>&;
auto results() const -> const ownvec<ValType>&;
auto params() const -> const ownvec<ValueType>&;
auto results() const -> const ownvec<ValueType>&;
};
@@ -329,10 +329,10 @@ public:
GlobalType() = delete;
~GlobalType();
static auto make(own<ValType>&&, Mutability) -> own<GlobalType>;
static auto make(own<ValueType>&&, Mutability) -> own<GlobalType>;
auto copy() const -> own<GlobalType>;
auto content() const -> const ValType*;
auto content() const -> const ValueType*;
auto mutability() const -> Mutability;
};
@@ -344,10 +344,10 @@ public:
TableType() = delete;
~TableType();
static auto make(own<ValType>&&, Limits) -> own<TableType>;
static auto make(own<ValueType>&&, Limits) -> own<TableType>;
auto copy() const -> own<TableType>;
auto element() const -> const ValType*;
auto element() const -> const ValueType*;
auto limits() const -> const Limits&;
};
@@ -423,8 +423,8 @@ public:
// Values
class Val {
ValKind kind_;
class Value {
ValueKind kind_;
union impl {
int32_t i32;
int64_t i64;
@@ -433,34 +433,34 @@ class Val {
Ref* ref;
} impl_;
Val(ValKind kind, impl impl) : kind_(kind), impl_(impl) {}
Value(ValueKind kind, impl impl) : kind_(kind), impl_(impl) {}
public:
Val() : kind_(ValKind::ANYREF) { impl_.ref = nullptr; }
explicit Val(int32_t i) : kind_(ValKind::I32) { impl_.i32 = i; }
explicit Val(int64_t i) : kind_(ValKind::I64) { impl_.i64 = i; }
explicit Val(float32_t z) : kind_(ValKind::F32) { impl_.f32 = z; }
explicit Val(float64_t z) : kind_(ValKind::F64) { impl_.f64 = z; }
explicit Val(own<Ref>&& r) : kind_(ValKind::ANYREF) { impl_.ref = r.release(); }
Value() : kind_(ValueKind::ANYREF) { impl_.ref = nullptr; }
explicit Value(int32_t i) : kind_(ValueKind::I32) { impl_.i32 = i; }
explicit Value(int64_t i) : kind_(ValueKind::I64) { impl_.i64 = i; }
explicit Value(float32_t z) : kind_(ValueKind::F32) { impl_.f32 = z; }
explicit Value(float64_t z) : kind_(ValueKind::F64) { impl_.f64 = z; }
explicit Value(own<Ref>&& r) : kind_(ValueKind::ANYREF) { impl_.ref = r.release(); }
Val(Val&& that) : kind_(that.kind_), impl_(that.impl_) {
Value(Value&& that) : kind_(that.kind_), impl_(that.impl_) {
if (is_ref()) that.impl_.ref = nullptr;
}
~Val() {
~Value() {
reset();
}
auto is_num() const -> bool { return wasm::is_num(kind_); }
auto is_ref() const -> bool { return wasm::is_ref(kind_); }
static auto i32(int32_t x) -> Val { return Val(x); }
static auto i64(int64_t x) -> Val { return Val(x); }
static auto f32(float32_t x) -> Val { return Val(x); }
static auto f64(float64_t x) -> Val { return Val(x); }
static auto ref(own<Ref>&& x) -> Val { return Val(std::move(x)); }
template<class T> inline static auto make(T x) -> Val;
template<class T> inline static auto make(own<T>&& x) -> Val;
static auto i32(int32_t x) -> Value { return Value(x); }
static auto i64(int64_t x) -> Value { return Value(x); }
static auto f32(float32_t x) -> Value { return Value(x); }
static auto f64(float64_t x) -> Value { return Value(x); }
static auto ref(own<Ref>&& x) -> Value { return Value(std::move(x)); }
template<class T> inline static auto make(T x) -> Value;
template<class T> inline static auto make(own<T>&& x) -> Value;
void reset() {
if (is_ref() && impl_.ref) {
@@ -469,23 +469,23 @@ public:
}
}
void reset(Val& that) {
void reset(Value& that) {
reset();
kind_ = that.kind_;
impl_ = that.impl_;
if (is_ref()) that.impl_.ref = nullptr;
}
auto operator=(Val&& that) -> Val& {
auto operator=(Value&& that) -> Value& {
reset(that);
return *this;
}
auto kind() const -> ValKind { return kind_; }
auto i32() const -> int32_t { assert(kind_ == ValKind::I32); return impl_.i32; }
auto i64() const -> int64_t { assert(kind_ == ValKind::I64); return impl_.i64; }
auto f32() const -> float32_t { assert(kind_ == ValKind::F32); return impl_.f32; }
auto f64() const -> float64_t { assert(kind_ == ValKind::F64); return impl_.f64; }
auto kind() const -> ValueKind { return kind_; }
auto i32() const -> int32_t { assert(kind_ == ValueKind::I32); return impl_.i32; }
auto i64() const -> int64_t { assert(kind_ == ValueKind::I64); return impl_.i64; }
auto f32() const -> float32_t { assert(kind_ == ValueKind::F32); return impl_.f32; }
auto f64() const -> float64_t { assert(kind_ == ValueKind::F64); return impl_.f64; }
auto ref() const -> Ref* { assert(is_ref()); return impl_.ref; }
template<class T> inline auto get() const -> T;
@@ -496,45 +496,45 @@ public:
return own<Ref>(ref);
}
auto copy() const -> Val {
auto copy() const -> Value {
if (is_ref() && impl_.ref != nullptr) {
// TODO(mvsc): MVSC cannot handle this:
// impl impl = {.ref = impl_.ref->copy().release()};
impl impl;
impl.ref = impl_.ref->copy().release();
return Val(kind_, impl);
return Value(kind_, impl);
} else {
return Val(kind_, impl_);
return Value(kind_, impl_);
}
}
};
template<> inline auto Val::make<int32_t>(int32_t x) -> Val { return Val(x); }
template<> inline auto Val::make<int64_t>(int64_t x) -> Val { return Val(x); }
template<> inline auto Val::make<float32_t>(float32_t x) -> Val { return Val(x); }
template<> inline auto Val::make<float64_t>(float64_t x) -> Val { return Val(x); }
template<> inline auto Val::make<Ref>(own<Ref>&& x) -> Val {
return Val(std::move(x));
template<> inline auto Value::make<int32_t>(int32_t x) -> Value { return Value(x); }
template<> inline auto Value::make<int64_t>(int64_t x) -> Value { return Value(x); }
template<> inline auto Value::make<float32_t>(float32_t x) -> Value { return Value(x); }
template<> inline auto Value::make<float64_t>(float64_t x) -> Value { return Value(x); }
template<> inline auto Value::make<Ref>(own<Ref>&& x) -> Value {
return Value(std::move(x));
}
template<> inline auto Val::make<uint32_t>(uint32_t x) -> Val {
return Val(static_cast<int32_t>(x));
template<> inline auto Value::make<uint32_t>(uint32_t x) -> Value {
return Value(static_cast<int32_t>(x));
}
template<> inline auto Val::make<uint64_t>(uint64_t x) -> Val {
return Val(static_cast<int64_t>(x));
template<> inline auto Value::make<uint64_t>(uint64_t x) -> Value {
return Value(static_cast<int64_t>(x));
}
template<> inline auto Val::get<int32_t>() const -> int32_t { return i32(); }
template<> inline auto Val::get<int64_t>() const -> int64_t { return i64(); }
template<> inline auto Val::get<float32_t>() const -> float32_t { return f32(); }
template<> inline auto Val::get<float64_t>() const -> float64_t { return f64(); }
template<> inline auto Val::get<Ref*>() const -> Ref* { return ref(); }
template<> inline auto Value::get<int32_t>() const -> int32_t { return i32(); }
template<> inline auto Value::get<int64_t>() const -> int64_t { return i64(); }
template<> inline auto Value::get<float32_t>() const -> float32_t { return f32(); }
template<> inline auto Value::get<float64_t>() const -> float64_t { return f64(); }
template<> inline auto Value::get<Ref*>() const -> Ref* { return ref(); }
template<> inline auto Val::get<uint32_t>() const -> uint32_t {
template<> inline auto Value::get<uint32_t>() const -> uint32_t {
return static_cast<uint32_t>(i32());
}
template<> inline auto Val::get<uint64_t>() const -> uint64_t {
template<> inline auto Value::get<uint64_t>() const -> uint64_t {
return static_cast<uint64_t>(i64());
}
@@ -654,8 +654,8 @@ public:
Func() = delete;
~Func();
using callback = auto (*)(const vec<Val>&, vec<Val>&) -> own<Trap>;
using callback_with_env = auto (*)(void*, const vec<Val>&, vec<Val>&) -> own<Trap>;
using callback = auto (*)(const vec<Value>&, vec<Value>&) -> own<Trap>;
using callback_with_env = auto (*)(void*, const vec<Value>&, vec<Value>&) -> own<Trap>;
static auto make(Store*, const FuncType*, callback) -> own<Func>;
static auto make(Store*, const FuncType*, callback_with_env,
@@ -666,7 +666,7 @@ public:
auto param_arity() const -> size_t;
auto result_arity() const -> size_t;
auto call(const vec<Val>&, vec<Val>&) const -> own<Trap>;
auto call(const vec<Value>&, vec<Value>&) const -> own<Trap>;
};
@@ -677,12 +677,12 @@ public:
Global() = delete;
~Global();
static auto make(Store*, const GlobalType*, const Val&) -> own<Global>;
static auto make(Store*, const GlobalType*, const Value&) -> own<Global>;
auto copy() const -> own<Global>;
auto type() const -> own<GlobalType>;
auto get() const -> Val;
void set(const Val&);
auto get() const -> Value;
void set(const Value&);
};