Consistently optimize small added constants into load/store offsets (#1924)

See #1919 - we did not do this consistently before.

This adds a lowMemoryUnused option to PassOptions. It can be passed on the commandline with --low-memory-unused. If enabled, we run the new optimize-added-constants pass, which does the real work here, replacing older code in post-emscripten.

Aside from running at the proper time (unlike the old pass, see #1919), this also has a -propagate mode, which can do stuff like this:

y = x + 10
[..]
load(y)
[..]
load(y)
=>
y = x + 10
[..]
load(x, offset=10)
[..]
load(x, offset=10)
That is, it can propagate such offsets to the loads/stores. This pattern is common in big interpreter loops, where the pointers are offsets into a big struct of state.

The pass does this propagation by using a new feature of LocalGraph, which can verify which locals are in SSA mode. Binaryen IR is not SSA (intentionally, since it's a later IR), but if a local only has a single set for all gets, that means that local is in such a state, and can be optimized. The tricky thing is that all locals are initialized to zero, so there are at minimum two sets. But if we verify that the real set dominates all the gets, then the zero initialization cannot reach them, and we are safe.

This PR also makes safe-heap aware of lowMemoryUnused. If so, we check for not just an access of 0, but the range 0-1023.

This makes zlib 5% faster, with either the wasm backend or asm2wasm. It also makes it 0.5% smaller. Also helps sqlite (1.5% faster) and lua (1% faster)

Author: kripken

build-js.sh

@@ -117,6 +117,7 @@ echo "building shared bitcode"
   $BINARYEN_SRC/passes/MinifyImportsAndExports.cpp \
   $BINARYEN_SRC/passes/NameList.cpp \
   $BINARYEN_SRC/passes/NoExitRuntime.cpp \
+  $BINARYEN_SRC/passes/OptimizeAddedConstants.cpp \
   $BINARYEN_SRC/passes/OptimizeInstructions.cpp \
   $BINARYEN_SRC/passes/PickLoadSigns.cpp \
   $BINARYEN_SRC/passes/PostEmscripten.cpp \

src/asm2wasm.h

@@ -957,6 +957,7 @@ void Asm2WasmBuilder::processAsm(Ref ast) {
     }
     optimizingBuilder = make_unique<OptimizingIncrementalModuleBuilder>(&wasm, numFunctions, passOptions, [&](PassRunner& passRunner) {
       // addPrePasses
+      passRunner.options.lowMemoryUnused = true;
       if (debug) {
         passRunner.setDebug(true);
         passRunner.setValidateGlobally(false);
@@ -1189,6 +1190,7 @@ void Asm2WasmBuilder::processAsm(Ref ast) {
     // functions). Optimize those now. Typically there are very few, just do it
     // sequentially.
     PassRunner passRunner(&wasm, passOptions);
+    passRunner.options.lowMemoryUnused = true;
     passRunner.addDefaultFunctionOptimizationPasses();
     for (auto& pair : trappingFunctions.getFunctions()) {
       auto* func = pair.second;
@@ -1447,6 +1449,7 @@ void Asm2WasmBuilder::processAsm(Ref ast) {
   };
 
   PassRunner passRunner(&wasm, passOptions);
+  passRunner.options.lowMemoryUnused = true;
   passRunner.setFeatures(passOptions.features);
   if (debug) {
     passRunner.setDebug(true);

src/ir/LocalGraph.cpp

@@ -242,5 +242,38 @@ void LocalGraph::computeInfluences() {
   }
 }
 
+void LocalGraph::computeSSAIndexes() {
+  std::unordered_map<Index, std::set<SetLocal*>> indexSets;
+  for (auto& pair : getSetses) {
+    auto* get = pair.first;
+    auto& sets = pair.second;
+    for (auto* set : sets) {
+      indexSets[get->index].insert(set);
+    }
+  }
+  for (auto& pair : locations) {
+    auto* curr = pair.first;
+    if (auto* set = curr->dynCast<SetLocal>()) {
+      auto& sets = indexSets[set->index];
+      if (sets.size() == 1 && *sets.begin() != curr) {
+        // While it has just one set, it is not the right one (us),
+        // so mark it invalid.
+        sets.clear();
+      }
+    }
+  }
+  for (auto& pair : indexSets) {
+    auto index = pair.first;
+    auto& sets = pair.second;
+    if (sets.size() == 1) {
+      SSAIndexes.insert(index);
+    }
+  }
+}
+
+bool LocalGraph::isSSA(Index x) {
+  return SSAIndexes.count(x);
+}
+
 } // namespace wasm
 

src/ir/local-graph.h

@@ -45,13 +45,40 @@ struct LocalGraph {
                        // value (0 for a var, the received value for a param)
   Locations locations; // where each get and set is (for easy replacing)
 
-  // optional computation: compute the influence graphs between sets and gets
-  // (useful for algorithms that propagate changes)
+  // Optional: compute the influence graphs between sets and gets
+  // (useful for algorithms that propagate changes).
+
+  void computeInfluences();
 
   std::unordered_map<GetLocal*, std::unordered_set<SetLocal*>> getInfluences; // for each get, the sets whose values are influenced by that get
   std::unordered_map<SetLocal*, std::unordered_set<GetLocal*>> setInfluences; // for each set, the gets whose values are influenced by that set
 
-  void computeInfluences();
+  // Optional: Compute the local indexes that are SSA, in the sense of
+  //  * a single set for all the gets for that local index
+  //  * the set dominates all the gets (logically implied by the former property)
+  //  * no other set (aside from the zero-init)
+  // The third property is not exactly standard SSA, but is useful since we are not in
+  // SSA form in our IR. To see why it matters, consider these:
+  //
+  // x = 0 // zero init
+  // [..]
+  // x = 10
+  // y = x + 20
+  // x = 30 // !!!
+  // f(y)
+  //
+  // The !!! line violates that property - it is another set for x, and it may interfere
+  // say with replacing f(y) with f(x + 20). Instead, if we know the only other possible set for x
+  // is the zero init, then things like the !!! line cannot exist, and it is valid to replace
+  // f(y) with f(x + 20).
+  // (This could be simpler, but in wasm the zero init always exists.)
+
+  void computeSSAIndexes();
+
+  bool isSSA(Index x);
+
+private:
+  std::set<Index> SSAIndexes;
 };
 
 } // namespace wasm

src/pass.h

@@ -56,14 +56,26 @@ struct PassRegistry {
 };
 
 struct PassOptions {
-  bool debug = false; // run passes in debug mode, doing extra validation and timing checks
-  bool validate = true; // whether to run the validator to check for errors
-  bool validateGlobally = false; // when validating validate globally and not just locally
-  int optimizeLevel = 0; // 0, 1, 2 correspond to -O0, -O1, -O2, etc.
-  int shrinkLevel = 0;   // 0, 1, 2 correspond to -O0, -Os, -Oz
-  bool ignoreImplicitTraps = false; // optimize assuming things like div by 0, bad load/store, will not trap
-  bool debugInfo = false; // whether to try to preserve debug info through, which are special calls
-  FeatureSet features = FeatureSet::All; // Which wasm features to accept, and be allowed to use
+  // Run passes in debug mode, doing extra validation and timing checks.
+  bool debug = false;
+  // Whether to run the validator to check for errors.
+  bool validate = true;
+  // When validating validate globally and not just locally
+  bool validateGlobally = false;
+  // 0, 1, 2 correspond to -O0, -O1, -O2, etc.
+  int optimizeLevel = 0;
+  // 0, 1, 2 correspond to -O0, -Os, -Oz
+  int shrinkLevel = 0;
+  // Optimize assuming things like div by 0, bad load/store, will not trap.
+  bool ignoreImplicitTraps = false;
+  // Optimize assuming that the low 1K of memory is not valid memory for the application
+  // to use. In that case, we can optimize load/store offsets in many cases.
+  bool lowMemoryUnused = false;
+  enum { LowMemoryBound = 1024 };
+  // Whether to try to preserve debug info through, which are special calls.
+  bool debugInfo = false;
+  // Which wasm features to accept, and be allowed to use.
+  FeatureSet features = FeatureSet::All;
 
   void setDefaultOptimizationOptions() {
     // -Os is our default

src/passes/CMakeLists.txt

@@ -31,6 +31,7 @@ SET(passes_SOURCES
   MinifyImportsAndExports.cpp
   NameList.cpp
   NoExitRuntime.cpp
+  OptimizeAddedConstants.cpp
   OptimizeInstructions.cpp
   PickLoadSigns.cpp
   PostEmscripten.cpp

src/passes/CodePushing.cpp

@@ -77,8 +77,8 @@ struct LocalAnalyzer : public PostWalker<LocalAnalyzer> {
   }
 };
 
-// Implement core optimization logic in a struct, used and then discarded entirely
-// for each block
+// Implements core optimization logic. Used and then discarded entirely
+// for each block.
 class Pusher {
   ExpressionList& list;
   LocalAnalyzer& analyzer;
@@ -92,7 +92,7 @@ class Pusher {
     // continuing forward.
     Index relevant = list.size() - 1; // we never need to push past a final element, as
                                       // we couldn't be used after it.
-    Index nothing = -1;
+    const Index nothing = -1;
     Index i = 0;
     Index firstPushable = nothing;
     while (i < relevant) {