Skip to content

Commit d32cb05

Browse files
mathetakemathetake
authoredAug 2, 2021
Delete unused raw_context arg in host functions. (#183)
Signed-off-by: Takeshi Yoneda <[email protected]>
1 parent 5607523 commit d32cb05

File tree

9 files changed

+369
-389
lines changed

9 files changed

+369
-389
lines changed
 

Diff for: ‎include/proxy-wasm/exports.h

+83-96
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,9 @@ namespace proxy_wasm {
2525

2626
class ContextBase;
2727

28+
// Any currently executing Wasm call context.
29+
::proxy_wasm::ContextBase *contextOrEffectiveContext();
30+
2831
extern thread_local ContextBase *current_context_;
2932

3033
namespace exports {
@@ -61,100 +64,87 @@ template <typename Pairs> void marshalPairs(const Pairs &result, char *buffer) {
6164

6265
// ABI functions exported from host to wasm.
6366

64-
Word get_configuration(void *raw_context, Word address, Word size);
65-
Word get_status(void *raw_context, Word status_code, Word address, Word size);
66-
Word log(void *raw_context, Word level, Word address, Word size);
67-
Word get_log_level(void *raw_context, Word result_level_uint32_ptr);
68-
Word get_property(void *raw_context, Word path_ptr, Word path_size, Word value_ptr_ptr,
69-
Word value_size_ptr);
70-
Word set_property(void *raw_context, Word key_ptr, Word key_size, Word value_ptr, Word value_size);
71-
Word continue_request(void *raw_context);
72-
Word continue_response(void *raw_context);
73-
Word continue_stream(void *raw_context, Word stream_type);
74-
Word close_stream(void *raw_context, Word stream_type);
75-
Word send_local_response(void *raw_context, Word response_code, Word response_code_details_ptr,
67+
Word get_configuration(Word address, Word size);
68+
Word get_status(Word status_code, Word address, Word size);
69+
Word log(Word level, Word address, Word size);
70+
Word get_log_level(Word result_level_uint32_ptr);
71+
Word get_property(Word path_ptr, Word path_size, Word value_ptr_ptr, Word value_size_ptr);
72+
Word set_property(Word key_ptr, Word key_size, Word value_ptr, Word value_size);
73+
Word continue_request();
74+
Word continue_response();
75+
Word continue_stream(Word stream_type);
76+
Word close_stream(Word stream_type);
77+
Word send_local_response(Word response_code, Word response_code_details_ptr,
7678
Word response_code_details_size, Word body_ptr, Word body_size,
7779
Word additional_response_header_pairs_ptr,
7880
Word additional_response_header_pairs_size, Word grpc_status);
79-
Word clear_route_cache(void *raw_context);
80-
Word get_shared_data(void *raw_context, Word key_ptr, Word key_size, Word value_ptr_ptr,
81-
Word value_size_ptr, Word cas_ptr);
82-
Word set_shared_data(void *raw_context, Word key_ptr, Word key_size, Word value_ptr,
83-
Word value_size, Word cas);
84-
Word register_shared_queue(void *raw_context, Word queue_name_ptr, Word queue_name_size,
85-
Word token_ptr);
86-
Word resolve_shared_queue(void *raw_context, Word vm_id_ptr, Word vm_id_size, Word queue_name_ptr,
81+
Word clear_route_cache();
82+
Word get_shared_data(Word key_ptr, Word key_size, Word value_ptr_ptr, Word value_size_ptr,
83+
Word cas_ptr);
84+
Word set_shared_data(Word key_ptr, Word key_size, Word value_ptr, Word value_size, Word cas);
85+
Word register_shared_queue(Word queue_name_ptr, Word queue_name_size, Word token_ptr);
86+
Word resolve_shared_queue(Word vm_id_ptr, Word vm_id_size, Word queue_name_ptr,
8787
Word queue_name_size, Word token_ptr);
88-
Word dequeue_shared_queue(void *raw_context, Word token, Word data_ptr_ptr, Word data_size_ptr);
89-
Word enqueue_shared_queue(void *raw_context, Word token, Word data_ptr, Word data_size);
90-
Word get_buffer_bytes(void *raw_context, Word type, Word start, Word length, Word ptr_ptr,
91-
Word size_ptr);
92-
Word get_buffer_status(void *raw_context, Word type, Word length_ptr, Word flags_ptr);
93-
Word set_buffer_bytes(void *raw_context, Word type, Word start, Word length, Word data_ptr,
94-
Word data_size);
95-
Word add_header_map_value(void *raw_context, Word type, Word key_ptr, Word key_size, Word value_ptr,
96-
Word value_size);
97-
Word get_header_map_value(void *raw_context, Word type, Word key_ptr, Word key_size,
98-
Word value_ptr_ptr, Word value_size_ptr);
99-
Word replace_header_map_value(void *raw_context, Word type, Word key_ptr, Word key_size,
100-
Word value_ptr, Word value_size);
101-
Word remove_header_map_value(void *raw_context, Word type, Word key_ptr, Word key_size);
102-
Word get_header_map_pairs(void *raw_context, Word type, Word ptr_ptr, Word size_ptr);
103-
Word set_header_map_pairs(void *raw_context, Word type, Word ptr, Word size);
104-
Word get_header_map_size(void *raw_context, Word type, Word result_ptr);
105-
Word getRequestBodyBufferBytes(void *raw_context, Word start, Word length, Word ptr_ptr,
106-
Word size_ptr);
107-
Word get_response_body_buffer_bytes(void *raw_context, Word start, Word length, Word ptr_ptr,
108-
Word size_ptr);
109-
Word http_call(void *raw_context, Word uri_ptr, Word uri_size, Word header_pairs_ptr,
110-
Word header_pairs_size, Word body_ptr, Word body_size, Word trailer_pairs_ptr,
111-
Word trailer_pairs_size, Word timeout_milliseconds, Word token_ptr);
112-
Word define_metric(void *raw_context, Word metric_type, Word name_ptr, Word name_size,
113-
Word result_ptr);
114-
Word increment_metric(void *raw_context, Word metric_id, int64_t offset);
115-
Word record_metric(void *raw_context, Word metric_id, uint64_t value);
116-
Word get_metric(void *raw_context, Word metric_id, Word result_uint64_ptr);
117-
Word grpc_call(void *raw_context, Word service_ptr, Word service_size, Word service_name_ptr,
118-
Word service_name_size, Word method_name_ptr, Word method_name_size,
119-
Word initial_metadata_ptr, Word initial_metadata_size, Word request_ptr,
120-
Word request_size, Word timeout_milliseconds, Word token_ptr);
121-
Word grpc_stream(void *raw_context, Word service_ptr, Word service_size, Word service_name_ptr,
122-
Word service_name_size, Word method_name_ptr, Word method_name_size,
123-
Word initial_metadata_ptr, Word initial_metadata_size, Word token_ptr);
124-
Word grpc_cancel(void *raw_context, Word token);
125-
Word grpc_close(void *raw_context, Word token);
126-
Word grpc_send(void *raw_context, Word token, Word message_ptr, Word message_size, Word end_stream);
127-
128-
Word set_tick_period_milliseconds(void *raw_context, Word tick_period_milliseconds);
129-
Word get_current_time_nanoseconds(void *raw_context, Word result_uint64_ptr);
130-
131-
Word set_effective_context(void *raw_context, Word context_id);
132-
Word done(void *raw_context);
133-
Word call_foreign_function(void *raw_context, Word function_name, Word function_name_size,
134-
Word arguments, Word warguments_size, Word results, Word results_size);
88+
Word dequeue_shared_queue(Word token, Word data_ptr_ptr, Word data_size_ptr);
89+
Word enqueue_shared_queue(Word token, Word data_ptr, Word data_size);
90+
Word get_buffer_bytes(Word type, Word start, Word length, Word ptr_ptr, Word size_ptr);
91+
Word get_buffer_status(Word type, Word length_ptr, Word flags_ptr);
92+
Word set_buffer_bytes(Word type, Word start, Word length, Word data_ptr, Word data_size);
93+
Word add_header_map_value(Word type, Word key_ptr, Word key_size, Word value_ptr, Word value_size);
94+
Word get_header_map_value(Word type, Word key_ptr, Word key_size, Word value_ptr_ptr,
95+
Word value_size_ptr);
96+
Word replace_header_map_value(Word type, Word key_ptr, Word key_size, Word value_ptr,
97+
Word value_size);
98+
Word remove_header_map_value(Word type, Word key_ptr, Word key_size);
99+
Word get_header_map_pairs(Word type, Word ptr_ptr, Word size_ptr);
100+
Word set_header_map_pairs(Word type, Word ptr, Word size);
101+
Word get_header_map_size(Word type, Word result_ptr);
102+
Word getRequestBodyBufferBytes(Word start, Word length, Word ptr_ptr, Word size_ptr);
103+
Word get_response_body_buffer_bytes(Word start, Word length, Word ptr_ptr, Word size_ptr);
104+
Word http_call(Word uri_ptr, Word uri_size, Word header_pairs_ptr, Word header_pairs_size,
105+
Word body_ptr, Word body_size, Word trailer_pairs_ptr, Word trailer_pairs_size,
106+
Word timeout_milliseconds, Word token_ptr);
107+
Word define_metric(Word metric_type, Word name_ptr, Word name_size, Word result_ptr);
108+
Word increment_metric(Word metric_id, int64_t offset);
109+
Word record_metric(Word metric_id, uint64_t value);
110+
Word get_metric(Word metric_id, Word result_uint64_ptr);
111+
Word grpc_call(Word service_ptr, Word service_size, Word service_name_ptr, Word service_name_size,
112+
Word method_name_ptr, Word method_name_size, Word initial_metadata_ptr,
113+
Word initial_metadata_size, Word request_ptr, Word request_size,
114+
Word timeout_milliseconds, Word token_ptr);
115+
Word grpc_stream(Word service_ptr, Word service_size, Word service_name_ptr, Word service_name_size,
116+
Word method_name_ptr, Word method_name_size, Word initial_metadata_ptr,
117+
Word initial_metadata_size, Word token_ptr);
118+
Word grpc_cancel(Word token);
119+
Word grpc_close(Word token);
120+
Word grpc_send(Word token, Word message_ptr, Word message_size, Word end_stream);
121+
122+
Word set_tick_period_milliseconds(Word tick_period_milliseconds);
123+
Word get_current_time_nanoseconds(Word result_uint64_ptr);
124+
125+
Word set_effective_context(Word context_id);
126+
Word done();
127+
Word call_foreign_function(Word function_name, Word function_name_size, Word arguments,
128+
Word warguments_size, Word results, Word results_size);
135129

136130
// Runtime environment functions exported from envoy to wasm.
137131

138-
Word wasi_unstable_fd_write(void *raw_context, Word fd, Word iovs, Word iovs_len,
139-
Word nwritten_ptr);
140-
Word wasi_unstable_fd_read(void *, Word, Word, Word, Word);
141-
Word wasi_unstable_fd_seek(void *, Word, int64_t, Word, Word);
142-
Word wasi_unstable_fd_close(void *, Word);
143-
Word wasi_unstable_fd_fdstat_get(void *, Word fd, Word statOut);
144-
Word wasi_unstable_environ_get(void *, Word, Word);
145-
Word wasi_unstable_environ_sizes_get(void *raw_context, Word count_ptr, Word buf_size_ptr);
146-
Word wasi_unstable_args_get(void *raw_context, Word argc_ptr, Word argv_buf_size_ptr);
147-
Word wasi_unstable_args_sizes_get(void *raw_context, Word argc_ptr, Word argv_buf_size_ptr);
148-
void wasi_unstable_proc_exit(void *, Word);
149-
Word wasi_unstable_clock_time_get(void *, Word, uint64_t, Word);
150-
Word wasi_unstable_random_get(void *, Word, Word);
151-
Word pthread_equal(void *, Word left, Word right);
132+
Word wasi_unstable_fd_write(Word fd, Word iovs, Word iovs_len, Word nwritten_ptr);
133+
Word wasi_unstable_fd_read(Word, Word, Word, Word);
134+
Word wasi_unstable_fd_seek(Word, int64_t, Word, Word);
135+
Word wasi_unstable_fd_close(Word);
136+
Word wasi_unstable_fd_fdstat_get(Word fd, Word statOut);
137+
Word wasi_unstable_environ_get(Word, Word);
138+
Word wasi_unstable_environ_sizes_get(Word count_ptr, Word buf_size_ptr);
139+
Word wasi_unstable_args_get(Word argc_ptr, Word argv_buf_size_ptr);
140+
Word wasi_unstable_args_sizes_get(Word argc_ptr, Word argv_buf_size_ptr);
141+
void wasi_unstable_proc_exit(Word);
142+
Word wasi_unstable_clock_time_get(Word, uint64_t, Word);
143+
Word wasi_unstable_random_get(Word, Word);
144+
Word pthread_equal(Word left, Word right);
152145

153146
// Support for embedders, not exported to Wasm.
154147

155-
// Any currently executing Wasm call context.
156-
::proxy_wasm::ContextBase *ContextOrEffectiveContext(::proxy_wasm::ContextBase *context);
157-
158148
#define FOR_ALL_HOST_FUNCTIONS(_f) \
159149
_f(log) _f(get_status) _f(set_property) _f(get_property) _f(send_local_response) \
160150
_f(get_shared_data) _f(set_shared_data) _f(register_shared_queue) _f(resolve_shared_queue) \
@@ -181,10 +171,9 @@ ::proxy_wasm::ContextBase *ContextOrEffectiveContext(::proxy_wasm::ContextBase *
181171
// Helpers to generate a stub to pass to VM, in place of a restricted proxy-wasm capability.
182172
#define _CREATE_PROXY_WASM_STUB(_fn) \
183173
template <typename F> struct _fn##Stub; \
184-
template <typename... Args> struct _fn##Stub<Word(void *, Args...)> { \
185-
static Word stub(void *raw_context, Args...) { \
186-
auto context = exports::ContextOrEffectiveContext( \
187-
static_cast<ContextBase *>((void)raw_context, current_context_)); \
174+
template <typename... Args> struct _fn##Stub<Word(Args...)> { \
175+
static Word stub(Args...) { \
176+
auto context = contextOrEffectiveContext(); \
188177
context->wasmVm()->integration()->error( \
189178
"Attempted call to restricted proxy-wasm capability: proxy_" #_fn); \
190179
return WasmResult::InternalFailure; \
@@ -197,19 +186,17 @@ FOR_ALL_HOST_FUNCTIONS_ABI_SPECIFIC(_CREATE_PROXY_WASM_STUB)
197186
// Helpers to generate a stub to pass to VM, in place of a restricted WASI capability.
198187
#define _CREATE_WASI_STUB(_fn) \
199188
template <typename F> struct _fn##Stub; \
200-
template <typename... Args> struct _fn##Stub<Word(void *, Args...)> { \
201-
static Word stub(void *raw_context, Args...) { \
202-
auto context = exports::ContextOrEffectiveContext( \
203-
static_cast<ContextBase *>((void)raw_context, current_context_)); \
189+
template <typename... Args> struct _fn##Stub<Word(Args...)> { \
190+
static Word stub(Args...) { \
191+
auto context = contextOrEffectiveContext(); \
204192
context->wasmVm()->integration()->error( \
205193
"Attempted call to restricted WASI capability: " #_fn); \
206194
return 76; /* __WASI_ENOTCAPABLE */ \
207195
} \
208196
}; \
209-
template <typename... Args> struct _fn##Stub<void(void *, Args...)> { \
210-
static void stub(void *raw_context, Args...) { \
211-
auto context = exports::ContextOrEffectiveContext( \
212-
static_cast<ContextBase *>((void)raw_context, current_context_)); \
197+
template <typename... Args> struct _fn##Stub<void(Args...)> { \
198+
static void stub(Args...) { \
199+
auto context = contextOrEffectiveContext(); \
213200
context->wasmVm()->integration()->error( \
214201
"Attempted call to restricted WASI capability: " #_fn); \
215202
} \

Diff for: ‎include/proxy-wasm/wasm_api_impl.h

+66-78
Large diffs are not rendered by default.

Diff for: ‎include/proxy-wasm/wasm_vm.h

+50-21
Original file line numberDiff line numberDiff line change
@@ -29,58 +29,87 @@ namespace proxy_wasm {
2929

3030
class ContextBase;
3131

32-
// These are templates and its helper for constructing signatures of functions calling into and out
33-
// of WASM VMs.
34-
// - WasmFuncTypeHelper is a helper for WasmFuncType and shouldn't be used anywhere else than
32+
// These are templates and its helper for constructing signatures of functions calling into Wasm
33+
// VMs.
34+
// - WasmCallInFuncTypeHelper is a helper for WasmFuncType and shouldn't be used anywhere else than
3535
// WasmFuncType definition.
36-
// - WasmFuncType takes 4 template parameter which are number of argument, return type, context type
37-
// and param type respectively, resolve to a function type.
36+
// - WasmCallInFuncType takes 4 template parameter which are number of argument, return type,
37+
// context type and param type respectively, resolve to a function type.
3838
// For example `WasmFuncType<3, void, Context*, Word>` resolves to `void(Context*, Word, Word,
3939
// Word)`
4040
template <size_t N, class ReturnType, class ContextType, class ParamType,
4141
class FuncBase = ReturnType(ContextType)>
42-
struct WasmFuncTypeHelper {};
42+
struct WasmCallInFuncTypeHelper {};
4343

4444
template <size_t N, class ReturnType, class ContextType, class ParamType, class... Args>
45-
struct WasmFuncTypeHelper<N, ReturnType, ContextType, ParamType, ReturnType(ContextType, Args...)> {
45+
struct WasmCallInFuncTypeHelper<N, ReturnType, ContextType, ParamType,
46+
ReturnType(ContextType, Args...)> {
4647
// NOLINTNEXTLINE(readability-identifier-naming)
47-
using type = typename WasmFuncTypeHelper<N - 1, ReturnType, ContextType, ParamType,
48-
ReturnType(ContextType, Args..., ParamType)>::type;
48+
using type = typename WasmCallInFuncTypeHelper<N - 1, ReturnType, ContextType, ParamType,
49+
ReturnType(ContextType, Args..., ParamType)>::type;
4950
};
5051

5152
template <class ReturnType, class ContextType, class ParamType, class... Args>
52-
struct WasmFuncTypeHelper<0, ReturnType, ContextType, ParamType, ReturnType(ContextType, Args...)> {
53+
struct WasmCallInFuncTypeHelper<0, ReturnType, ContextType, ParamType,
54+
ReturnType(ContextType, Args...)> {
5355
using type = ReturnType(ContextType, Args...); // NOLINT(readability-identifier-naming)
5456
};
5557

5658
template <size_t N, class ReturnType, class ContextType, class ParamType>
57-
using WasmFuncType = typename WasmFuncTypeHelper<N, ReturnType, ContextType, ParamType>::type;
59+
using WasmCallInFuncType =
60+
typename WasmCallInFuncTypeHelper<N, ReturnType, ContextType, ParamType>::type;
5861

5962
// Calls into the WASM VM.
6063
// 1st arg is always a pointer to Context (Context*).
61-
template <size_t N> using WasmCallVoid = std::function<WasmFuncType<N, void, ContextBase *, Word>>;
62-
template <size_t N> using WasmCallWord = std::function<WasmFuncType<N, Word, ContextBase *, Word>>;
64+
template <size_t N>
65+
using WasmCallVoid = std::function<WasmCallInFuncType<N, void, ContextBase *, Word>>;
66+
template <size_t N>
67+
using WasmCallWord = std::function<WasmCallInFuncType<N, Word, ContextBase *, Word>>;
6368

6469
#define FOR_ALL_WASM_VM_EXPORTS(_f) \
6570
_f(proxy_wasm::WasmCallVoid<0>) _f(proxy_wasm::WasmCallVoid<1>) _f(proxy_wasm::WasmCallVoid<2>) \
6671
_f(proxy_wasm::WasmCallVoid<3>) _f(proxy_wasm::WasmCallVoid<5>) \
6772
_f(proxy_wasm::WasmCallWord<1>) _f(proxy_wasm::WasmCallWord<2>) \
6873
_f(proxy_wasm::WasmCallWord<3>)
6974

75+
// These are templates and its helper for constructing signatures of functions callbacks from Wasm
76+
// VMs.
77+
// - WasmCallbackFuncTypeHelper is a helper for WasmFuncType and shouldn't be used anywhere else
78+
// than WasmFuncType definition.
79+
// - WasmCallbackFuncType takes 3 template parameter which are number of argument, return type, and
80+
// param type respectively, resolve to a function type.
81+
// For example `WasmFuncType<3, Word>` resolves to `void(Word, Word, Word)`
82+
template <size_t N, class ReturnType, class ParamType, class FuncBase = ReturnType()>
83+
struct WasmCallbackFuncTypeHelper {};
84+
85+
template <size_t N, class ReturnType, class ParamType, class... Args>
86+
struct WasmCallbackFuncTypeHelper<N, ReturnType, ParamType, ReturnType(Args...)> {
87+
// NOLINTNEXTLINE(readability-identifier-naming)
88+
using type = typename WasmCallbackFuncTypeHelper<N - 1, ReturnType, ParamType,
89+
ReturnType(Args..., ParamType)>::type;
90+
};
91+
92+
template <class ReturnType, class ParamType, class... Args>
93+
struct WasmCallbackFuncTypeHelper<0, ReturnType, ParamType, ReturnType(Args...)> {
94+
using type = ReturnType(Args...); // NOLINT(readability-identifier-naming)
95+
};
96+
97+
template <size_t N, class ReturnType, class ParamType>
98+
using WasmCallbackFuncType = typename WasmCallbackFuncTypeHelper<N, ReturnType, ParamType>::type;
99+
70100
// Calls out of the WASM VM.
71-
// 1st arg is always a pointer to raw_context (void*).
72-
template <size_t N> using WasmCallbackVoid = WasmFuncType<N, void, void *, Word> *;
73-
template <size_t N> using WasmCallbackWord = WasmFuncType<N, Word, void *, Word> *;
101+
template <size_t N> using WasmCallbackVoid = WasmCallbackFuncType<N, void, Word> *;
102+
template <size_t N> using WasmCallbackWord = WasmCallbackFuncType<N, Word, Word> *;
74103

75104
// Using the standard g++/clang mangling algorithm:
76105
// https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling-builtin
77106
// Extended with W = Word
78107
// Z = void, j = uint32_t, l = int64_t, m = uint64_t
79-
using WasmCallback_WWl = Word (*)(void *, Word, int64_t);
80-
using WasmCallback_WWlWW = Word (*)(void *, Word, int64_t, Word, Word);
81-
using WasmCallback_WWm = Word (*)(void *, Word, uint64_t);
82-
using WasmCallback_WWmW = Word (*)(void *, Word, uint64_t, Word);
83-
using WasmCallback_dd = double (*)(void *, double);
108+
using WasmCallback_WWl = Word (*)(Word, int64_t);
109+
using WasmCallback_WWlWW = Word (*)(Word, int64_t, Word, Word);
110+
using WasmCallback_WWm = Word (*)(Word, uint64_t);
111+
using WasmCallback_WWmW = Word (*)(Word, uint64_t, Word);
112+
using WasmCallback_dd = double (*)(double);
84113

85114
#define FOR_ALL_WASM_VM_IMPORTS(_f) \
86115
_f(proxy_wasm::WasmCallbackVoid<0>) _f(proxy_wasm::WasmCallbackVoid<1>) \

Diff for: ‎src/exports.cc

+136-148
Large diffs are not rendered by default.

Diff for: ‎src/v8/v8.cc

+8-10
Original file line numberDiff line numberDiff line change
@@ -97,11 +97,11 @@ class V8 : public WasmVm {
9797

9898
template <typename... Args>
9999
void registerHostFunctionImpl(std::string_view module_name, std::string_view function_name,
100-
void (*function)(void *, Args...));
100+
void (*function)(Args...));
101101

102102
template <typename R, typename... Args>
103103
void registerHostFunctionImpl(std::string_view module_name, std::string_view function_name,
104-
R (*function)(void *, Args...));
104+
R (*function)(Args...));
105105

106106
template <typename... Args>
107107
void getModuleFunctionImpl(std::string_view function_name,
@@ -448,7 +448,7 @@ bool V8::setWord(uint64_t pointer, Word word) {
448448

449449
template <typename... Args>
450450
void V8::registerHostFunctionImpl(std::string_view module_name, std::string_view function_name,
451-
void (*function)(void *, Args...)) {
451+
void (*function)(Args...)) {
452452
auto data =
453453
std::make_unique<FuncData>(std::string(module_name) + "." + std::string(function_name));
454454
auto type = wasm::FuncType::make(convertArgsTupleToValTypes<std::tuple<Args...>>(),
@@ -462,9 +462,8 @@ void V8::registerHostFunctionImpl(std::string_view module_name, std::string_view
462462
func_data->vm_->integration()->trace("[vm->host] " + func_data->name_ + "(" +
463463
printValues(params, sizeof...(Args)) + ")");
464464
}
465-
auto args_tuple = convertValTypesToArgsTuple<std::tuple<Args...>>(params);
466-
auto args = std::tuple_cat(std::make_tuple(current_context_), args_tuple);
467-
auto function = reinterpret_cast<void (*)(void *, Args...)>(func_data->raw_func_);
465+
auto args = convertValTypesToArgsTuple<std::tuple<Args...>>(params);
466+
auto function = reinterpret_cast<void (*)(Args...)>(func_data->raw_func_);
468467
std::apply(function, args);
469468
if (log) {
470469
func_data->vm_->integration()->trace("[vm<-host] " + func_data->name_ + " return: void");
@@ -482,7 +481,7 @@ void V8::registerHostFunctionImpl(std::string_view module_name, std::string_view
482481

483482
template <typename R, typename... Args>
484483
void V8::registerHostFunctionImpl(std::string_view module_name, std::string_view function_name,
485-
R (*function)(void *, Args...)) {
484+
R (*function)(Args...)) {
486485
auto data =
487486
std::make_unique<FuncData>(std::string(module_name) + "." + std::string(function_name));
488487
auto type = wasm::FuncType::make(convertArgsTupleToValTypes<std::tuple<Args...>>(),
@@ -496,9 +495,8 @@ void V8::registerHostFunctionImpl(std::string_view module_name, std::string_view
496495
func_data->vm_->integration()->trace("[vm->host] " + func_data->name_ + "(" +
497496
printValues(params, sizeof...(Args)) + ")");
498497
}
499-
auto args_tuple = convertValTypesToArgsTuple<std::tuple<Args...>>(params);
500-
auto args = std::tuple_cat(std::make_tuple(current_context_), args_tuple);
501-
auto function = reinterpret_cast<R (*)(void *, Args...)>(func_data->raw_func_);
498+
auto args = convertValTypesToArgsTuple<std::tuple<Args...>>(params);
499+
auto function = reinterpret_cast<R (*)(Args...)>(func_data->raw_func_);
502500
R rvalue = std::apply(function, args);
503501
results[0] = makeVal(rvalue);
504502
if (log) {

Diff for: ‎src/wamr/wamr.cc

+8-10
Original file line numberDiff line numberDiff line change
@@ -88,11 +88,11 @@ class Wamr : public WasmVm {
8888
private:
8989
template <typename... Args>
9090
void registerHostFunctionImpl(std::string_view module_name, std::string_view function_name,
91-
void (*function)(void *, Args...));
91+
void (*function)(Args...));
9292

9393
template <typename R, typename... Args>
9494
void registerHostFunctionImpl(std::string_view module_name, std::string_view function_name,
95-
R (*function)(void *, Args...));
95+
R (*function)(Args...));
9696

9797
template <typename... Args>
9898
void getModuleFunctionImpl(std::string_view function_name,
@@ -442,7 +442,7 @@ template <typename T> WasmFunctypePtr newWasmNewFuncType() {
442442

443443
template <typename... Args>
444444
void Wamr::registerHostFunctionImpl(std::string_view module_name, std::string_view function_name,
445-
void (*function)(void *, Args...)) {
445+
void (*function)(Args...)) {
446446
auto data =
447447
std::make_unique<HostFuncData>(std::string(module_name) + "." + std::string(function_name));
448448

@@ -456,9 +456,8 @@ void Wamr::registerHostFunctionImpl(std::string_view module_name, std::string_vi
456456
func_data->vm_->integration()->trace("[vm->host] " + func_data->name_ + "(" +
457457
printValues(params, sizeof...(Args)) + ")");
458458
}
459-
auto args_tuple = convertValTypesToArgsTuple<std::tuple<Args...>>(params);
460-
auto args = std::tuple_cat(std::make_tuple(current_context_), args_tuple);
461-
auto fn = reinterpret_cast<void (*)(void *, Args...)>(func_data->raw_func_);
459+
auto args = convertValTypesToArgsTuple<std::tuple<Args...>>(params);
460+
auto fn = reinterpret_cast<void (*)(Args...)>(func_data->raw_func_);
462461
std::apply(fn, args);
463462
if (log) {
464463
func_data->vm_->integration()->trace("[vm<-host] " + func_data->name_ + " return: void");
@@ -476,7 +475,7 @@ void Wamr::registerHostFunctionImpl(std::string_view module_name, std::string_vi
476475

477476
template <typename R, typename... Args>
478477
void Wamr::registerHostFunctionImpl(std::string_view module_name, std::string_view function_name,
479-
R (*function)(void *, Args...)) {
478+
R (*function)(Args...)) {
480479
auto data =
481480
std::make_unique<HostFuncData>(std::string(module_name) + "." + std::string(function_name));
482481
WasmFunctypePtr type = newWasmNewFuncType<R, std::tuple<Args...>>();
@@ -489,9 +488,8 @@ void Wamr::registerHostFunctionImpl(std::string_view module_name, std::string_vi
489488
func_data->vm_->integration()->trace("[vm->host] " + func_data->name_ + "(" +
490489
printValues(params, sizeof...(Args)) + ")");
491490
}
492-
auto args_tuple = convertValTypesToArgsTuple<std::tuple<Args...>>(params);
493-
auto args = std::tuple_cat(std::make_tuple(current_context_), args_tuple);
494-
auto fn = reinterpret_cast<R (*)(void *, Args...)>(func_data->raw_func_);
491+
auto args = convertValTypesToArgsTuple<std::tuple<Args...>>(params);
492+
auto fn = reinterpret_cast<R (*)(Args...)>(func_data->raw_func_);
495493
R res = std::apply(fn, args);
496494
assignVal<R>(res, results[0]);
497495
if (log) {

Diff for: ‎src/wasmtime/wasmtime.cc

+8-12
Original file line numberDiff line numberDiff line change
@@ -84,11 +84,11 @@ class Wasmtime : public WasmVm {
8484
private:
8585
template <typename... Args>
8686
void registerHostFunctionImpl(std::string_view module_name, std::string_view function_name,
87-
void (*function)(void *, Args...));
87+
void (*function)(Args...));
8888

8989
template <typename R, typename... Args>
9090
void registerHostFunctionImpl(std::string_view module_name, std::string_view function_name,
91-
R (*function)(void *, Args...));
91+
R (*function)(Args...));
9292

9393
template <typename... Args>
9494
void getModuleFunctionImpl(std::string_view function_name,
@@ -456,8 +456,7 @@ template <typename T> WasmFunctypePtr newWasmNewFuncType() {
456456

457457
template <typename... Args>
458458
void Wasmtime::registerHostFunctionImpl(std::string_view module_name,
459-
std::string_view function_name,
460-
void (*function)(void *, Args...)) {
459+
std::string_view function_name, void (*function)(Args...)) {
461460
auto data =
462461
std::make_unique<HostFuncData>(std::string(module_name) + "." + std::string(function_name));
463462

@@ -471,10 +470,9 @@ void Wasmtime::registerHostFunctionImpl(std::string_view module_name,
471470
func_data->vm_->integration()->trace("[vm->host] " + func_data->name_ + "(" +
472471
printValues(params) + ")");
473472
}
474-
auto args_tuple = convertValTypesToArgsTuple<std::tuple<Args...>>(
473+
auto args = convertValTypesToArgsTuple<std::tuple<Args...>>(
475474
params, std::make_index_sequence<sizeof...(Args)>{});
476-
auto args = std::tuple_cat(std::make_tuple(current_context_), args_tuple);
477-
auto fn = reinterpret_cast<void (*)(void *, Args...)>(func_data->raw_func_);
475+
auto fn = reinterpret_cast<void (*)(Args...)>(func_data->raw_func_);
478476
std::apply(fn, args);
479477
if (log) {
480478
func_data->vm_->integration()->trace("[vm<-host] " + func_data->name_ + " return: void");
@@ -492,8 +490,7 @@ void Wasmtime::registerHostFunctionImpl(std::string_view module_name,
492490

493491
template <typename R, typename... Args>
494492
void Wasmtime::registerHostFunctionImpl(std::string_view module_name,
495-
std::string_view function_name,
496-
R (*function)(void *, Args...)) {
493+
std::string_view function_name, R (*function)(Args...)) {
497494
auto data =
498495
std::make_unique<HostFuncData>(std::string(module_name) + "." + std::string(function_name));
499496
WasmFunctypePtr type = newWasmNewFuncType<R, std::tuple<Args...>>();
@@ -506,10 +503,9 @@ void Wasmtime::registerHostFunctionImpl(std::string_view module_name,
506503
func_data->vm_->integration()->trace("[vm->host] " + func_data->name_ + "(" +
507504
printValues(params) + ")");
508505
}
509-
auto args_tuple = convertValTypesToArgsTuple<std::tuple<Args...>>(
506+
auto args = convertValTypesToArgsTuple<std::tuple<Args...>>(
510507
params, std::make_index_sequence<sizeof...(Args)>{});
511-
auto args = std::tuple_cat(std::make_tuple(current_context_), args_tuple);
512-
auto fn = reinterpret_cast<R (*)(void *, Args...)>(func_data->raw_func_);
508+
auto fn = reinterpret_cast<R (*)(Args...)>(func_data->raw_func_);
513509
R res = std::apply(fn, args);
514510
assignVal<R>(res, results->data[0]);
515511
if (log) {

Diff for: ‎src/wavm/wavm.cc

+2-3
Original file line numberDiff line numberDiff line change
@@ -359,10 +359,9 @@ std::string_view Wavm::getPrecompiledSectionName() { return "wavm.precompiled_ob
359359

360360
std::unique_ptr<WasmVm> createWavmVm() { return std::make_unique<proxy_wasm::Wavm::Wavm>(); }
361361

362-
template <typename R, typename... Args>
363-
IR::FunctionType inferHostFunctionType(R (*)(void *, Args...)) {
362+
template <typename R, typename... Args> IR::FunctionType inferHostFunctionType(R (*)(Args...)) {
364363
return IR::FunctionType(IR::inferResultType<R>(), IR::TypeTuple({IR::inferValueType<Args>()...}),
365-
IR::CallingConvention::intrinsic);
364+
IR::CallingConvention::c);
366365
}
367366

368367
using namespace Wavm;

Diff for: ‎test/runtime_test.cc

+8-11
Original file line numberDiff line numberDiff line change
@@ -98,14 +98,14 @@ class TestContext : public ContextBase {
9898
int64_t counter = 0;
9999
};
100100

101-
void nopCallback(void *raw_context) {}
101+
void nopCallback() {}
102102

103-
void callback(void *) {
104-
TestContext *context = static_cast<TestContext *>(current_context_);
103+
void callback() {
104+
TestContext *context = static_cast<TestContext *>(contextOrEffectiveContext());
105105
context->increment();
106106
}
107107

108-
Word callback2(void *, Word val) { return val + 100; }
108+
Word callback2(Word val) { return val + 100; }
109109

110110
TEST_P(TestVM, StraceLogLevel) {
111111
if (runtime_ == "wavm") {
@@ -140,7 +140,6 @@ TEST_P(TestVM, Callback) {
140140
ASSERT_TRUE(vm_->load(source_, {}, {}));
141141

142142
TestContext context;
143-
current_context_ = &context;
144143

145144
vm_->registerCallback(
146145
"env", "callback", &callback,
@@ -156,13 +155,13 @@ TEST_P(TestVM, Callback) {
156155
vm_->getFunction("run", &run);
157156
EXPECT_TRUE(run != nullptr);
158157
for (auto i = 0; i < 100; i++) {
159-
run(current_context_);
158+
run(&context);
160159
}
161160
ASSERT_EQ(context.counter, 100);
162161

163162
WasmCallWord<1> run2;
164163
vm_->getFunction("run2", &run2);
165-
Word res = run2(current_context_, Word{0});
164+
Word res = run2(&context, Word{0});
166165
ASSERT_EQ(res.u32(), 100100); // 10000 (global) + 100(in callback)
167166
}
168167

@@ -171,11 +170,10 @@ TEST_P(TestVM, Trap) {
171170
ASSERT_TRUE(vm_->load(source_, {}, {}));
172171
ASSERT_TRUE(vm_->link(""));
173172
TestContext context;
174-
current_context_ = &context;
175173
WasmCallVoid<0> trigger;
176174
vm_->getFunction("trigger", &trigger);
177175
EXPECT_TRUE(trigger != nullptr);
178-
trigger(current_context_);
176+
trigger(&context);
179177
std::string exp_message = "Function: trigger failed";
180178
ASSERT_TRUE(integration_->error_message_.find(exp_message) != std::string::npos);
181179
}
@@ -191,11 +189,10 @@ TEST_P(TestVM, Trap2) {
191189
ASSERT_TRUE(vm_->load(source_, {}, {}));
192190
ASSERT_TRUE(vm_->link(""));
193191
TestContext context;
194-
current_context_ = &context;
195192
WasmCallWord<1> trigger2;
196193
vm_->getFunction("trigger2", &trigger2);
197194
EXPECT_TRUE(trigger2 != nullptr);
198-
trigger2(current_context_, 0);
195+
trigger2(&context, 0);
199196
std::string exp_message = "Function: trigger2 failed";
200197
ASSERT_TRUE(integration_->error_message_.find(exp_message) != std::string::npos);
201198
}

0 commit comments

Comments
 (0)
Please sign in to comment.