RC1 commit

Author: Erik McClure

include/innative/export.h

@@ -104,7 +104,7 @@ typedef struct IN__EXPORTS
   /// \param name A name to use for the module. If the module data does not contain a name, this will be used.
   /// \param err A pointer to an integer that receives an error code should the function fail. Not valid until
   /// FinalizeEnvironment() is called.
-  void (*AddModule)(Environment* env, const void* data, uint64_t size, const char* name, int* err);
+  void (*AddModule)(Environment* env, const void* data, size_t size, const char* name, int* err);
 
   /// Adds a prebuilt module object to the environment. This happens synchronously, regardless of multithreading flags.
   /// \param env The environment to modify.
@@ -128,7 +128,7 @@ typedef struct IN__EXPORTS
   /// \param size The length of the memory that the
   /// data pointer points to. If size is 0, the data pointer is actually a null terminated UTF8 encoded file path.
   /// \param name_override Resolves all functions in this embedded library as raw C functions with the given module name.
-  enum IN_ERROR (*AddEmbedding)(Environment* env, int tag, const void* data, uint64_t size, const char* name_override);
+  enum IN_ERROR (*AddEmbedding)(Environment* env, int tag, const void* data, size_t size, const char* name_override);
 
   /// Tells the linker to export the given symbol from the resulting binary.
   /// \param env The environment to modify.
@@ -204,6 +204,15 @@ typedef struct IN__EXPORTS
   /// \param global_index The index of the linear memory to retrieve.
   INGlobal* (*LoadMemoryIndex)(void* assembly, uint32_t module_index, uint32_t memory_index);
 
+  /// Searches for an exported function with the given name in a table and replaces the function pointer with another.
+  /// \param assembly A pointer to a WebAssembly binary loaded by LoadAssembly.
+  /// \param module_index The index of the module the table is exported from.
+  /// \param table_index The index of the table to search through.
+  /// \param function Name of the exported function to search the table for.
+  /// \param replace function pointer to another function that should replace the function's table entry
+  int (*ReplaceTableFuncPtr)(void* assembly, uint32_t module_index, uint32_t table_index, const char* function,
+                                     IN_Entrypoint replace);
+
   /// Clears the environment's cached compilation of a given module, or clears the entire cache if the module is a null
   /// pointer.
   /// \param env The environment to clear.

include/innative/innative.h

@@ -86,14 +86,26 @@ limitations under the License.
     #define IN_CPU_POWERPC
     #define IN_32BIT
   #endif
+#elif defined(__wasm64) || defined(__wasm64__)
+  #define IN_CPU_WASM64
+  #define IN_CPU_WASM
+  #define IN_64BIT
+#elif defined(__wasm32) || defined(__wasm32__) || defined(__wasm) || defined(__wasm__)
+  #define IN_CPU_WASM32
+  #define IN_CPU_WASM
+  #define IN_32BIT
 #else
   #define IN_CPU_UNKNOWN // Unknown CPU architecture (should force architecture independent C implementations)
 #endif
 
 // Compiler detection and macro generation
 #if defined(__clang__) // Clang (must be before GCC, because clang also pretends it's GCC)
   #define IN_COMPILER_CLANG
-  #define IN_COMPILER_DLLEXPORT __attribute__((dllexport))
+  #ifdef IN_CPU_WASM
+    #define IN_COMPILER_DLLEXPORT __attribute__((visibility("default")))
+  #else
+    #define IN_COMPILER_DLLEXPORT __attribute__((dllexport))
+  #endif
   #define IN_COMPILER_DLLIMPORT __attribute__((dllimport))
   #define IN_COMPILER_FASTCALL  __attribute__((fastcall))
   #define IN_COMPILER_NAKED     __attribute__((naked))
@@ -157,11 +169,17 @@ limitations under the License.
 
 #if !(defined(IN_PLATFORM_WIN32) || defined(IN_PLATFORM_POSIX) || defined(IN_PLATFORM_WIN32_CE) || \
       defined(IN_PLATFORM_APPLE))
-  #error "Unknown Platform"
+  #ifdef IN_CPU_WASM // On webassembly we assume the WASI platform
+    #define IN_PLATFORM_WASI
+  #else
+    #error "Unknown Platform"
+  #endif
 #endif
 
 // Endianness detection
-#if defined(IN_PLATFORM_WIN32) || defined(IN_PLATFORM_WIN32_CE) || defined(IN_CPU_x86_64) || defined(IN_CPU_x86) || \
+#ifdef IN_CPU_WASM
+  #define IN_ENDIAN_LITTLE
+#elif defined(IN_PLATFORM_WIN32) || defined(IN_PLATFORM_WIN32_CE) || defined(IN_CPU_x86_64) || defined(IN_CPU_x86) || \
   defined(IN_CPU_IA_64) // Windows, x86, x86_64 and itanium all only run in little-endian (except on HP-UX but we don't
                         // support that)
   #define IN_ENDIAN_LITTLE

innative-cmd/main.cpp

@@ -510,7 +510,7 @@ int main(int argc, char* argv[])
         env->log = stdout;
       return env;
     };
-    exports.AddModule = [](Environment* env, const void* data, uint64_t size, const char* name, int* err) {
+    exports.AddModule = [](Environment* env, const void* data, size_t size, const char* name, int* err) {
       if(!size)
       {
         long sz   = 0;
@@ -534,7 +534,7 @@ int main(int argc, char* argv[])
       }
       return ERR_SUCCESS;
     };
-    exports.AddEmbedding = [](Environment* env, int tag, const void* data, uint64_t size,
+    exports.AddEmbedding = [](Environment* env, int tag, const void* data, size_t size,
                               const char* name_override) -> IN_ERROR {
       char buf[20];
       _itoa_s(tag, buf, 10);

innative-test/benchmark.cpp

@@ -22,7 +22,7 @@ void Benchmarks::Run(FILE* out)
   fprintf(out, "%-*s %-*s %-*s %-*s %-*s %-*s\n", COLUMNS[0], "---------", COLUMNS[1], "-----", COLUMNS[2], "-----",
           COLUMNS[3], "------", COLUMNS[4], "-------", COLUMNS[5], "------");
 
-  DoBenchmark<int, int>(out, "../scripts/benchmark_debug.wasm", "debug", COLUMNS, &Benchmarks::debug, 20);
+  //DoBenchmark<int, int>(out, "../scripts/benchmark_debug.wasm", "debug", COLUMNS, &Benchmarks::debug, 20);
   DoBenchmark<int, int>(out, "../scripts/benchmark_n-body.wasm", "nbody", COLUMNS, &Benchmarks::nbody, 11);
   DoBenchmark<int64_t, int64_t>(out, "../scripts/benchmark_fib.wasm", "fib", COLUMNS, &Benchmarks::fib, 37);
   DoBenchmark<int, int>(out, "../scripts/benchmark_fannkuch-redux.wasm", "fannkuch_redux", COLUMNS,

innative-test/benchmark_debug.cpp

@@ -9,9 +9,6 @@ struct Complex
 
   Complex() : a(0), b(1.0) {}
   explicit Complex(int i) : a(i), b(1.0) {}
-  // virtual ~Complex() {}
-  // virtual float get() { return a + b; }
-  // virtual float get2() { return c->b + b; }
 };
 
 /*struct Foo : virtual Complex
@@ -30,10 +27,14 @@ struct FooBar : Foo, Bar
 {
   FooBar(int i) { a = i; }
   virtual ~FooBar() {}
-  float get3() { return get2(); }
   virtual float get() { return Foo::get(); }
 };*/
 
+struct FooBar : Complex
+{
+  long long d;
+};
+
 extern "C" int converti(Complex* p) { return (int)p; }
 extern "C" float convertf(int p) { return (float)p; }
 extern "C" int addi(int a, int b) { return a + b; }
@@ -42,10 +43,14 @@ extern "C" int addi(int a, int b) { return a + b; }
   #include "benchmark.h"
   #include <stdint.h>
 
+float (*testfn)(int) = nullptr;
+
 int Benchmarks::debug(int n)
 #else
   #include <stdint.h>
 
+__attribute__((visibility("default"))) float (*testfn)(int) = nullptr;
+
 extern "C" void* malloc(uintptr_t n);
 extern "C" __attribute__((visibility("default"))) int debug(int n)
 #endif
@@ -55,7 +60,14 @@ extern "C" __attribute__((visibility("default"))) int debug(int n)
   f[1].a     = n * n;
   f[2].a     = n * n * n;
 
-  f[0].b = convertf(converti(&f[1]));
+  testfn = &convertf;
+  f[0].b = (*testfn)(converti(&f[1]));
+
+  auto& f1 = f[1].a;
+  f1       = n * n + 1;
+
+  FooBar* foobar = (FooBar*)malloc(sizeof(FooBar));
+  f[0].c         = foobar;
 
   f[0].c = &f[1];
   f[1].c = &f[2];

innative-test/funcreplace.c

@@ -0,0 +1,8 @@
+__attribute__((visibility("default"))) int replace_me(int a, int b) { return a; }
+
+int (*testfn)(int, int) = &replace_me;
+
+__attribute__((visibility("default"))) extern int test(int i, int j)
+{
+  return (*testfn)(i, j);
+}

innative-test/innative-test.vcxproj

@@ -344,6 +344,7 @@
     <ClCompile Include="test_embedding.cpp" />
     <ClCompile Include="test_environment.cpp" />
     <ClCompile Include="test_errors.cpp" />
+    <ClCompile Include="test_funcreplace.cpp" />
     <ClCompile Include="test_harness.cpp" />
     <ClCompile Include="test_malloc.cpp" />
     <ClCompile Include="test_manual.cpp" />

innative-test/innative-test.vcxproj.filters

@@ -84,6 +84,9 @@
     <ClCompile Include="benchmark_debug.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="test_funcreplace.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="benchmark.h">

innative-test/test.h

@@ -32,6 +32,7 @@ class TestHarness
   void test_malloc();
   void test_embedding();
   void test_errors();
+  void test_funcreplace();
   int CompileWASM(const path& file);
 
   inline std::pair<uint32_t, uint32_t> Results()

innative-test/test_funcreplace.cpp

@@ -0,0 +1,56 @@
+// Copyright (c)2019 Black Sphere Studios
+// For conditions of distribution and use, see copyright notice in innative.h
+
+#include "test.h"
+#include "../innative/util.h"
+#include <signal.h>
+#include <setjmp.h>
+
+using namespace innative;
+
+int replacement(int a, int b) { return a + b; }
+
+void TestHarness::test_funcreplace()
+{
+  constexpr int i                  = 4;
+  constexpr int j                  = 2;
+  path dll_path                    = _folder / "funcreplace" IN_LIBRARY_EXTENSION;
+  constexpr const char wasm_path[] = "../scripts/funcreplace.wasm";
+
+  Environment* env = (*_exports.CreateEnvironment)(1, 0, 0);
+  env->flags |= ENV_LIBRARY | ENV_ENABLE_WAT;
+  env->system = "env";
+#ifdef IN_DEBUG
+  env->optimize = ENV_OPTIMIZE_O0;
+  env->flags |= ENV_DEBUG;
+#endif
+
+  int err = (*_exports.AddEmbedding)(env, 0, (void*)INNATIVE_DEFAULT_ENVIRONMENT, 0, 0);
+  TEST(!err);
+
+  (*_exports.AddModule)(env, wasm_path, 0, "funcreplace", &err);
+  TEST(!err);
+  err = (*_exports.FinalizeEnvironment)(env);
+  TEST(!err);
+
+  err = (*_exports.Compile)(env, dll_path.u8string().c_str());
+  TEST(!err);
+
+  (*_exports.DestroyEnvironment)(env);
+
+  void* assembly = (*_exports.LoadAssembly)(dll_path.u8string().c_str());
+  if(assembly)
+  {
+    int (*test)(int, int) = (int (*)(int, int))(*_exports.LoadFunction)(assembly, "funcreplace", "test");
+    TEST(test != nullptr);
+
+    (*_exports.ReplaceTableFuncPtr)(assembly, 0, 0, "replace_me", (IN_Entrypoint)&replacement);
+
+    if(test)
+      TEST((*test)(i, j) == 6);
+
+    (*_exports.FreeAssembly)(assembly);
+  }
+
+  remove(dll_path);
+}