ttmg-wasm-tool 1.0.0 → 1.0.2

package/src/wasm-buffer-ops.cc

@@ -1,867 +0,0 @@
-//
-// Buffer-based WASM operations implementation
-//
-
-#include "wasm-buffer-ops.h"
-#include "src/binary-writer.h"
-#include "src/apply-names.h"
-#include "src/wast-lexer.h"
-#include "src/stream.h"
-#include "src/binary-reader-ir.h"
-#include "src/common.h"
-#include "src/validator.h"
-#include "src/generate-names.h"
-#include "src/wast-parser.h"
-#include "src/ir.h"
-#include "src/expr-visitor.h"
-#include "src/tools/wat-writer.h"
-
-#include <map>
-#include <set>
-
-using namespace wabt;
-
-namespace wasm_tool {
-
-// Helper to write WAT to a temporary buffer, then convert to WASM
-static bool WatToWasmBuffer(const std::string& wat_content, std::vector<uint8_t>& output, std::string& error) {
-  std::unique_ptr<WastLexer> lexer = WastLexer::CreateBufferLexer(
-      "buffer.wat", wat_content.c_str(), wat_content.size());
-  
-  Errors errors;
-  std::unique_ptr<Module> module;
-  static Features features;
-  WastParseOptions parse_wast_options(features);
-  
-  Result result = ParseWatModule(lexer.get(), &module, &errors, &parse_wast_options);
-  if (!Succeeded(result) || !errors.empty()) {
-    error = "Failed to parse WAT";
-    return false;
-  }
-  
-  ValidateOptions options(features);
-  result = ValidateModule(module.get(), &errors, options);
-  if (!Succeeded(result) || !errors.empty()) {
-    error = "Invalid WAT module";
-    return false;
-  }
-  
-  MemoryStream stream;
-  WriteBinaryOptions binary_options;
-  result = WriteBinaryModule(&stream, module.get(), binary_options);
-  if (!Succeeded(result)) {
-    error = "Failed to write binary module";
-    return false;
-  }
-  
-  auto& buffer = stream.output_buffer();
-  output.assign(buffer.data.begin(), buffer.data.end());
-  return true;
-}
-
-// Helper class for WASM module operations (for Prepare)
-class WasmModule {
-public:
-  WasmModule() : module_(MakeUnique<Module>()) {
-    InitStdio();
-  }
-
-  bool ReadFromBuffer(const uint8_t* data, size_t size, bool generate_names = true) {
-    Errors errors;
-    ReadBinaryOptions options;
-    Result result = ReadBinaryIr("buffer", data, size, options, &errors, module_.get());
-    if (!Succeeded(result)) {
-      error_ = "Failed to read WASM binary";
-      return false;
-    }
-
-    result = ValidateModule(module_.get(), &errors, ValidateOptions());
-    if (!Succeeded(result)) {
-      error_ = "Invalid WASM module";
-      return false;
-    }
-
-    if (generate_names) {
-      result = GenerateNames(module_.get());
-      if (!Succeeded(result)) {
-        error_ = "Failed to generate names";
-        return false;
-      }
-      ApplyNames(module_.get());
-    }
-    
-    parsed_ = true;
-    return true;
-  }
-
-  bool WriteToBuffer(std::vector<uint8_t>& output, bool write_debug_names = false) {
-    if (!parsed_) {
-      error_ = "Module not parsed";
-      return false;
-    }
-    
-    MemoryStream stream;
-    WriteBinaryOptions binary_options;
-    binary_options.write_debug_names = write_debug_names;
-    Result result = WriteBinaryModule(&stream, module_.get(), binary_options);
-    if (!Succeeded(result)) {
-      error_ = "Failed to write binary module";
-      return false;
-    }
-    
-    auto& buffer = stream.output_buffer();
-    output.assign(buffer.data.begin(), buffer.data.end());
-    return true;
-  }
-
-  Module* GetModule() { return module_.get(); }
-  uint64_t GetFuncCount() { return module_ ? module_->funcs.size() : 0; }
-  const std::string& GetError() const { return error_; }
-  bool IsParsed() const { return parsed_; }
-
-private:
-  std::unique_ptr<Module> module_;
-  bool parsed_ = false;
-  std::string error_;
-};
-
-// Insert logCall instrumentation
-void InsertLogCallInstrumentation(Module* module) {
-  std::string module_name = "scwebgl";
-  std::string field_name = "logCall";
-  std::string func_name = "$" + module_name + "." + field_name;
-  
-  auto import = MakeUnique<FuncImport>();
-  import->func.decl.sig.param_types.push_back(Type(Type::Enum::I32));
-  auto index = module->GetFuncTypeIndex(import->func.decl.sig);
-  if (index == kInvalidIndex) {
-    auto typeField = MakeUnique<TypeModuleField>();
-    auto func_type = MakeUnique<FuncType>();
-    func_type->sig = import->func.decl.sig;
-    typeField->type = std::move(func_type);
-    index = module->types.size();
-    typeField->type->name = "$t" + std::to_string(index);
-  }
-  import->func.decl.has_func_type = true;
-  import->func.decl.type_var = Var("$t" + std::to_string(index));
-  import->func.name = func_name;
-  import->module_name = module_name;
-  import->field_name = field_name;
-  auto field = MakeUnique<ImportModuleField>(std::move(import));
-  module->fields.push_back(std::move(field));
-
-  Index func_index = 0;
-  for (auto iter = module->funcs.begin(); iter < module->funcs.end(); ++iter) {
-    (*iter)->exprs.insert((*iter)->exprs.begin(), MakeUnique<CallExpr>(Var(func_name)));
-    (*iter)->exprs.insert((*iter)->exprs.begin(), MakeUnique<ConstExpr>(Const::I32(func_index++)));
-  }
-}
-
-PrepareResult PrepareWasmFromBuffer(const uint8_t* data, size_t size) {
-  PrepareResult result;
-  result.success = false;
-  result.func_count = 0;
-
-  WasmModule module;
-  if (!module.ReadFromBuffer(data, size)) {
-    result.error = module.GetError();
-    return result;
-  }
-
-  result.func_count = module.GetFuncCount();
-  
-  // Insert instrumentation
-  InsertLogCallInstrumentation(module.GetModule());
-
-  // Write back to buffer
-  if (!module.WriteToBuffer(result.wasm_buffer)) {
-    result.error = module.GetError();
-    return result;
-  }
-
-  result.success = true;
-  return result;
-}
-
-// ============================================================================
-// WasmSplit implementation (buffer-based, adapted from wasm-split.cc)
-// ============================================================================
-
-static void SplitString(const std::string& s, const std::string& separator, std::vector<std::string>& result) {
-  std::string::size_type begin_pos, end_pos;
-  end_pos = s.find(separator);
-  begin_pos = 0;
-  while (std::string::npos != end_pos) {
-    result.push_back(s.substr(begin_pos, end_pos - begin_pos));
-    begin_pos = end_pos + separator.size();
-    end_pos = s.find(separator, begin_pos);
-  }
-  if (begin_pos != s.length())
-    result.push_back(s.substr(begin_pos));
-}
-
-class WasmSplitBuffer {
-public:
-  WasmSplitBuffer() {
-    InitStdio();
-  }
-
-  bool ReadModule(const uint8_t* data, size_t size, const std::string& func_id_list = "") {
-    Errors errors;
-    ReadBinaryOptions options;
-    Result result = ReadBinaryIr("buffer", data, size, options, &errors, &module_);
-    if (!Succeeded(result)) {
-      error_ = "Failed to read WASM binary";
-      return false;
-    }
-
-    result = ValidateModule(&module_, &errors, ValidateOptions());
-    if (!Succeeded(result)) {
-      error_ = "Invalid WASM module";
-      return false;
-    }
-
-    result = GenerateNames(&module_);
-    if (!Succeeded(result)) {
-      error_ = "Failed to generate names";
-      return false;
-    }
-    ApplyNames(&module_);
-
-    ReadAllInputFuncIds(func_id_list);
-    ReadAllFuncs();
-    ReadAllImportFuncs();
-    ReadAllExportFuncs();
-    CheckHasImportTableAndMemory();
-    ReadSubWatFuncs();
-    ReadAllElemFuncs();
-    ReadAllCallExprNotInMainWatFuncs();
-    ReadAllCallExprNotInSubWatFuncs();
-    GetIndirectCallFuncsInMainWat();
-    GetAllFuncElems();
-    UpdateTableSizeIfNeed();
-    
-    return true;
-  }
-
-  bool WriteMainWasm(std::vector<uint8_t>& output) {
-    MemoryStream stream;
-    bytedance::WatWriter wat_writer(&stream, module_);
-    wat_writer.PrepareModule();
-    
-    wat_writer.WriteModuleBegin();
-    wat_writer.WriteTypes();
-    WriteImportsForMainWat(wat_writer);
-    WriteAlternativeFuncsForMainWat(wat_writer);
-    WriteExtraFuncsForMainWat(wat_writer);
-    WriteIndirectCallFuncsForMainWat(wat_writer);
-    wat_writer.WriteTables();
-    wat_writer.WriteMemories();
-    WriteImmutableGlobalValues(wat_writer);
-    WriteOneGlobalValue(wat_writer);
-    WriteExportsForMainWat(wat_writer);
-    wat_writer.WriteStarts();
-    WriteElementsForMainWat(wat_writer);
-    wat_writer.WriteDataSegments();
-    wat_writer.WriteModuleEnd();
-    
-    // Get WAT content and convert to WASM
-    const auto& buffer = stream.output_buffer();
-    std::string wat_content(buffer.data.begin(), buffer.data.end());
-    
-    return WatToWasmBuffer(wat_content, output, error_);
-  }
-
-  bool WriteSubWasm(std::vector<uint8_t>& output) {
-    MemoryStream stream;
-    bytedance::WatWriter wat_writer(&stream, module_);
-    wat_writer.PrepareModule();
-    
-    wat_writer.WriteModuleBegin();
-    wat_writer.WriteTypes();
-    WriteImportsForSubWat(wat_writer);
-    WriteAlternativeFuncsForSubWat(wat_writer);
-    WriteIndirectCallFuncsForSubWat(wat_writer);
-    WriteImmutableGlobalValues(wat_writer);
-    WriteOneGlobalValue(wat_writer);
-    WriteElementsForSubWat(wat_writer);
-    wat_writer.WriteModuleEnd();
-    
-    // Get WAT content and convert to WASM
-    const auto& buffer = stream.output_buffer();
-    std::string wat_content(buffer.data.begin(), buffer.data.end());
-    
-    return WatToWasmBuffer(wat_content, output, error_);
-  }
-
-  uint64_t GetTotalFuncCount() const { return all_funcs_.size(); }
-  uint64_t GetMainFuncCount() const { return main_wat_funcs_.size(); }
-  uint64_t GetSubFuncCount() const { return sub_wat_funcs_.size(); }
-  int64_t GetTableSize() const { return table_initial_size_; }
-  const std::string& GetGlobalVarList() const { return global_var_list_; }
-  const std::string& GetError() const { return error_; }
-
-private:
-  // Expression visitor for finding call instructions
-  class WasmExprVisitor : public ExprVisitor::DelegateNop {
-  public:
-    explicit WasmExprVisitor(WasmSplitBuffer* splitter, bool is_main_wat)
-        : splitter_(splitter), is_main_wat_(is_main_wat) {}
-    
-    Result OnCallExpr(CallExpr* expr) override {
-      const auto func_name = expr->var.name();
-      if (is_main_wat_) {
-        if (!funcs_set_.count(func_name)) {
-          splitter_->call_not_in_main_wat_funcs_.push_back(func_name);
-          funcs_set_.insert(func_name);
-        }
-      } else {
-        if (!splitter_->sub_wat_funcs_.count(func_name)) {
-          if (!funcs_set_.count(func_name)) {
-            splitter_->call_not_in_sub_wat_funcs_.push_back(func_name);
-            funcs_set_.insert(func_name);
-          }
-        }
-      }
-      return Result::Ok;
-    }
-    
-  private:
-    WasmSplitBuffer* splitter_;
-    bool is_main_wat_;
-    std::set<std::string> funcs_set_;
-  };
-
-  void ReadAllInputFuncIds(const std::string& content) {
-    if (content.empty()) return;
-    std::vector<std::string> lines;
-    SplitString(content, "\n", lines);
-    auto total_funcs = module_.funcs.size();
-    for (size_t i = 0; i < lines.size(); ++i) {
-      const auto& line = lines[i];
-      if (line.empty()) continue;
-      try {
-        auto id = std::stoi(line);
-        if (id > 0 && static_cast<size_t>(id) < total_funcs) {
-          main_wat_funcs_.insert(module_.funcs[id]->name);
-        }
-      } catch (...) {}
-    }
-  }
-
-  void ReadAllFuncs() {
-    int func_index = 0;
-    for (auto iter = module_.funcs.begin(); iter < module_.funcs.end(); ++iter) {
-      all_funcs_[(*iter)->name] = *iter;
-      all_func_indexes_[(*iter)->name] = func_index++;
-    }
-  }
-
-  void CheckHasImportTableAndMemory() {
-    has_import_table_ = false;
-    has_import_memory_ = false;
-    for (auto p_import : module_.imports) {
-      if (p_import->kind() == ExternalKind::Table) {
-        has_import_table_ = true;
-      } else if (p_import->kind() == ExternalKind::Memory) {
-        has_import_memory_ = true;
-      }
-    }
-  }
-
-  void ReadAllImportFuncs() {
-    for (auto p_import : module_.imports) {
-      if (p_import->kind() == ExternalKind::Func) {
-        std::string func_name = "$" + p_import->module_name + "." + p_import->field_name;
-        import_funcs_.insert(func_name);
-        main_wat_funcs_.insert(func_name);
-        all_funcs_in_main_wat_.push_back(func_name);
-        all_funcs_in_sub_wat_.push_back(func_name);
-      }
-    }
-  }
-
-  void ReadAllExportFuncs() {
-    for (auto p_export : module_.exports) {
-      if (p_export->kind == ExternalKind::Func) {
-        export_funcs_.insert(p_export->var.name());
-        main_wat_funcs_.insert(p_export->var.name());
-      }
-    }
-  }
-
-  void ReadSubWatFuncs() {
-    for (auto func : module_.funcs) {
-      if (main_wat_funcs_.count(func->name) && !import_funcs_.count(func->name)) {
-        continue;
-      }
-      sub_wat_funcs_.insert(func->name);
-    }
-  }
-
-  void ReadAllElemFuncs() {
-    std::set<std::string> export_funcs_set;
-    all_elem_funcs_after_split_.clear();
-    int offset = 0;
-    for (auto elem : module_.elem_segments) {
-      if (!elem->offset.empty()) {
-        auto iter = elem->offset.begin();
-        if (iter->type() == wabt::ExprType::Const) {
-          offset = dynamic_cast<ConstExpr*>(&(*iter))->const_.u32();
-        }
-      }
-      if (elem->elem_type == Type::Enum::FuncRef) {
-        for (const auto& elem_expr : elem->elem_exprs) {
-          if (elem_expr.kind == ElemExprKind::RefFunc) {
-            all_elem_funcs_after_split_.push_back(elem_expr.var.name());
-            if (!export_funcs_set.count(elem_expr.var.name())) {
-              original_elem_funcs_.push_back(elem_expr.var.name());
-              export_funcs_set.insert(elem_expr.var.name());
-            }
-          }
-        }
-      }
-    }
-    elem_offset_ = offset;
-  }
-
-  void ReadAllCallExprNotInMainWatFuncs() {
-    WasmExprVisitor delegate(this, true);
-    ExprVisitor visitor(&delegate);
-    for (const auto& func_name : main_wat_funcs_) {
-      if (all_funcs_.count(func_name) && !import_funcs_.count(func_name)) {
-        const auto p_func = all_funcs_[func_name];
-        visitor.VisitExprList(const_cast<ExprList&>(p_func->exprs));
-      }
-    }
-  }
-
-  void ReadAllCallExprNotInSubWatFuncs() {
-    WasmExprVisitor delegate(this, false);
-    ExprVisitor visitor(&delegate);
-    for (const auto& func_name : sub_wat_funcs_) {
-      if (all_funcs_.find(func_name) != all_funcs_.end()) {
-        const auto p_func = all_funcs_[func_name];
-        visitor.VisitExprList(const_cast<ExprList&>(p_func->exprs));
-      }
-    }
-    extra_elem_count_in_main_wat_ = call_not_in_sub_wat_funcs_.size();
-  }
-
-  void GetIndirectCallFuncsInMainWat() {
-    std::set<std::string> uniq_funcs;
-    indirect_call_in_main_wat_funcs_.clear();
-    for (const auto& func_name : original_elem_funcs_) {
-      if (main_wat_funcs_.count(func_name) || uniq_funcs.count(func_name)) continue;
-      uniq_funcs.insert(func_name);
-      indirect_call_in_main_wat_funcs_.push_back(func_name);
-    }
-    for (const auto& func_name : call_not_in_main_wat_funcs_) {
-      if (main_wat_funcs_.count(func_name) || uniq_funcs.count(func_name)) continue;
-      uniq_funcs.insert(func_name);
-      indirect_call_in_main_wat_funcs_.push_back(func_name);
-    }
-  }
-
-  void GetAllFuncElems() {
-    all_elem_funcs_after_split_.insert(
-        all_elem_funcs_after_split_.end(),
-        call_not_in_sub_wat_funcs_.begin(),
-        call_not_in_sub_wat_funcs_.end());
-    all_elem_funcs_after_split_.insert(
-        all_elem_funcs_after_split_.end(),
-        indirect_call_in_main_wat_funcs_.begin(),
-        indirect_call_in_main_wat_funcs_.end());
-  }
-
-  void UpdateTableSizeIfNeed() {
-    if (!module_.tables.empty()) {
-      auto& elem_limits = module_.tables[0]->elem_limits;
-      original_table_size_ = elem_limits.initial;
-      elem_limits.initial += indirect_call_in_main_wat_funcs_.size() + extra_elem_count_in_main_wat_;
-      table_initial_size_ = elem_limits.initial;
-      if (elem_limits.has_max) {
-        elem_limits.max += indirect_call_in_main_wat_funcs_.size() + extra_elem_count_in_main_wat_;
-      }
-    }
-  }
-
-  // Write functions for main WAT
-  void WriteAlternativeFuncsForMainWat(bytedance::WatWriter& writer) {
-    for (const auto& func_name : main_wat_funcs_) {
-      if (import_funcs_.count(func_name)) continue;
-      if (all_funcs_.count(func_name)) {
-        writer.WriteFunc(*all_funcs_[func_name]);
-        all_funcs_in_main_wat_.push_back(func_name);
-      }
-    }
-  }
-
-  Export CreateExport(const std::string& func_name, const std::string& var_name) {
-    Export exp;
-    exp.name = func_name;
-    exp.kind = ExternalKind::Func;
-    exp.var = Var(var_name);
-    return exp;
-  }
-
-  void WriteExportsForMainWat(bytedance::WatWriter& writer) {
-    writer.WriteExports();
-    writer.WriteExport(CreateExport("setSubWasmLoaded", "$setSubWasmLoaded"));
-    writer.WriteExport(CreateExport("initGlobal", "$initGlobal"));
-  }
-
-  void WriteAlternativeFuncsForSubWat(bytedance::WatWriter& writer) {
-    for (const auto& func_name : sub_wat_funcs_) {
-      if (main_wat_funcs_.count(func_name)) continue;
-      if (all_funcs_.count(func_name)) {
-        auto p_func = all_funcs_[func_name];
-        if (func_name.substr(0, 2) == "$f") {
-          Index func_index = std::stoi(func_name.substr(2));
-          p_func->exprs.insert(p_func->exprs.begin(), MakeUnique<CallExpr>(Var("$scwebgl.logCall")));
-          p_func->exprs.insert(p_func->exprs.begin(), MakeUnique<ConstExpr>(Const::I32(func_index)));
-        }
-        writer.WriteFunc(*p_func);
-        all_funcs_in_sub_wat_.push_back(func_name);
-      }
-    }
-  }
-
-  void WriteElementsForMainWat(bytedance::WatWriter& writer) {
-    writer.WriteElemSegments();
-    AppendElemsIfNeed(writer);
-  }
-
-  void WriteElementsForSubWat(bytedance::WatWriter& writer) {
-    if (indirect_call_in_main_wat_funcs_.empty()) return;
-    ElemSegment elem_segment("");
-    elem_segment.kind = SegmentKind::Active;
-    for (const auto& func_name : indirect_call_in_main_wat_funcs_) {
-      auto expr = ElemExpr();
-      expr.kind = ElemExprKind::RefFunc;
-      expr.var = Var(func_name);
-      elem_segment.elem_exprs.push_back(expr);
-    }
-    auto ptr = MakeUnique<ConstExpr>(Const::I32(original_table_size_ + extra_elem_count_in_main_wat_));
-    elem_segment.offset.push_back(std::move(ptr));
-    elem_segment.table_var = Var(0);
-    elem_segment.elem_type = Type::FuncRef;
-    writer.WriteElemSegment(elem_segment, 0);
-  }
-
-  void AppendElemsIfNeed(bytedance::WatWriter& writer) {
-    if (call_not_in_sub_wat_funcs_.empty()) return;
-    ElemSegment elem_segment("");
-    elem_segment.kind = SegmentKind::Active;
-    for (const auto& func_name : call_not_in_sub_wat_funcs_) {
-      auto expr = ElemExpr();
-      expr.kind = ElemExprKind::RefFunc;
-      expr.var = Var(func_name);
-      elem_segment.elem_exprs.push_back(expr);
-    }
-    auto ptr = MakeUnique<ConstExpr>(Const::I32(original_table_size_));
-    elem_segment.offset.push_back(std::move(ptr));
-    elem_segment.table_var = Var(0);
-    elem_segment.elem_type = Type::FuncRef;
-    writer.WriteElemSegment(elem_segment, module_.elem_segments.size());
-  }
-
-  static Global MakeGlobal(std::string name, bool mut = true, Type type = Type::I32, Const defaultVal = Const::I32(0)) {
-    Global global(name);
-    global.mutable_ = mut;
-    global.type = type;
-    auto const0Expr = MakeUnique<ConstExpr>(defaultVal);
-    global.init_expr.push_back(std::move(const0Expr));
-    return global;
-  }
-
-  void WriteImportMemory(bytedance::WatWriter& writer) {
-    if (!has_import_memory_ && !module_.memories.empty()) {
-      std::string moduleName = "scwebgl";
-      std::string fieldName = "memory";
-      MemoryImport import;
-      import.memory.name = module_.memories[0]->name;
-      import.module_name = moduleName;
-      import.field_name = fieldName;
-      auto& page_limits = module_.memories[0]->page_limits;
-      import.memory.page_limits.initial = page_limits.initial;
-      import.memory.page_limits.max = page_limits.max;
-      import.memory.page_limits.has_max = page_limits.has_max;
-      writer.WriteImport(import, 0);
-    }
-  }
-
-  void WriteImportTable(bytedance::WatWriter& writer) {
-    if (!has_import_table_ && !module_.tables.empty()) {
-      std::string moduleName = "scwebgl";
-      std::string fieldName = "table";
-      TableImport import;
-      import.table.name = module_.tables[0]->name;
-      import.module_name = moduleName;
-      import.field_name = fieldName;
-      auto elem_limits = module_.tables[0]->elem_limits;
-      import.table.elem_limits.initial = elem_limits.initial;
-      import.table.elem_limits.max = elem_limits.max;
-      import.table.elem_limits.has_max = elem_limits.has_max;
-      writer.WriteImport(import, 0);
-    }
-  }
-
-  void WriteWaitFunc(bytedance::WatWriter& writer) {
-    std::string moduleName = "scwebgl";
-    std::string fieldName = "wait";
-    std::string waitFuncName = "$" + moduleName + "." + fieldName;
-    FuncImport import;
-    import.func.decl.sig.param_types.push_back(Type(Type::Enum::I32));
-    auto index = module_.GetFuncTypeIndex(import.func.decl.sig);
-    if (index == kInvalidIndex) {
-      auto typeField = MakeUnique<TypeModuleField>();
-      auto func_type = MakeUnique<FuncType>();
-      func_type->sig = import.func.decl.sig;
-      typeField->type = std::move(func_type);
-      index = module_.types.size();
-      typeField->type->name = "$t" + std::to_string(index);
-      writer.WriteTypeEntry(*typeField->type, index);
-    }
-    import.func.decl.has_func_type = true;
-    import.func.decl.type_var = Var("$t" + std::to_string(index));
-    import.func.name = waitFuncName;
-    import.module_name = moduleName;
-    import.field_name = fieldName;
-    writer.WriteImport(import, -1);
-    all_funcs_in_main_wat_.push_back(import.func.name);
-  }
-
-  void WriteLogCallFunc(bytedance::WatWriter& writer) {
-    std::string moduleName = "scwebgl";
-    std::string fieldName = "logCall";
-    std::string waitFuncName = "$" + moduleName + "." + fieldName;
-    FuncImport import;
-    import.func.decl.sig.param_types.push_back(Type(Type::Enum::I32));
-    auto index = module_.GetFuncTypeIndex(import.func.decl.sig);
-    if (index == kInvalidIndex) {
-      auto typeField = MakeUnique<TypeModuleField>();
-      auto func_type = MakeUnique<FuncType>();
-      func_type->sig = import.func.decl.sig;
-      typeField->type = std::move(func_type);
-      index = module_.types.size();
-      typeField->type->name = "$t" + std::to_string(index);
-      writer.WriteTypeEntry(*typeField->type, index);
-    }
-    import.func.decl.has_func_type = true;
-    import.func.decl.type_var = Var("$t" + std::to_string(index));
-    import.func.name = waitFuncName;
-    import.module_name = moduleName;
-    import.field_name = fieldName;
-    writer.WriteImport(import, -1);
-    all_funcs_in_sub_wat_.push_back(import.func.name);
-  }
-
-  void WriteImportGlobals(bytedance::WatWriter& writer) {
-    std::string moduleName = "scwebgl";
-    const auto& globalFields = writer.GetGlobalFields();
-    auto globalImportsCount = globalFields.size();
-    std::vector<std::string> global_list;
-    for (size_t i = 0; i < globalImportsCount; ++i) {
-      const auto ptr = globalFields[i];
-      if (!ptr->global.mutable_) continue;
-      GlobalImport import;
-      import.global.name = ptr->global.name;
-      import.global.mutable_ = ptr->global.mutable_;
-      import.global.type = ptr->global.type;
-      import.module_name = moduleName;
-      import.field_name = "global" + std::to_string(i);
-      writer.WriteImport(import, -1);
-      std::string global_item = import.field_name + "," + ptr->global.type.GetName() + "," + std::to_string(int(import.global.mutable_));
-      global_list.push_back(global_item);
-    }
-    std::string global_str;
-    for (size_t i = 0; i < global_list.size(); ++i) {
-      global_str += global_list[i];
-      if (i < global_list.size() - 1) {
-        global_str += ";";
-      }
-    }
-    global_var_list_ = global_str;
-  }
-
-  void WriteImmutableGlobalValues(bytedance::WatWriter& writer) {
-    const auto& globalFields = writer.GetGlobalFields();
-    for (size_t i = 0; i < globalFields.size(); ++i) {
-      const auto ptr = globalFields[i];
-      if (!ptr->global.mutable_) {
-        writer.WriteGlobal(ptr->global, -1);
-      }
-    }
-  }
-
-  void WriteOneGlobalValue(bytedance::WatWriter& writer) {
-    std::string name = "$g" + std::to_string(module_.globals.size());
-    writer.WriteGlobal(MakeGlobal(name, true), -1);
-  }
-
-  void WriteImportsForMainWat(bytedance::WatWriter& writer) {
-    writer.WriteImports();
-    WriteWaitFunc(writer);
-    WriteImportGlobals(writer);
-  }
-
-  void WriteImportsForSubWat(bytedance::WatWriter& writer) {
-    WriteImportTable(writer);
-    WriteImportMemory(writer);
-    writer.WriteImports();
-    WriteLogCallFunc(writer);
-    WriteImportGlobals(writer);
-  }
-
-  void WriteExtraFuncsForMainWat(bytedance::WatWriter& writer) {
-    auto globalValue = "$g" + std::to_string(module_.globals.size());
-    auto ifExpr = MakeUnique<IfExpr>();
-    Func func1("$ensureSubWasm");
-    func1.exprs.push_back(std::move(MakeUnique<GlobalGetExpr>(Var(globalValue))));
-    func1.exprs.push_back(std::move(MakeUnique<ConvertExpr>(Opcode::I32Eqz)));
-    func1.decl.sig.param_types.push_back(Type(Type::Enum::I32));
-    ifExpr->true_.exprs.push_back(MakeUnique<LocalGetExpr>(Var(0)));
-    ifExpr->true_.exprs.push_back(MakeUnique<CallExpr>(Var("$scwebgl.wait")));
-    func1.exprs.push_back(std::move(ifExpr));
-    writer.WriteFunc(func1);
-
-    Func func2("$setSubWasmLoaded");
-    func2.exprs.push_back(std::move(MakeUnique<ConstExpr>(Const::I32(1))));
-    func2.exprs.push_back(std::move(MakeUnique<GlobalSetExpr>(Var(globalValue))));
-    func2.decl.sig.param_types.push_back(Type(Type::Enum::I32));
-    writer.WriteFunc(func2);
-
-    Func func3("$initGlobal");
-    const auto& globalFields = writer.GetGlobalFields();
-    for (size_t i = 0; i < globalFields.size(); ++i) {
-      const auto ptr = globalFields[i];
-      if (!ptr->global.mutable_) continue;
-      if (!ptr->global.init_expr.empty()) {
-        auto iter = ptr->global.init_expr.begin();
-        if (iter->type() == wabt::ExprType::Const) {
-          const auto& expr = dynamic_cast<const ConstExpr&>(*iter);
-          func3.exprs.push_back(std::move(MakeUnique<ConstExpr>(expr.const_)));
-          func3.exprs.push_back(std::move(MakeUnique<GlobalSetExpr>(Var(ptr->global.name))));
-        } else if (iter->type() == wabt::ExprType::GlobalGet) {
-          const auto& expr = dynamic_cast<const GlobalGetExpr&>(*iter);
-          func3.exprs.push_back(std::move(MakeUnique<GlobalGetExpr>(Var(expr.var.name()))));
-          func3.exprs.push_back(std::move(MakeUnique<GlobalSetExpr>(Var(ptr->global.name))));
-        }
-      }
-    }
-    writer.WriteFunc(func3);
-
-    all_funcs_in_main_wat_.push_back(func1.name);
-    all_funcs_in_main_wat_.push_back(func2.name);
-    all_funcs_in_main_wat_.push_back(func3.name);
-  }
-
-  void WriteIndirectCallFuncsForMainWat(bytedance::WatWriter& writer) {
-    Index index = original_table_size_ + extra_elem_count_in_main_wat_;
-    for (const auto& func_name : indirect_call_in_main_wat_funcs_) {
-      if (main_wat_funcs_.count(func_name)) continue;
-      if (all_funcs_.find(func_name) != all_funcs_.end()) {
-        Func func(func_name);
-        func.decl = all_funcs_[func_name]->decl;
-        if (func_name.substr(0, 2) == "$f") {
-          Index func_index = std::stoi(func_name.substr(2));
-          func.exprs.push_back(std::move(MakeUnique<ConstExpr>(Const::I32(func_index))));
-          func.exprs.push_back(std::move(MakeUnique<CallExpr>(Var("$ensureSubWasm"))));
-          for (size_t i = 0; i < func.decl.sig.param_types.size(); ++i) {
-            func.exprs.push_back(std::move(MakeUnique<LocalGetExpr>(Var(i))));
-          }
-          func.exprs.push_back(std::move(MakeUnique<ConstExpr>(Const::I32(index++))));
-          auto call_indirect_expr = MakeUnique<CallIndirectExpr>();
-          call_indirect_expr->decl.type_var = func.decl.type_var;
-          call_indirect_expr->table = Var(0);
-          func.exprs.push_back(std::move(call_indirect_expr));
-          writer.WriteFunc(func);
-          all_funcs_in_main_wat_.push_back(func_name);
-        }
-      }
-    }
-  }
-
-  void WriteIndirectCallFuncsForSubWat(bytedance::WatWriter& writer) {
-    Index index = original_table_size_;
-    for (const auto& func_name : call_not_in_sub_wat_funcs_) {
-      if (all_funcs_.find(func_name) != all_funcs_.end()) {
-        Func func(func_name);
-        func.decl = all_funcs_[func_name]->decl;
-        for (size_t i = 0; i < func.decl.sig.param_types.size(); ++i) {
-          func.exprs.push_back(std::move(MakeUnique<LocalGetExpr>(Var(i))));
-        }
-        func.exprs.push_back(std::move(MakeUnique<ConstExpr>(Const::I32(index++))));
-        auto call_indirect_expr = MakeUnique<CallIndirectExpr>();
-        call_indirect_expr->decl.type_var = func.decl.type_var;
-        call_indirect_expr->table = Var(0);
-        func.exprs.push_back(std::move(call_indirect_expr));
-        writer.WriteFunc(func);
-        all_funcs_in_sub_wat_.push_back(func_name);
-      }
-    }
-  }
-
-  Module module_;
-  std::map<std::string, Func*> all_funcs_;
-  std::map<std::string, int> all_func_indexes_;
-  std::set<std::string> import_funcs_;
-  std::set<std::string> export_funcs_;
-  std::vector<std::string> original_elem_funcs_;
-  std::vector<std::string> all_elem_funcs_after_split_;
-  std::vector<std::string> call_not_in_main_wat_funcs_;
-  std::vector<std::string> call_not_in_sub_wat_funcs_;
-  std::vector<std::string> all_funcs_in_main_wat_;
-  std::vector<std::string> all_funcs_in_sub_wat_;
-  std::vector<std::string> indirect_call_in_main_wat_funcs_;
-  std::set<std::string> main_wat_funcs_;
-  std::set<std::string> sub_wat_funcs_;
-
-  uint64_t original_table_size_ = 0;
-  uint64_t table_initial_size_ = 0;
-  uint64_t elem_offset_ = 0;
-  uint64_t extra_elem_count_in_main_wat_ = 0;
-  std::string global_var_list_;
-  bool has_import_table_ = false;
-  bool has_import_memory_ = false;
-  std::string error_;
-
-  friend class WasmExprVisitor;
-};
-
-SplitResult SplitWasmFromBuffer(const uint8_t* data, size_t size, const std::string& func_id_list) {
-  SplitResult result;
-  result.success = false;
-  result.total_func_count = 0;
-  result.main_func_count = 0;
-  result.sub_func_count = 0;
-  result.table_size = 0;
-
-  WasmSplitBuffer splitter;
-  if (!splitter.ReadModule(data, size, func_id_list)) {
-    result.error = splitter.GetError();
-    return result;
-  }
-
-  result.total_func_count = splitter.GetTotalFuncCount();
-  result.main_func_count = splitter.GetMainFuncCount();
-  result.sub_func_count = splitter.GetSubFuncCount();
-  result.table_size = splitter.GetTableSize();
-  result.global_var_list = splitter.GetGlobalVarList();
-
-  if (!splitter.WriteMainWasm(result.main_wasm_buffer)) {
-    result.error = splitter.GetError();
-    return result;
-  }
-
-  if (!splitter.WriteSubWasm(result.sub_wasm_buffer)) {
-    result.error = splitter.GetError();
-    return result;
-  }
-
-  result.success = true;
-  return result;
-}
-
-} // namespace wasm_tool