optimize in for low memory device

include/wabt/binary-reader-ir.h

@@ -32,6 +32,11 @@ Result ReadBinaryIr(const char* filename,
                     Errors*,
                     Module* out_module);
 
-}  // namespace wabt
+class OpcodeRawExpr;
+Result ExtractOpcodeRawExpr(OpcodeRawExpr& expr,
+                            Module& module,
+                            const ReadBinaryOptions& options);
+
+} // namespace wabt
 
 #endif /* WABT_BINARY_READER_IR_H_ */

include/wabt/binary-reader-logging.h

@@ -188,6 +188,7 @@ class BinaryReaderLogging : public BinaryReaderDelegate {
   Result OnDropExpr() override;
   Result OnElseExpr() override;
   Result OnEndExpr() override;
+  Result OnSkipFunctionBodyExpr(std::vector<uint8_t>& opcode_buffer) override;
   Result OnF32ConstExpr(uint32_t value_bits) override;
   Result OnF64ConstExpr(uint64_t value_bits) override;
   Result OnV128ConstExpr(v128 value_bits) override;

include/wabt/binary-reader-nop.h

@@ -259,6 +259,9 @@ class BinaryReaderNop : public BinaryReaderDelegate {
   Result OnDropExpr() override { return Result::Ok; }
   Result OnElseExpr() override { return Result::Ok; }
   Result OnEndExpr() override { return Result::Ok; }
+  Result OnSkipFunctionBodyExpr(std::vector<uint8_t>& opcode_buffer) override {
+    return Result::Ok;
+  }
   Result OnF32ConstExpr(uint32_t value_bits) override { return Result::Ok; }
   Result OnF64ConstExpr(uint64_t value_bits) override { return Result::Ok; }
   Result OnV128ConstExpr(v128 value_bits) override { return Result::Ok; }

include/wabt/binary-reader.h

@@ -264,6 +264,8 @@ class BinaryReaderDelegate {
   virtual Result OnDropExpr() = 0;
   virtual Result OnElseExpr() = 0;
   virtual Result OnEndExpr() = 0;
+  virtual Result OnSkipFunctionBodyExpr(
+      std::vector<uint8_t>& opcode_buffer) = 0;
   virtual Result OnF32ConstExpr(uint32_t value_bits) = 0;
   virtual Result OnF64ConstExpr(uint64_t value_bits) = 0;
   virtual Result OnV128ConstExpr(v128 value_bits) = 0;
@@ -511,6 +513,12 @@ Result ReadBinary(const void* data,
                   BinaryReaderDelegate* reader,
                   const ReadBinaryOptions& options);
 
+Result ExtractFunctionBody(const void* data,
+                           size_t size,
+                           Location& loc,
+                           BinaryReaderDelegate* delegate,
+                           const ReadBinaryOptions& options);
+
 size_t ReadU32Leb128(const uint8_t* ptr,
                      const uint8_t* end,
                      uint32_t* out_value);

include/wabt/binary-writer.h

@@ -46,6 +46,11 @@ struct WriteBinaryOptions {
 
 Result WriteBinaryModule(Stream*, const Module*, const WriteBinaryOptions&);
 
+class OpcodeRawExpr;
+Result PackOpcodeRawExpr(OpcodeRawExpr& expr,
+                         Module& module,
+                         const WriteBinaryOptions& options);
+
 void WriteType(Stream* stream, Type type, const char* desc = nullptr);
 
 void WriteStr(Stream* stream,

include/wabt/common.h

@@ -196,7 +196,7 @@ enum class LabelType {
   Try,
   TryTable,
   Catch,
-
+  ExtractFunc,
   First = Func,
   Last = Catch,
 };

include/wabt/expr-visitor.h

@@ -43,6 +43,7 @@ class ExprVisitor {
     Try,
     TryTable,
     Catch,
+    OpcodeRaw
   };
 
   Result HandleDefaultState(Expr*);
@@ -141,6 +142,7 @@ class ExprVisitor::Delegate {
   virtual Result OnSimdShuffleOpExpr(SimdShuffleOpExpr*) = 0;
   virtual Result OnLoadSplatExpr(LoadSplatExpr*) = 0;
   virtual Result OnLoadZeroExpr(LoadZeroExpr*) = 0;
+  virtual Result OnOpcodeRawExpr(OpcodeRawExpr*) = 0;
 };
 
 class ExprVisitor::DelegateNop : public ExprVisitor::Delegate {
@@ -222,6 +224,7 @@ class ExprVisitor::DelegateNop : public ExprVisitor::Delegate {
   Result OnSimdShuffleOpExpr(SimdShuffleOpExpr*) override { return Result::Ok; }
   Result OnLoadSplatExpr(LoadSplatExpr*) override { return Result::Ok; }
   Result OnLoadZeroExpr(LoadZeroExpr*) override { return Result::Ok; }
+  Result OnOpcodeRawExpr(OpcodeRawExpr*) override { return Result::Ok; }
 };
 
 }  // namespace wabt

include/wabt/ir.h

@@ -429,7 +429,8 @@ enum class ExprType {
   Unreachable,
 
   First = AtomicLoad,
-  Last = Unreachable
+  Last = Unreachable,
+  OpCodeRaw = Last + 1,  // virtual type
 };
 
 const char* GetExprTypeName(ExprType type);
@@ -839,6 +840,22 @@ class AtomicFenceExpr : public ExprMixin<ExprType::AtomicFence> {
   uint32_t consistency_model;
 };
 
+class OpcodeRawExpr : public ExprMixin<ExprType::OpCodeRaw> {
+ public:
+  explicit OpcodeRawExpr(std::vector<uint8_t>&& in_opcode_buffer,
+                         FuncSignature& in_func_sig,
+                         const Location& loc = Location())
+      : ExprMixin<ExprType::OpCodeRaw>(loc),
+        opcode_buffer(std::move(in_opcode_buffer)),
+        is_extracted(false),
+        func_sig(&in_func_sig) {}
+
+  std::vector<uint8_t> opcode_buffer;
+  bool is_extracted;
+  ExprList extracted_exprs;
+  const FuncSignature* func_sig;
+};
+
 struct Tag {
   explicit Tag(std::string_view name) : name(name) {}