4 files changed, 61 insertions, 0 deletions

diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
index 44f323339..d70f31912 100644
--- a/src/binaryen-c.cpp
+++ b/src/binaryen-c.cpp
@@ -30,6 +30,7 @@
 #include "wasm-builder.h"
 #include "wasm-interpreter.h"
 #include "wasm-s-parser.h"
+#include "wasm-stack.h"
 #include "wasm-validator.h"
 #include "wasm.h"
 #include "wasm2js.h"
@@ -3908,6 +3909,10 @@ void BinaryenModulePrint(BinaryenModuleRef module) {
   std::cout << *(Module*)module;
 }
 
+void BinaryenModulePrintStackIR(BinaryenModuleRef module) {
+  wasm::printStackIR(std::cout, (Module*)module);
+}
+
 void BinaryenModulePrintAsmjs(BinaryenModuleRef module) {
   auto* wasm = (Module*)module;
   Wasm2JSBuilder::Flags flags;
@@ -4090,6 +4095,21 @@ size_t BinaryenModuleWriteText(BinaryenModuleRef module,
   return std::min(outputSize, temp.size());
 }
 
+size_t BinaryenModuleWriteStackIR(BinaryenModuleRef module,
+                                  char* output,
+                                  size_t outputSize) {
+  // use a stringstream as an std::ostream. Extract the std::string
+  // representation, and then store in the output.
+  std::stringstream ss;
+  wasm::printStackIR(ss, (Module*)module);
+
+  const auto temp = ss.str();
+  const auto ctemp = temp.c_str();
+
+  strncpy(output, ctemp, outputSize);
+  return std::min(outputSize, temp.size());
+}
+
 BinaryenBufferSizes BinaryenModuleWriteWithSourceMap(BinaryenModuleRef module,
                                                      const char* url,
                                                      char* output,
@@ -4139,6 +4159,21 @@ char* BinaryenModuleAllocateAndWriteText(BinaryenModuleRef module) {
   return cout;
 }
 
+char* BinaryenModuleAllocateAndWriteStackIR(BinaryenModuleRef module) {
+  std::stringstream ss;
+  bool colors = Colors::isEnabled();
+
+  Colors::setEnabled(false); // do not use colors for writing
+  wasm::printStackIR(ss, (Module*)module);
+  Colors::setEnabled(colors); // restore colors state
+
+  const std::string out = ss.str();
+  const int len = out.length() + 1;
+  char* cout = (char*)malloc(len);
+  strncpy(cout, out.c_str(), len);
+  return cout;
+}
+
 BinaryenModuleRef BinaryenModuleRead(char* input, size_t inputSize) {
   auto* wasm = new Module;
   std::vector<char> buffer(false);
diff --git a/src/binaryen-c.h b/src/binaryen-c.h
index 715b08880..387e54b72 100644
--- a/src/binaryen-c.h
+++ b/src/binaryen-c.h
@@ -2330,6 +2330,9 @@ BINARYEN_API BinaryenModuleRef BinaryenModuleParse(const char* text);
 // Print a module to stdout in s-expression text format. Useful for debugging.
 BINARYEN_API void BinaryenModulePrint(BinaryenModuleRef module);
 
+// Print a module to stdout in stack IR text format. Useful for debugging.
+BINARYEN_API void BinaryenModulePrintStackIR(BinaryenModuleRef module);
+
 // Print a module to stdout in asm.js syntax.
 BINARYEN_API void BinaryenModulePrintAsmjs(BinaryenModuleRef module);
 
@@ -2464,6 +2467,13 @@ BINARYEN_API size_t BinaryenModuleWriteText(BinaryenModuleRef module,
                                             char* output,
                                             size_t outputSize);
 
+// Serialize a module in stack IR text format.
+// @return how many bytes were written. This will be less than or equal to
+//         outputSize
+BINARYEN_API size_t BinaryenModuleWriteStackIR(BinaryenModuleRef module,
+                                               char* output,
+                                               size_t outputSize);
+
 typedef struct BinaryenBufferSizes {
   size_t outputBytes;
   size_t sourceMapBytes;
@@ -2504,6 +2514,12 @@ BinaryenModuleAllocateAndWrite(BinaryenModuleRef module,
 // once not needed anymore.
 BINARYEN_API char* BinaryenModuleAllocateAndWriteText(BinaryenModuleRef module);
 
+// Serialize a module in stack IR form. Implicitly allocates the returned
+// char* with malloc(), and expects the user to free() them manually
+// once not needed anymore.
+BINARYEN_API char*
+BinaryenModuleAllocateAndWriteStackIR(BinaryenModuleRef module);
+
 // Deserialize a module from binary form.
 BINARYEN_API BinaryenModuleRef BinaryenModuleRead(char* input,
                                                   size_t inputSize);
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
index ce70f50fd..3f22265eb 100644
--- a/src/passes/Print.cpp
+++ b/src/passes/Print.cpp
@@ -3442,6 +3442,14 @@ printStackIR(StackIR* ir, std::ostream& o, Function* func) {
   return o;
 }
 
+std::ostream& printStackIR(std::ostream& o, Module* module) {
+  wasm::PassRunner runner(module);
+  runner.add("generate-stack-ir");
+  runner.add(std::make_unique<PrintStackIR>(&o));
+  runner.run();
+  return o;
+}
+
 } // namespace wasm
 
 namespace std {
diff --git a/src/wasm-stack.h b/src/wasm-stack.h
index bd527b51a..6e39f45c6 100644
--- a/src/wasm-stack.h
+++ b/src/wasm-stack.h
@@ -472,6 +472,8 @@ private:
   Function* func;
 };
 
+std::ostream& printStackIR(std::ostream& o, Module* module);
+
 } // namespace wasm
 
 #endif // wasm_stack_h