ttmg-wasm-tool 1.0.0

package/build/config.h

@@ -0,0 +1,316 @@
+/*
+ * Copyright 2016 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef WABT_CONFIG_H_
+#define WABT_CONFIG_H_
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#define CMAKE_PROJECT_VERSION "1.0.0"
+
+/* TODO(binji): nice way to define these with WABT_ prefix? */
+
+/* Whether <alloca.h> is available */
+#define HAVE_ALLOCA_H 1
+
+/* Whether <unistd.h> is available */
+#define HAVE_UNISTD_H 1
+
+/* Whether snprintf is defined by stdio.h */
+#define HAVE_SNPRINTF 1
+
+/* Whether ssize_t is defined by stddef.h */
+#define HAVE_SSIZE_T 1
+
+/* Whether strcasecmp is defined by strings.h */
+#define HAVE_STRCASECMP 1
+
+/* Whether ENABLE_VIRTUAL_TERMINAL_PROCESSING is defined by windows.h */
+#define HAVE_WIN32_VT100 0
+
+#define COMPILER_IS_CLANG 1
+#define COMPILER_IS_GNU 0
+#define COMPILER_IS_MSVC 0
+
+#define WITH_EXCEPTIONS 0
+
+#define SIZEOF_SIZE_T 8
+
+#if HAVE_ALLOCA_H
+#include <alloca.h>
+#elif COMPILER_IS_MSVC
+#include <malloc.h>
+#define alloca _alloca
+#elif defined(__MINGW32__)
+#include <malloc.h>
+#endif
+
+#if COMPILER_IS_CLANG || COMPILER_IS_GNU
+
+#define WABT_UNUSED __attribute__((unused))
+#define WABT_WARN_UNUSED __attribute__((warn_unused_result))
+#define WABT_INLINE inline
+#define WABT_UNLIKELY(x) __builtin_expect(!!(x), 0)
+#define WABT_LIKELY(x) __builtin_expect(!!(x), 1)
+
+#define WABT_VECTORCALL
+
+#if __MINGW32__
+// mingw defaults to printf format specifier being ms_printf (which doesn't
+// understand 'llu', etc.) We always want gnu_printf, and force mingw to always
+// use mingw_printf, mingw_vprintf, etc.
+#define WABT_PRINTF_FORMAT(format_arg, first_arg) \
+  __attribute__((format(gnu_printf, (format_arg), (first_arg))))
+#else
+#define WABT_PRINTF_FORMAT(format_arg, first_arg) \
+  __attribute__((format(printf, (format_arg), (first_arg))))
+#endif
+
+#ifdef __cplusplus
+#if __cplusplus >= 201103L
+#define WABT_STATIC_ASSERT(x) static_assert((x), #x)
+#else
+#define WABT_STATIC_ASSERT__(x, c) \
+  static int static_assert_##c[(x ? 0 : -1)] WABT_UNUSED
+#define WABT_STATIC_ASSERT_(x, c) WABT_STATIC_ASSERT__(x, c)
+#define WABT_STATIC_ASSERT(x) WABT_STATIC_ASSERT_(x, __COUNTER__)
+#endif
+#else
+#define WABT_STATIC_ASSERT(x) _Static_assert((x), #x)
+#endif
+
+#elif COMPILER_IS_MSVC
+
+#include <intrin.h>
+#include <string.h>
+
+#define WABT_UNUSED
+#define WABT_WARN_UNUSED
+#define WABT_INLINE __inline
+#define WABT_STATIC_ASSERT(x) _STATIC_ASSERT(x)
+#define WABT_UNLIKELY(x) (x)
+#define WABT_LIKELY(x) (x)
+#define WABT_PRINTF_FORMAT(format_arg, first_arg)
+
+#define WABT_VECTORCALL __vectorcall
+
+#else
+
+#error unknown compiler
+
+#endif
+
+#define WABT_UNREACHABLE abort()
+
+#ifdef __cplusplus
+
+namespace wabt {
+
+#if COMPILER_IS_CLANG || COMPILER_IS_GNU
+
+inline int Clz(unsigned x) { return x ? __builtin_clz(x) : sizeof(x) * 8; }
+inline int Clz(unsigned long x) { return x ? __builtin_clzl(x) : sizeof(x) * 8; }
+inline int Clz(unsigned long long x) { return x ? __builtin_clzll(x) : sizeof(x) * 8; }
+
+inline int Ctz(unsigned x) { return x ? __builtin_ctz(x) : sizeof(x) * 8; }
+inline int Ctz(unsigned long x) { return x ? __builtin_ctzl(x) : sizeof(x) * 8; }
+inline int Ctz(unsigned long long x) { return x ? __builtin_ctzll(x) : sizeof(x) * 8; }
+
+inline int Popcount(uint8_t x) { return __builtin_popcount(x); }
+inline int Popcount(unsigned x) { return __builtin_popcount(x); }
+inline int Popcount(unsigned long x) { return __builtin_popcountl(x); }
+inline int Popcount(unsigned long long x) { return __builtin_popcountll(x); }
+
+#elif COMPILER_IS_MSVC
+
+#if _M_IX86
+inline unsigned long LowDword(unsigned __int64 value) {
+  return (unsigned long)value;
+}
+
+inline unsigned long HighDword(unsigned __int64 value) {
+  unsigned long high;
+  memcpy(&high, (unsigned char*)&value + sizeof(high), sizeof(high));
+  return high;
+}
+#endif
+
+inline int Clz(unsigned long mask) {
+  if (mask == 0)
+    return 32;
+
+  unsigned long index;
+  _BitScanReverse(&index, mask);
+  return sizeof(unsigned long) * 8 - (index + 1);
+}
+
+inline int Clz(unsigned int mask) {
+  return Clz((unsigned long)mask);
+}
+
+inline int Clz(unsigned __int64 mask) {
+#if _M_X64
+  if (mask == 0)
+    return 64;
+
+  unsigned long index;
+  _BitScanReverse64(&index, mask);
+  return sizeof(unsigned __int64) * 8 - (index + 1);
+#elif _M_IX86
+  int result = Clz(HighDword(mask));
+  if (result == 32)
+    result += Clz(LowDword(mask));
+
+  return result;
+#else
+#error unexpected architecture
+#endif
+}
+
+inline int Ctz(unsigned long mask) {
+  if (mask == 0)
+    return 32;
+
+  unsigned long index;
+  _BitScanForward(&index, mask);
+  return index;
+}
+
+inline int Ctz(unsigned int mask) {
+  return Ctz((unsigned long)mask);
+}
+
+inline int Ctz(unsigned __int64 mask) {
+#if _M_X64
+  if (mask == 0)
+    return 64;
+
+  unsigned long index;
+  _BitScanForward64(&index, mask);
+  return index;
+#elif _M_IX86
+  int result = Ctz(LowDword(mask));
+  if (result == 32)
+    result += Ctz(HighDword(mask));
+
+  return result;
+#else
+#error unexpected architecture
+#endif
+}
+
+inline int Popcount(uint8_t value) {
+  return __popcnt(value);
+}
+
+inline int Popcount(unsigned long value) {
+  return __popcnt(value);
+}
+
+inline int Popcount(unsigned int value) {
+  return Popcount((unsigned long)value);
+}
+
+inline int Popcount(unsigned __int64 value) {
+#if _M_X64
+  return __popcnt64(value);
+#elif _M_IX86
+  return Popcount(HighDword(value)) + Popcount(LowDword(value));
+#else
+#error unexpected architecture
+#endif
+}
+
+#else
+
+#error unknown compiler
+
+#endif
+
+}  // namespace wabt
+
+#if COMPILER_IS_MSVC
+
+/* print format specifier for size_t */
+#if SIZEOF_SIZE_T == 4
+#define PRIzd "d"
+#define PRIzx "x"
+#elif SIZEOF_SIZE_T == 8
+#define PRIzd "I64d"
+#define PRIzx "I64x"
+#else
+#error "weird sizeof size_t"
+#endif
+
+#elif COMPILER_IS_CLANG || COMPILER_IS_GNU
+
+/* print format specifier for size_t */
+#define PRIzd "zd"
+#define PRIzx "zx"
+
+#else
+
+#error unknown compiler
+
+#endif
+
+#if HAVE_SNPRINTF
+#define wabt_snprintf snprintf
+#elif COMPILER_IS_MSVC
+/* can't just use _snprintf because it doesn't always null terminate */
+#include <cstdarg>
+int wabt_snprintf(char* str, size_t size, const char* format, ...);
+#else
+#error no snprintf
+#endif
+
+#if COMPILER_IS_MSVC
+/* can't just use vsnprintf because it doesn't always null terminate */
+int wabt_vsnprintf(char* str, size_t size, const char* format, va_list ap);
+#else
+#define wabt_vsnprintf vsnprintf
+#endif
+
+#if !HAVE_SSIZE_T
+#if COMPILER_IS_MSVC
+/* define ssize_t identically to how LLVM does, to avoid conflicts if including both */
+#if defined(_WIN64)
+typedef signed __int64 ssize_t;
+#else
+typedef signed int ssize_t;
+#endif /* _WIN64 */
+#else
+typedef long ssize_t;
+#endif
+#endif
+
+#if !HAVE_STRCASECMP
+#if COMPILER_IS_MSVC
+#define strcasecmp _stricmp
+#else
+#error no strcasecmp
+#endif
+#endif
+
+double wabt_convert_uint64_to_double(uint64_t x);
+float wabt_convert_uint64_to_float(uint64_t x);
+double wabt_convert_int64_to_double(int64_t x);
+float wabt_convert_int64_to_float(int64_t x);
+
+#endif  // __cplusplus
+
+#endif /* WABT_CONFIG_H_ */

package/index.d.ts

@@ -0,0 +1,99 @@
+/**
+ * WASM Tool Node - Native module for WASM manipulation
+ */
+
+/**
+ * Result of prepareWasm operation
+ */
+export interface PrepareResult {
+  /** Whether the operation succeeded */
+  success: boolean;
+  /** Error message if operation failed */
+  error?: string;
+  /** Number of functions in the WASM module */
+  funcCount?: number;
+  /** The instrumented WASM binary buffer */
+  wasmBuffer?: Buffer;
+}
+
+/**
+ * Result of splitWasm operation
+ */
+export interface SplitResult {
+  /** Whether the operation succeeded */
+  success: boolean;
+  /** Error message if operation failed */
+  error?: string;
+  /** Total number of functions in original WASM */
+  totalFuncCount?: number;
+  /** Number of functions in main package */
+  mainFuncCount?: number;
+  /** Number of functions in sub package */
+  subFuncCount?: number;
+  /** Table size after split */
+  tableSize?: number;
+  /** Global variable list info */
+  globalVarList?: string;
+  /** Main package WASM buffer */
+  mainWasmBuffer?: Buffer;
+  /** Sub package WASM buffer */
+  subWasmBuffer?: Buffer;
+}
+
+/**
+ * Prepare a WASM module by inserting logCall instrumentation
+ * This inserts a call to scwebgl.logCall at the beginning of each function
+ * 
+ * @param wasmBuffer - The input WASM binary buffer
+ * @returns PrepareResult containing the instrumented WASM
+ * 
+ * @example
+ * ```typescript
+ * import { prepareWasm } from '@aspect/wasm-tool-node';
+ * import { readFileSync, writeFileSync } from 'fs';
+ * 
+ * const wasm = readFileSync('input.wasm');
+ * const result = prepareWasm(wasm);
+ * 
+ * if (result.success) {
+ *   console.log(`Prepared ${result.funcCount} functions`);
+ *   writeFileSync('output.wasm', result.wasmBuffer!);
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+export function prepareWasm(wasmBuffer: Buffer): PrepareResult;
+
+/**
+ * Split a WASM module into main and sub packages
+ * 
+ * The split follows these rules:
+ * 1. All import functions and elem segment functions go to main package
+ * 2. Main package creates stub functions for missing calls that wait for sub package
+ * 3. Sub package contains all non-main package functions
+ * 4. Sub package functions get logCall instrumentation
+ * 5. Global variables are converted to imports for sharing between packages
+ * 
+ * @param wasmBuffer - The input WASM binary buffer
+ * @param funcIdList - Optional newline-separated list of function IDs to include in main package
+ * @returns SplitResult containing main and sub package WASM buffers
+ * 
+ * @example
+ * ```typescript
+ * import { splitWasm } from '@aspect/wasm-tool-node';
+ * import { readFileSync, writeFileSync } from 'fs';
+ * 
+ * const wasm = readFileSync('input.wasm');
+ * const result = splitWasm(wasm);
+ * 
+ * if (result.success) {
+ *   console.log(`Total: ${result.totalFuncCount}, Main: ${result.mainFuncCount}, Sub: ${result.subFuncCount}`);
+ *   writeFileSync('main.wasm', result.mainWasmBuffer!);
+ *   writeFileSync('sub.wasm', result.subWasmBuffer!);
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+export function splitWasm(wasmBuffer: Buffer, funcIdList?: string): SplitResult;

package/index.js

@@ -0,0 +1,104 @@
+/**
+ * WASM Tool Node - Native module for WASM manipulation
+ * 
+ * This module provides Node.js bindings for WASM preparation and splitting tools.
+ */
+
+const path = require('path');
+const os = require('os');
+
+// Determine the correct binary path based on platform
+function getBindingPath() {
+  const platform = os.platform();
+  const arch = os.arch();
+  
+  // Try prebuilt binary first
+  const prebuiltDir = path.join(__dirname, 'prebuilds', `${platform}-${arch}`);
+  const prebuiltPath = path.join(prebuiltDir, 'wasm_tool_node.node');
+  
+  try {
+    require.resolve(prebuiltPath);
+    return prebuiltPath;
+  } catch (e) {
+    // Fall back to build directory
+    const buildPath = path.join(__dirname, 'build', 'Release', 'wasm_tool_node.node');
+    try {
+      require.resolve(buildPath);
+      return buildPath;
+    } catch (e2) {
+      // Try Debug build
+      const debugPath = path.join(__dirname, 'build', 'Debug', 'wasm_tool_node.node');
+      return debugPath;
+    }
+  }
+}
+
+let binding;
+
+try {
+  binding = require(getBindingPath());
+} catch (e) {
+  console.error('Failed to load wasm_tool_node native module.');
+  console.error('Please ensure the module is properly built using: npm run build');
+  console.error('Error:', e.message);
+  throw e;
+}
+
+/**
+ * Prepare a WASM module by inserting logCall instrumentation
+ * @param {Buffer} wasmBuffer - The input WASM binary buffer
+ * @returns {import('./index').PrepareResult} Result containing the instrumented WASM
+ */
+function prepareWasm(wasmBuffer) {
+  if (!Buffer.isBuffer(wasmBuffer)) {
+    return {
+      success: false,
+      error: 'Input must be a Buffer'
+    };
+  }
+  
+  if (wasmBuffer.length === 0) {
+    return {
+      success: false,
+      error: 'Empty buffer provided'
+    };
+  }
+  
+  return binding.prepareWasm(wasmBuffer);
+}
+
+/**
+ * Split a WASM module into main and sub packages
+ * @param {Buffer} wasmBuffer - The input WASM binary buffer
+ * @param {string} [funcIdList] - Optional newline-separated list of function IDs for main package
+ * @returns {import('./index').SplitResult} Result containing main and sub package WASM buffers
+ */
+function splitWasm(wasmBuffer, funcIdList) {
+  if (!Buffer.isBuffer(wasmBuffer)) {
+    return {
+      success: false,
+      error: 'Input must be a Buffer'
+    };
+  }
+  
+  if (wasmBuffer.length === 0) {
+    return {
+      success: false,
+      error: 'Empty buffer provided'
+    };
+  }
+  
+  if (funcIdList !== undefined && typeof funcIdList !== 'string') {
+    return {
+      success: false,
+      error: 'funcIdList must be a string if provided'
+    };
+  }
+  
+  return binding.splitWasm(wasmBuffer, funcIdList || '');
+}
+
+module.exports = {
+  prepareWasm,
+  splitWasm
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "ttmg-wasm-tool",
+  "version": "1.0.0",
+  "description": "Native Node.js module for WASM preparation and splitting",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "src/",
+    "CMakeLists.txt",
+    "prebuilds/",
+    "build/"
+  ],
+  "scripts": {
+    "install": "cmake-js compile -G \"Unix Makefiles\"",
+    "build": "cmake-js compile --release -G \"Unix Makefiles\"",
+    "build:debug": "cmake-js compile --debug -G \"Unix Makefiles\"",
+    "rebuild": "cmake-js rebuild --release -G \"Unix Makefiles\"",
+    "clean": "cmake-js clean",
+    "test": "node test/test.js"
+  },
+  "keywords": [
+    "wasm",
+    "webassembly",
+    "split",
+    "native",
+    "napi"
+  ],
+  "author": "gaopeng.anran",
+  "license": "MIT",
+  "devDependencies": {
+    "cmake-js": "^7.3.0"
+  },
+  "dependencies": {
+    "node-addon-api": "^7.0.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "binary": {
+    "napi_versions": [8]
+  },
+  "os": [
+    "darwin",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ]
+}

package/src/napi-binding.cc

@@ -0,0 +1,139 @@
+//
+// N-API binding for WASM tools
+//
+
+#include <napi.h>
+#include "wasm-buffer-ops.h"
+
+namespace {
+
+// Convert PrepareResult to Napi::Object
+Napi::Object PrepareResultToObject(Napi::Env env, const wasm_tool::PrepareResult& result) {
+  Napi::Object obj = Napi::Object::New(env);
+  
+  obj.Set("success", Napi::Boolean::New(env, result.success));
+  
+  if (!result.success) {
+    obj.Set("error", Napi::String::New(env, result.error));
+    return obj;
+  }
+  
+  obj.Set("funcCount", Napi::Number::New(env, static_cast<double>(result.func_count)));
+  
+  // Create Buffer from wasm data
+  Napi::Buffer<uint8_t> buffer = Napi::Buffer<uint8_t>::Copy(
+      env, result.wasm_buffer.data(), result.wasm_buffer.size());
+  obj.Set("wasmBuffer", buffer);
+  
+  return obj;
+}
+
+// Convert SplitResult to Napi::Object
+Napi::Object SplitResultToObject(Napi::Env env, const wasm_tool::SplitResult& result) {
+  Napi::Object obj = Napi::Object::New(env);
+  
+  obj.Set("success", Napi::Boolean::New(env, result.success));
+  
+  if (!result.success) {
+    obj.Set("error", Napi::String::New(env, result.error));
+    return obj;
+  }
+  
+  obj.Set("totalFuncCount", Napi::Number::New(env, static_cast<double>(result.total_func_count)));
+  obj.Set("mainFuncCount", Napi::Number::New(env, static_cast<double>(result.main_func_count)));
+  obj.Set("subFuncCount", Napi::Number::New(env, static_cast<double>(result.sub_func_count)));
+  obj.Set("tableSize", Napi::Number::New(env, static_cast<double>(result.table_size)));
+  obj.Set("globalVarList", Napi::String::New(env, result.global_var_list));
+  
+  // Create Buffers from wasm data
+  Napi::Buffer<uint8_t> mainBuffer = Napi::Buffer<uint8_t>::Copy(
+      env, result.main_wasm_buffer.data(), result.main_wasm_buffer.size());
+  obj.Set("mainWasmBuffer", mainBuffer);
+  
+  Napi::Buffer<uint8_t> subBuffer = Napi::Buffer<uint8_t>::Copy(
+      env, result.sub_wasm_buffer.data(), result.sub_wasm_buffer.size());
+  obj.Set("subWasmBuffer", subBuffer);
+  
+  return obj;
+}
+
+// prepareWasm(wasmBuffer: Buffer) => PrepareResult
+Napi::Value PrepareWasm(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  
+  // Validate arguments
+  if (info.Length() < 1) {
+    Napi::TypeError::New(env, "Expected 1 argument: wasmBuffer").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  if (!info[0].IsBuffer()) {
+    Napi::TypeError::New(env, "First argument must be a Buffer").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  Napi::Buffer<uint8_t> buffer = info[0].As<Napi::Buffer<uint8_t>>();
+  const uint8_t* data = buffer.Data();
+  size_t size = buffer.Length();
+  
+  if (size == 0) {
+    Napi::Object result = Napi::Object::New(env);
+    result.Set("success", Napi::Boolean::New(env, false));
+    result.Set("error", Napi::String::New(env, "Empty buffer provided"));
+    return result;
+  }
+  
+  // Call the C++ implementation
+  wasm_tool::PrepareResult result = wasm_tool::PrepareWasmFromBuffer(data, size);
+  
+  return PrepareResultToObject(env, result);
+}
+
+// splitWasm(wasmBuffer: Buffer, funcIdList?: string) => SplitResult
+Napi::Value SplitWasm(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  
+  // Validate arguments
+  if (info.Length() < 1) {
+    Napi::TypeError::New(env, "Expected at least 1 argument: wasmBuffer").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  if (!info[0].IsBuffer()) {
+    Napi::TypeError::New(env, "First argument must be a Buffer").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  Napi::Buffer<uint8_t> buffer = info[0].As<Napi::Buffer<uint8_t>>();
+  const uint8_t* data = buffer.Data();
+  size_t size = buffer.Length();
+  
+  if (size == 0) {
+    Napi::Object result = Napi::Object::New(env);
+    result.Set("success", Napi::Boolean::New(env, false));
+    result.Set("error", Napi::String::New(env, "Empty buffer provided"));
+    return result;
+  }
+  
+  // Get optional func id list
+  std::string funcIdList;
+  if (info.Length() >= 2 && info[1].IsString()) {
+    funcIdList = info[1].As<Napi::String>().Utf8Value();
+  }
+  
+  // Call the C++ implementation
+  wasm_tool::SplitResult result = wasm_tool::SplitWasmFromBuffer(data, size, funcIdList);
+  
+  return SplitResultToObject(env, result);
+}
+
+// Module initialization
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+  exports.Set("prepareWasm", Napi::Function::New(env, PrepareWasm));
+  exports.Set("splitWasm", Napi::Function::New(env, SplitWasm));
+  return exports;
+}
+
+NODE_API_MODULE(wasm_tool_node, Init)
+
+} // anonymous namespace