capi: Get function type from module

Author: gumb0

include/fizzy/fizzy.h

@@ -51,23 +51,21 @@ typedef FizzyExecutionResult (*FizzyExternalFn)(void* context, FizzyInstance* in
     const union FizzyValue* args, size_t args_size, int depth);
 
 /// Value type.
-enum FizzyValueType
-{
-    FizzyValueTypeI32 = 0x7f,
-    FizzyValueTypeI64 = 0x7e,
-    FizzyValueTypeF32 = 0x7d,
-    FizzyValueTypeF64 = 0x7c,
-};
+typedef uint8_t FizzyValueType;
+static const FizzyValueType FizzyValueTypeI32 = 0x7f;
+static const FizzyValueType FizzyValueTypeI64 = 0x7e;
+static const FizzyValueType FizzyValueTypeF32 = 0x7d;
+static const FizzyValueType FizzyValueTypeF64 = 0x7c;
 
 /// Function type.
 typedef struct FizzyFunctionType
 {
     /// Pointer to input types array.
-    const enum FizzyValueType* inputs;
+    const FizzyValueType* inputs;
     /// Input types array size.
     size_t inputs_size;
     /// Pointer to output types array.
-    const enum FizzyValueType* outputs;
+    const FizzyValueType* outputs;
     /// Output types array size.
     size_t outputs_size;
 } FizzyFunctionType;
@@ -97,6 +95,15 @@ const FizzyModule* fizzy_parse(const uint8_t* wasm_binary, size_t wasm_binary_si
 /// If passed pointer is NULL, has no effect.
 void fizzy_free_module(const FizzyModule* module);
 
+/// Get type of the function defined in the module.
+///
+/// @param module   Pointer to module.
+/// @param func_idx Function index. Can be either index of an imported function or of a function
+///                 defined in module.
+///
+/// @note All module function indices are greater than all imported function indices.
+FizzyFunctionType fizzy_get_function_type(const FizzyModule* module, uint32_t func_idx);
+
 /// Find index of exported function by name.
 ///
 /// @param  module          Pointer to module.

lib/fizzy/capi.cpp

@@ -21,9 +21,21 @@ inline const fizzy::Module* unwrap(const FizzyModule* module) noexcept
     return reinterpret_cast<const fizzy::Module*>(module);
 }
 
+inline const FizzyValueType* wrap(const fizzy::ValType* value_types) noexcept
+{
+    static_assert(sizeof(FizzyValueType) == sizeof(fizzy::ValType));
+    return reinterpret_cast<const FizzyValueType*>(value_types);
+}
+
 inline fizzy::ValType unwrap(FizzyValueType value_type) noexcept
 {
-    return static_cast<fizzy::ValType>(static_cast<uint8_t>(value_type));
+    return static_cast<fizzy::ValType>(value_type);
+}
+
+inline FizzyFunctionType wrap(const fizzy::FuncType& type) noexcept
+{
+    return {(type.inputs.empty() ? nullptr : wrap(&type.inputs[0])), type.inputs.size(),
+        (type.outputs.empty() ? nullptr : wrap(&type.outputs[0])), type.outputs.size()};
 }
 
 inline fizzy::FuncType unwrap(const FizzyFunctionType& type)
@@ -133,6 +145,11 @@ void fizzy_free_module(const FizzyModule* module)
     delete unwrap(module);
 }
 
+FizzyFunctionType fizzy_get_function_type(const FizzyModule* module, uint32_t func_idx)
+{
+    return wrap(unwrap(module)->get_function_type(func_idx));
+}
+
 bool fizzy_find_exported_function(
     const FizzyModule* module, const char* name, uint32_t* out_func_idx)
 {

test/unittests/capi_test.cpp

@@ -32,6 +32,45 @@ TEST(capi, free_module_null)
     fizzy_free_module(nullptr);
 }
 
+TEST(capi, get_function_type)
+{
+    /* wat2wasm
+      (func)
+      (func (param i32 i32) (result i32) (i32.const 0))
+      (func (param i64))
+      (func (param f64) (result f32) (f32.const 0))
+    */
+    const auto wasm = from_hex(
+        "0061736d0100000001130460000060027f7f017f60017e0060017c017d030504000102030a140402000b040041"
+        "000b02000b070043000000000b");
+    const auto module = fizzy_parse(wasm.data(), wasm.size());
+    EXPECT_NE(module, nullptr);
+
+    const auto type0 = fizzy_get_function_type(module, 0);
+    EXPECT_EQ(type0.inputs_size, 0);
+    EXPECT_EQ(type0.outputs_size, 0);
+
+    const auto type1 = fizzy_get_function_type(module, 1);
+    EXPECT_EQ(type1.inputs_size, 2);
+    EXPECT_EQ(type1.inputs[0], FizzyValueTypeI32);
+    EXPECT_EQ(type1.inputs[1], FizzyValueTypeI32);
+    EXPECT_EQ(type1.outputs_size, 1);
+    EXPECT_EQ(type1.outputs[0], FizzyValueTypeI32);
+
+    const auto type2 = fizzy_get_function_type(module, 2);
+    EXPECT_EQ(type2.inputs_size, 1);
+    EXPECT_EQ(type2.inputs[0], FizzyValueTypeI64);
+    EXPECT_EQ(type2.outputs_size, 0);
+
+    const auto type3 = fizzy_get_function_type(module, 3);
+    EXPECT_EQ(type3.inputs_size, 1);
+    EXPECT_EQ(type3.inputs[0], FizzyValueTypeF64);
+    EXPECT_EQ(type3.outputs_size, 1);
+    EXPECT_EQ(type3.outputs[0], FizzyValueTypeF32);
+
+    fizzy_free_module(module);
+}
+
 TEST(capi, find_exported_function)
 {
     /* wat2wasm