diff options
Diffstat (limited to 'third_party/wasm2c/src/c-writer.cc')
| -rw-r--r-- | third_party/wasm2c/src/c-writer.cc | 5241 |
1 files changed, 5241 insertions, 0 deletions
diff --git a/third_party/wasm2c/src/c-writer.cc b/third_party/wasm2c/src/c-writer.cc new file mode 100644 index 0000000000..798f85f9bc --- /dev/null +++ b/third_party/wasm2c/src/c-writer.cc @@ -0,0 +1,5241 @@ +/* + * Copyright 2017 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. + */ + +#include "wabt/c-writer.h" + +#include <cctype> +#include <cinttypes> +#include <iterator> +#include <limits> +#include <map> +#include <set> +#include <string_view> +#include <vector> + +#include "wabt/cast.h" +#include "wabt/common.h" +#include "wabt/ir.h" +#include "wabt/literal.h" +#include "wabt/sha256.h" +#include "wabt/stream.h" +#include "wabt/string-util.h" + +#define INDENT_SIZE 2 + +#define UNIMPLEMENTED(x) printf("unimplemented: %s\n", (x)), abort() + +// code to be inserted into the generated output +extern const char* s_header_top; +extern const char* s_header_bottom; +extern const char* s_source_includes; +extern const char* s_source_declarations; + +namespace wabt { + +namespace { + +struct Label { + Label(LabelType label_type, + const std::string& name, + const TypeVector& sig, + size_t type_stack_size, + size_t try_catch_stack_size, + bool used = false) + : label_type(label_type), + name(name), + sig(sig), + type_stack_size(type_stack_size), + try_catch_stack_size(try_catch_stack_size), + used(used) {} + + bool HasValue() const { return !sig.empty(); } + + LabelType label_type; + const std::string& name; + const TypeVector& sig; + size_t type_stack_size; + size_t try_catch_stack_size; + bool used = false; +}; + +struct LocalName { + explicit LocalName(const std::string& name) : name(name) {} + const std::string& name; +}; + +struct ParamName : LocalName { + using LocalName::LocalName; + ParamName(const Var& var) : LocalName(var.name()) {} +}; + +struct LabelName : LocalName { + using LocalName::LocalName; +}; + +struct GlobalName { + GlobalName(ModuleFieldType type, const std::string& name) + : type(type), name(name) {} + ModuleFieldType type; + const std::string& name; +}; + +struct ExternalPtr : GlobalName { + using GlobalName::GlobalName; +}; + +struct ExternalRef : GlobalName { + using GlobalName::GlobalName; +}; + +struct ExternalInstancePtr : GlobalName { + using GlobalName::GlobalName; +}; + +struct ExternalInstanceRef : GlobalName { + using GlobalName::GlobalName; +}; + +struct GotoLabel { + explicit GotoLabel(const Var& var) : var(var) {} + const Var& var; +}; + +struct LabelDecl { + explicit LabelDecl(const std::string& name) : name(name) {} + std::string name; +}; + +struct GlobalInstanceVar { + explicit GlobalInstanceVar(const Var& var) : var(var) {} + const Var& var; +}; + +struct StackVar { + explicit StackVar(Index index, Type type = Type::Any) + : index(index), type(type) {} + Index index; + Type type; +}; + +struct TypeEnum { + explicit TypeEnum(Type type) : type(type) {} + Type type; +}; + +struct SignedType { + explicit SignedType(Type type) : type(type) {} + Type type; +}; + +struct ResultType { + explicit ResultType(const TypeVector& types) : types(types) {} + const TypeVector& types; +}; + +struct TryCatchLabel { + TryCatchLabel(const std::string& name, size_t try_catch_stack_size) + : name(name), try_catch_stack_size(try_catch_stack_size), used(false) {} + std::string name; + size_t try_catch_stack_size; + bool used; +}; + +struct FuncTypeExpr { + const FuncType* func_type; + FuncTypeExpr(const FuncType* f) : func_type(f) {} +}; + +struct Newline {}; +struct OpenBrace {}; +struct CloseBrace {}; + +int GetShiftMask(Type type) { + // clang-format off + switch (type) { + case Type::I32: return 31; + case Type::I64: return 63; + default: WABT_UNREACHABLE; return 0; + } + // clang-format on +} + +/* + * This function is the default behavior for name_to_output_file_index_. For + * single .c output, this function returns a vector filled with 0. For multiple + * .c outputs, this function sorts all non-imported functions in the module by + * their names, and then divides all non-imported functions into equal-sized + * buckets (# of non-imported functions / # of .c outputs) based on the sorting. + */ +static std::vector<size_t> default_name_to_output_file_index( + std::vector<Func*>::const_iterator func_begin, + std::vector<Func*>::const_iterator func_end, + size_t num_imports, + size_t num_streams) { + std::vector<size_t> result; + result.resize(std::distance(func_begin, func_end)); + if (num_streams == 1) { + return result; + } + + std::map<std::string, Index> sorted_functions; + size_t non_imported_funcs = result.size() - num_imports; + size_t bucket_size = non_imported_funcs / num_streams + + (non_imported_funcs % num_streams ? 1 : 0); + Index func_index = 0; + for (auto func = func_begin; func != func_end; func++) { + sorted_functions.insert({(*func)->name, func_index}); + ++func_index; + } + Index sorted_func_index = 0; + for (const auto& [func_name, index] : sorted_functions) { + bool is_import = index < num_imports; + if (!is_import) { + result.at(index) = sorted_func_index / bucket_size; + ++sorted_func_index; + } + } + return result; +} + +class CWriter { + public: + CWriter(std::vector<Stream*>&& c_streams, + Stream* h_stream, + Stream* h_impl_stream, + const char* header_name, + const char* header_impl_name, + const WriteCOptions& options) + : options_(options), + c_streams_(std::move(c_streams)), + h_stream_(h_stream), + h_impl_stream_(h_impl_stream), + header_name_(header_name), + header_impl_name_(header_impl_name) { + module_prefix_ = MangleModuleName(options_.module_name); + if (c_streams_.size() != 1 && options.name_to_output_file_index) { + name_to_output_file_index_ = options.name_to_output_file_index; + } else { + name_to_output_file_index_ = default_name_to_output_file_index; + } + } + + Result WriteModule(const Module&); + + private: + using SymbolSet = std::set<std::string>; + using SymbolMap = std::map<std::string, std::string>; + using StackTypePair = std::pair<Index, Type>; + using StackVarSymbolMap = std::map<StackTypePair, std::string>; + + void WriteCHeader(); + void WriteCSource(); + + size_t MarkTypeStack() const; + void ResetTypeStack(size_t mark); + Type StackType(Index) const; + void PushType(Type); + void PushTypes(const TypeVector&); + void DropTypes(size_t count); + + void PushLabel(LabelType, + const std::string& name, + const FuncSignature&, + bool used = false); + const Label* FindLabel(const Var& var, bool mark_used = true); + bool IsTopLabelUsed() const; + void PopLabel(); + + static constexpr char MangleType(Type); + static constexpr char MangleField(ModuleFieldType); + static std::string MangleMultivalueTypes(const TypeVector&); + static std::string MangleTagTypes(const TypeVector&); + static std::string Mangle(std::string_view name, bool double_underscores); + static std::string MangleName(std::string_view); + static std::string MangleModuleName(std::string_view); + std::string ExportName(std::string_view module_name, + std::string_view export_name); + std::string ExportName(std::string_view export_name); + std::string ModuleInstanceTypeName() const; + static std::string ModuleInstanceTypeName(std::string_view module_name); + void ClaimName(SymbolSet& set, + SymbolMap& map, + char type_suffix, + std::string_view wasm_name, + const std::string& c_name); + std::string FindUniqueName(SymbolSet& set, std::string_view proposed_name); + std::string ClaimUniqueName(SymbolSet& set, + SymbolMap& map, + char type_suffix, + std::string_view wasm_name, + const std::string& proposed_c_name); + void DefineImportName(const Import* import, + std::string_view module_name, + std::string_view field_name); + void ReserveExportNames(); + void ReserveExportName(std::string_view); + std::string DefineImportedModuleInstanceName(std::string_view name); + std::string DefineInstanceMemberName(ModuleFieldType, std::string_view); + std::string DefineGlobalScopeName(ModuleFieldType, std::string_view); + std::string DefineLocalScopeName(std::string_view name, bool is_label); + std::string DefineParamName(std::string_view); + std::string DefineLabelName(std::string_view); + std::string DefineStackVarName(Index, Type, std::string_view); + + static void SerializeFuncType(const FuncType&, std::string&); + + std::string GetGlobalName(ModuleFieldType, const std::string&) const; + std::string GetLocalName(const std::string&, bool is_label) const; + + void Indent(int size = INDENT_SIZE); + void Dedent(int size = INDENT_SIZE); + void WriteIndent(); + void WriteData(const char* src, size_t size); + void Writef(const char* format, ...); + + template <typename T, typename U, typename... Args> + void Write(T&& t, U&& u, Args&&... args) { + Write(std::forward<T>(t)); + Write(std::forward<U>(u)); + Write(std::forward<Args>(args)...); + } + + static const char* GetReferenceTypeName(const Type& type); + static const char* GetReferenceNullValue(const Type& type); + static const char* GetCTypeName(const Type& type); + + const char* InternalSymbolScope() const; + + enum class CWriterPhase { + Declarations, + Definitions, + }; + + void Write() {} + void Write(Newline); + void Write(OpenBrace); + void Write(CloseBrace); + void Write(uint64_t); + void Write(std::string_view); + void Write(const ParamName&); + void Write(const LabelName&); + void Write(const GlobalName&); + void Write(const ExternalPtr&); + void Write(const ExternalRef&); + void Write(const ExternalInstancePtr&); + void Write(const ExternalInstanceRef&); + void Write(Type); + void Write(SignedType); + void Write(TypeEnum); + void Write(const GotoLabel&); + void Write(const LabelDecl&); + void Write(const GlobalInstanceVar&); + void Write(const StackVar&); + void Write(const ResultType&); + void Write(const Const&); + void WriteInitExpr(const ExprList&); + void WriteInitExprTerminal(const Expr*); + std::string GenerateHeaderGuard() const; + void WriteSourceTop(); + void WriteMultiCTop(); + void WriteMultiCTopEmpty(); + void WriteMultivalueTypes(); + void WriteTagTypes(); + void WriteFuncTypeDecls(); + void WriteFuncTypes(); + void Write(const FuncTypeExpr&); + void WriteTagDecls(); + void WriteTags(); + void ComputeUniqueImports(); + void BeginInstance(); + void WriteImports(); + void WriteFuncDeclarations(); + void WriteFuncDeclaration(const FuncDeclaration&, const std::string&); + void WriteImportFuncDeclaration(const FuncDeclaration&, + const std::string& module_name, + const std::string&); + void WriteCallIndirectFuncDeclaration(const FuncDeclaration&, + const std::string&); + void WriteFeatureMacros(); + void WriteModuleInstance(); + void WriteGlobals(); + void WriteGlobal(const Global&, const std::string&); + void WriteGlobalPtr(const Global&, const std::string&); + void WriteMemories(); + void WriteMemory(const std::string&); + void WriteMemoryPtr(const std::string&); + void WriteTables(); + void WriteTable(const std::string&, const wabt::Type&); + void WriteTablePtr(const std::string&, const Table&); + void WriteTableType(const wabt::Type&); + void WriteDataInstances(); + void WriteElemInstances(); + void WriteGlobalInitializers(); + void WriteDataInitializerDecls(); + void WriteDataInitializers(); + void WriteElemInitializerDecls(); + void WriteElemInitializers(); + void WriteElemTableInit(bool, const ElemSegment*, const Table*); + void WriteExports(CWriterPhase); + void WriteInitDecl(); + void WriteFreeDecl(); + void WriteGetFuncTypeDecl(); + void WriteInit(); + void WriteFree(); + void WriteGetFuncType(); + void WriteInitInstanceImport(); + void WriteImportProperties(CWriterPhase); + void WriteFuncs(); + void Write(const Func&); + void WriteParamsAndLocals(); + void WriteParams(const std::vector<std::string>& index_to_name); + void WriteParamSymbols(const std::vector<std::string>& index_to_name); + void WriteParamTypes(const FuncDeclaration& decl); + void WriteLocals(const std::vector<std::string>& index_to_name); + void WriteStackVarDeclarations(); + void Write(const ExprList&); + + enum class AssignOp { + Disallowed, + Allowed, + }; + + void WriteSimpleUnaryExpr(Opcode, const char* op); + void WriteInfixBinaryExpr(Opcode, + const char* op, + AssignOp = AssignOp::Allowed); + void WritePrefixBinaryExpr(Opcode, const char* op); + void WriteSignedBinaryExpr(Opcode, const char* op); + void Write(const BinaryExpr&); + void Write(const CompareExpr&); + void Write(const ConvertExpr&); + void Write(const LoadExpr&); + void Write(const StoreExpr&); + void Write(const UnaryExpr&); + void Write(const TernaryExpr&); + void Write(const SimdLaneOpExpr&); + void Write(const SimdLoadLaneExpr&); + void Write(const SimdStoreLaneExpr&); + void Write(const SimdShuffleOpExpr&); + void Write(const LoadSplatExpr&); + void Write(const LoadZeroExpr&); + void Write(const Block&); + + size_t BeginTry(const TryExpr& tryexpr); + void WriteTryCatch(const TryExpr& tryexpr); + void WriteTryDelegate(const TryExpr& tryexpr); + void Write(const Catch& c); + void WriteThrow(); + + void PushTryCatch(const std::string& name); + void PopTryCatch(); + + void PushFuncSection(std::string_view include_condition = ""); + + const WriteCOptions& options_; + const Module* module_ = nullptr; + const Func* func_ = nullptr; + Stream* stream_ = nullptr; + std::vector<Stream*> c_streams_; + Stream* h_stream_ = nullptr; + Stream* h_impl_stream_ = nullptr; + std::string header_name_; + std::string header_impl_name_; + Result result_ = Result::Ok; + int indent_ = 0; + bool should_write_indent_next_ = false; + int consecutive_newline_count_ = 0; + + SymbolMap global_sym_map_; + SymbolMap local_sym_map_; + SymbolMap import_module_sym_map_; + StackVarSymbolMap stack_var_sym_map_; + SymbolSet global_syms_; + SymbolSet local_syms_; + SymbolSet import_syms_; + TypeVector type_stack_; + std::vector<Label> label_stack_; + std::vector<TryCatchLabel> try_catch_stack_; + std::string module_prefix_; + + std::vector<const Import*> unique_imports_; + SymbolSet import_module_set_; // modules that are imported from + SymbolSet import_func_module_set_; // modules that funcs are imported from + + std::vector<std::pair<std::string, MemoryStream>> func_sections_; + SymbolSet func_includes_; + + std::vector<std::string> unique_func_type_names_; + + std::function<std::vector<size_t>(std::vector<Func*>::const_iterator, + std::vector<Func*>::const_iterator, + size_t, + size_t)> + name_to_output_file_index_; +}; + +// TODO: if WABT begins supporting debug names for labels, +// will need to avoid conflict between a label named "$Bfunc" and +// the implicit func label +static constexpr char kImplicitFuncLabel[] = "$Bfunc"; + +// These should be greater than any ModuleFieldType (used for MangleField). +static constexpr char kParamSuffix = + 'a' + static_cast<char>(ModuleFieldType::Tag) + 1; +static constexpr char kLabelSuffix = kParamSuffix + 1; + +static constexpr char kGlobalSymbolPrefix[] = "w2c_"; +static constexpr char kLocalSymbolPrefix[] = "var_"; +static constexpr char kAdminSymbolPrefix[] = "wasm2c_"; + +size_t CWriter::MarkTypeStack() const { + return type_stack_.size(); +} + +void CWriter::ResetTypeStack(size_t mark) { + assert(mark <= type_stack_.size()); + type_stack_.erase(type_stack_.begin() + mark, type_stack_.end()); +} + +Type CWriter::StackType(Index index) const { + assert(index < type_stack_.size()); + return *(type_stack_.rbegin() + index); +} + +void CWriter::PushType(Type type) { + type_stack_.push_back(type); +} + +void CWriter::PushTypes(const TypeVector& types) { + type_stack_.insert(type_stack_.end(), types.begin(), types.end()); +} + +void CWriter::DropTypes(size_t count) { + assert(count <= type_stack_.size()); + type_stack_.erase(type_stack_.end() - count, type_stack_.end()); +} + +void CWriter::PushLabel(LabelType label_type, + const std::string& name, + const FuncSignature& sig, + bool used) { + if (label_type == LabelType::Loop) + label_stack_.emplace_back(label_type, name, sig.param_types, + type_stack_.size(), try_catch_stack_.size(), + used); + else + label_stack_.emplace_back(label_type, name, sig.result_types, + type_stack_.size(), try_catch_stack_.size(), + used); +} + +const Label* CWriter::FindLabel(const Var& var, bool mark_used) { + Label* label = nullptr; + + if (var.is_index()) { + // We've generated names for all labels, so we should only be using an + // index when branching to the implicit function label, which can't be + // named. + assert(var.index() + 1 == label_stack_.size()); + label = &label_stack_[0]; + } else { + assert(var.is_name()); + for (Index i = label_stack_.size(); i > 0; --i) { + label = &label_stack_[i - 1]; + if (label->name == var.name()) + break; + } + } + + assert(label); + if (mark_used) { + label->used = true; + } + return label; +} + +bool CWriter::IsTopLabelUsed() const { + assert(!label_stack_.empty()); + return label_stack_.back().used; +} + +void CWriter::PopLabel() { + label_stack_.pop_back(); +} + +// static +constexpr char CWriter::MangleType(Type type) { + // clang-format off + switch (type) { + case Type::I32: return 'i'; + case Type::I64: return 'j'; + case Type::F32: return 'f'; + case Type::F64: return 'd'; + case Type::V128: return 'o'; + case Type::FuncRef: return 'r'; + case Type::ExternRef: return 'e'; + default: + WABT_UNREACHABLE; + } + // clang-format on +} + +// static +constexpr char CWriter::MangleField(ModuleFieldType type) { + assert(static_cast<std::underlying_type<ModuleFieldType>::type>(type) < + std::numeric_limits<char>::max()); + return 'a' + static_cast<char>(type); +} + +// remove risky characters for pasting into a C-style comment +static std::string SanitizeForComment(std::string_view str) { + std::string result; + + for (const uint8_t ch : str) { + // escape control chars, DEL, >7-bit chars, trigraphs, and end of comment + if (ch < ' ' || ch > '~' || ch == '?' || ch == '/') { + result += "\\" + StringPrintf("%02X", ch); + } else { + result += ch; + } + } + + return result; +} + +// static +std::string CWriter::MangleMultivalueTypes(const TypeVector& types) { + assert(types.size() >= 2); + std::string result = "wasm_multi_"; + for (auto type : types) { + result += MangleType(type); + } + return result; +} + +// static +std::string CWriter::MangleTagTypes(const TypeVector& types) { + assert(types.size() >= 2); + std::string result = "wasm_tag_"; + for (auto type : types) { + result += MangleType(type); + } + return result; +} + +/* The C symbol for an export from this module. */ +std::string CWriter::ExportName(std::string_view export_name) { + return kGlobalSymbolPrefix + module_prefix_ + '_' + MangleName(export_name); +} + +/* The C symbol for an export from an arbitrary module. */ +// static +std::string CWriter::ExportName(std::string_view module_name, + std::string_view export_name) { + return kGlobalSymbolPrefix + MangleModuleName(module_name) + '_' + + MangleName(export_name); +} + +/* The type name of an instance of this module. */ +std::string CWriter::ModuleInstanceTypeName() const { + return kGlobalSymbolPrefix + module_prefix_; +} + +/* The type name of an instance of an arbitrary module. */ +// static +std::string CWriter::ModuleInstanceTypeName(std::string_view module_name) { + return kGlobalSymbolPrefix + MangleModuleName(module_name); +} + +/* + * Hardcoded "C"-locale versions of isalpha/isdigit/isalnum/isxdigit for use + * in CWriter::Mangle(). We don't use the standard isalpha/isdigit/isalnum + * because the caller might have changed the current locale. + */ +static bool internal_isalpha(uint8_t ch) { + return (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'); +} + +static bool internal_isdigit(uint8_t ch) { + return (ch >= '0' && ch <= '9'); +} + +static bool internal_isalnum(uint8_t ch) { + return internal_isalpha(ch) || internal_isdigit(ch); +} + +static bool internal_ishexdigit(uint8_t ch) { + return internal_isdigit(ch) || (ch >= 'A' && ch <= 'F'); // capitals only +} + +// static +std::string CWriter::Mangle(std::string_view name, bool double_underscores) { + /* + * Name mangling transforms arbitrary Wasm names into "safe" C names + * in a deterministic way. To avoid collisions, distinct Wasm names must be + * transformed into distinct C names. + * + * The rules implemented here are: + * 1) any hex digit ('A' through 'F') that follows the sequence "0x" + * is escaped + * 2) any underscore at the beginning, at the end, or following another + * underscore, is escaped + * 3) if double_underscores is set, underscores are replaced with + * two underscores. + * 4) otherwise, any alphanumeric character is kept as-is, + * and any other character is escaped + * + * "Escaped" means the character is represented with the sequence "0xAB", + * where A B are hex digits ('0'-'9' or 'A'-'F') representing the character's + * numeric value. + * + * Module names are mangled with double_underscores=true to prevent + * collisions between, e.g., a module "alfa" with export + * "bravo_charlie" vs. a module "alfa_bravo" with export "charlie". + */ + + enum State { Any, Zero, ZeroX, ZeroXHexDigit } state{Any}; + bool last_was_underscore = false; + + std::string result; + auto append_escaped = [&](const uint8_t ch) { + result += "0x" + StringPrintf("%02X", ch); + last_was_underscore = false; + state = Any; + }; + + auto append_verbatim = [&](const uint8_t ch) { + result += ch; + last_was_underscore = (ch == '_'); + }; + + for (auto it = name.begin(); it != name.end(); ++it) { + const uint8_t ch = *it; + switch (state) { + case Any: + state = (ch == '0') ? Zero : Any; + break; + case Zero: + state = (ch == 'x') ? ZeroX : Any; + break; + case ZeroX: + state = internal_ishexdigit(ch) ? ZeroXHexDigit : Any; + break; + case ZeroXHexDigit: + WABT_UNREACHABLE; + break; + } + + /* rule 1 */ + if (state == ZeroXHexDigit) { + append_escaped(ch); + continue; + } + + /* rule 2 */ + if ((ch == '_') && ((it == name.begin()) || (std::next(it) == name.end()) || + last_was_underscore)) { + append_escaped(ch); + continue; + } + + /* rule 3 */ + if (double_underscores && ch == '_') { + append_verbatim(ch); + append_verbatim(ch); + continue; + } + + /* rule 4 */ + if (internal_isalnum(ch) || (ch == '_')) { + append_verbatim(ch); + } else { + append_escaped(ch); + } + } + + return result; +} + +// static +std::string CWriter::MangleName(std::string_view name) { + return Mangle(name, false); +} + +// static +std::string CWriter::MangleModuleName(std::string_view name) { + return Mangle(name, true); +} + +/* + * Allocate a C symbol (must be unused) in the SymbolSet, + * and a mapping from the Wasm name (tagged with + * the index space of the name) to that C symbol. + */ +void CWriter::ClaimName(SymbolSet& set, + SymbolMap& map, + char type_suffix, + std::string_view wasm_name, + const std::string& c_name) { + const std::string type_tagged_wasm_name = + std::string(wasm_name) + type_suffix; + + [[maybe_unused]] bool success; + success = set.insert(c_name).second; + assert(success); + + success = map.emplace(type_tagged_wasm_name, c_name).second; + assert(success); +} + +/* + * Make a proposed C symbol unique in a given symbol set by appending + * an integer to the symbol if necessary. + */ +std::string CWriter::FindUniqueName(SymbolSet& set, + std::string_view proposed_name) { + std::string unique{proposed_name}; + if (set.find(unique) != set.end()) { + std::string base = unique + "_"; + size_t count = 0; + do { + unique = base + std::to_string(count++); + } while (set.find(unique) != set.end()); + } + return unique; +} + +/* + * Find a unique C symbol in the symbol set and claim it (mapping the + * type-tagged Wasm name to it). + */ +std::string CWriter::ClaimUniqueName(SymbolSet& set, + SymbolMap& map, + char type_suffix, + std::string_view wasm_name, + const std::string& proposed_c_name) { + const std::string unique = FindUniqueName(set, proposed_c_name); + ClaimName(set, map, type_suffix, wasm_name, unique); + return unique; +} + +std::string_view StripLeadingDollar(std::string_view name) { + assert(!name.empty()); + assert(name.front() == '$'); + name.remove_prefix(1); + return name; +} + +void CWriter::DefineImportName(const Import* import, + std::string_view module, + std::string_view field_name) { + std::string name; + ModuleFieldType type{}; + + switch (import->kind()) { + case ExternalKind::Func: + type = ModuleFieldType::Func; + name = cast<FuncImport>(import)->func.name; + break; + case ExternalKind::Tag: + type = ModuleFieldType::Tag; + name = cast<TagImport>(import)->tag.name; + break; + case ExternalKind::Global: + type = ModuleFieldType::Global; + name = cast<GlobalImport>(import)->global.name; + break; + case ExternalKind::Memory: + type = ModuleFieldType::Memory; + name = cast<MemoryImport>(import)->memory.name; + break; + case ExternalKind::Table: + type = ModuleFieldType::Table; + name = cast<TableImport>(import)->table.name; + break; + } + + import_syms_.insert(name); + import_module_sym_map_.emplace(name, import->module_name); + + const std::string mangled = ExportName(module, field_name); + global_syms_.erase(mangled); // duplicate imports are allowed + ClaimName(global_syms_, global_sym_map_, MangleField(type), name, mangled); +} + +/* + * Reserve a C symbol for the public name of a module's export. The + * format of these is "w2c_" + the module prefix + "_" + the mangled + * export name. Reserving the symbol prevents internal functions and + * other names from shadowing/overlapping the exports. + */ +void CWriter::ReserveExportName(std::string_view name) { + ClaimName(global_syms_, global_sym_map_, MangleField(ModuleFieldType::Export), + name, ExportName(name)); +} + +/* + * Names for functions, function types, tags, and segments are globally unique + * across modules (formatted the same as an export, as "w2c_" + module prefix + + * "_" + the name, made unique if necessary). + */ +std::string CWriter::DefineGlobalScopeName(ModuleFieldType type, + std::string_view name) { + return ClaimUniqueName(global_syms_, global_sym_map_, MangleField(type), name, + ExportName(StripLeadingDollar(name))); +} + +std::string CWriter::GetGlobalName(ModuleFieldType type, + const std::string& name) const { + std::string mangled = name + MangleField(type); + assert(global_sym_map_.count(mangled) == 1); + return global_sym_map_.at(mangled); +} + +/* Names for params, locals, and stack vars are formatted as "var_" + name. */ +std::string CWriter::DefineLocalScopeName(std::string_view name, + bool is_label) { + return ClaimUniqueName( + local_syms_, local_sym_map_, is_label ? kLabelSuffix : kParamSuffix, name, + kLocalSymbolPrefix + MangleName(StripLeadingDollar(name))); +} + +std::string CWriter::GetLocalName(const std::string& name, + bool is_label) const { + std::string mangled = name + (is_label ? kLabelSuffix : kParamSuffix); + assert(local_sym_map_.count(mangled) == 1); + return local_sym_map_.at(mangled); +} + +std::string CWriter::DefineParamName(std::string_view name) { + return DefineLocalScopeName(name, false); +} + +std::string CWriter::DefineLabelName(std::string_view name) { + return DefineLocalScopeName(name, true); +} + +std::string CWriter::DefineStackVarName(Index index, + Type type, + std::string_view name) { + std::string unique = + FindUniqueName(local_syms_, kLocalSymbolPrefix + MangleName(name)); + StackTypePair stp = {index, type}; + [[maybe_unused]] bool success = + stack_var_sym_map_.emplace(stp, unique).second; + assert(success); + return unique; +} + +/* + * Members of the module instance (globals, tables, and memories) are formatted + * as "w2c_" + the mangled name of the element (made unique if necessary). + */ +std::string CWriter::DefineInstanceMemberName(ModuleFieldType type, + std::string_view name) { + return ClaimUniqueName( + global_syms_, global_sym_map_, MangleField(type), name, + kGlobalSymbolPrefix + MangleName(StripLeadingDollar(name))); +} + +/* + * The name of a module-instance member that points to the originating + * instance of an imported function is formatted as "w2c_" + originating + * module prefix + "_instance". + */ +std::string CWriter::DefineImportedModuleInstanceName(std::string_view name) { + return ClaimUniqueName(global_syms_, global_sym_map_, + MangleField(ModuleFieldType::Import), name, + ExportName(name, "instance")); +} + +void CWriter::Indent(int size) { + indent_ += size; +} + +void CWriter::Dedent(int size) { + indent_ -= size; + assert(indent_ >= 0); +} + +void CWriter::WriteIndent() { + static char s_indent[] = + " " + " "; + static size_t s_indent_len = sizeof(s_indent) - 1; + size_t to_write = indent_; + while (to_write >= s_indent_len) { + stream_->WriteData(s_indent, s_indent_len); + to_write -= s_indent_len; + } + if (to_write > 0) { + stream_->WriteData(s_indent, to_write); + } +} + +void CWriter::WriteData(const char* src, size_t size) { + if (should_write_indent_next_) { + WriteIndent(); + should_write_indent_next_ = false; + } + if (size > 0 && src[0] != '\n') { + consecutive_newline_count_ = 0; + } + stream_->WriteData(src, size); +} + +void WABT_PRINTF_FORMAT(2, 3) CWriter::Writef(const char* format, ...) { + WABT_SNPRINTF_ALLOCA(buffer, length, format); + WriteData(buffer, length); +} + +void CWriter::Write(Newline) { + // Allow maximum one blank line between sections + if (consecutive_newline_count_ < 2) { + Write("\n"); + consecutive_newline_count_++; + } + should_write_indent_next_ = true; +} + +void CWriter::Write(OpenBrace) { + Write("{"); + Indent(); + Write(Newline()); +} + +void CWriter::Write(CloseBrace) { + Dedent(); + Write("}"); +} + +void CWriter::Write(uint64_t val) { + Writef("%" PRIu64, val); +} + +void CWriter::Write(std::string_view s) { + WriteData(s.data(), s.size()); +} + +void CWriter::Write(const ParamName& name) { + Write(GetLocalName(name.name, false)); +} + +void CWriter::Write(const LabelName& name) { + Write(GetLocalName(name.name, true)); +} + +void CWriter::Write(const GlobalName& name) { + Write(GetGlobalName(name.type, name.name)); +} + +void CWriter::Write(const ExternalPtr& name) { + bool is_import = import_syms_.count(name.name) != 0; + if (!is_import) { + Write("&"); + } + Write(GlobalName(name)); +} + +void CWriter::Write(const ExternalInstancePtr& name) { + bool is_import = import_syms_.count(name.name) != 0; + if (!is_import) { + Write("&"); + } + Write("instance->", GlobalName(name)); +} + +void CWriter::Write(const ExternalRef& name) { + bool is_import = import_syms_.count(name.name) != 0; + if (is_import) { + Write("(*", GlobalName(name), ")"); + } else { + Write(GlobalName(name)); + } +} + +void CWriter::Write(const ExternalInstanceRef& name) { + bool is_import = import_syms_.count(name.name) != 0; + if (is_import) { + Write("(*instance->", GlobalName(name), ")"); + } else { + Write("instance->", GlobalName(name)); + } +} + +void CWriter::Write(const GotoLabel& goto_label) { + const Label* label = FindLabel(goto_label.var); + if (label->HasValue()) { + size_t amount = label->sig.size(); + assert(type_stack_.size() >= label->type_stack_size); + assert(type_stack_.size() >= amount); + assert(type_stack_.size() - amount >= label->type_stack_size); + Index offset = type_stack_.size() - label->type_stack_size - amount; + if (offset != 0) { + for (Index i = 0; i < amount; ++i) { + Write(StackVar(amount - i - 1 + offset, label->sig[i]), " = ", + StackVar(amount - i - 1), "; "); + } + } + } + + assert(try_catch_stack_.size() >= label->try_catch_stack_size); + + if (try_catch_stack_.size() != label->try_catch_stack_size) { + const std::string& name = + try_catch_stack_.at(label->try_catch_stack_size).name; + + Write("wasm_rt_set_unwind_target(", name, "_outer_target);", Newline()); + } + + if (goto_label.var.is_name()) { + Write("goto ", LabelName(goto_label.var.name()), ";"); + } else { + // We've generated names for all labels, so we should only be using an + // index when branching to the implicit function label, which can't be + // named. + Write("goto ", LabelName(kImplicitFuncLabel), ";"); + } +} + +void CWriter::Write(const LabelDecl& label) { + if (IsTopLabelUsed()) + Write(label.name, ":;", Newline()); +} + +void CWriter::Write(const GlobalInstanceVar& var) { + assert(var.var.is_name()); + Write(ExternalInstanceRef(ModuleFieldType::Global, var.var.name())); +} + +void CWriter::Write(const StackVar& sv) { + Index index = type_stack_.size() - 1 - sv.index; + Type type = sv.type; + if (type == Type::Any) { + assert(index < type_stack_.size()); + type = type_stack_[index]; + } + + StackTypePair stp = {index, type}; + auto iter = stack_var_sym_map_.find(stp); + if (iter == stack_var_sym_map_.end()) { + std::string name = MangleType(type) + std::to_string(index); + Write(DefineStackVarName(index, type, name)); + } else { + Write(iter->second); + } +} + +// static +const char* CWriter::GetCTypeName(const Type& type) { + // clang-format off + switch (type) { + case Type::I32: return "u32"; + case Type::I64: return "u64"; + case Type::F32: return "f32"; + case Type::F64: return "f64"; + case Type::V128: return "v128"; + case Type::FuncRef: return "wasm_rt_funcref_t"; + case Type::ExternRef: return "wasm_rt_externref_t"; + default: + WABT_UNREACHABLE; + } + // clang-format on +} + +void CWriter::Write(Type type) { + Write(GetCTypeName(type)); +} + +void CWriter::Write(TypeEnum type) { + // clang-format off + switch (type.type) { + case Type::I32: Write("WASM_RT_I32"); break; + case Type::I64: Write("WASM_RT_I64"); break; + case Type::F32: Write("WASM_RT_F32"); break; + case Type::F64: Write("WASM_RT_F64"); break; + case Type::V128: Write("WASM_RT_V128"); break; + case Type::FuncRef: Write("WASM_RT_FUNCREF"); break; + case Type::ExternRef: Write("WASM_RT_EXTERNREF"); break; + default: + WABT_UNREACHABLE; + } + // clang-format on +} + +void CWriter::Write(SignedType type) { + // clang-format off + switch (type.type) { + case Type::I32: Write("s32"); break; + case Type::I64: Write("s64"); break; + default: + WABT_UNREACHABLE; + } + // clang-format on +} + +void CWriter::Write(const ResultType& rt) { + if (rt.types.empty()) { + Write("void"); + } else if (rt.types.size() == 1) { + Write(rt.types[0]); + } else { + Write("struct ", MangleMultivalueTypes(rt.types)); + } +} + +void CWriter::Write(const Const& const_) { + switch (const_.type()) { + case Type::I32: + Writef("%uu", static_cast<int32_t>(const_.u32())); + break; + + case Type::I64: + Writef("%" PRIu64 "ull", static_cast<int64_t>(const_.u64())); + break; + + case Type::F32: { + uint32_t f32_bits = const_.f32_bits(); + // TODO(binji): Share with similar float info in interp.cc and literal.cc + if ((f32_bits & 0x7f800000u) == 0x7f800000u) { + const char* sign = (f32_bits & 0x80000000) ? "-" : ""; + uint32_t significand = f32_bits & 0x7fffffu; + if (significand == 0) { + // Infinity. + Writef("%sINFINITY", sign); + } else { + // Nan. + Writef("f32_reinterpret_i32(0x%08x) /* %snan:0x%06x */", f32_bits, + sign, significand); + } + } else if (f32_bits == 0x80000000) { + // Negative zero. Special-cased so it isn't written as -0 below. + Writef("-0.f"); + } else { + Writef("%.9g", Bitcast<float>(f32_bits)); + } + break; + } + + case Type::F64: { + uint64_t f64_bits = const_.f64_bits(); + // TODO(binji): Share with similar float info in interp.cc and literal.cc + if ((f64_bits & 0x7ff0000000000000ull) == 0x7ff0000000000000ull) { + const char* sign = (f64_bits & 0x8000000000000000ull) ? "-" : ""; + uint64_t significand = f64_bits & 0xfffffffffffffull; + if (significand == 0) { + // Infinity. + Writef("%sINFINITY", sign); + } else { + // Nan. + Writef("f64_reinterpret_i64(0x%016" PRIx64 ") /* %snan:0x%013" PRIx64 + " */", + f64_bits, sign, significand); + } + } else if (f64_bits == 0x8000000000000000ull) { + // Negative zero. Special-cased so it isn't written as -0 below. + Writef("-0.0"); + } else { + Writef("%.17g", Bitcast<double>(f64_bits)); + } + break; + } + case Type::V128: { + Writef("simde_wasm_i32x4_const(0x%08x, 0x%08x, 0x%08x, 0x%08x)", + const_.vec128().u32(0), const_.vec128().u32(1), + const_.vec128().u32(2), const_.vec128().u32(3)); + break; + } + + default: + WABT_UNREACHABLE; + } +} + +void CWriter::WriteInitDecl() { + Write("void ", kAdminSymbolPrefix, module_prefix_, "_instantiate(", + ModuleInstanceTypeName(), "*"); + for (const auto& import_module_name : import_module_set_) { + Write(", struct ", ModuleInstanceTypeName(import_module_name), "*"); + } + Write(");", Newline()); +} + +void CWriter::WriteFreeDecl() { + Write("void ", kAdminSymbolPrefix, module_prefix_, "_free(", + ModuleInstanceTypeName(), "*);", Newline()); +} + +void CWriter::WriteGetFuncTypeDecl() { + Write("wasm_rt_func_type_t ", kAdminSymbolPrefix, module_prefix_, + "_get_func_type(uint32_t param_count, uint32_t result_count, ...);", + Newline()); +} + +void CWriter::WriteInitExpr(const ExprList& expr_list) { + if (expr_list.empty()) { + WABT_UNREACHABLE; + } + + std::vector<std::string> mini_stack; + + for (const auto& expr : expr_list) { + if (expr.type() == ExprType::Binary) { + // Extended const expressions include at least one binary op. + // This builds a C expression from the operands. + if (mini_stack.size() < 2) { + WABT_UNREACHABLE; + } + + const auto binexpr = cast<BinaryExpr>(&expr); + char op; + switch (binexpr->opcode) { + case Opcode::I32Add: + case Opcode::I64Add: + case Opcode::F32Add: + case Opcode::F64Add: + op = '+'; + break; + + case Opcode::I32Sub: + case Opcode::I64Sub: + case Opcode::F32Sub: + case Opcode::F64Sub: + op = '-'; + break; + + case Opcode::I32Mul: + case Opcode::I64Mul: + case Opcode::F32Mul: + case Opcode::F64Mul: + op = '*'; + break; + + default: + WABT_UNREACHABLE; + } + + std::string combination = + "((" + std::string(GetCTypeName(binexpr->opcode.GetParamType1())) + + ")" + mini_stack.at(mini_stack.size() - 2) + ")" + op + "((" + + std::string(GetCTypeName(binexpr->opcode.GetParamType2())) + ")" + + mini_stack.at(mini_stack.size() - 1) + ")"; + mini_stack.resize(mini_stack.size() - 2); + mini_stack.push_back(std::move(combination)); + } else { + // Leaf node (nullary const expression) + Stream* existing_stream = stream_; + MemoryStream terminal_stream; + stream_ = &terminal_stream; + WriteInitExprTerminal(&expr); + const auto& buf = terminal_stream.output_buffer(); + mini_stack.emplace_back(reinterpret_cast<const char*>(buf.data.data()), + buf.data.size()); + stream_ = existing_stream; + } + } + + if (mini_stack.size() != 1) { + WABT_UNREACHABLE; + } + + Write(mini_stack.front()); +} + +void CWriter::WriteInitExprTerminal(const Expr* expr) { + switch (expr->type()) { + case ExprType::Const: + Write(cast<ConstExpr>(expr)->const_); + break; + + case ExprType::GlobalGet: + Write(GlobalInstanceVar(cast<GlobalGetExpr>(expr)->var)); + break; + + case ExprType::RefFunc: { + const Func* func = module_->GetFunc(cast<RefFuncExpr>(expr)->var); + const FuncDeclaration& decl = func->decl; + + assert(decl.has_func_type); + const FuncType* func_type = module_->GetFuncType(decl.type_var); + + Write("(wasm_rt_funcref_t){", FuncTypeExpr(func_type), ", ", + "(wasm_rt_function_ptr_t)", + ExternalPtr(ModuleFieldType::Func, func->name), ", "); + + bool is_import = import_module_sym_map_.count(func->name) != 0; + if (is_import) { + Write("instance->", GlobalName(ModuleFieldType::Import, + import_module_sym_map_[func->name])); + } else { + Write("instance"); + } + + Write("};", Newline()); + } break; + + case ExprType::RefNull: + Write(GetReferenceNullValue(cast<RefNullExpr>(expr)->type)); + break; + + default: + WABT_UNREACHABLE; + } +} + +std::string CWriter::GenerateHeaderGuard() const { + std::string result; + for (char c : header_name_) { + if (isalnum(c) || c == '_') { + result += toupper(c); + } else { + result += '_'; + } + } + result += "_GENERATED_"; + return result; +} + +void CWriter::WriteSourceTop() { + Write(s_source_includes); + Write(Newline(), "#include \"", header_name_, "\"", Newline()); + Write(s_source_declarations); +} + +void CWriter::WriteMultiCTop() { + if (c_streams_.size() > 1) { + assert(header_impl_name_.size() > 0); + Write("/* Automatically generated by wasm2c */", Newline()); + Write("#include \"", header_impl_name_, "\"", Newline()); + } +} + +void CWriter::WriteMultiCTopEmpty() { + for (auto& stream : c_streams_) { + if (stream->offset() == 0) { + stream_ = stream; + Write("/* Empty wasm2c generated file */\n"); + Write("typedef int dummy_def;"); + } + } +} + +void CWriter::WriteMultivalueTypes() { + for (TypeEntry* type : module_->types) { + FuncType* func_type = cast<FuncType>(type); + Index num_results = func_type->GetNumResults(); + if (num_results <= 1) { + continue; + } + std::string name = MangleMultivalueTypes(func_type->sig.result_types); + // these ifndefs are actually to support importing multiple modules + // incidentally they also mean we don't have to bother with deduplication + Write("#ifndef ", name, Newline()); + Write("#define ", name, " ", name, Newline()); + Write("struct ", name, " ", OpenBrace()); + for (Index i = 0; i < num_results; ++i) { + Type type = func_type->GetResultType(i); + Write(type); + Writef(" %c%d;", MangleType(type), i); + Write(Newline()); + } + Write(CloseBrace(), ";", Newline(), "#endif /* ", name, " */", Newline()); + } +} + +void CWriter::WriteTagTypes() { + for (const Tag* tag : module_->tags) { + const FuncDeclaration& tag_type = tag->decl; + Index num_params = tag_type.GetNumParams(); + if (num_params <= 1) { + continue; + } + const std::string name = MangleTagTypes(tag_type.sig.param_types); + // use same method as WriteMultivalueTypes + Write("#ifndef ", name, Newline()); + Write("#define ", name, " ", name, Newline()); + Write("struct ", name, " ", OpenBrace()); + for (Index i = 0; i < num_params; ++i) { + Type type = tag_type.GetParamType(i); + Write(type); + Writef(" %c%d;", MangleType(type), i); + Write(Newline()); + } + Write(CloseBrace(), ";", Newline(), "#endif /* ", name, " */", Newline()); + } +} + +void CWriter::WriteFuncTypeDecls() { + if (module_->types.empty()) { + return; + } + + Write(Newline()); + + std::string serialized_type; + for (const TypeEntry* type : module_->types) { + const std::string name = + DefineGlobalScopeName(ModuleFieldType::Type, type->name); + + if (c_streams_.size() > 1) { + Write("FUNC_TYPE_DECL_EXTERN_T(", name, ");", Newline()); + } + } +} + +void CWriter::WriteFuncTypes() { + if (module_->types.empty()) { + return; + } + + Write(Newline()); + + std::unordered_map<std::string, std::string> type_hash; + + std::string serialized_type; + for (const TypeEntry* type : module_->types) { + const std::string name = GetGlobalName(ModuleFieldType::Type, type->name); + SerializeFuncType(*cast<FuncType>(type), serialized_type); + + auto prior_type = type_hash.find(serialized_type); + if (prior_type != type_hash.end()) { + /* duplicate function type */ + unique_func_type_names_.push_back(prior_type->second); + } else { + unique_func_type_names_.push_back(name); + type_hash.emplace(serialized_type, name); + if (c_streams_.size() > 1) { + Write("FUNC_TYPE_EXTERN_T("); + } else { + Write("FUNC_TYPE_T("); + } + Write(name, ") = \""); + for (uint8_t x : serialized_type) { + Writef("\\x%02x", x); + } + Write("\";", Newline()); + } + } +} + +void CWriter::Write(const FuncTypeExpr& expr) { + Index func_type_index = module_->GetFuncTypeIndex(expr.func_type->sig); + Write(unique_func_type_names_.at(func_type_index)); +} + +// static +void CWriter::SerializeFuncType(const FuncType& func_type, + std::string& serialized_type) { + unsigned int len = func_type.GetNumParams() + func_type.GetNumResults() + 1; + + char* const mangled_signature = static_cast<char*>(alloca(len)); + char* next_byte = mangled_signature; + + // step 1: serialize each param type + for (Index i = 0; i < func_type.GetNumParams(); ++i) { + *next_byte++ = MangleType(func_type.GetParamType(i)); + } + + // step 2: separate params and results with a space + *next_byte++ = ' '; + + // step 3: serialize each result type + for (Index i = 0; i < func_type.GetNumResults(); ++i) { + *next_byte++ = MangleType(func_type.GetResultType(i)); + } + + assert(next_byte - mangled_signature == len); + + // step 4: SHA-256 the whole string + sha256({mangled_signature, len}, serialized_type); +} + +void CWriter::WriteTagDecls() { + Index tag_index = 0; + for (const Tag* tag : module_->tags) { + bool is_import = tag_index < module_->num_tag_imports; + if (!is_import) { + // Tags are identified and compared solely by their (unique) address. + // The data stored in this variable is never read. + if (tag_index == module_->num_tag_imports) { + Write(Newline()); + Write("typedef char wasm_tag_placeholder_t;", Newline()); + } + DefineGlobalScopeName(ModuleFieldType::Tag, tag->name); + if (c_streams_.size() > 1) { + Write("extern const wasm_tag_placeholder_t ", + GlobalName(ModuleFieldType::Tag, tag->name), ";", Newline()); + } + } + tag_index++; + } +} + +void CWriter::WriteTags() { + Write(Newline()); + Index tag_index = 0; + for (const Tag* tag : module_->tags) { + bool is_import = tag_index < module_->num_tag_imports; + if (!is_import) { + Write(InternalSymbolScope(), "const wasm_tag_placeholder_t ", + GlobalName(ModuleFieldType::Tag, tag->name), ";", Newline()); + } + tag_index++; + } +} + +void CWriter::ComputeUniqueImports() { + using modname_name_pair = std::pair<std::string, std::string>; + std::map<modname_name_pair, const Import*> import_map; + for (const Import* import : module_->imports) { + // After emplacing, the returned bool says whether the insert happened; + // i.e., was there already an import with the same modname and name? + // If there was, make sure it was at least the same kind of import. + const auto iterator_and_insertion_bool = import_map.emplace( + modname_name_pair(import->module_name, import->field_name), import); + if (!iterator_and_insertion_bool.second) { + if (iterator_and_insertion_bool.first->second->kind() != import->kind()) { + UNIMPLEMENTED("contradictory import declaration"); + } else { + fprintf(stderr, "warning: duplicate import declaration \"%s\" \"%s\"\n", + import->module_name.c_str(), import->field_name.c_str()); + } + } + import_module_set_.insert(import->module_name); + if (import->kind() == ExternalKind::Func) { + import_func_module_set_.insert(import->module_name); + } + } + + for (const auto& node : import_map) { + unique_imports_.push_back(node.second); + } +} + +void CWriter::BeginInstance() { + if (module_->imports.empty()) { + Write("typedef struct ", ModuleInstanceTypeName(), " ", OpenBrace()); + return; + } + + ComputeUniqueImports(); + + // define names of per-instance imports + for (const Import* import : module_->imports) { + DefineImportName(import, import->module_name, import->field_name); + } + + // Forward declaring module instance types + for (const auto& import_module : import_module_set_) { + DefineImportedModuleInstanceName(import_module); + Write("struct ", ModuleInstanceTypeName(import_module), ";", Newline()); + } + + // Forward declaring module imports + for (const Import* import : unique_imports_) { + if ((import->kind() == ExternalKind::Func) || + (import->kind() == ExternalKind::Tag)) { + continue; + } + + Write("extern "); + switch (import->kind()) { + case ExternalKind::Global: { + const Global& global = cast<GlobalImport>(import)->global; + Write(global.type); + break; + } + + case ExternalKind::Memory: { + Write("wasm_rt_memory_t"); + break; + } + + case ExternalKind::Table: + WriteTableType(cast<TableImport>(import)->table.elem_type); + break; + + default: + WABT_UNREACHABLE; + } + Write("* ", ExportName(import->module_name, import->field_name), "(struct ", + ModuleInstanceTypeName(import->module_name), "*);", Newline()); + } + Write(Newline()); + + // Add pointers to module instances that any func is imported from, + // so that imported functions can be given their own module instances + // when invoked + Write("typedef struct ", ModuleInstanceTypeName(), " ", OpenBrace()); + for (const auto& import_module : import_func_module_set_) { + Write("struct ", ModuleInstanceTypeName(import_module), "* ", + GlobalName(ModuleFieldType::Import, import_module), ";", Newline()); + } + + for (const Import* import : unique_imports_) { + if ((import->kind() == ExternalKind::Func) || + (import->kind() == ExternalKind::Tag)) { + continue; + } + + Write("/* import: '", SanitizeForComment(import->module_name), "' '", + SanitizeForComment(import->field_name), "' */", Newline()); + + switch (import->kind()) { + case ExternalKind::Global: + WriteGlobal(cast<GlobalImport>(import)->global, + std::string("*") + + ExportName(import->module_name, import->field_name)); + break; + + case ExternalKind::Memory: + WriteMemory(std::string("*") + + ExportName(import->module_name, import->field_name)); + break; + + case ExternalKind::Table: { + const Table& table = cast<TableImport>(import)->table; + WriteTable(std::string("*") + + ExportName(import->module_name, import->field_name), + table.elem_type); + } break; + + default: + WABT_UNREACHABLE; + } + + Write(Newline()); + } +} + +// Write module-wide imports (funcs & tags), which aren't tied to an instance. +void CWriter::WriteImports() { + if (unique_imports_.empty()) + return; + + Write(Newline()); + + for (const Import* import : unique_imports_) { + if (import->kind() == ExternalKind::Func) { + Write(Newline(), "/* import: '", SanitizeForComment(import->module_name), + "' '", SanitizeForComment(import->field_name), "' */", Newline()); + const Func& func = cast<FuncImport>(import)->func; + WriteImportFuncDeclaration( + func.decl, import->module_name, + ExportName(import->module_name, import->field_name)); + Write(";"); + Write(Newline()); + } else if (import->kind() == ExternalKind::Tag) { + Write(Newline(), "/* import: '", SanitizeForComment(import->module_name), + "' '", SanitizeForComment(import->field_name), "' */", Newline()); + Write("extern const wasm_rt_tag_t ", + ExportName(import->module_name, import->field_name), ";", + Newline()); + } + } +} + +void CWriter::WriteFuncDeclarations() { + if (module_->funcs.size() == module_->num_func_imports) + return; + + Write(Newline()); + + Index func_index = 0; + for (const Func* func : module_->funcs) { + bool is_import = func_index < module_->num_func_imports; + if (!is_import) { + Write(InternalSymbolScope()); + WriteFuncDeclaration( + func->decl, DefineGlobalScopeName(ModuleFieldType::Func, func->name)); + Write(";", Newline()); + } + ++func_index; + } +} + +void CWriter::WriteFuncDeclaration(const FuncDeclaration& decl, + const std::string& name) { + Write(ResultType(decl.sig.result_types), " ", name, "("); + Write(ModuleInstanceTypeName(), "*"); + WriteParamTypes(decl); + Write(")"); +} + +void CWriter::WriteImportFuncDeclaration(const FuncDeclaration& decl, + const std::string& module_name, + const std::string& name) { + Write(ResultType(decl.sig.result_types), " ", name, "("); + Write("struct ", ModuleInstanceTypeName(module_name), "*"); + WriteParamTypes(decl); + Write(")"); +} + +void CWriter::WriteCallIndirectFuncDeclaration(const FuncDeclaration& decl, + const std::string& name) { + Write(ResultType(decl.sig.result_types), " ", name, "(void*"); + WriteParamTypes(decl); + Write(")"); +} + +void CWriter::WriteFeatureMacros() { + if (options_.features->exceptions_enabled()) { + Write("#define WASM_RT_ENABLE_EXCEPTION_HANDLING", Newline(), Newline()); + } + if (options_.features->simd_enabled()) { + Write("#define WASM_RT_ENABLE_SIMD", Newline(), Newline()); + } +} + +void CWriter::WriteModuleInstance() { + BeginInstance(); + WriteGlobals(); + WriteMemories(); + WriteTables(); + WriteDataInstances(); + WriteElemInstances(); + + // C forbids an empty struct + if (module_->globals.empty() && module_->memories.empty() && + module_->tables.empty() && import_func_module_set_.empty()) { + Write("char dummy_member;", Newline()); + } + + Write(CloseBrace(), " ", ModuleInstanceTypeName(), ";", Newline()); + Write(Newline()); +} + +void CWriter::WriteGlobals() { + Index global_index = 0; + if (module_->globals.size() != module_->num_global_imports) { + for (const Global* global : module_->globals) { + bool is_import = global_index < module_->num_global_imports; + if (!is_import) { + WriteGlobal(*global, DefineInstanceMemberName(ModuleFieldType::Global, + global->name)); + Write(Newline()); + } + ++global_index; + } + } +} + +void CWriter::WriteGlobal(const Global& global, const std::string& name) { + Write(global.type, " ", name, ";"); +} + +void CWriter::WriteGlobalPtr(const Global& global, const std::string& name) { + Write(global.type, "* ", name, "(", ModuleInstanceTypeName(), "* instance)"); +} + +void CWriter::WriteMemories() { + if (module_->memories.size() == module_->num_memory_imports) + return; + + Index memory_index = 0; + for (const Memory* memory : module_->memories) { + bool is_import = memory_index < module_->num_memory_imports; + if (!is_import) { + WriteMemory( + DefineInstanceMemberName(ModuleFieldType::Memory, memory->name)); + Write(Newline()); + } + ++memory_index; + } +} + +void CWriter::WriteMemory(const std::string& name) { + Write("wasm_rt_memory_t ", name, ";"); +} + +void CWriter::WriteMemoryPtr(const std::string& name) { + Write("wasm_rt_memory_t* ", name, "(", ModuleInstanceTypeName(), + "* instance)"); +} + +void CWriter::WriteTables() { + if (module_->tables.size() == module_->num_table_imports) { + return; + } + + Index table_index = 0; + for (const Table* table : module_->tables) { + bool is_import = table_index < module_->num_table_imports; + if (!is_import) { + WriteTable(DefineInstanceMemberName(ModuleFieldType::Table, table->name), + table->elem_type); + Write(Newline()); + } + ++table_index; + } +} + +void CWriter::WriteTable(const std::string& name, const wabt::Type& type) { + WriteTableType(type); + Write(" ", name, ";"); +} + +void CWriter::WriteTablePtr(const std::string& name, const Table& table) { + WriteTableType(table.elem_type); + Write("* ", name, "(", ModuleInstanceTypeName(), "* instance)"); +} + +void CWriter::WriteTableType(const wabt::Type& type) { + Write("wasm_rt_", GetReferenceTypeName(type), "_table_t"); +} + +void CWriter::WriteGlobalInitializers() { + if (module_->globals.empty()) + return; + + Write(Newline(), "static void init_globals(", ModuleInstanceTypeName(), + "* instance) ", OpenBrace()); + Index global_index = 0; + for (const Global* global : module_->globals) { + bool is_import = global_index < module_->num_global_imports; + if (!is_import) { + assert(!global->init_expr.empty()); + Write(ExternalInstanceRef(ModuleFieldType::Global, global->name), " = "); + WriteInitExpr(global->init_expr); + Write(";", Newline()); + } + ++global_index; + } + Write(CloseBrace(), Newline()); +} + +static inline bool is_droppable(const DataSegment* data_segment) { + return (data_segment->kind == SegmentKind::Passive) && + (!data_segment->data.empty()); +} + +static inline bool is_droppable(const ElemSegment* elem_segment) { + return (elem_segment->kind == SegmentKind::Passive) && + (!elem_segment->elem_exprs.empty()); +} + +void CWriter::WriteDataInstances() { + for (const DataSegment* data_segment : module_->data_segments) { + std::string name = + DefineGlobalScopeName(ModuleFieldType::DataSegment, data_segment->name); + if (is_droppable(data_segment)) { + Write("bool ", "data_segment_dropped_", name, " : 1;", Newline()); + } + } +} + +void CWriter::WriteDataInitializerDecls() { + if (module_->memories.empty()) { + return; + } + + for (const DataSegment* data_segment : module_->data_segments) { + if (data_segment->data.empty()) { + continue; + } + + if (c_streams_.size() > 1) { + Write(Newline(), "extern const u8 data_segment_data_", + GlobalName(ModuleFieldType::DataSegment, data_segment->name), "[];", + Newline()); + } + } +} + +void CWriter::WriteDataInitializers() { + if (module_->memories.empty()) { + return; + } + + for (const DataSegment* data_segment : module_->data_segments) { + if (data_segment->data.empty()) { + continue; + } + + Write(Newline(), InternalSymbolScope(), "const u8 data_segment_data_", + GlobalName(ModuleFieldType::DataSegment, data_segment->name), + "[] = ", OpenBrace()); + size_t i = 0; + for (uint8_t x : data_segment->data) { + Writef("0x%02x, ", x); + if ((++i % 12) == 0) + Write(Newline()); + } + if (i > 0) + Write(Newline()); + Write(CloseBrace(), ";", Newline()); + } + + Write(Newline(), "static void init_memories(", ModuleInstanceTypeName(), + "* instance) ", OpenBrace()); + if (module_->memories.size() > module_->num_memory_imports) { + Index memory_idx = module_->num_memory_imports; + for (Index i = memory_idx; i < module_->memories.size(); i++) { + const Memory* memory = module_->memories[i]; + uint64_t max; + if (memory->page_limits.has_max) { + max = memory->page_limits.max; + } else { + max = memory->page_limits.is_64 ? (static_cast<uint64_t>(1) << 48) + : 65536; + } + Write("wasm_rt_allocate_memory(", + ExternalInstancePtr(ModuleFieldType::Memory, memory->name), ", ", + memory->page_limits.initial, ", ", max, ", ", + memory->page_limits.is_64, ");", Newline()); + } + } + + for (const DataSegment* data_segment : module_->data_segments) { + if (data_segment->kind != SegmentKind::Active) { + continue; + } + const Memory* memory = + module_->memories[module_->GetMemoryIndex(data_segment->memory_var)]; + Write("LOAD_DATA(", + ExternalInstanceRef(ModuleFieldType::Memory, memory->name), ", "); + WriteInitExpr(data_segment->offset); + if (data_segment->data.empty()) { + Write(", NULL, 0"); + } else { + Write(", data_segment_data_", + GlobalName(ModuleFieldType::DataSegment, data_segment->name), ", ", + data_segment->data.size()); + } + Write(");", Newline()); + } + + Write(CloseBrace(), Newline()); + + if (!module_->data_segments.empty()) { + Write(Newline(), "static void init_data_instances(", + ModuleInstanceTypeName(), " *instance) ", OpenBrace()); + + for (const DataSegment* data_segment : module_->data_segments) { + if (is_droppable(data_segment)) { + Write("instance->data_segment_dropped_", + GlobalName(ModuleFieldType::DataSegment, data_segment->name), + " = false;", Newline()); + } + } + + Write(CloseBrace(), Newline()); + } +} + +void CWriter::WriteElemInstances() { + for (const ElemSegment* elem_segment : module_->elem_segments) { + std::string name = + DefineGlobalScopeName(ModuleFieldType::ElemSegment, elem_segment->name); + if (is_droppable(elem_segment)) { + Write("bool ", "elem_segment_dropped_", name, " : 1;", Newline()); + } + } +} + +void CWriter::WriteElemInitializerDecls() { + if (module_->tables.empty()) { + return; + } + + for (const ElemSegment* elem_segment : module_->elem_segments) { + if (elem_segment->elem_exprs.empty()) { + continue; + } + + if (elem_segment->elem_type == Type::ExternRef) { + // no need to store externref elem initializers because only + // ref.null is possible + continue; + } + + if (c_streams_.size() > 1) { + Write(Newline(), + "extern const wasm_elem_segment_expr_t elem_segment_exprs_", + GlobalName(ModuleFieldType::ElemSegment, elem_segment->name), "[];", + Newline()); + } + } +} + +void CWriter::WriteElemInitializers() { + if (module_->tables.empty()) { + return; + } + + for (const ElemSegment* elem_segment : module_->elem_segments) { + if (elem_segment->elem_exprs.empty()) { + continue; + } + + if (elem_segment->elem_type == Type::ExternRef) { + // no need to store externref elem initializers because only + // ref.null is possible + continue; + } + + Write(Newline(), InternalSymbolScope(), + "const wasm_elem_segment_expr_t elem_segment_exprs_", + GlobalName(ModuleFieldType::ElemSegment, elem_segment->name), + "[] = ", OpenBrace()); + + for (const ExprList& elem_expr : elem_segment->elem_exprs) { + assert(elem_expr.size() == 1); + const Expr& expr = elem_expr.front(); + switch (expr.type()) { + case ExprType::RefFunc: { + const Func* func = module_->GetFunc(cast<RefFuncExpr>(&expr)->var); + const FuncType* func_type = module_->GetFuncType(func->decl.type_var); + Write("{", FuncTypeExpr(func_type), ", (wasm_rt_function_ptr_t)", + ExternalPtr(ModuleFieldType::Func, func->name), ", "); + const bool is_import = import_module_sym_map_.count(func->name) != 0; + if (is_import) { + Write("offsetof(", ModuleInstanceTypeName(), ", ", + GlobalName(ModuleFieldType::Import, + import_module_sym_map_[func->name]), + ")"); + } else { + Write("0"); + } + Write("},", Newline()); + } break; + case ExprType::RefNull: + Write("{NULL, NULL, 0},", Newline()); + break; + default: + WABT_UNREACHABLE; + } + } + Write(CloseBrace(), ";", Newline()); + } + + Write(Newline(), "static void init_tables(", ModuleInstanceTypeName(), + "* instance) ", OpenBrace()); + + if (module_->tables.size() > module_->num_table_imports) { + Index table_idx = module_->num_table_imports; + for (Index i = table_idx; i < module_->tables.size(); i++) { + const Table* table = module_->tables[i]; + uint32_t max = + table->elem_limits.has_max ? table->elem_limits.max : UINT32_MAX; + Write("wasm_rt_allocate_", GetReferenceTypeName(table->elem_type), + "_table(", ExternalInstancePtr(ModuleFieldType::Table, table->name), + ", ", table->elem_limits.initial, ", ", max, ");", Newline()); + } + } + + for (const ElemSegment* elem_segment : module_->elem_segments) { + if (elem_segment->kind != SegmentKind::Active) { + continue; + } + + const Table* table = module_->GetTable(elem_segment->table_var); + + WriteElemTableInit(true, elem_segment, table); + } + + Write(CloseBrace(), Newline()); + + if (!module_->elem_segments.empty()) { + Write(Newline(), "static void init_elem_instances(", + ModuleInstanceTypeName(), " *instance) ", OpenBrace()); + + for (const ElemSegment* elem_segment : module_->elem_segments) { + if (is_droppable(elem_segment)) { + Write("instance->elem_segment_dropped_", + GlobalName(ModuleFieldType::ElemSegment, elem_segment->name), + " = false;", Newline()); + } + } + + Write(CloseBrace(), Newline()); + } +} + +void CWriter::WriteElemTableInit(bool active_initialization, + const ElemSegment* src_segment, + const Table* dst_table) { + assert(dst_table->elem_type == Type::FuncRef || + dst_table->elem_type == Type::ExternRef); + assert(dst_table->elem_type == src_segment->elem_type); + + Write(GetReferenceTypeName(dst_table->elem_type), "_table_init(", + ExternalInstancePtr(ModuleFieldType::Table, dst_table->name), ", "); + + // elem segment exprs needed only for funcref tables + // because externref tables can only be initialized with ref.null + if (dst_table->elem_type == Type::FuncRef) { + if (src_segment->elem_exprs.empty()) { + Write("NULL, "); + } else { + Write("elem_segment_exprs_", + GlobalName(ModuleFieldType::ElemSegment, src_segment->name), ", "); + } + } + + // src_size, dest_addr, src_addr, N + if (active_initialization) { + Write(src_segment->elem_exprs.size(), ", "); + WriteInitExpr(src_segment->offset); + Write(", 0, ", src_segment->elem_exprs.size()); + } else { + if (is_droppable(src_segment)) { + Write("(instance->elem_segment_dropped_", + GlobalName(ModuleFieldType::ElemSegment, src_segment->name), + " ? 0 : ", src_segment->elem_exprs.size(), "), "); + } else { + Write("0, "); + } + Write(StackVar(2), ", ", StackVar(1), ", ", StackVar(0)); + } + + if (dst_table->elem_type == Type::FuncRef) { + Write(", instance"); + } + + Write(");", Newline()); +} + +void CWriter::WriteExports(CWriterPhase kind) { + if (module_->exports.empty()) + return; + + for (const Export* export_ : module_->exports) { + Write(Newline(), "/* export: '", SanitizeForComment(export_->name), "' */", + Newline()); + + const std::string mangled_name = ExportName(export_->name); + std::string internal_name; + std::vector<std::string> index_to_name; + + switch (export_->kind) { + case ExternalKind::Func: { + const Func* func = module_->GetFunc(export_->var); + internal_name = func->name; + if (kind == CWriterPhase::Declarations) { + WriteFuncDeclaration(func->decl, mangled_name); + } else { + func_ = func; + local_syms_ = global_syms_; + local_sym_map_.clear(); + stack_var_sym_map_.clear(); + Write(ResultType(func_->decl.sig.result_types), " ", mangled_name, + "("); + MakeTypeBindingReverseMapping(func_->GetNumParamsAndLocals(), + func_->bindings, &index_to_name); + WriteParams(index_to_name); + } + break; + } + + case ExternalKind::Global: { + const Global* global = module_->GetGlobal(export_->var); + internal_name = global->name; + WriteGlobalPtr(*global, mangled_name); + break; + } + + case ExternalKind::Memory: { + const Memory* memory = module_->GetMemory(export_->var); + internal_name = memory->name; + WriteMemoryPtr(mangled_name); + break; + } + + case ExternalKind::Table: { + const Table* table = module_->GetTable(export_->var); + internal_name = table->name; + WriteTablePtr(mangled_name, *table); + break; + } + + case ExternalKind::Tag: { + const Tag* tag = module_->GetTag(export_->var); + internal_name = tag->name; + if (kind == CWriterPhase::Declarations) { + Write("extern "); + } + Write("const wasm_rt_tag_t ", mangled_name); + break; + } + + default: + WABT_UNREACHABLE; + } + + if (kind == CWriterPhase::Declarations) { + Write(";", Newline()); + continue; + } + + Write(" "); + switch (export_->kind) { + case ExternalKind::Func: { + Write(OpenBrace()); + Write("return ", ExternalRef(ModuleFieldType::Func, internal_name), + "("); + + bool is_import = import_module_sym_map_.count(internal_name) != 0; + if (is_import) { + Write("instance->", + GlobalName(ModuleFieldType::Import, + import_module_sym_map_[internal_name])); + } else { + Write("instance"); + } + WriteParamSymbols(index_to_name); + Write(CloseBrace(), Newline()); + + local_sym_map_.clear(); + stack_var_sym_map_.clear(); + func_ = nullptr; + break; + } + + case ExternalKind::Global: + Write(OpenBrace()); + Write("return ", + ExternalInstancePtr(ModuleFieldType::Global, internal_name), ";", + Newline()); + Write(CloseBrace(), Newline()); + break; + + case ExternalKind::Memory: + Write(OpenBrace()); + Write("return ", + ExternalInstancePtr(ModuleFieldType::Memory, internal_name), ";", + Newline()); + Write(CloseBrace(), Newline()); + break; + + case ExternalKind::Table: + Write(OpenBrace()); + Write("return ", + ExternalInstancePtr(ModuleFieldType::Table, internal_name), ";", + Newline()); + Write(CloseBrace(), Newline()); + break; + + case ExternalKind::Tag: + Write("= ", ExternalPtr(ModuleFieldType::Tag, internal_name), ";", + Newline()); + break; + + default: + WABT_UNREACHABLE; + } + } +} + +void CWriter::WriteInit() { + Write(Newline(), "void ", kAdminSymbolPrefix, module_prefix_, "_instantiate(", + ModuleInstanceTypeName(), "* instance"); + for (const auto& import_module_name : import_module_set_) { + Write(", struct ", ModuleInstanceTypeName(import_module_name), "* ", + GlobalName(ModuleFieldType::Import, import_module_name)); + } + Write(") ", OpenBrace()); + + Write("assert(wasm_rt_is_initialized());", Newline()); + + if (!import_module_set_.empty()) { + Write("init_instance_import(instance"); + for (const auto& import_module_name : import_module_set_) { + Write(", ", GlobalName(ModuleFieldType::Import, import_module_name)); + } + Write(");", Newline()); + } + + if (!module_->globals.empty()) { + Write("init_globals(instance);", Newline()); + } + if (!module_->tables.empty()) { + Write("init_tables(instance);", Newline()); + } + if (!module_->memories.empty()) { + Write("init_memories(instance);", Newline()); + } + if (!module_->tables.empty() && !module_->elem_segments.empty()) { + Write("init_elem_instances(instance);", Newline()); + } + if (!module_->memories.empty() && !module_->data_segments.empty()) { + Write("init_data_instances(instance);", Newline()); + } + + for (Var* var : module_->starts) { + Write(ExternalRef(ModuleFieldType::Func, module_->GetFunc(*var)->name)); + bool is_import = + import_module_sym_map_.count(module_->GetFunc(*var)->name) != 0; + if (is_import) { + Write("(instance->", + GlobalName(ModuleFieldType::Import, + import_module_sym_map_[module_->GetFunc(*var)->name]), + ");"); + } else { + Write("(instance);"); + } + Write(Newline()); + } + Write(CloseBrace(), Newline()); +} + +void CWriter::WriteGetFuncType() { + Write(Newline(), "wasm_rt_func_type_t ", kAdminSymbolPrefix, module_prefix_, + "_get_func_type(uint32_t param_count, uint32_t result_count, " + "...) ", + OpenBrace()); + + Write("va_list args;", Newline()); + + for (const TypeEntry* type : module_->types) { + const FuncType* func_type = cast<FuncType>(type); + const FuncSignature& signature = func_type->sig; + + Write(Newline(), "if (param_count == ", signature.GetNumParams(), + " && result_count == ", signature.GetNumResults(), ") ", OpenBrace()); + Write("va_start(args, result_count);", Newline()); + Write("if (true"); + for (const auto& t : signature.param_types) { + Write(" && va_arg(args, wasm_rt_type_t) == ", TypeEnum(t)); + } + for (const auto& t : signature.result_types) { + Write(" && va_arg(args, wasm_rt_type_t) == ", TypeEnum(t)); + } + Write(") ", OpenBrace()); + Write("va_end(args);", Newline()); + Write("return ", FuncTypeExpr(func_type), ";", Newline()); + Write(CloseBrace(), Newline()); + Write("va_end(args);", Newline()); + Write(CloseBrace(), Newline()); + } + + Write(Newline(), "return NULL;", Newline()); + Write(CloseBrace(), Newline()); +} + +void CWriter::WriteInitInstanceImport() { + if (import_module_set_.empty()) + return; + + Write(Newline(), "static void init_instance_import(", + ModuleInstanceTypeName(), "* instance"); + for (const auto& import_module_name : import_module_set_) { + Write(", struct ", ModuleInstanceTypeName(import_module_name), "* ", + GlobalName(ModuleFieldType::Import, import_module_name)); + } + Write(")", OpenBrace()); + + for (const auto& import_module : import_func_module_set_) { + Write("instance->", GlobalName(ModuleFieldType::Import, import_module), + " = ", GlobalName(ModuleFieldType::Import, import_module), ";", + Newline()); + } + + for (const Import* import : unique_imports_) { + switch (import->kind()) { + case ExternalKind::Func: + case ExternalKind::Tag: + break; + + case ExternalKind::Global: + case ExternalKind::Memory: + case ExternalKind::Table: { + Write("instance->", ExportName(import->module_name, import->field_name), + " = ", ExportName(import->module_name, import->field_name), "(", + GlobalName(ModuleFieldType::Import, import->module_name), ");", + Newline()); + break; + } + + default: + WABT_UNREACHABLE; + } + } + Write(CloseBrace(), Newline()); +} + +void CWriter::WriteImportProperties(CWriterPhase kind) { + if (import_module_set_.empty()) + return; + + Write(Newline()); + + auto write_import_prop = [&](const Import* import, std::string prop, + std::string type, uint64_t value) { + if (kind == CWriterPhase::Declarations) { + Write("extern "); + } + Write("const ", type, " ", kAdminSymbolPrefix, module_prefix_, "_", prop, + "_", MangleModuleName(import->module_name), "_", + MangleName(import->field_name)); + if (kind == CWriterPhase::Definitions) { + Write(" = ", value); + } + + Write(";", Newline()); + }; + + for (const Import* import : unique_imports_) { + if (import->kind() == ExternalKind::Memory) { + const Limits* limits = &(cast<MemoryImport>(import)->memory.page_limits); + // We use u64 so we can handle both 32-bit and 64-bit memories + const uint64_t default_max = limits->is_64 + ? (static_cast<uint64_t>(1) << 48) + : (static_cast<uint64_t>(1) << 16); + write_import_prop(import, "min", "u64", limits->initial); + write_import_prop(import, "max", "u64", + limits->has_max ? limits->max : default_max); + write_import_prop(import, "is64", "u8", limits->is_64); + } else if (import->kind() == ExternalKind::Table) { + const Limits* limits = &(cast<TableImport>(import)->table.elem_limits); + const uint64_t default_max = std::numeric_limits<uint32_t>::max(); + write_import_prop(import, "min", "u32", limits->initial); + write_import_prop(import, "max", "u32", + limits->has_max ? limits->max : default_max); + } else { + continue; + } + } +} + +void CWriter::WriteFree() { + Write(Newline(), "void ", kAdminSymbolPrefix, module_prefix_, "_free(", + ModuleInstanceTypeName(), "* instance) ", OpenBrace()); + + { + Index table_index = 0; + for (const Table* table : module_->tables) { + bool is_import = table_index < module_->num_table_imports; + if (!is_import) { + Write("wasm_rt_free_", GetReferenceTypeName(table->elem_type), + "_table(", + ExternalInstancePtr(ModuleFieldType::Table, table->name), ");", + Newline()); + } + ++table_index; + } + } + + { + Index memory_index = 0; + for (const Memory* memory : module_->memories) { + bool is_import = memory_index < module_->num_memory_imports; + if (!is_import) { + Write("wasm_rt_free_memory(", + ExternalInstancePtr(ModuleFieldType::Memory, memory->name), ");", + Newline()); + } + ++memory_index; + } + } + + Write(CloseBrace(), Newline()); +} + +void CWriter::WriteFuncs() { + std::vector<size_t> c_stream_assignment = + name_to_output_file_index_(module_->funcs.begin(), module_->funcs.end(), + module_->num_func_imports, c_streams_.size()); + Index func_index = 0; + for (const Func* func : module_->funcs) { + bool is_import = func_index < module_->num_func_imports; + if (!is_import) { + stream_ = c_streams_.at(c_stream_assignment.at(func_index)); + Write(*func); + } + ++func_index; + } +} + +void CWriter::PushFuncSection(std::string_view include_condition) { + func_sections_.emplace_back(include_condition, MemoryStream{}); + stream_ = &func_sections_.back().second; +} + +void CWriter::Write(const Func& func) { + func_ = &func; + local_syms_.clear(); + local_sym_map_.clear(); + stack_var_sym_map_.clear(); + func_sections_.clear(); + func_includes_.clear(); + + Stream* prev_stream = stream_; + + /* + * If offset of stream_ is 0, this is the first time some function is written + * to this stream, then write multi c top. + */ + if (stream_->offset() == 0) { + WriteMultiCTop(); + } + Write(Newline()); + + PushFuncSection(); + Write(ResultType(func.decl.sig.result_types), " ", + GlobalName(ModuleFieldType::Func, func.name), "("); + WriteParamsAndLocals(); + Write("FUNC_PROLOGUE;", Newline()); + + PushFuncSection(); + + std::string label = DefineLabelName(kImplicitFuncLabel); + ResetTypeStack(0); + std::string empty; // Must not be temporary, since address is taken by Label. + PushLabel(LabelType::Func, empty, func.decl.sig); + Write(func.exprs, LabelDecl(label)); + PopLabel(); + ResetTypeStack(0); + PushTypes(func.decl.sig.result_types); + Write("FUNC_EPILOGUE;", Newline()); + + // Return the top of the stack implicitly. + Index num_results = func.GetNumResults(); + if (num_results == 1) { + Write("return ", StackVar(0), ";", Newline()); + } else if (num_results >= 2) { + Write(OpenBrace()); + Write(ResultType(func.decl.sig.result_types), " tmp;", Newline()); + for (Index i = 0; i < num_results; ++i) { + Type type = func.GetResultType(i); + Writef("tmp.%c%d = ", MangleType(type), i); + Write(StackVar(num_results - i - 1), ";", Newline()); + } + Write("return tmp;", Newline()); + Write(CloseBrace(), Newline()); + } + + stream_ = prev_stream; + + for (size_t i = 0; i < func_sections_.size(); ++i) { + auto& [condition, stream] = func_sections_.at(i); + std::unique_ptr<OutputBuffer> buf = stream.ReleaseOutputBuffer(); + if (condition.empty() || func_includes_.count(condition)) { + stream_->WriteData(buf->data.data(), buf->data.size()); + } + + if (i == 0) { + WriteStackVarDeclarations(); // these come immediately after section #0 + // (return type/name/params/locals) + } + } + + Write(CloseBrace(), Newline()); + + func_ = nullptr; +} + +void CWriter::WriteParamsAndLocals() { + std::vector<std::string> index_to_name; + MakeTypeBindingReverseMapping(func_->GetNumParamsAndLocals(), func_->bindings, + &index_to_name); + WriteParams(index_to_name); + Write(" ", OpenBrace()); + WriteLocals(index_to_name); +} + +void CWriter::WriteParams(const std::vector<std::string>& index_to_name) { + Write(ModuleInstanceTypeName(), "* instance"); + if (func_->GetNumParams() != 0) { + Indent(4); + for (Index i = 0; i < func_->GetNumParams(); ++i) { + Write(", "); + if (i != 0 && (i % 8) == 0) { + Write(Newline()); + } + Write(func_->GetParamType(i), " ", DefineParamName(index_to_name[i])); + } + Dedent(4); + } + Write(")"); +} + +void CWriter::WriteParamSymbols(const std::vector<std::string>& index_to_name) { + if (func_->GetNumParams() != 0) { + Indent(4); + for (Index i = 0; i < func_->GetNumParams(); ++i) { + Write(", "); + if (i != 0 && (i % 8) == 0) { + Write(Newline()); + } + Write(ParamName(index_to_name[i])); + } + Dedent(4); + } + Write(");", Newline()); +} + +void CWriter::WriteParamTypes(const FuncDeclaration& decl) { + if (decl.GetNumParams() != 0) { + for (Index i = 0; i < decl.GetNumParams(); ++i) { + Write(", "); + Write(decl.GetParamType(i)); + } + } +} + +void CWriter::WriteLocals(const std::vector<std::string>& index_to_name) { + Index num_params = func_->GetNumParams(); + for (Type type : {Type::I32, Type::I64, Type::F32, Type::F64, Type::V128, + Type::FuncRef, Type::ExternRef}) { + Index local_index = 0; + size_t count = 0; + for (Type local_type : func_->local_types) { + if (local_type == type) { + if (count == 0) { + Write(type, " "); + Indent(4); + } else { + Write(", "); + if ((count % 8) == 0) + Write(Newline()); + } + + Write(DefineParamName(index_to_name[num_params + local_index]), " = "); + if (local_type == Type::FuncRef || local_type == Type::ExternRef) { + Write(GetReferenceNullValue(local_type)); + } else if (local_type == Type::V128) { + Write("simde_wasm_i64x2_make(0, 0)"); + } else { + Write("0"); + } + ++count; + } + ++local_index; + } + if (count != 0) { + Dedent(4); + Write(";", Newline()); + } + } +} + +void CWriter::WriteStackVarDeclarations() { + for (Type type : {Type::I32, Type::I64, Type::F32, Type::F64, Type::V128, + Type::FuncRef, Type::ExternRef}) { + size_t count = 0; + for (const auto& [pair, name] : stack_var_sym_map_) { + Type stp_type = pair.second; + + if (stp_type == type) { + if (count == 0) { + Write(type, " "); + Indent(4); + } else { + Write(", "); + if ((count % 8) == 0) + Write(Newline()); + } + + Write(name); + ++count; + } + } + if (count != 0) { + Dedent(4); + Write(";", Newline()); + } + } +} + +void CWriter::Write(const Block& block) { + std::string label = DefineLabelName(block.label); + DropTypes(block.decl.GetNumParams()); + size_t mark = MarkTypeStack(); + PushLabel(LabelType::Block, block.label, block.decl.sig); + PushTypes(block.decl.sig.param_types); + Write(block.exprs, LabelDecl(label)); + ResetTypeStack(mark); + PopLabel(); + PushTypes(block.decl.sig.result_types); +} + +size_t CWriter::BeginTry(const TryExpr& tryexpr) { + Write(OpenBrace()); /* beginning of try-catch */ + const std::string tlabel = DefineLabelName(tryexpr.block.label); + Write("WASM_RT_UNWIND_TARGET *", tlabel, + "_outer_target = wasm_rt_get_unwind_target();", Newline()); + Write("WASM_RT_UNWIND_TARGET ", tlabel, "_unwind_target;", Newline()); + Write("if (!wasm_rt_try(", tlabel, "_unwind_target)) "); + Write(OpenBrace()); /* beginning of try block */ + DropTypes(tryexpr.block.decl.GetNumParams()); + const size_t mark = MarkTypeStack(); + PushLabel(LabelType::Try, tryexpr.block.label, tryexpr.block.decl.sig); + PushTypes(tryexpr.block.decl.sig.param_types); + Write("wasm_rt_set_unwind_target(&", tlabel, "_unwind_target);", Newline()); + PushTryCatch(tlabel); + Write(tryexpr.block.exprs); + ResetTypeStack(mark); + Write("wasm_rt_set_unwind_target(", tlabel, "_outer_target);", Newline()); + Write(CloseBrace()); /* end of try block */ + Write(" else ", OpenBrace()); /* beginning of catch blocks or delegate */ + assert(label_stack_.back().name == tryexpr.block.label); + assert(label_stack_.back().label_type == LabelType::Try); + label_stack_.back().label_type = LabelType::Catch; + if (try_catch_stack_.back().used) { + Write(tlabel, "_catch:;", Newline()); + } + + return mark; +} + +void CWriter::WriteTryCatch(const TryExpr& tryexpr) { + const size_t mark = BeginTry(tryexpr); + + /* exception has been thrown -- do we catch it? */ + + const LabelName tlabel = LabelName(tryexpr.block.label); + + Write("wasm_rt_set_unwind_target(", tlabel, "_outer_target);", Newline()); + PopTryCatch(); + + /* save the thrown exception to the stack if it might be rethrown later */ + PushFuncSection(tryexpr.block.label); + Write("/* save exception ", tlabel, " for rethrow */", Newline()); + Write("const wasm_rt_tag_t ", tlabel, "_tag = wasm_rt_exception_tag();", + Newline()); + Write("uint32_t ", tlabel, "_size = wasm_rt_exception_size();", Newline()); + Write("void *", tlabel, " = alloca(", tlabel, "_size);", Newline()); + Write("wasm_rt_memcpy(", tlabel, ", wasm_rt_exception(), ", tlabel, "_size);", + Newline()); + PushFuncSection(); + + assert(!tryexpr.catches.empty()); + bool has_catch_all{}; + for (auto it = tryexpr.catches.cbegin(); it != tryexpr.catches.cend(); ++it) { + if (it == tryexpr.catches.cbegin()) { + Write(Newline()); + } else { + Write(" else "); + } + ResetTypeStack(mark); + Write(*it); + if (it->IsCatchAll()) { + has_catch_all = true; + break; + } + } + if (!has_catch_all) { + /* if not caught, rethrow */ + Write(" else ", OpenBrace()); + WriteThrow(); + Write(CloseBrace(), Newline()); + } + Write(CloseBrace(), Newline()); /* end of catch blocks */ + Write(CloseBrace(), Newline()); /* end of try-catch */ + + ResetTypeStack(mark); + Write(LabelDecl(label_stack_.back().name)); + PopLabel(); + PushTypes(tryexpr.block.decl.sig.result_types); +} + +void CWriter::Write(const Catch& c) { + if (c.IsCatchAll()) { + Write(c.exprs); + return; + } + + Write("if (wasm_rt_exception_tag() == ", + ExternalPtr(ModuleFieldType::Tag, module_->GetTag(c.var)->name), ") ", + OpenBrace()); + + const Tag* tag = module_->GetTag(c.var); + const FuncDeclaration& tag_type = tag->decl; + const Index num_params = tag_type.GetNumParams(); + if (num_params == 1) { + PushType(tag_type.GetParamType(0)); + Write("wasm_rt_memcpy(&", StackVar(0), ", wasm_rt_exception(), sizeof(", + tag_type.GetParamType(0), "));", Newline()); + } else if (num_params > 1) { + for (const auto& type : tag_type.sig.param_types) { + PushType(type); + } + Write(OpenBrace()); + Write("struct ", MangleTagTypes(tag_type.sig.param_types), " tmp;", + Newline()); + Write("wasm_rt_memcpy(&tmp, wasm_rt_exception(), sizeof(tmp));", Newline()); + for (unsigned int i = 0; i < tag_type.sig.param_types.size(); ++i) { + Write(StackVar(i)); + Writef(" = tmp.%c%d;", MangleType(tag_type.sig.param_types.at(i)), i); + Write(Newline()); + } + + Write(CloseBrace(), Newline()); + } + + Write(c.exprs); + Write(CloseBrace()); +} + +void CWriter::WriteThrow() { + if (try_catch_stack_.empty()) { + Write("wasm_rt_throw();", Newline()); + } else { + Write("goto ", try_catch_stack_.back().name, "_catch;", Newline()); + try_catch_stack_.back().used = true; + } +} + +void CWriter::PushTryCatch(const std::string& name) { + try_catch_stack_.emplace_back(name, try_catch_stack_.size()); +} + +void CWriter::PopTryCatch() { + assert(!try_catch_stack_.empty()); + try_catch_stack_.pop_back(); +} + +void CWriter::WriteTryDelegate(const TryExpr& tryexpr) { + const size_t mark = BeginTry(tryexpr); + + /* exception has been thrown -- where do we delegate it? */ + + if (tryexpr.delegate_target.is_index()) { + /* must be the implicit function label */ + assert(!try_catch_stack_.empty()); + const std::string& unwind_name = try_catch_stack_.at(0).name; + Write("wasm_rt_set_unwind_target(", unwind_name, "_outer_target);", + Newline()); + + Write("wasm_rt_throw();", Newline()); + } else { + const Label* label = FindLabel(tryexpr.delegate_target, false); + + assert(try_catch_stack_.size() >= label->try_catch_stack_size); + + if (label->label_type == LabelType::Try) { + Write("goto ", LabelName(label->name), "_catch;", Newline()); + try_catch_stack_.at(label->try_catch_stack_size).used = true; + } else if (label->try_catch_stack_size == 0) { + assert(!try_catch_stack_.empty()); + const std::string& unwind_name = try_catch_stack_.at(0).name; + Write("wasm_rt_set_unwind_target(", unwind_name, "_outer_target);", + Newline()); + + Write("wasm_rt_throw();", Newline()); + } else { + const std::string label_target = + try_catch_stack_.at(label->try_catch_stack_size - 1).name + "_catch"; + Write("goto ", label_target, ";", Newline()); + try_catch_stack_.at(label->try_catch_stack_size - 1).used = true; + } + } + + Write(CloseBrace(), Newline()); + Write(CloseBrace(), Newline()); + + PopTryCatch(); + ResetTypeStack(mark); + Write(LabelDecl(label_stack_.back().name)); + PopLabel(); + PushTypes(tryexpr.block.decl.sig.result_types); +} + +void CWriter::Write(const ExprList& exprs) { + for (const Expr& expr : exprs) { + switch (expr.type()) { + case ExprType::Binary: + Write(*cast<BinaryExpr>(&expr)); + break; + + case ExprType::Block: + Write(cast<BlockExpr>(&expr)->block); + break; + + case ExprType::Br: + Write(GotoLabel(cast<BrExpr>(&expr)->var), Newline()); + // Stop processing this ExprList, since the following are unreachable. + return; + + case ExprType::BrIf: + Write("if (", StackVar(0), ") {"); + DropTypes(1); + Write(GotoLabel(cast<BrIfExpr>(&expr)->var), "}", Newline()); + break; + + case ExprType::BrTable: { + const auto* bt_expr = cast<BrTableExpr>(&expr); + Write("switch (", StackVar(0), ") ", OpenBrace()); + DropTypes(1); + Index i = 0; + for (const Var& var : bt_expr->targets) { + Write("case ", i++, ": ", GotoLabel(var), Newline()); + } + Write("default: "); + Write(GotoLabel(bt_expr->default_target), Newline(), CloseBrace(), + Newline()); + // Stop processing this ExprList, since the following are unreachable. + return; + } + + case ExprType::Call: { + const Var& var = cast<CallExpr>(&expr)->var; + const Func& func = *module_->GetFunc(var); + Index num_params = func.GetNumParams(); + Index num_results = func.GetNumResults(); + assert(type_stack_.size() >= num_params); + if (num_results > 1) { + Write(OpenBrace()); + Write("struct ", MangleMultivalueTypes(func.decl.sig.result_types)); + Write(" tmp = "); + } else if (num_results == 1) { + Write(StackVar(num_params - 1, func.GetResultType(0)), " = "); + } + + assert(var.is_name()); + Write(ExternalRef(ModuleFieldType::Func, var.name()), "("); + bool is_import = import_module_sym_map_.count(func.name) != 0; + if (is_import) { + Write("instance->", GlobalName(ModuleFieldType::Import, + import_module_sym_map_[func.name])); + } else { + Write("instance"); + } + for (Index i = 0; i < num_params; ++i) { + Write(", "); + Write(StackVar(num_params - i - 1)); + } + Write(");", Newline()); + DropTypes(num_params); + if (num_results > 1) { + for (Index i = 0; i < num_results; ++i) { + Type type = func.GetResultType(i); + PushType(type); + Write(StackVar(0)); + Writef(" = tmp.%c%d;", MangleType(type), i); + Write(Newline()); + } + Write(CloseBrace(), Newline()); + } else { + PushTypes(func.decl.sig.result_types); + } + break; + } + + case ExprType::CallIndirect: { + const FuncDeclaration& decl = cast<CallIndirectExpr>(&expr)->decl; + Index num_params = decl.GetNumParams(); + Index num_results = decl.GetNumResults(); + assert(type_stack_.size() > num_params); + if (num_results > 1) { + Write(OpenBrace()); + Write("struct ", MangleMultivalueTypes(decl.sig.result_types)); + Write(" tmp = "); + } else if (num_results == 1) { + Write(StackVar(num_params, decl.GetResultType(0)), " = "); + } + + const Table* table = + module_->GetTable(cast<CallIndirectExpr>(&expr)->table); + + assert(decl.has_func_type); + const FuncType* func_type = module_->GetFuncType(decl.type_var); + + Write("CALL_INDIRECT(", + ExternalInstanceRef(ModuleFieldType::Table, table->name), ", "); + WriteCallIndirectFuncDeclaration(decl, "(*)"); + Write(", ", FuncTypeExpr(func_type), ", ", StackVar(0)); + Write(", ", ExternalInstanceRef(ModuleFieldType::Table, table->name), + ".data[", StackVar(0), "].module_instance"); + for (Index i = 0; i < num_params; ++i) { + Write(", ", StackVar(num_params - i)); + } + Write(");", Newline()); + DropTypes(num_params + 1); + if (num_results > 1) { + for (Index i = 0; i < num_results; ++i) { + Type type = decl.GetResultType(i); + PushType(type); + Write(StackVar(0)); + Writef(" = tmp.%c%d;", MangleType(type), i); + Write(Newline()); + } + Write(CloseBrace(), Newline()); + } else { + PushTypes(decl.sig.result_types); + } + break; + } + + case ExprType::CodeMetadata: + break; + + case ExprType::Compare: + Write(*cast<CompareExpr>(&expr)); + break; + + case ExprType::Const: { + const Const& const_ = cast<ConstExpr>(&expr)->const_; + PushType(const_.type()); + Write(StackVar(0), " = ", const_, ";", Newline()); + break; + } + + case ExprType::Convert: + Write(*cast<ConvertExpr>(&expr)); + break; + + case ExprType::Drop: + DropTypes(1); + break; + + case ExprType::GlobalGet: { + const Var& var = cast<GlobalGetExpr>(&expr)->var; + PushType(module_->GetGlobal(var)->type); + Write(StackVar(0), " = ", GlobalInstanceVar(var), ";", Newline()); + break; + } + + case ExprType::GlobalSet: { + const Var& var = cast<GlobalSetExpr>(&expr)->var; + Write(GlobalInstanceVar(var), " = ", StackVar(0), ";", Newline()); + DropTypes(1); + break; + } + + case ExprType::If: { + const IfExpr& if_ = *cast<IfExpr>(&expr); + Write("if (", StackVar(0), ") ", OpenBrace()); + DropTypes(1); + std::string label = DefineLabelName(if_.true_.label); + DropTypes(if_.true_.decl.GetNumParams()); + size_t mark = MarkTypeStack(); + PushLabel(LabelType::If, if_.true_.label, if_.true_.decl.sig); + PushTypes(if_.true_.decl.sig.param_types); + Write(if_.true_.exprs, CloseBrace()); + if (!if_.false_.empty()) { + ResetTypeStack(mark); + PushTypes(if_.true_.decl.sig.param_types); + Write(" else ", OpenBrace(), if_.false_, CloseBrace()); + } + ResetTypeStack(mark); + Write(Newline(), LabelDecl(label)); + PopLabel(); + PushTypes(if_.true_.decl.sig.result_types); + break; + } + + case ExprType::Load: + Write(*cast<LoadExpr>(&expr)); + break; + + case ExprType::LocalGet: { + const Var& var = cast<LocalGetExpr>(&expr)->var; + PushType(func_->GetLocalType(var)); + Write(StackVar(0), " = ", var, ";", Newline()); + break; + } + + case ExprType::LocalSet: { + const Var& var = cast<LocalSetExpr>(&expr)->var; + Write(var, " = ", StackVar(0), ";", Newline()); + DropTypes(1); + break; + } + + case ExprType::LocalTee: { + const Var& var = cast<LocalTeeExpr>(&expr)->var; + Write(var, " = ", StackVar(0), ";", Newline()); + break; + } + + case ExprType::Loop: { + const Block& block = cast<LoopExpr>(&expr)->block; + if (!block.exprs.empty()) { + Write(DefineLabelName(block.label), ": "); + Indent(); + DropTypes(block.decl.GetNumParams()); + size_t mark = MarkTypeStack(); + PushLabel(LabelType::Loop, block.label, block.decl.sig); + PushTypes(block.decl.sig.param_types); + Write(Newline(), block.exprs); + ResetTypeStack(mark); + PopLabel(); + PushTypes(block.decl.sig.result_types); + Dedent(); + } + break; + } + + case ExprType::MemoryFill: { + const auto inst = cast<MemoryFillExpr>(&expr); + Memory* memory = + module_->memories[module_->GetMemoryIndex(inst->memidx)]; + Write("memory_fill(", + ExternalInstancePtr(ModuleFieldType::Memory, memory->name), ", ", + StackVar(2), ", ", StackVar(1), ", ", StackVar(0), ");", + Newline()); + DropTypes(3); + } break; + + case ExprType::MemoryCopy: { + const auto inst = cast<MemoryCopyExpr>(&expr); + Memory* dest_memory = + module_->memories[module_->GetMemoryIndex(inst->destmemidx)]; + const Memory* src_memory = module_->GetMemory(inst->srcmemidx); + Write("memory_copy(", + ExternalInstancePtr(ModuleFieldType::Memory, dest_memory->name), + ", ", + ExternalInstancePtr(ModuleFieldType::Memory, src_memory->name), + ", ", StackVar(2), ", ", StackVar(1), ", ", StackVar(0), ");", + Newline()); + DropTypes(3); + } break; + + case ExprType::MemoryInit: { + const auto inst = cast<MemoryInitExpr>(&expr); + Memory* dest_memory = + module_->memories[module_->GetMemoryIndex(inst->memidx)]; + const DataSegment* src_data = module_->GetDataSegment(inst->var); + Write("memory_init(", + ExternalInstancePtr(ModuleFieldType::Memory, dest_memory->name), + ", "); + if (src_data->data.empty()) { + Write("NULL, 0"); + } else { + Write("data_segment_data_", + GlobalName(ModuleFieldType::DataSegment, src_data->name), ", "); + if (is_droppable(src_data)) { + Write("(", "instance->data_segment_dropped_", + GlobalName(ModuleFieldType::DataSegment, src_data->name), + " ? 0 : ", src_data->data.size(), ")"); + } else { + Write("0"); + } + } + + Write(", ", StackVar(2), ", ", StackVar(1), ", ", StackVar(0), ");", + Newline()); + DropTypes(3); + } break; + + case ExprType::TableInit: { + const auto inst = cast<TableInitExpr>(&expr); + Table* dest_table = + module_->tables[module_->GetTableIndex(inst->table_index)]; + const ElemSegment* src_segment = + module_->GetElemSegment(inst->segment_index); + + WriteElemTableInit(false, src_segment, dest_table); + DropTypes(3); + } break; + + case ExprType::DataDrop: { + const auto inst = cast<DataDropExpr>(&expr); + const DataSegment* data = module_->GetDataSegment(inst->var); + if (is_droppable(data)) { + Write("instance->data_segment_dropped_", + GlobalName(ModuleFieldType::DataSegment, data->name), + " = true;", Newline()); + } + } break; + + case ExprType::ElemDrop: { + const auto inst = cast<ElemDropExpr>(&expr); + const ElemSegment* seg = module_->GetElemSegment(inst->var); + if (is_droppable(seg)) { + Write("instance->elem_segment_dropped_", + GlobalName(ModuleFieldType::ElemSegment, seg->name), " = true;", + Newline()); + } + } break; + + case ExprType::TableCopy: { + const auto inst = cast<TableCopyExpr>(&expr); + Table* dest_table = + module_->tables[module_->GetTableIndex(inst->dst_table)]; + const Table* src_table = module_->GetTable(inst->src_table); + if (dest_table->elem_type != src_table->elem_type) { + WABT_UNREACHABLE; + } + + Write( + GetReferenceTypeName(dest_table->elem_type), "_table_copy(", + ExternalInstancePtr(ModuleFieldType::Table, dest_table->name), ", ", + ExternalInstancePtr(ModuleFieldType::Table, src_table->name), ", ", + StackVar(2), ", ", StackVar(1), ", ", StackVar(0), ");", Newline()); + DropTypes(3); + } break; + + case ExprType::TableGet: { + const Table* table = module_->GetTable(cast<TableGetExpr>(&expr)->var); + Write(StackVar(0, table->elem_type), " = ", + GetReferenceTypeName(table->elem_type), "_table_get(", + ExternalInstancePtr(ModuleFieldType::Table, table->name), ", ", + StackVar(0), ");", Newline()); + DropTypes(1); + PushType(table->elem_type); + } break; + + case ExprType::TableSet: { + const Table* table = module_->GetTable(cast<TableSetExpr>(&expr)->var); + Write(GetReferenceTypeName(table->elem_type), "_table_set(", + ExternalInstancePtr(ModuleFieldType::Table, table->name), ", ", + StackVar(1), ", ", StackVar(0), ");", Newline()); + DropTypes(2); + } break; + + case ExprType::TableGrow: { + const Table* table = module_->GetTable(cast<TableGrowExpr>(&expr)->var); + Write(StackVar(1, Type::I32), " = wasm_rt_grow_", + GetReferenceTypeName(table->elem_type), "_table(", + ExternalInstancePtr(ModuleFieldType::Table, table->name), ", ", + StackVar(0), ", ", StackVar(1), ");", Newline()); + DropTypes(2); + PushType(Type::I32); + } break; + + case ExprType::TableSize: { + const Table* table = module_->GetTable(cast<TableSizeExpr>(&expr)->var); + + PushType(Type::I32); + Write(StackVar(0), " = ", + ExternalInstanceRef(ModuleFieldType::Table, table->name), + ".size;", Newline()); + } break; + + case ExprType::TableFill: { + const Table* table = module_->GetTable(cast<TableFillExpr>(&expr)->var); + Write(GetReferenceTypeName(table->elem_type), "_table_fill(", + ExternalInstancePtr(ModuleFieldType::Table, table->name), ", ", + StackVar(2), ", ", StackVar(1), ", ", StackVar(0), ");", + Newline()); + DropTypes(3); + } break; + + case ExprType::RefFunc: { + const Func* func = module_->GetFunc(cast<RefFuncExpr>(&expr)->var); + PushType(Type::FuncRef); + const FuncDeclaration& decl = func->decl; + + assert(decl.has_func_type); + const FuncType* func_type = module_->GetFuncType(decl.type_var); + + Write(StackVar(0), " = (wasm_rt_funcref_t){", FuncTypeExpr(func_type), + ", (wasm_rt_function_ptr_t)", + ExternalPtr(ModuleFieldType::Func, func->name), ", "); + + bool is_import = import_module_sym_map_.count(func->name) != 0; + if (is_import) { + Write("instance->", GlobalName(ModuleFieldType::Import, + import_module_sym_map_[func->name])); + } else { + Write("instance"); + } + + Write("};", Newline()); + } break; + + case ExprType::RefNull: + PushType(cast<RefNullExpr>(&expr)->type); + Write(StackVar(0), " = ", + GetReferenceNullValue(cast<RefNullExpr>(&expr)->type), ";", + Newline()); + break; + + case ExprType::RefIsNull: + switch (StackType(0)) { + case Type::FuncRef: + Write(StackVar(0, Type::I32), " = (", StackVar(0), ".func == NULL", + ");", Newline()); + break; + case Type::ExternRef: + Write(StackVar(0, Type::I32), " = (", StackVar(0), + " == ", GetReferenceNullValue(Type::ExternRef), ");", + Newline()); + break; + default: + WABT_UNREACHABLE; + } + + DropTypes(1); + PushType(Type::I32); + break; + + case ExprType::MemoryGrow: { + Memory* memory = module_->memories[module_->GetMemoryIndex( + cast<MemoryGrowExpr>(&expr)->memidx)]; + + Write(StackVar(0), " = wasm_rt_grow_memory(", + ExternalInstancePtr(ModuleFieldType::Memory, memory->name), ", ", + StackVar(0), ");", Newline()); + break; + } + + case ExprType::MemorySize: { + Memory* memory = module_->memories[module_->GetMemoryIndex( + cast<MemorySizeExpr>(&expr)->memidx)]; + + PushType(memory->page_limits.IndexType()); + Write(StackVar(0), " = ", + ExternalInstanceRef(ModuleFieldType::Memory, memory->name), + ".pages;", Newline()); + break; + } + + case ExprType::Nop: + break; + + case ExprType::Return: + // Goto the function label instead; this way we can do shared function + // cleanup code in one place. + Write(GotoLabel(Var(label_stack_.size() - 1, {})), Newline()); + // Stop processing this ExprList, since the following are unreachable. + return; + + case ExprType::Select: { + Type type = StackType(1); + Write(StackVar(2), " = ", StackVar(0), " ? ", StackVar(2), " : ", + StackVar(1), ";", Newline()); + DropTypes(3); + PushType(type); + break; + } + + case ExprType::Store: + Write(*cast<StoreExpr>(&expr)); + break; + + case ExprType::Unary: + Write(*cast<UnaryExpr>(&expr)); + break; + + case ExprType::Ternary: + Write(*cast<TernaryExpr>(&expr)); + break; + + case ExprType::SimdLaneOp: { + Write(*cast<SimdLaneOpExpr>(&expr)); + break; + } + + case ExprType::SimdLoadLane: { + Write(*cast<SimdLoadLaneExpr>(&expr)); + break; + } + + case ExprType::SimdStoreLane: { + Write(*cast<SimdStoreLaneExpr>(&expr)); + break; + } + + case ExprType::SimdShuffleOp: { + Write(*cast<SimdShuffleOpExpr>(&expr)); + break; + } + + case ExprType::LoadSplat: + Write(*cast<LoadSplatExpr>(&expr)); + break; + + case ExprType::LoadZero: + Write(*cast<LoadZeroExpr>(&expr)); + break; + + case ExprType::Unreachable: + Write("UNREACHABLE;", Newline()); + return; + + case ExprType::Throw: { + const Var& var = cast<ThrowExpr>(&expr)->var; + const Tag* tag = module_->GetTag(var); + + Index num_params = tag->decl.GetNumParams(); + if (num_params == 0) { + Write("wasm_rt_load_exception(", + ExternalPtr(ModuleFieldType::Tag, tag->name), ", 0, NULL);", + Newline()); + } else if (num_params == 1) { + Write("wasm_rt_load_exception(", + ExternalPtr(ModuleFieldType::Tag, tag->name), ", sizeof(", + tag->decl.GetParamType(0), "), &", StackVar(0), ");", + Newline()); + } else { + Write(OpenBrace()); + Write("struct ", MangleTagTypes(tag->decl.sig.param_types)); + Write(" tmp = {"); + for (Index i = 0; i < num_params; ++i) { + Write(StackVar(i), ", "); + } + Write("};", Newline()); + Write("wasm_rt_load_exception(", + ExternalPtr(ModuleFieldType::Tag, tag->name), + ", sizeof(tmp), &tmp);", Newline()); + Write(CloseBrace(), Newline()); + } + + WriteThrow(); + } break; + + case ExprType::Rethrow: { + const RethrowExpr* rethrow = cast<RethrowExpr>(&expr); + assert(rethrow->var.is_name()); + const LabelName ex{rethrow->var.name()}; + func_includes_.insert(rethrow->var.name()); + Write("wasm_rt_load_exception(", ex, "_tag, ", ex, "_size, ", ex, ");", + Newline()); + WriteThrow(); + } break; + + case ExprType::Try: { + const TryExpr& tryexpr = *cast<TryExpr>(&expr); + switch (tryexpr.kind) { + case TryKind::Plain: + Write(tryexpr.block); + break; + case TryKind::Catch: + WriteTryCatch(tryexpr); + break; + case TryKind::Delegate: + WriteTryDelegate(tryexpr); + break; + } + } break; + + case ExprType::AtomicLoad: + case ExprType::AtomicRmw: + case ExprType::AtomicRmwCmpxchg: + case ExprType::AtomicStore: + case ExprType::AtomicWait: + case ExprType::AtomicFence: + case ExprType::AtomicNotify: + case ExprType::ReturnCall: + case ExprType::ReturnCallIndirect: + case ExprType::CallRef: + UNIMPLEMENTED("..."); + break; + } + } +} + +void CWriter::WriteSimpleUnaryExpr(Opcode opcode, const char* op) { + Type result_type = opcode.GetResultType(); + Write(StackVar(0, result_type), " = ", op, "(", StackVar(0), ");", Newline()); + DropTypes(1); + PushType(opcode.GetResultType()); +} + +void CWriter::WriteInfixBinaryExpr(Opcode opcode, + const char* op, + AssignOp assign_op) { + Type result_type = opcode.GetResultType(); + Write(StackVar(1, result_type)); + if (assign_op == AssignOp::Allowed) { + Write(" ", op, "= ", StackVar(0)); + } else { + Write(" = ", StackVar(1), " ", op, " ", StackVar(0)); + } + Write(";", Newline()); + DropTypes(2); + PushType(result_type); +} + +void CWriter::WritePrefixBinaryExpr(Opcode opcode, const char* op) { + Type result_type = opcode.GetResultType(); + Write(StackVar(1, result_type), " = ", op, "(", StackVar(1), ", ", + StackVar(0), ");", Newline()); + DropTypes(2); + PushType(result_type); +} + +void CWriter::WriteSignedBinaryExpr(Opcode opcode, const char* op) { + Type result_type = opcode.GetResultType(); + Type type = opcode.GetParamType1(); + assert(opcode.GetParamType2() == type); + Write(StackVar(1, result_type), " = (", type, ")((", SignedType(type), ")", + StackVar(1), " ", op, " (", SignedType(type), ")", StackVar(0), ");", + Newline()); + DropTypes(2); + PushType(result_type); +} + +void CWriter::Write(const BinaryExpr& expr) { + switch (expr.opcode) { + case Opcode::I32Add: + case Opcode::I64Add: + case Opcode::F32Add: + case Opcode::F64Add: + WriteInfixBinaryExpr(expr.opcode, "+"); + break; + + case Opcode::I32Sub: + case Opcode::I64Sub: + case Opcode::F32Sub: + case Opcode::F64Sub: + WriteInfixBinaryExpr(expr.opcode, "-"); + break; + + case Opcode::I32Mul: + case Opcode::I64Mul: + case Opcode::F32Mul: + case Opcode::F64Mul: + WriteInfixBinaryExpr(expr.opcode, "*"); + break; + + case Opcode::I32DivS: + WritePrefixBinaryExpr(expr.opcode, "I32_DIV_S"); + break; + + case Opcode::I64DivS: + WritePrefixBinaryExpr(expr.opcode, "I64_DIV_S"); + break; + + case Opcode::I32DivU: + case Opcode::I64DivU: + WritePrefixBinaryExpr(expr.opcode, "DIV_U"); + break; + + case Opcode::F32Div: + case Opcode::F64Div: + WriteInfixBinaryExpr(expr.opcode, "/"); + break; + + case Opcode::I32RemS: + WritePrefixBinaryExpr(expr.opcode, "I32_REM_S"); + break; + + case Opcode::I64RemS: + WritePrefixBinaryExpr(expr.opcode, "I64_REM_S"); + break; + + case Opcode::I32RemU: + case Opcode::I64RemU: + WritePrefixBinaryExpr(expr.opcode, "REM_U"); + break; + + case Opcode::I32And: + case Opcode::I64And: + WriteInfixBinaryExpr(expr.opcode, "&"); + break; + + case Opcode::I32Or: + case Opcode::I64Or: + WriteInfixBinaryExpr(expr.opcode, "|"); + break; + + case Opcode::I32Xor: + case Opcode::I64Xor: + WriteInfixBinaryExpr(expr.opcode, "^"); + break; + + case Opcode::I32Shl: + case Opcode::I64Shl: + Write(StackVar(1), " <<= (", StackVar(0), " & ", + GetShiftMask(expr.opcode.GetResultType()), ");", Newline()); + DropTypes(1); + break; + + case Opcode::I32ShrS: + case Opcode::I64ShrS: { + Type type = expr.opcode.GetResultType(); + Write(StackVar(1), " = (", type, ")((", SignedType(type), ")", + StackVar(1), " >> (", StackVar(0), " & ", GetShiftMask(type), "));", + Newline()); + DropTypes(1); + break; + } + + case Opcode::I32ShrU: + case Opcode::I64ShrU: + Write(StackVar(1), " >>= (", StackVar(0), " & ", + GetShiftMask(expr.opcode.GetResultType()), ");", Newline()); + DropTypes(1); + break; + + case Opcode::I32Rotl: + WritePrefixBinaryExpr(expr.opcode, "I32_ROTL"); + break; + + case Opcode::I64Rotl: + WritePrefixBinaryExpr(expr.opcode, "I64_ROTL"); + break; + + case Opcode::I32Rotr: + WritePrefixBinaryExpr(expr.opcode, "I32_ROTR"); + break; + + case Opcode::I64Rotr: + WritePrefixBinaryExpr(expr.opcode, "I64_ROTR"); + break; + + case Opcode::F32Min: + case Opcode::F64Min: + WritePrefixBinaryExpr(expr.opcode, "FMIN"); + break; + + case Opcode::F32Max: + case Opcode::F64Max: + WritePrefixBinaryExpr(expr.opcode, "FMAX"); + break; + + case Opcode::F32Copysign: + WritePrefixBinaryExpr(expr.opcode, "copysignf"); + break; + + case Opcode::F64Copysign: + WritePrefixBinaryExpr(expr.opcode, "copysign"); + break; + + case Opcode::I8X16Add: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i8x16_add"); + break; + + case Opcode::I8X16AddSatS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i8x16_add_sat"); + break; + + case Opcode::I8X16AddSatU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u8x16_add_sat"); + break; + + case Opcode::I8X16AvgrU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u8x16_avgr"); + break; + + case Opcode::I8X16MaxS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i8x16_max"); + break; + + case Opcode::I8X16MaxU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u8x16_max"); + break; + + case Opcode::I8X16MinS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i8x16_min"); + break; + + case Opcode::I8X16MinU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u8x16_min"); + break; + + case Opcode::I8X16NarrowI16X8S: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i8x16_narrow_i16x8"); + break; + + case Opcode::I8X16NarrowI16X8U: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u8x16_narrow_i16x8"); + break; + + case Opcode::I8X16Shl: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i8x16_shl"); + break; + + case Opcode::I8X16ShrS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i8x16_shr"); + break; + + case Opcode::I8X16ShrU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u8x16_shr"); + break; + + case Opcode::I8X16Sub: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i8x16_sub"); + break; + + case Opcode::I8X16SubSatS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i8x16_sub_sat"); + break; + + case Opcode::I8X16SubSatU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u8x16_sub_sat"); + break; + + case Opcode::I8X16Swizzle: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i8x16_swizzle"); + break; + + case Opcode::I16X8Add: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i16x8_add"); + break; + + case Opcode::I16X8AvgrU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u16x8_avgr"); + break; + + case Opcode::I16X8AddSatS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i16x8_add_sat"); + break; + + case Opcode::I16X8AddSatU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u16x8_add_sat"); + break; + + case Opcode::I16X8ExtmulHighI8X16S: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i16x8_extmul_high_i8x16"); + break; + + case Opcode::I16X8ExtmulHighI8X16U: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u16x8_extmul_high_u8x16"); + break; + + case Opcode::I16X8ExtmulLowI8X16S: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i16x8_extmul_low_i8x16"); + break; + + case Opcode::I16X8ExtmulLowI8X16U: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u16x8_extmul_low_u8x16"); + break; + + case Opcode::I16X8MaxS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i16x8_max"); + break; + + case Opcode::I16X8MaxU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u16x8_max"); + break; + + case Opcode::I16X8MinS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i16x8_min"); + break; + + case Opcode::I16X8MinU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u16x8_min"); + break; + + case Opcode::I16X8Mul: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i16x8_mul"); + break; + + case Opcode::I16X8NarrowI32X4S: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i16x8_narrow_i32x4"); + break; + + case Opcode::I16X8NarrowI32X4U: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u16x8_narrow_i32x4"); + break; + + case Opcode::I16X8Q15mulrSatS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i16x8_q15mulr_sat"); + break; + + case Opcode::I16X8Shl: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i16x8_shl"); + break; + + case Opcode::I16X8ShrS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i16x8_shr"); + break; + + case Opcode::I16X8ShrU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u16x8_shr"); + break; + + case Opcode::I16X8Sub: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i16x8_sub"); + break; + + case Opcode::I16X8SubSatS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i16x8_sub_sat"); + break; + + case Opcode::I16X8SubSatU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u16x8_sub_sat"); + break; + + case Opcode::I32X4Add: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i32x4_add"); + break; + + case Opcode::I32X4DotI16X8S: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i32x4_dot_i16x8"); + break; + + case Opcode::I32X4ExtmulHighI16X8S: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i32x4_extmul_high_i16x8"); + break; + + case Opcode::I32X4ExtmulHighI16X8U: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u32x4_extmul_high_u16x8"); + break; + + case Opcode::I32X4ExtmulLowI16X8S: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i32x4_extmul_low_i16x8"); + break; + + case Opcode::I32X4ExtmulLowI16X8U: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u32x4_extmul_low_u16x8"); + break; + + case Opcode::I32X4MaxS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i32x4_max"); + break; + + case Opcode::I32X4MaxU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u32x4_max"); + break; + + case Opcode::I32X4MinS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i32x4_min"); + break; + + case Opcode::I32X4MinU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u32x4_min"); + break; + + case Opcode::I32X4Mul: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i32x4_mul"); + break; + + case Opcode::I32X4Shl: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i32x4_shl"); + break; + + case Opcode::I32X4ShrS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i32x4_shr"); + break; + + case Opcode::I32X4ShrU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u32x4_shr"); + break; + + case Opcode::I32X4Sub: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i32x4_sub"); + break; + + case Opcode::I64X2Add: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i64x2_add"); + break; + + case Opcode::I64X2ExtmulHighI32X4S: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i64x2_extmul_high_i32x4"); + break; + + case Opcode::I64X2ExtmulHighI32X4U: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u64x2_extmul_high_u32x4"); + break; + + case Opcode::I64X2ExtmulLowI32X4S: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i64x2_extmul_low_i32x4"); + break; + + case Opcode::I64X2ExtmulLowI32X4U: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u64x2_extmul_low_u32x4"); + break; + + case Opcode::I64X2Mul: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i64x2_mul"); + break; + + case Opcode::I64X2Shl: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i64x2_shl"); + break; + + case Opcode::I64X2ShrS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i64x2_shr"); + break; + + case Opcode::I64X2ShrU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u64x2_shr"); + break; + + case Opcode::I64X2Sub: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i64x2_sub"); + break; + + case Opcode::F32X4Add: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f32x4_add"); + break; + + case Opcode::F32X4Div: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f32x4_div"); + break; + + case Opcode::F32X4Max: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f32x4_max"); + break; + + case Opcode::F32X4Mul: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f32x4_mul"); + break; + + case Opcode::F32X4Min: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f32x4_min"); + break; + + case Opcode::F32X4PMax: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f32x4_pmax"); + break; + + case Opcode::F32X4PMin: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f32x4_pmin"); + break; + + case Opcode::F32X4Sub: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f32x4_sub"); + break; + + case Opcode::F64X2Add: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f64x2_add"); + break; + + case Opcode::F64X2Div: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f64x2_div"); + break; + + case Opcode::F64X2Max: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f64x2_max"); + break; + + case Opcode::F64X2Mul: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f64x2_mul"); + break; + + case Opcode::F64X2Min: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f64x2_min"); + break; + + case Opcode::F64X2PMax: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f64x2_pmax"); + break; + + case Opcode::F64X2PMin: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f64x2_pmin"); + break; + + case Opcode::F64X2Sub: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f64x2_sub"); + break; + + case Opcode::V128And: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_v128_and"); + break; + + case Opcode::V128Andnot: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_v128_andnot"); + break; + + case Opcode::V128Or: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_v128_or"); + break; + + case Opcode::V128Xor: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_v128_xor"); + break; + + default: + WABT_UNREACHABLE; + } +} + +void CWriter::Write(const CompareExpr& expr) { + switch (expr.opcode) { + case Opcode::I32Eq: + case Opcode::I64Eq: + case Opcode::F32Eq: + case Opcode::F64Eq: + WriteInfixBinaryExpr(expr.opcode, "==", AssignOp::Disallowed); + break; + + case Opcode::I32Ne: + case Opcode::I64Ne: + case Opcode::F32Ne: + case Opcode::F64Ne: + WriteInfixBinaryExpr(expr.opcode, "!=", AssignOp::Disallowed); + break; + + case Opcode::I32LtS: + case Opcode::I64LtS: + WriteSignedBinaryExpr(expr.opcode, "<"); + break; + + case Opcode::I32LtU: + case Opcode::I64LtU: + case Opcode::F32Lt: + case Opcode::F64Lt: + WriteInfixBinaryExpr(expr.opcode, "<", AssignOp::Disallowed); + break; + + case Opcode::I32LeS: + case Opcode::I64LeS: + WriteSignedBinaryExpr(expr.opcode, "<="); + break; + + case Opcode::I32LeU: + case Opcode::I64LeU: + case Opcode::F32Le: + case Opcode::F64Le: + WriteInfixBinaryExpr(expr.opcode, "<=", AssignOp::Disallowed); + break; + + case Opcode::I32GtS: + case Opcode::I64GtS: + WriteSignedBinaryExpr(expr.opcode, ">"); + break; + + case Opcode::I32GtU: + case Opcode::I64GtU: + case Opcode::F32Gt: + case Opcode::F64Gt: + WriteInfixBinaryExpr(expr.opcode, ">", AssignOp::Disallowed); + break; + + case Opcode::I32GeS: + case Opcode::I64GeS: + WriteSignedBinaryExpr(expr.opcode, ">="); + break; + + case Opcode::I32GeU: + case Opcode::I64GeU: + case Opcode::F32Ge: + case Opcode::F64Ge: + WriteInfixBinaryExpr(expr.opcode, ">=", AssignOp::Disallowed); + break; + + case Opcode::I8X16Eq: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i8x16_eq"); + break; + + case Opcode::I8X16GeS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i8x16_ge"); + break; + + case Opcode::I8X16GeU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u8x16_ge"); + break; + + case Opcode::I8X16GtS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i8x16_gt"); + break; + + case Opcode::I8X16GtU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u8x16_gt"); + break; + + case Opcode::I8X16LeS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i8x16_le"); + break; + + case Opcode::I8X16LeU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u8x16_le"); + break; + + case Opcode::I8X16LtS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i8x16_lt"); + break; + + case Opcode::I8X16LtU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u8x16_lt"); + break; + + case Opcode::I8X16Ne: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i8x16_ne"); + break; + + case Opcode::I16X8Eq: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i16x8_eq"); + break; + + case Opcode::I16X8GeS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i16x8_ge"); + break; + + case Opcode::I16X8GeU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u16x8_ge"); + break; + + case Opcode::I16X8GtS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i16x8_gt"); + break; + case Opcode::I16X8GtU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u16x8_gt"); + break; + + case Opcode::I16X8LeS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i16x8_le"); + break; + + case Opcode::I16X8LeU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u16x8_le"); + break; + + case Opcode::I16X8LtS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i16x8_lt"); + break; + + case Opcode::I16X8LtU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u16x8_lt"); + break; + + case Opcode::I16X8Ne: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i16x8_ne"); + break; + + case Opcode::I32X4Eq: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i32x4_eq"); + break; + + case Opcode::I32X4GeS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i32x4_ge"); + break; + + case Opcode::I32X4GeU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u32x4_ge"); + break; + + case Opcode::I32X4GtS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i32x4_gt"); + break; + + case Opcode::I32X4GtU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u32x4_gt"); + break; + + case Opcode::I32X4LeS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i32x4_le"); + break; + + case Opcode::I32X4LeU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u32x4_le"); + break; + + case Opcode::I32X4LtS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i32x4_lt"); + break; + + case Opcode::I32X4LtU: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_u32x4_lt"); + break; + + case Opcode::I32X4Ne: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i32x4_ne"); + break; + + case Opcode::I64X2Eq: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i64x2_eq"); + break; + + case Opcode::I64X2GeS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i64x2_ge"); + break; + + case Opcode::I64X2GtS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i64x2_gt"); + break; + + case Opcode::I64X2LeS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i64x2_le"); + break; + + case Opcode::I64X2LtS: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i64x2_lt"); + break; + + case Opcode::I64X2Ne: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_i64x2_ne"); + break; + + case Opcode::F32X4Eq: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f32x4_eq"); + break; + + case Opcode::F32X4Ge: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f32x4_ge"); + break; + + case Opcode::F32X4Gt: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f32x4_gt"); + break; + + case Opcode::F32X4Le: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f32x4_le"); + break; + + case Opcode::F32X4Lt: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f32x4_lt"); + break; + + case Opcode::F32X4Ne: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f32x4_ne"); + break; + + case Opcode::F64X2Eq: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f64x2_eq"); + break; + + case Opcode::F64X2Ge: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f64x2_ge"); + break; + + case Opcode::F64X2Gt: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f64x2_gt"); + break; + + case Opcode::F64X2Le: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f64x2_le"); + break; + + case Opcode::F64X2Lt: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f64x2_lt"); + break; + + case Opcode::F64X2Ne: + WritePrefixBinaryExpr(expr.opcode, "simde_wasm_f64x2_ne"); + break; + + default: + WABT_UNREACHABLE; + } +} + +void CWriter::Write(const ConvertExpr& expr) { + switch (expr.opcode) { + case Opcode::I32Eqz: + case Opcode::I64Eqz: + WriteSimpleUnaryExpr(expr.opcode, "!"); + break; + + case Opcode::I64ExtendI32S: + WriteSimpleUnaryExpr(expr.opcode, "(u64)(s64)(s32)"); + break; + + case Opcode::I64ExtendI32U: + WriteSimpleUnaryExpr(expr.opcode, "(u64)"); + break; + + case Opcode::I32WrapI64: + WriteSimpleUnaryExpr(expr.opcode, "(u32)"); + break; + + case Opcode::I32TruncF32S: + WriteSimpleUnaryExpr(expr.opcode, "I32_TRUNC_S_F32"); + break; + + case Opcode::I64TruncF32S: + WriteSimpleUnaryExpr(expr.opcode, "I64_TRUNC_S_F32"); + break; + + case Opcode::I32TruncF64S: + WriteSimpleUnaryExpr(expr.opcode, "I32_TRUNC_S_F64"); + break; + + case Opcode::I64TruncF64S: + WriteSimpleUnaryExpr(expr.opcode, "I64_TRUNC_S_F64"); + break; + + case Opcode::I32TruncF32U: + WriteSimpleUnaryExpr(expr.opcode, "I32_TRUNC_U_F32"); + break; + + case Opcode::I64TruncF32U: + WriteSimpleUnaryExpr(expr.opcode, "I64_TRUNC_U_F32"); + break; + + case Opcode::I32TruncF64U: + WriteSimpleUnaryExpr(expr.opcode, "I32_TRUNC_U_F64"); + break; + + case Opcode::I64TruncF64U: + WriteSimpleUnaryExpr(expr.opcode, "I64_TRUNC_U_F64"); + break; + + case Opcode::I32TruncSatF32S: + WriteSimpleUnaryExpr(expr.opcode, "I32_TRUNC_SAT_S_F32"); + break; + + case Opcode::I64TruncSatF32S: + WriteSimpleUnaryExpr(expr.opcode, "I64_TRUNC_SAT_S_F32"); + break; + + case Opcode::I32TruncSatF64S: + WriteSimpleUnaryExpr(expr.opcode, "I32_TRUNC_SAT_S_F64"); + break; + + case Opcode::I64TruncSatF64S: + WriteSimpleUnaryExpr(expr.opcode, "I64_TRUNC_SAT_S_F64"); + break; + + case Opcode::I32TruncSatF32U: + WriteSimpleUnaryExpr(expr.opcode, "I32_TRUNC_SAT_U_F32"); + break; + + case Opcode::I64TruncSatF32U: + WriteSimpleUnaryExpr(expr.opcode, "I64_TRUNC_SAT_U_F32"); + break; + + case Opcode::I32TruncSatF64U: + WriteSimpleUnaryExpr(expr.opcode, "I32_TRUNC_SAT_U_F64"); + break; + + case Opcode::I64TruncSatF64U: + WriteSimpleUnaryExpr(expr.opcode, "I64_TRUNC_SAT_U_F64"); + break; + + case Opcode::F32ConvertI32S: + WriteSimpleUnaryExpr(expr.opcode, "(f32)(s32)"); + break; + + case Opcode::F32ConvertI64S: + WriteSimpleUnaryExpr(expr.opcode, "(f32)(s64)"); + break; + + case Opcode::F32ConvertI32U: + WriteSimpleUnaryExpr(expr.opcode, "(f32)"); + break; + + case Opcode::F32DemoteF64: + WriteSimpleUnaryExpr(expr.opcode, "(f32)wasm_quiet"); + break; + + case Opcode::F32ConvertI64U: + // TODO(binji): This needs to be handled specially (see + // wabt_convert_uint64_to_float). + WriteSimpleUnaryExpr(expr.opcode, "(f32)"); + break; + + case Opcode::F64ConvertI32S: + WriteSimpleUnaryExpr(expr.opcode, "(f64)(s32)"); + break; + + case Opcode::F64ConvertI64S: + WriteSimpleUnaryExpr(expr.opcode, "(f64)(s64)"); + break; + + case Opcode::F64ConvertI32U: + WriteSimpleUnaryExpr(expr.opcode, "(f64)"); + break; + + case Opcode::F64PromoteF32: + WriteSimpleUnaryExpr(expr.opcode, "(f64)wasm_quietf"); + break; + + case Opcode::F64ConvertI64U: + // TODO(binji): This needs to be handled specially (see + // wabt_convert_uint64_to_double). + WriteSimpleUnaryExpr(expr.opcode, "(f64)"); + break; + + case Opcode::F32ReinterpretI32: + WriteSimpleUnaryExpr(expr.opcode, "f32_reinterpret_i32"); + break; + + case Opcode::I32ReinterpretF32: + WriteSimpleUnaryExpr(expr.opcode, "i32_reinterpret_f32"); + break; + + case Opcode::F64ReinterpretI64: + WriteSimpleUnaryExpr(expr.opcode, "f64_reinterpret_i64"); + break; + + case Opcode::I64ReinterpretF64: + WriteSimpleUnaryExpr(expr.opcode, "i64_reinterpret_f64"); + break; + + case Opcode::I32X4TruncSatF32X4S: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i32x4_trunc_sat_f32x4"); + break; + + case Opcode::I32X4TruncSatF32X4U: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_u32x4_trunc_sat_f32x4"); + break; + + case Opcode::I32X4TruncSatF64X2SZero: + WriteSimpleUnaryExpr(expr.opcode, + "simde_wasm_i32x4_trunc_sat_f64x2_zero"); + break; + + case Opcode::I32X4TruncSatF64X2UZero: + WriteSimpleUnaryExpr(expr.opcode, + "simde_wasm_u32x4_trunc_sat_f64x2_zero"); + break; + + case Opcode::F32X4ConvertI32X4S: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f32x4_convert_i32x4"); + break; + + case Opcode::F32X4ConvertI32X4U: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f32x4_convert_u32x4"); + break; + + case Opcode::F32X4DemoteF64X2Zero: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f32x4_demote_f64x2_zero"); + break; + + case Opcode::F64X2ConvertLowI32X4S: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f64x2_convert_low_i32x4"); + break; + + case Opcode::F64X2ConvertLowI32X4U: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f64x2_convert_low_u32x4"); + break; + + case Opcode::F64X2PromoteLowF32X4: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f64x2_promote_low_f32x4"); + break; + + default: + WABT_UNREACHABLE; + } +} + +void CWriter::Write(const LoadExpr& expr) { + const char* func = nullptr; + // clang-format off + switch (expr.opcode) { + case Opcode::I32Load: func = "i32_load"; break; + case Opcode::I64Load: func = "i64_load"; break; + case Opcode::F32Load: func = "f32_load"; break; + case Opcode::F64Load: func = "f64_load"; break; + case Opcode::I32Load8S: func = "i32_load8_s"; break; + case Opcode::I64Load8S: func = "i64_load8_s"; break; + case Opcode::I32Load8U: func = "i32_load8_u"; break; + case Opcode::I64Load8U: func = "i64_load8_u"; break; + case Opcode::I32Load16S: func = "i32_load16_s"; break; + case Opcode::I64Load16S: func = "i64_load16_s"; break; + case Opcode::I32Load16U: func = "i32_load16_u"; break; + case Opcode::I64Load16U: func = "i64_load16_u"; break; + case Opcode::I64Load32S: func = "i64_load32_s"; break; + case Opcode::I64Load32U: func = "i64_load32_u"; break; + case Opcode::V128Load: func = "v128_load"; break; + case Opcode::V128Load8X8S: func = "i16x8_load8x8"; break; + case Opcode::V128Load8X8U: func = "u16x8_load8x8"; break; + case Opcode::V128Load16X4S: func = "i32x4_load16x4"; break; + case Opcode::V128Load16X4U: func = "u32x4_load16x4"; break; + case Opcode::V128Load32X2S: func = "i64x2_load32x2"; break; + case Opcode::V128Load32X2U: func = "u64x2_load32x2"; break; + + default: + WABT_UNREACHABLE; + } + // clang-format on + + Memory* memory = module_->memories[module_->GetMemoryIndex(expr.memidx)]; + + Type result_type = expr.opcode.GetResultType(); + Write(StackVar(0, result_type), " = ", func, "(", + ExternalInstancePtr(ModuleFieldType::Memory, memory->name), ", (u64)(", + StackVar(0), ")"); + if (expr.offset != 0) + Write(" + ", expr.offset, "u"); + Write(");", Newline()); + DropTypes(1); + PushType(result_type); +} + +void CWriter::Write(const StoreExpr& expr) { + const char* func = nullptr; + // clang-format off + switch (expr.opcode) { + case Opcode::I32Store: func = "i32_store"; break; + case Opcode::I64Store: func = "i64_store"; break; + case Opcode::F32Store: func = "f32_store"; break; + case Opcode::F64Store: func = "f64_store"; break; + case Opcode::I32Store8: func = "i32_store8"; break; + case Opcode::I64Store8: func = "i64_store8"; break; + case Opcode::I32Store16: func = "i32_store16"; break; + case Opcode::I64Store16: func = "i64_store16"; break; + case Opcode::I64Store32: func = "i64_store32"; break; + case Opcode::V128Store: func = "v128_store"; break; + + default: + WABT_UNREACHABLE; + } + // clang-format on + + Memory* memory = module_->memories[module_->GetMemoryIndex(expr.memidx)]; + + Write(func, "(", ExternalInstancePtr(ModuleFieldType::Memory, memory->name), + ", (u64)(", StackVar(1), ")"); + if (expr.offset != 0) + Write(" + ", expr.offset); + Write(", ", StackVar(0), ");", Newline()); + DropTypes(2); +} + +void CWriter::Write(const UnaryExpr& expr) { + switch (expr.opcode) { + case Opcode::I32Clz: + WriteSimpleUnaryExpr(expr.opcode, "I32_CLZ"); + break; + + case Opcode::I64Clz: + WriteSimpleUnaryExpr(expr.opcode, "I64_CLZ"); + break; + + case Opcode::I32Ctz: + WriteSimpleUnaryExpr(expr.opcode, "I32_CTZ"); + break; + + case Opcode::I64Ctz: + WriteSimpleUnaryExpr(expr.opcode, "I64_CTZ"); + break; + + case Opcode::I32Popcnt: + WriteSimpleUnaryExpr(expr.opcode, "I32_POPCNT"); + break; + + case Opcode::I64Popcnt: + WriteSimpleUnaryExpr(expr.opcode, "I64_POPCNT"); + break; + + case Opcode::F32Neg: + case Opcode::F64Neg: + WriteSimpleUnaryExpr(expr.opcode, "-"); + break; + + case Opcode::F32Abs: + WriteSimpleUnaryExpr(expr.opcode, "wasm_fabsf"); + break; + + case Opcode::F64Abs: + WriteSimpleUnaryExpr(expr.opcode, "wasm_fabs"); + break; + + case Opcode::F32Sqrt: + WriteSimpleUnaryExpr(expr.opcode, "wasm_sqrtf"); + break; + + case Opcode::F64Sqrt: + WriteSimpleUnaryExpr(expr.opcode, "wasm_sqrt"); + break; + + case Opcode::F32Ceil: + WriteSimpleUnaryExpr(expr.opcode, "wasm_ceilf"); + break; + + case Opcode::F64Ceil: + WriteSimpleUnaryExpr(expr.opcode, "wasm_ceil"); + break; + + case Opcode::F32Floor: + WriteSimpleUnaryExpr(expr.opcode, "wasm_floorf"); + break; + + case Opcode::F64Floor: + WriteSimpleUnaryExpr(expr.opcode, "wasm_floor"); + break; + + case Opcode::F32Trunc: + WriteSimpleUnaryExpr(expr.opcode, "wasm_truncf"); + break; + + case Opcode::F64Trunc: + WriteSimpleUnaryExpr(expr.opcode, "wasm_trunc"); + break; + + case Opcode::F32Nearest: + WriteSimpleUnaryExpr(expr.opcode, "wasm_nearbyintf"); + break; + + case Opcode::F64Nearest: + WriteSimpleUnaryExpr(expr.opcode, "wasm_nearbyint"); + break; + + case Opcode::I32Extend8S: + WriteSimpleUnaryExpr(expr.opcode, "(u32)(s32)(s8)(u8)"); + break; + + case Opcode::I32Extend16S: + WriteSimpleUnaryExpr(expr.opcode, "(u32)(s32)(s16)(u16)"); + break; + + case Opcode::I64Extend8S: + WriteSimpleUnaryExpr(expr.opcode, "(u64)(s64)(s8)(u8)"); + break; + + case Opcode::I64Extend16S: + WriteSimpleUnaryExpr(expr.opcode, "(u64)(s64)(s16)(u16)"); + break; + + case Opcode::I64Extend32S: + WriteSimpleUnaryExpr(expr.opcode, "(u64)(s64)(s32)(u32)"); + break; + + case Opcode::I8X16Abs: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i8x16_abs"); + break; + + case Opcode::I8X16AllTrue: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i8x16_all_true"); + break; + + case Opcode::I8X16Bitmask: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i8x16_bitmask"); + break; + + case Opcode::I8X16Neg: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i8x16_neg"); + break; + + case Opcode::I8X16Popcnt: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i8x16_popcnt"); + break; + + case Opcode::I8X16Splat: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i8x16_splat"); + break; + + case Opcode::I16X8Abs: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i16x8_abs"); + break; + + case Opcode::I16X8AllTrue: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i16x8_all_true"); + break; + + case Opcode::I16X8Bitmask: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i16x8_bitmask"); + break; + + case Opcode::I16X8ExtaddPairwiseI8X16S: + WriteSimpleUnaryExpr(expr.opcode, + "simde_wasm_i16x8_extadd_pairwise_i8x16"); + break; + + case Opcode::I16X8ExtaddPairwiseI8X16U: + WriteSimpleUnaryExpr(expr.opcode, + "simde_wasm_u16x8_extadd_pairwise_u8x16"); + break; + + case Opcode::I16X8ExtendHighI8X16S: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i16x8_extend_high_i8x16"); + break; + + case Opcode::I16X8ExtendHighI8X16U: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_u16x8_extend_high_u8x16"); + break; + + case Opcode::I16X8ExtendLowI8X16S: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i16x8_extend_low_i8x16"); + break; + + case Opcode::I16X8ExtendLowI8X16U: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_u16x8_extend_low_u8x16"); + break; + + case Opcode::I16X8Neg: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i16x8_neg"); + break; + + case Opcode::I16X8Splat: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i16x8_splat"); + break; + + case Opcode::I32X4Abs: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i32x4_abs"); + break; + + case Opcode::I32X4AllTrue: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i32x4_all_true"); + break; + + case Opcode::I32X4Bitmask: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i32x4_bitmask"); + break; + + case Opcode::I32X4ExtaddPairwiseI16X8S: + WriteSimpleUnaryExpr(expr.opcode, + "simde_wasm_i32x4_extadd_pairwise_i16x8"); + break; + + case Opcode::I32X4ExtaddPairwiseI16X8U: + WriteSimpleUnaryExpr(expr.opcode, + "simde_wasm_u32x4_extadd_pairwise_u16x8"); + break; + + case Opcode::I32X4ExtendHighI16X8S: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i32x4_extend_high_i16x8"); + break; + + case Opcode::I32X4ExtendHighI16X8U: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_u32x4_extend_high_u16x8"); + break; + + case Opcode::I32X4ExtendLowI16X8S: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i32x4_extend_low_i16x8"); + break; + + case Opcode::I32X4ExtendLowI16X8U: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_u32x4_extend_low_u16x8"); + break; + + case Opcode::I32X4Neg: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i32x4_neg"); + break; + + case Opcode::I32X4Splat: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i32x4_splat"); + break; + + case Opcode::I64X2Abs: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i64x2_abs"); + break; + + case Opcode::I64X2AllTrue: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i64x2_all_true"); + break; + + case Opcode::I64X2Bitmask: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i64x2_bitmask"); + break; + + case Opcode::I64X2ExtendHighI32X4S: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i64x2_extend_high_i32x4"); + break; + + case Opcode::I64X2ExtendHighI32X4U: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_u64x2_extend_high_u32x4"); + break; + + case Opcode::I64X2ExtendLowI32X4S: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i64x2_extend_low_i32x4"); + break; + + case Opcode::I64X2ExtendLowI32X4U: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_u64x2_extend_low_u32x4"); + break; + + case Opcode::I64X2Neg: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i64x2_neg"); + break; + + case Opcode::I64X2Splat: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_i64x2_splat"); + break; + + case Opcode::F32X4Abs: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f32x4_abs"); + break; + + case Opcode::F32X4Ceil: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f32x4_ceil"); + break; + + case Opcode::F32X4Floor: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f32x4_floor"); + break; + + case Opcode::F32X4Nearest: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f32x4_nearest"); + break; + + case Opcode::F32X4Neg: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f32x4_neg"); + break; + + case Opcode::F32X4Splat: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f32x4_splat"); + break; + + case Opcode::F32X4Sqrt: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f32x4_sqrt"); + break; + + case Opcode::F32X4Trunc: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f32x4_trunc"); + break; + + case Opcode::F64X2Abs: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f64x2_abs"); + break; + + case Opcode::F64X2Ceil: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f64x2_ceil"); + break; + + case Opcode::F64X2Floor: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f64x2_floor"); + break; + + case Opcode::F64X2Nearest: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f64x2_nearest"); + break; + + case Opcode::F64X2Neg: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f64x2_neg"); + break; + + case Opcode::F64X2Splat: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f64x2_splat"); + break; + + case Opcode::F64X2Sqrt: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f64x2_sqrt"); + break; + + case Opcode::F64X2Trunc: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_f64x2_trunc"); + break; + + case Opcode::V128AnyTrue: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_v128_any_true"); + break; + + case Opcode::V128Not: + WriteSimpleUnaryExpr(expr.opcode, "simde_wasm_v128_not"); + break; + + default: + WABT_UNREACHABLE; + } +} + +void CWriter::Write(const TernaryExpr& expr) { + switch (expr.opcode) { + case Opcode::V128BitSelect: { + Type result_type = expr.opcode.GetResultType(); + Write(StackVar(2, result_type), " = ", "simde_wasm_v128_bitselect", "(", + StackVar(2), ", ", StackVar(1), ", ", StackVar(0), ");", Newline()); + DropTypes(3); + PushType(result_type); + break; + } + default: + WABT_UNREACHABLE; + } +} + +void CWriter::Write(const SimdLaneOpExpr& expr) { + Type result_type = expr.opcode.GetResultType(); + + switch (expr.opcode) { + case Opcode::I8X16ExtractLaneS: { + Write(StackVar(0, result_type), " = simde_wasm_i8x16_extract_lane(", + StackVar(0), ", ", expr.val, ");", Newline()); + DropTypes(1); + break; + } + case Opcode::I8X16ExtractLaneU: { + Write(StackVar(0, result_type), " = simde_wasm_u8x16_extract_lane(", + StackVar(0), ", ", expr.val, ");", Newline()); + DropTypes(1); + break; + } + case Opcode::I16X8ExtractLaneS: { + Write(StackVar(0, result_type), " = simde_wasm_i16x8_extract_lane(", + StackVar(0), ", ", expr.val, ");", Newline()); + DropTypes(1); + break; + } + case Opcode::I16X8ExtractLaneU: { + Write(StackVar(0, result_type), " = simde_wasm_u16x8_extract_lane(", + StackVar(0), ", ", expr.val, ");", Newline()); + DropTypes(1); + break; + } + case Opcode::I32X4ExtractLane: { + Write(StackVar(0, result_type), " = simde_wasm_i32x4_extract_lane(", + StackVar(0), ", ", expr.val, ");", Newline()); + DropTypes(1); + break; + } + case Opcode::I64X2ExtractLane: { + Write(StackVar(0, result_type), " = simde_wasm_i64x2_extract_lane(", + StackVar(0), ", ", expr.val, ");", Newline()); + DropTypes(1); + break; + } + case Opcode::F32X4ExtractLane: { + Write(StackVar(0, result_type), " = simde_wasm_f32x4_extract_lane(", + StackVar(0), ", ", expr.val, ");", Newline()); + DropTypes(1); + break; + } + case Opcode::F64X2ExtractLane: { + Write(StackVar(0, result_type), " = simde_wasm_f64x2_extract_lane(", + StackVar(0), ", ", expr.val, ");", Newline()); + DropTypes(1); + break; + } + case Opcode::I8X16ReplaceLane: { + Write(StackVar(1, result_type), " = simde_wasm_i8x16_replace_lane(", + StackVar(1), ", ", expr.val, ", ", StackVar(0), ");", Newline()); + DropTypes(2); + break; + } + case Opcode::I16X8ReplaceLane: { + Write(StackVar(1, result_type), " = simde_wasm_i16x8_replace_lane(", + StackVar(1), ", ", expr.val, ", ", StackVar(0), ");", Newline()); + DropTypes(2); + break; + } + case Opcode::I32X4ReplaceLane: { + Write(StackVar(1, result_type), " = simde_wasm_i32x4_replace_lane(", + StackVar(1), ", ", expr.val, ", ", StackVar(0), ");", Newline()); + DropTypes(2); + break; + } + case Opcode::I64X2ReplaceLane: { + Write(StackVar(1, result_type), " = simde_wasm_i64x2_replace_lane(", + StackVar(1), ", ", expr.val, ", ", StackVar(0), ");", Newline()); + DropTypes(2); + break; + } + case Opcode::F32X4ReplaceLane: { + Write(StackVar(1, result_type), " = simde_wasm_f32x4_replace_lane(", + StackVar(1), ", ", expr.val, ", ", StackVar(0), ");", Newline()); + DropTypes(2); + break; + } + case Opcode::F64X2ReplaceLane: { + Write(StackVar(1, result_type), " = simde_wasm_f64x2_replace_lane(", + StackVar(1), ", ", expr.val, ", ", StackVar(0), ");", Newline()); + DropTypes(2); + break; + } + default: + WABT_UNREACHABLE; + } + + PushType(result_type); +} + +void CWriter::Write(const SimdLoadLaneExpr& expr) { + const char* func = nullptr; + // clang-format off + switch (expr.opcode) { + case Opcode::V128Load8Lane: func = "v128_load8_lane"; break; + case Opcode::V128Load16Lane: func = "v128_load16_lane"; break; + case Opcode::V128Load32Lane: func = "v128_load32_lane"; break; + case Opcode::V128Load64Lane: func = "v128_load64_lane"; break; + default: + WABT_UNREACHABLE; + } + // clang-format on + Memory* memory = module_->memories[module_->GetMemoryIndex(expr.memidx)]; + Type result_type = expr.opcode.GetResultType(); + Write(StackVar(1, result_type), " = ", func, expr.val, "(", + ExternalInstancePtr(ModuleFieldType::Memory, memory->name), ", (u64)(", + StackVar(1), ")"); + + if (expr.offset != 0) + Write(" + ", expr.offset, "u"); + Write(", ", StackVar(0)); + Write(");", Newline()); + + DropTypes(2); + PushType(result_type); +} + +void CWriter::Write(const SimdStoreLaneExpr& expr) { + const char* func = nullptr; + // clang-format off + switch (expr.opcode) { + case Opcode::V128Store8Lane: func = "v128_store8_lane"; break; + case Opcode::V128Store16Lane: func = "v128_store16_lane"; break; + case Opcode::V128Store32Lane: func = "v128_store32_lane"; break; + case Opcode::V128Store64Lane: func = "v128_store64_lane"; break; + default: + WABT_UNREACHABLE; + } + // clang-format on + Memory* memory = module_->memories[module_->GetMemoryIndex(expr.memidx)]; + + Write(func, expr.val, "(", + ExternalInstancePtr(ModuleFieldType::Memory, memory->name), ", (u64)(", + StackVar(1), ")"); + + if (expr.offset != 0) + Write(" + ", expr.offset, "u"); + Write(", ", StackVar(0)); + Write(");", Newline()); + + DropTypes(2); +} + +void CWriter::Write(const SimdShuffleOpExpr& expr) { + Type result_type = expr.opcode.GetResultType(); + switch (expr.opcode) { + case Opcode::I8X16Shuffle: { + Write(StackVar(1, result_type), " = simde_wasm_i8x16_shuffle(", + StackVar(1), ", ", StackVar(0), ", ", expr.val.u8(0), ", ", + expr.val.u8(1), ", ", expr.val.u8(2), ", ", expr.val.u8(3), ", ", + expr.val.u8(4), ", ", expr.val.u8(5), ", ", expr.val.u8(6), ", ", + expr.val.u8(7), ", ", expr.val.u8(8), ", ", expr.val.u8(9), ", ", + expr.val.u8(10), ", ", expr.val.u8(11), ", ", expr.val.u8(12), ", ", + expr.val.u8(13), ", ", expr.val.u8(14), ", ", expr.val.u8(15), ");", + Newline()); + DropTypes(2); + break; + } + default: + WABT_UNREACHABLE; + } + PushType(result_type); +} + +void CWriter::Write(const LoadSplatExpr& expr) { + Memory* memory = module_->memories[module_->GetMemoryIndex(expr.memidx)]; + + const char* func = nullptr; + // clang-format off + switch (expr.opcode) { + case Opcode::V128Load8Splat: func = "v128_load8_splat"; break; + case Opcode::V128Load16Splat: func = "v128_load16_splat"; break; + case Opcode::V128Load32Splat: func = "v128_load32_splat"; break; + case Opcode::V128Load64Splat: func = "v128_load64_splat"; break; + default: + WABT_UNREACHABLE; + } + // clang-format on + Type result_type = expr.opcode.GetResultType(); + Write(StackVar(0, result_type), " = ", func, "(", + ExternalInstancePtr(ModuleFieldType::Memory, memory->name), ", (u64)(", + StackVar(0), ")"); + if (expr.offset != 0) + Write(" + ", expr.offset); + Write(");", Newline()); + + DropTypes(1); + PushType(result_type); +} + +void CWriter::Write(const LoadZeroExpr& expr) { + Memory* memory = module_->memories[module_->GetMemoryIndex(expr.memidx)]; + + const char* func = nullptr; + // clang-format off + switch (expr.opcode) { + case Opcode::V128Load32Zero: func = "v128_load32_zero"; break; + case Opcode::V128Load64Zero: func = "v128_load64_zero"; break; + default: + WABT_UNREACHABLE; + } + // clang-format on + + Type result_type = expr.opcode.GetResultType(); + Write(StackVar(0, result_type), " = ", func, "(", + ExternalInstancePtr(ModuleFieldType::Memory, memory->name), ", (u64)(", + StackVar(0), ")"); + if (expr.offset != 0) + Write(" + ", expr.offset); + Write(");", Newline()); + + DropTypes(1); + PushType(result_type); +} + +void CWriter::ReserveExportNames() { + for (const Export* export_ : module_->exports) { + ReserveExportName(export_->name); + } +} + +void CWriter::WriteCHeader() { + ReserveExportNames(); + + stream_ = h_stream_; + std::string guard = GenerateHeaderGuard(); + Write("/* Automatically generated by wasm2c */", Newline()); + Write("#ifndef ", guard, Newline()); + Write("#define ", guard, Newline()); + Write(Newline()); + WriteFeatureMacros(); + Write(s_header_top); + Write(Newline()); + WriteModuleInstance(); + WriteInitDecl(); + WriteFreeDecl(); + WriteGetFuncTypeDecl(); + WriteMultivalueTypes(); + WriteImports(); + WriteImportProperties(CWriterPhase::Declarations); + WriteExports(CWriterPhase::Declarations); + Write(Newline()); + Write(s_header_bottom); + Write(Newline(), "#endif /* ", guard, " */", Newline()); +} + +void CWriter::WriteCSource() { + /* Write the "top" to h_impl stream */ + stream_ = h_impl_stream_; + Write("/* Automatically generated by wasm2c */", Newline()); + WriteSourceTop(); + + /* Write module-wide declarations to impl header */ + WriteFuncTypeDecls(); + WriteTagTypes(); + WriteTagDecls(); + WriteFuncDeclarations(); + WriteDataInitializerDecls(); + WriteElemInitializerDecls(); + + /* Write the module-wide material to the first output stream */ + stream_ = c_streams_.front(); + WriteMultiCTop(); + WriteFuncTypes(); + WriteTags(); + WriteGlobalInitializers(); + WriteDataInitializers(); + WriteElemInitializers(); + WriteExports(CWriterPhase::Definitions); + WriteInitInstanceImport(); + WriteImportProperties(CWriterPhase::Definitions); + WriteInit(); + WriteFree(); + WriteGetFuncType(); + + /* Write function bodies across the different output streams */ + WriteFuncs(); + + /* For any empty .c output, write a dummy typedef to avoid gcc warning */ + WriteMultiCTopEmpty(); +} + +Result CWriter::WriteModule(const Module& module) { + WABT_USE(options_); + module_ = &module; + WriteCHeader(); + WriteCSource(); + return result_; +} + +// static +const char* CWriter::GetReferenceTypeName(const Type& type) { + switch (type) { + case Type::FuncRef: + return "funcref"; + case Type::ExternRef: + return "externref"; + default: + WABT_UNREACHABLE; + } +} + +// static +const char* CWriter::GetReferenceNullValue(const Type& type) { + switch (type) { + case Type::FuncRef: + return "wasm_rt_funcref_null_value"; + case Type::ExternRef: + return "wasm_rt_externref_null_value"; + default: + WABT_UNREACHABLE; + } +} + +const char* CWriter::InternalSymbolScope() const { + if (c_streams_.size() == 1) { + return "static "; + } else { + return ""; + } +} + +} // end anonymous namespace + +Result WriteC(std::vector<Stream*>&& c_streams, + Stream* h_stream, + Stream* h_impl_stream, + const char* header_name, + const char* header_impl_name, + const Module* module, + const WriteCOptions& options) { + CWriter c_writer(std::move(c_streams), h_stream, h_impl_stream, header_name, + header_impl_name, options); + return c_writer.WriteModule(*module); +} + +} // namespace wabt |