Add flags indicating whether a function shall always be inlined

build-js.sh

@@ -148,6 +148,7 @@ export_function "_BinaryenInt64"
 export_function "_BinaryenFloat32"
 export_function "_BinaryenFloat64"
 export_function "_BinaryenUndefined"
+export_function "_BinaryenAlwaysInline"
 export_function "_BinaryenInvalidId"
 export_function "_BinaryenBlockId"
 export_function "_BinaryenIfId"
@@ -389,6 +390,8 @@ export_function "_BinaryenModuleWrite"
 export_function "_BinaryenModuleRead"
 export_function "_BinaryenModuleInterpret"
 export_function "_BinaryenFunctionGetBody"
+export_function "_BinaryenFunctionGetFlags"
+export_function "_BinaryenFunctionSetFlags"
 export_function "_BinaryenFunctionOptimize"
 export_function "_BinaryenFunctionRunPasses"
 export_function "_RelooperCreate"

src/binaryen-c.cpp

@@ -106,6 +106,10 @@ BinaryenType BinaryenFloat32(void) { return f32; }
 BinaryenType BinaryenFloat64(void) { return f64; }
 BinaryenType BinaryenUndefined(void) { return uint32_t(-1); }
 
+// Flags
+
+BinaryenFlags BinaryenAlwaysInline(void) { return Function::Flags::AlwaysInline; }
+
 // Expression ids
 
 BinaryenExpressionId BinaryenInvalidId(void) { return Expression::Id::InvalidId; }
@@ -1350,7 +1354,20 @@ BinaryenExpressionRef BinaryenFunctionGetBody(BinaryenFunctionRef func) {
 
   return ((Function*)func)->body;
 }
+BinaryenFlags BinaryenFunctionGetFlags(BinaryenFunctionRef func) {
+  if (tracing) {
+    std::cout << "  BinaryenFunctionGetFlags(functions[" << functions[func] << "]);\n";
+  }
+
+  return ((Function*)func)->flags;
+}
+void BinaryenFunctionSetFlags(BinaryenFunctionRef func, BinaryenFlags flags) {
+  if (tracing) {
+    std::cout << "  BinaryenFunctionSetFlags(functions[" << functions[func] << "], " << flags << ");\n";
+  }
 
+  ((Function*)func)->flags = (Function::Flags)flags;
+}
 void BinaryenFunctionOptimize(BinaryenFunctionRef func, BinaryenModuleRef module) {
   if (tracing) {
     std::cout << "  BinaryenFunctionOptimize(functions[" << functions[func] << "], the_module);\n";
@@ -1361,7 +1378,6 @@ void BinaryenFunctionOptimize(BinaryenFunctionRef func, BinaryenModuleRef module
   passRunner.addDefaultOptimizationPasses();
   passRunner.runFunction((Function*)func);
 }
-
 void BinaryenFunctionRunPasses(BinaryenFunctionRef func, BinaryenModuleRef module, const char **passes, BinaryenIndex numPasses) {
   if (tracing) {
     std::cout << "  {\n";

src/binaryen-c.h

@@ -78,6 +78,12 @@ BinaryenType BinaryenFloat64(void);
 // the API figure out the type instead of providing one.
 BinaryenType BinaryenUndefined(void);
 
+// Flags type used for enum-like values.
+
+typedef uint32_t BinaryenFlags;
+
+BinaryenFlags BinaryenAlwaysInline(void);
+
 // Expression ids (call to get the value of each; you can cache them)
 
 typedef uint32_t BinaryenExpressionId;
@@ -506,6 +512,12 @@ void BinaryenModuleInterpret(BinaryenModuleRef module);
 // Gets the body of the function.
 BinaryenExpressionRef BinaryenFunctionGetBody(BinaryenFunctionRef func);
 
+// Gets the flags set for the function.
+BinaryenFlags BinaryenFunctionGetFlags(BinaryenFunctionRef func);
+
+// Sets the function's flags, e.g., 'AlwaysInline'.
+void BinaryenFunctionSetFlags(BinaryenFunctionRef func, BinaryenFlags flags);
+
 // Runs the standard optimization passes on the function.
 void BinaryenFunctionOptimize(BinaryenFunctionRef func, BinaryenModuleRef module);
 

src/js/binaryen.js-post.js

@@ -29,6 +29,8 @@
   Module['f64'] = Module['_BinaryenFloat64']();
   Module['undefined'] = Module['_BinaryenUndefined']();
 
+  Module['AlwaysInline'] = Module['_BinaryenAlwaysInline']();
+
   Module['InvalidId'] = Module['_BinaryenInvalidId']();
   Module['BlockId'] = Module['_BinaryenBlockId']();
   Module['IfId'] = Module['_BinaryenIfId']();
@@ -1231,6 +1233,14 @@
     return Module['_BinaryenFunctionGetBody'](func);
   };
 
+  Module['getFunctionFlags'] = function(func) {
+    return Module['_BinaryenFunctionGetFlags'](func);
+  };
+
+  Module['setFunctionFlags'] = function(func, flags) {
+    return Module['_BinaryenFunctionSetFlags'](func, flags);
+  };
+
   // emit text of an expression or a module
   Module['emitText'] = function(expr) {
     if (typeof expr === 'object') {

src/passes/Inlining.cpp

@@ -52,8 +52,11 @@ struct FunctionInfo {
   Index size;
   bool lightweight = true;
   bool usedGlobally = false; // in a table or export
+  bool alwaysInline = false;
 
   bool worthInlining(PassOptions& options, bool allowMultipleInliningsPerFunction) {
+    // if it's explicitly set to be inlined, just do it
+    if (alwaysInline) return true;
     // if it's big, it's just not worth doing (TODO: investigate more)
     if (size > FLEXIBLE_SIZE_LIMIT) return false;
     // if it has one use, then inlining it would likely reduce code size
@@ -94,6 +97,8 @@ struct FunctionInfoScanner : public WalkerPass<PostWalker<FunctionInfoScanner>>
 
   void visitFunction(Function* curr) {
     (*infos)[curr->name].size = Measurer::measure(curr->body);
+    if (curr->flags & Function::Flags::AlwaysInline)
+      (*infos)[curr->name].alwaysInline = true;
   }
 
 private:

src/wasm.h

@@ -596,6 +596,11 @@ class Function {
   std::vector<WasmType> vars;   // params plus vars
   Name type; // if null, it is implicit in params and result
   Expression* body;
+  enum Flags {
+    None = 0,
+    AlwaysInline = 1 << 0
+  };
+  Flags flags;
 
   // local names. these are optional.
   std::map<Index, Name> localNames;
@@ -608,7 +613,7 @@ class Function {
   };
   std::unordered_map<Expression*, DebugLocation> debugLocations;
 
-  Function() : result(none) {}
+  Function() : result(none), flags(None) {}
 
   size_t getNumParams();
   size_t getNumVars();

test/binaryen.js/kitchen-sink.js

@@ -43,6 +43,10 @@ function test_types() {
   console.log("BinaryenFloat64: " + Binaryen.f64);
 }
 
+function test_flags() {
+  console.log("BinaryenAlwaysInline: " + Binaryen.AlwaysInline);
+}
+
 function test_ids() {
   console.log("BinaryenInvalidId: " + Binaryen.InvalidId);
   console.log("BinaryenBlockId: " + Binaryen.BlockId);
@@ -449,6 +453,13 @@ function test_relooper() {
     module.addFunction("return", i, localTypes, body);
   }
 
+  { // setting flags
+    var func = module.addFunction("set-flags", i, [], module.i32.const(0));
+    console.log("flags=" + Binaryen.getFunctionFlags(func));
+    Binaryen.setFunctionFlags(func, Binaryen.AlwaysInline);
+    console.log("flags=" + Binaryen.getFunctionFlags(func));
+  }
+
   console.log("raw:");
   console.log(module.emitText());
 
@@ -562,6 +573,7 @@ function test_parsing() {
 
 function main() {
   test_types();
+  test_flags();
   test_ids();
   test_core();
   test_relooper();

test/binaryen.js/kitchen-sink.js.txt

@@ -3,6 +3,7 @@ BinaryenInt32: 1
 BinaryenInt64: 2
 BinaryenFloat32: 3
 BinaryenFloat64: 4
+BinaryenAlwaysInline: 1
 BinaryenInvalidId: 0
 BinaryenBlockId: 1
 BinaryenIfId: 2
@@ -572,6 +573,8 @@ getExpressionType=3
  )
 )
 
+flags=0
+flags=1
 raw:
 (module
  (type $v (func))
@@ -1058,6 +1061,9 @@ raw:
    )
   )
  )
+ (func $set-flags (; 16 ;) (type $i) (result i32)
+  (i32.const 0)
+ )
 )
 
 optimized:
@@ -2453,6 +2459,16 @@ getExpressionType=3
     BinaryenType varTypes[] = { 1 };
     functions[14] = BinaryenAddFunction(the_module, "return", functionTypes[2], varTypes, 1, expressions[141]);
   }
+  expressions[142] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  {
+    BinaryenType varTypes[] = { 0 };
+    functions[15] = BinaryenAddFunction(the_module, "set-flags", functionTypes[2], varTypes, 0, expressions[142]);
+  }
+  BinaryenFunctionGetFlags(functions[15]);
+flags=0
+  BinaryenFunctionSetFlags(functions[15], 1);
+  BinaryenFunctionGetFlags(functions[15]);
+flags=1
 raw:
   BinaryenModulePrint(the_module);
 (module
@@ -2940,6 +2956,9 @@ raw:
    )
   )
  )
+ (func $set-flags (; 16 ;) (type $i) (result i32)
+  (i32.const 0)
+ )
 )
 
   BinaryenModuleValidate(the_module);