Apply format changes from #2048 (#2059)

Mass change to apply clang-format to everything. We are applying this in a PR by me so the (git) blame is all mine ;) but @aheejin did all the work to get clang-format set up and all the manual work to tidy up some things to make the output nicer in #2048

4 files changed, 573 insertions, 362 deletions

diff --git a/src/cfg/Relooper.cpp b/src/cfg/Relooper.cpp
index 3acdabd52..8a15fe75c 100644
--- a/src/cfg/Relooper.cpp
+++ b/src/cfg/Relooper.cpp
@@ -16,8 +16,8 @@
 
 #include "Relooper.h"
 
-#include <string.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include <list>
 #include <stack>
@@ -29,12 +29,13 @@
 
 namespace CFG {
 
-template<class T, class U> static bool contains(const T& container, const U& contained) {
+template<class T, class U>
+static bool contains(const T& container, const U& contained) {
   return !!container.count(contained);
 }
 
 #ifdef RELOOPER_DEBUG
-static void PrintDebug(const char *Format, ...);
+static void PrintDebug(const char* Format, ...);
 #define DebugDump(x, ...) Debugging::Dump(x, __VA_ARGS__)
 #else
 #define PrintDebug(x, ...)
@@ -43,8 +44,12 @@ static void PrintDebug(const char *Format, ...);
 
 // Rendering utilities
 
-static wasm::Expression* HandleFollowupMultiples(wasm::Expression* Ret, Shape* Parent, RelooperBuilder& Builder, bool InLoop) {
-  if (!Parent->Next) return Ret;
+static wasm::Expression* HandleFollowupMultiples(wasm::Expression* Ret,
+                                                 Shape* Parent,
+                                                 RelooperBuilder& Builder,
+                                                 bool InLoop) {
+  if (!Parent->Next)
+    return Ret;
 
   auto* Curr = Ret->dynCast<wasm::Block>();
   if (!Curr || Curr->name.is()) {
@@ -53,7 +58,8 @@ static wasm::Expression* HandleFollowupMultiples(wasm::Expression* Ret, Shape* P
   // for each multiple after us, we create a block target for breaks to reach
   while (Parent->Next) {
     auto* Multiple = Shape::IsMultiple(Parent->Next);
-    if (!Multiple) break;
+    if (!Multiple)
+      break;
     for (auto& iter : Multiple->InnerMap) {
       int Id = iter.first;
       Shape* Body = iter.second;
@@ -66,9 +72,9 @@ static wasm::Expression* HandleFollowupMultiples(wasm::Expression* Ret, Shape* P
     }
     Parent->Next = Parent->Next->Next;
   }
-  // after the multiples is a simple or a loop, in both cases we must hit an entry
-  // block, and so this is the last one we need to take into account now (this
-  // is why we require that loops hit an entry).
+  // after the multiples is a simple or a loop, in both cases we must hit an
+  // entry block, and so this is the last one we need to take into account now
+  // (this is why we require that loops hit an entry).
   if (Parent->Next) {
     auto* Simple = Shape::IsSimple(Parent->Next);
     if (Simple) {
@@ -99,19 +105,25 @@ static wasm::Expression* HandleFollowupMultiples(wasm::Expression* Ret, Shape* P
 
 // Branch
 
-Branch::Branch(wasm::Expression* ConditionInit, wasm::Expression* CodeInit) : Condition(ConditionInit), Code(CodeInit) {}
+Branch::Branch(wasm::Expression* ConditionInit, wasm::Expression* CodeInit)
+  : Condition(ConditionInit), Code(CodeInit) {}
 
-Branch::Branch(std::vector<wasm::Index>&& ValuesInit, wasm::Expression* CodeInit) : Condition(nullptr), Code(CodeInit) {
+Branch::Branch(std::vector<wasm::Index>&& ValuesInit,
+               wasm::Expression* CodeInit)
+  : Condition(nullptr), Code(CodeInit) {
   if (ValuesInit.size() > 0) {
     SwitchValues = wasm::make_unique<std::vector<wasm::Index>>(ValuesInit);
   }
   // otherwise, it is the default
 }
 
-wasm::Expression* Branch::Render(RelooperBuilder& Builder, Block* Target, bool SetLabel) {
+wasm::Expression*
+Branch::Render(RelooperBuilder& Builder, Block* Target, bool SetLabel) {
   auto* Ret = Builder.makeBlock();
-  if (Code) Ret->list.push_back(Code);
-  if (SetLabel) Ret->list.push_back(Builder.makeSetLabel(Target->Id));
+  if (Code)
+    Ret->list.push_back(Code);
+  if (SetLabel)
+    Ret->list.push_back(Builder.makeSetLabel(Target->Id));
   if (Type == Break) {
     Ret->list.push_back(Builder.makeBlockBreak(Target->Id));
   } else if (Type == Continue) {
@@ -124,7 +136,9 @@ wasm::Expression* Branch::Render(RelooperBuilder& Builder, Block* Target, bool S
 
 // Block
 
-Block::Block(wasm::Expression* CodeInit, wasm::Expression* SwitchConditionInit) : Code(CodeInit), SwitchCondition(SwitchConditionInit), IsCheckedMultipleEntry(false) {}
+Block::Block(wasm::Expression* CodeInit, wasm::Expression* SwitchConditionInit)
+  : Code(CodeInit), SwitchCondition(SwitchConditionInit),
+    IsCheckedMultipleEntry(false) {}
 
 Block::~Block() {
   for (auto& iter : ProcessedBranchesOut) {
@@ -135,13 +149,19 @@ Block::~Block() {
   }
 }
 
-void Block::AddBranchTo(Block* Target, wasm::Expression* Condition, wasm::Expression* Code) {
-  assert(!contains(BranchesOut, Target)); // cannot add more than one branch to the same target
+void Block::AddBranchTo(Block* Target,
+                        wasm::Expression* Condition,
+                        wasm::Expression* Code) {
+  // cannot add more than one branch to the same target
+  assert(!contains(BranchesOut, Target));
   BranchesOut[Target] = new Branch(Condition, Code);
 }
 
-void Block::AddSwitchBranchTo(Block* Target, std::vector<wasm::Index>&& Values, wasm::Expression* Code) {
-  assert(!contains(BranchesOut, Target)); // cannot add more than one branch to the same target
+void Block::AddSwitchBranchTo(Block* Target,
+                              std::vector<wasm::Index>&& Values,
+                              wasm::Expression* Code) {
+  // cannot add more than one branch to the same target
+  assert(!contains(BranchesOut, Target));
   BranchesOut[Target] = new Branch(std::move(Values), Code);
 }
 
@@ -150,14 +170,16 @@ wasm::Expression* Block::Render(RelooperBuilder& Builder, bool InLoop) {
   if (IsCheckedMultipleEntry && InLoop) {
     Ret->list.push_back(Builder.makeSetLabel(0));
   }
-  if (Code) Ret->list.push_back(Code);
+  if (Code)
+    Ret->list.push_back(Code);
 
   if (!ProcessedBranchesOut.size()) {
     Ret->finalize();
     return Ret;
   }
 
-  bool SetLabel = true; // in some cases it is clear we can avoid setting label, see later
+  // in some cases it is clear we can avoid setting label, see later
+  bool SetLabel = true;
 
   // A setting of the label variable (label = x) is necessary if it can
   // cause an impact. The main case is where we set label to x, then elsewhere
@@ -189,31 +211,40 @@ wasm::Expression* Block::Render(RelooperBuilder& Builder, bool InLoop) {
     // When the Multiple has the same number of groups as we have branches,
     // they will all be fused, so it is safe to not set the label at all.
     // If a switch, then we can have multiple branches to the same target
-    // (in different table indexes), and so this check is not sufficient TODO: optimize
-    if (SetLabel && Fused->InnerMap.size() == ProcessedBranchesOut.size() && !SwitchCondition) {
+    // (in different table indexes), and so this check is not sufficient
+    // TODO: optimize
+    if (SetLabel && Fused->InnerMap.size() == ProcessedBranchesOut.size() &&
+        !SwitchCondition) {
       SetLabel = false;
     }
   }
 
-  Block* DefaultTarget = nullptr; // The block we branch to without checking the condition, if none of the other conditions held.
+  // The block we branch to without checking the condition, if none of the other
+  // conditions held.
+  Block* DefaultTarget = nullptr;
 
   // Find the default target, the one without a condition
   for (auto& iter : ProcessedBranchesOut) {
-    if ((!SwitchCondition && !iter.second->Condition) || (SwitchCondition && !iter.second->SwitchValues)) {
-      assert(!DefaultTarget && "block has branches without a default (nullptr for the condition)"); // Must be exactly one default // nullptr
+    if ((!SwitchCondition && !iter.second->Condition) ||
+        (SwitchCondition && !iter.second->SwitchValues)) {
+      assert(!DefaultTarget &&
+             "block has branches without a default (nullptr for the "
+             "condition)"); // Must be exactly one default // nullptr
       DefaultTarget = iter.first;
     }
   }
-  assert(DefaultTarget); // Since each Block* must* branch somewhere, this must be set
+  // Since each Block* must* branch somewhere, this must be set
+  assert(DefaultTarget);
 
-  wasm::Expression* Root = nullptr; // root of the main part, that we are about to emit
+  // root of the main part, that we are about to emit
+  wasm::Expression* Root = nullptr;
 
   if (!SwitchCondition) {
     // We'll emit a chain of if-elses
     wasm::If* CurrIf = nullptr;
 
-    // we build an if, then add a child, then add a child to that, etc., so we must
-    // finalize them in reverse order
+    // we build an if, then add a child, then add a child to that, etc., so we
+    // must finalize them in reverse order
     std::vector<wasm::If*> finalizeStack;
 
     wasm::Expression* RemainingConditions = nullptr;
@@ -223,9 +254,11 @@ wasm::Expression* Block::Render(RelooperBuilder& Builder, bool InLoop) {
       Branch* Details;
       if (iter != ProcessedBranchesOut.end()) {
         Target = iter->first;
-        if (Target == DefaultTarget) continue; // done at the end
+        if (Target == DefaultTarget)
+          continue; // done at the end
         Details = iter->second;
-        assert(Details->Condition); // must have a condition if this is not the default target
+        // must have a condition if this is not the default target
+        assert(Details->Condition);
       } else {
         Target = DefaultTarget;
         Details = ProcessedBranchesOut[DefaultTarget];
@@ -238,10 +271,13 @@ wasm::Expression* Block::Render(RelooperBuilder& Builder, bool InLoop) {
       }
       wasm::Expression* CurrContent = nullptr;
       bool IsDefault = iter == ProcessedBranchesOut.end();
-      if (SetCurrLabel || Details->Type != Branch::Direct || HasFusedContent || Details->Code) {
+      if (SetCurrLabel || Details->Type != Branch::Direct || HasFusedContent ||
+          Details->Code) {
         CurrContent = Details->Render(Builder, Target, SetCurrLabel);
         if (HasFusedContent) {
-          CurrContent = Builder.blockify(CurrContent, Fused->InnerMap.find(Target->Id)->second->Render(Builder, InLoop));
+          CurrContent = Builder.blockify(
+            CurrContent,
+            Fused->InnerMap.find(Target->Id)->second->Render(Builder, InLoop));
         }
       }
       // If there is nothing to show in this branch, omit the condition
@@ -276,12 +312,14 @@ wasm::Expression* Block::Render(RelooperBuilder& Builder, bool InLoop) {
       } else {
         auto* Now = Builder.makeUnary(wasm::EqZInt32, Details->Condition);
         if (RemainingConditions) {
-          RemainingConditions = Builder.makeBinary(wasm::AndInt32, RemainingConditions, Now);
+          RemainingConditions =
+            Builder.makeBinary(wasm::AndInt32, RemainingConditions, Now);
         } else {
           RemainingConditions = Now;
         }
       }
-      if (IsDefault) break;
+      if (IsDefault)
+        break;
     }
 
     // finalize the if-chains
@@ -317,17 +355,21 @@ wasm::Expression* Block::Render(RelooperBuilder& Builder, bool InLoop) {
         Details->Type = Branch::Direct;
       }
       wasm::Expression* CurrContent = nullptr;
-      if (SetCurrLabel || Details->Type != Branch::Direct || HasFusedContent || Details->Code) {
+      if (SetCurrLabel || Details->Type != Branch::Direct || HasFusedContent ||
+          Details->Code) {
         CurrContent = Details->Render(Builder, Target, SetCurrLabel);
         if (HasFusedContent) {
-          CurrContent = Builder.blockify(CurrContent, Fused->InnerMap.find(Target->Id)->second->Render(Builder, InLoop));
+          CurrContent = Builder.blockify(
+            CurrContent,
+            Fused->InnerMap.find(Target->Id)->second->Render(Builder, InLoop));
         }
       }
       // generate a block to branch to, if we have content
       if (CurrContent) {
         auto* NextOuter = Builder.makeBlock();
         NextOuter->list.push_back(Outer);
-        Outer->name = CurrName; // breaking on Outer leads to the content in NextOuter
+        // breaking on Outer leads to the content in NextOuter
+        Outer->name = CurrName;
         NextOuter->list.push_back(CurrContent);
         // if this is not a dead end, also need to break to the outside
         // this is both an optimization, and avoids incorrectness as adding
@@ -340,23 +382,27 @@ wasm::Expression* Block::Render(RelooperBuilder& Builder, bool InLoop) {
       } else {
         CurrName = SwitchLeave; // just go out straight from the table
         if (!Details->SwitchValues) {
-          // this is the default, and it has no content. So make the default be the leave
+          // this is the default, and it has no content. So make the default be
+          // the leave
           for (auto& Value : Table) {
-            if (Value == SwitchDefault) Value = SwitchLeave;
+            if (Value == SwitchDefault)
+              Value = SwitchLeave;
           }
           SwitchDefault = SwitchLeave;
         }
       }
       if (Details->SwitchValues) {
         for (auto Value : *Details->SwitchValues) {
-          while (Table.size() <= Value) Table.push_back(SwitchDefault);
+          while (Table.size() <= Value)
+            Table.push_back(SwitchDefault);
           Table[Value] = CurrName;
         }
       }
     }
     // finish up the whole pattern
     Outer->name = SwitchLeave;
-    Inner->list.push_back(Builder.makeSwitch(Table, SwitchDefault, SwitchCondition));
+    Inner->list.push_back(
+      Builder.makeSwitch(Table, SwitchDefault, SwitchCondition));
     Root = Outer;
   }
 
@@ -379,7 +425,6 @@ wasm::Expression* SimpleShape::Render(RelooperBuilder& Builder, bool InLoop) {
   return Ret;
 }
 
-
 // MultipleShape
 
 wasm::Expression* MultipleShape::Render(RelooperBuilder& Builder, bool InLoop) {
@@ -389,10 +434,8 @@ wasm::Expression* MultipleShape::Render(RelooperBuilder& Builder, bool InLoop) {
   wasm::If* CurrIf = nullptr;
   std::vector<wasm::If*> finalizeStack;
   for (auto& iter : InnerMap) {
-    auto* Now = Builder.makeIf(
-      Builder.makeCheckLabel(iter.first),
-      iter.second->Render(Builder, InLoop)
-    );
+    auto* Now = Builder.makeIf(Builder.makeCheckLabel(iter.first),
+                               iter.second->Render(Builder, InLoop));
     finalizeStack.push_back(Now);
     if (!CurrIf) {
       FirstIf = CurrIf = Now;
@@ -418,7 +461,8 @@ wasm::Expression* MultipleShape::Render(RelooperBuilder& Builder, bool InLoop) {
 // LoopShape
 
 wasm::Expression* LoopShape::Render(RelooperBuilder& Builder, bool InLoop) {
-  wasm::Expression* Ret = Builder.makeLoop(Builder.getShapeContinueName(Id), Inner->Render(Builder, true));
+  wasm::Expression* Ret = Builder.makeLoop(Builder.getShapeContinueName(Id),
+                                           Inner->Render(Builder, true));
   Ret = HandleFollowupMultiples(Ret, this, Builder, InLoop);
   if (Next) {
     Ret = Builder.makeSequence(Ret, Next->Render(Builder, InLoop));
@@ -428,14 +472,16 @@ wasm::Expression* LoopShape::Render(RelooperBuilder& Builder, bool InLoop) {
 
 // Relooper
 
-Relooper::Relooper(wasm::Module* ModuleInit) :
-  Module(ModuleInit), Root(nullptr), MinSize(false),
-  BlockIdCounter(1), ShapeIdCounter(0) { // block ID 0 is reserved for clearings
+Relooper::Relooper(wasm::Module* ModuleInit)
+  : Module(ModuleInit), Root(nullptr), MinSize(false), BlockIdCounter(1),
+    ShapeIdCounter(0) { // block ID 0 is reserved for clearings
 }
 
 Relooper::~Relooper() {
-  for (unsigned i = 0; i < Blocks.size(); i++) delete Blocks[i];
-  for (unsigned i = 0; i < Shapes.size(); i++) delete Shapes[i];
+  for (unsigned i = 0; i < Blocks.size(); i++)
+    delete Blocks[i];
+  for (unsigned i = 0; i < Shapes.size(); i++)
+    delete Shapes[i];
 }
 
 void Relooper::AddBlock(Block* New, int Id) {
@@ -462,7 +508,8 @@ struct Liveness : public RelooperRecursor {
     while (ToInvestigate.size() > 0) {
       Block* Curr = ToInvestigate.front();
       ToInvestigate.pop_front();
-      if (contains(Live, Curr)) continue;
+      if (contains(Live, Curr))
+        continue;
       Live.insert(Curr);
       for (auto& iter : Curr->BranchesOut) {
         ToInvestigate.push_back(iter.first);
@@ -475,7 +522,8 @@ typedef std::pair<Branch*, Block*> BranchBlock;
 
 struct Optimizer : public RelooperRecursor {
   Optimizer(Relooper* Parent) : RelooperRecursor(Parent) {
-    // TODO: there are likely some rare but possible O(N^2) cases with this looping
+    // TODO: there are likely some rare but possible O(N^2) cases with this
+    // looping
     bool More = true;
 #if RELOOPER_OPTIMIZER_DEBUG
     std::cout << "pre-optimize\n";
@@ -494,9 +542,9 @@ struct Optimizer : public RelooperRecursor {
       More = MergeEquivalentBranches() || More;
       More = UnSwitch() || More;
       More = MergeConsecutiveBlocks() || More;
-      // TODO: Merge identical blocks. This would avoid taking into account their
-      // position / how they are reached, which means that the merging
-      // may add overhead, so we do it carefully:
+      // TODO: Merge identical blocks. This would avoid taking into account
+      // their position / how they are reached, which means that the merging may
+      // add overhead, so we do it carefully:
       //  * Merging a large-enough block is good for size, and we do it
       //    in we are in MinSize mode, which means we can tolerate slightly
       //    slower throughput.
@@ -541,12 +589,12 @@ struct Optimizer : public RelooperRecursor {
         auto* First = Next;
         auto* Replacement = First;
 #if RELOOPER_OPTIMIZER_DEBUG
-        std::cout << " maybeskip from " << Block->Id << " to next=" << Next->Id << '\n';
+        std::cout << " maybeskip from " << Block->Id << " to next=" << Next->Id
+                  << '\n';
 #endif
         std::unordered_set<decltype(Replacement)> Seen;
         while (1) {
-          if (IsEmpty(Next) &&
-              Next->BranchesOut.size() == 1) {
+          if (IsEmpty(Next) && Next->BranchesOut.size() == 1) {
             auto iter = Next->BranchesOut.begin();
             Block* NextNext = iter->first;
             Branch* NextNextBranch = iter->second;
@@ -554,13 +602,13 @@ struct Optimizer : public RelooperRecursor {
             if (!NextNextBranch->Code) { // TODO: handle extra code too
               // We can skip through!
               Next = Replacement = NextNext;
-              // If we've already seen this, stop - it's an infinite loop of empty
-              // blocks we can skip through.
+              // If we've already seen this, stop - it's an infinite loop of
+              // empty blocks we can skip through.
               if (Seen.count(Replacement)) {
-                // Stop here. Note that if we started from X and ended up with X once
-                // more, then Replacement == First and so lower down we will not
-                // report that we did any work, avoiding an infinite loop due to
-                // always thinking there is more work to do.
+                // Stop here. Note that if we started from X and ended up with X
+                // once more, then Replacement == First and so lower down we
+                // will not report that we did any work, avoiding an infinite
+                // loop due to always thinking there is more work to do.
                 break;
               } else {
                 // Otherwise, keep going.
@@ -573,12 +621,14 @@ struct Optimizer : public RelooperRecursor {
         }
         if (Replacement != First) {
 #if RELOOPER_OPTIMIZER_DEBUG
-          std::cout << "  skip to replacement! " << CurrBlock->Id << " -> " << First->Id << " -> " << Replacement->Id << '\n';
+          std::cout << "  skip to replacement! " << CurrBlock->Id << " -> "
+                    << First->Id << " -> " << Replacement->Id << '\n';
 #endif
           Worked = true;
         }
-        // Add a branch to the target (which may be the unchanged original) in the set of new branches.
-        // If it's a replacement, it may collide, and we need to merge.
+        // Add a branch to the target (which may be the unchanged original) in
+        // the set of new branches. If it's a replacement, it may collide, and
+        // we need to merge.
         if (NewBranchesOut.count(Replacement)) {
 #if RELOOPER_OPTIMIZER_DEBUG
           std::cout << "  merge\n";
@@ -588,7 +638,8 @@ struct Optimizer : public RelooperRecursor {
           NewBranchesOut[Replacement] = NextBranch;
         }
       }
-      CurrBlock->BranchesOut.swap(NewBranchesOut); // FIXME do we leak old unused Branches?
+      // FIXME do we leak old unused Branches?
+      CurrBlock->BranchesOut.swap(NewBranchesOut);
     }
     return Worked;
   }
@@ -603,7 +654,8 @@ struct Optimizer : public RelooperRecursor {
       std::cout << "at parent " << ParentBlock->Id << '\n';
 #endif
       if (ParentBlock->BranchesOut.size() >= 2) {
-        std::unordered_map<wasm::HashType, std::vector<BranchBlock>> HashedBranchesOut;
+        std::unordered_map<wasm::HashType, std::vector<BranchBlock>>
+          HashedBranchesOut;
         std::vector<Block*> BlocksToErase;
         for (auto& iter : ParentBlock->BranchesOut) {
           Block* CurrBlock = iter.first;
@@ -633,7 +685,8 @@ struct Optimizer : public RelooperRecursor {
             }
 #if RELOOPER_OPTIMIZER_DEBUG
             else {
-              std::cout << "    same hash, but not equiv to " << SiblingBlock->Id << '\n';
+              std::cout << "    same hash, but not equiv to "
+                        << SiblingBlock->Id << '\n';
             }
 #endif
           }
@@ -672,9 +725,11 @@ struct Optimizer : public RelooperRecursor {
           wasm::Builder Builder(*Parent->Module);
           // Merge in code on the branch as well, if any.
           if (NextBranch->Code) {
-            CurrBlock->Code = Builder.makeSequence(CurrBlock->Code, NextBranch->Code);
+            CurrBlock->Code =
+              Builder.makeSequence(CurrBlock->Code, NextBranch->Code);
           }
-          CurrBlock->Code = Builder.makeSequence(CurrBlock->Code, NextBlock->Code);
+          CurrBlock->Code =
+            Builder.makeSequence(CurrBlock->Code, NextBlock->Code);
           // Use the next block's branching behavior
           CurrBlock->BranchesOut.swap(NextBlock->BranchesOut);
           NextBlock->BranchesOut.clear();
@@ -694,7 +749,9 @@ struct Optimizer : public RelooperRecursor {
     bool Worked = false;
     for (auto* ParentBlock : Parent->Blocks) {
 #if RELOOPER_OPTIMIZER_DEBUG
-      std::cout << "un-switching at " << ParentBlock->Id << ' ' << !!ParentBlock->SwitchCondition << ' ' << ParentBlock->BranchesOut.size() << '\n';
+      std::cout << "un-switching at " << ParentBlock->Id << ' '
+                << !!ParentBlock->SwitchCondition << ' '
+                << ParentBlock->BranchesOut.size() << '\n';
 #endif
       if (ParentBlock->SwitchCondition) {
         if (ParentBlock->BranchesOut.size() <= 1) {
@@ -761,24 +818,25 @@ private:
         SeenUnreachableType = true;
       }
     };
-    std::function<void (wasm::Block*)> FlattenIntoNewList = [&](wasm::Block* Curr) {
-      assert(!Curr->name.is());
-      for (auto* Item : Curr->list) {
-        if (auto* Block = Item->dynCast<wasm::Block>()) {
-          if (Block->name.is()) {
-            // Leave it whole, it's not a trivial block.
-            Add(Block);
+    std::function<void(wasm::Block*)> FlattenIntoNewList =
+      [&](wasm::Block* Curr) {
+        assert(!Curr->name.is());
+        for (auto* Item : Curr->list) {
+          if (auto* Block = Item->dynCast<wasm::Block>()) {
+            if (Block->name.is()) {
+              // Leave it whole, it's not a trivial block.
+              Add(Block);
+            } else {
+              FlattenIntoNewList(Block);
+            }
           } else {
-            FlattenIntoNewList(Block);
+            // A random item.
+            Add(Item);
           }
-        } else {
-          // A random item.
-          Add(Item);
         }
-      }
-      // All the items have been moved out.
-      Curr->list.clear();
-    };
+        // All the items have been moved out.
+        Curr->list.clear();
+      };
     FlattenIntoNewList(Outer);
     assert(Outer->list.empty());
     Outer->list.swap(NewList);
@@ -831,7 +889,8 @@ private:
       if (!IsPossibleCodeEquivalent(ABranch->Condition, BBranch->Condition)) {
         return false;
       }
-      if (!IsPossibleUniquePtrEquivalent(ABranch->SwitchValues, BBranch->SwitchValues)) {
+      if (!IsPossibleUniquePtrEquivalent(ABranch->SwitchValues,
+                                         BBranch->SwitchValues)) {
         return false;
       }
       if (!IsPossibleCodeEquivalent(ABranch->Code, BBranch->Code)) {
@@ -841,18 +900,25 @@ private:
     return true;
   }
 
-  // Checks if values referred to by pointers are identical, allowing the code to also be nullptr
+  // Checks if values referred to by pointers are identical, allowing the code
+  // to also be nullptr
   template<typename T>
-  static bool IsPossibleUniquePtrEquivalent(std::unique_ptr<T>& A, std::unique_ptr<T>& B) {
-    if (A == B) return true;
-    if (!A || !B) return false;
+  static bool IsPossibleUniquePtrEquivalent(std::unique_ptr<T>& A,
+                                            std::unique_ptr<T>& B) {
+    if (A == B)
+      return true;
+    if (!A || !B)
+      return false;
     return *A == *B;
   }
 
   // Checks if code is equivalent, allowing the code to also be nullptr
-  static bool IsPossibleCodeEquivalent(wasm::Expression* A, wasm::Expression* B) {
-    if (A == B) return true;
-    if (!A || !B) return false;
+  static bool IsPossibleCodeEquivalent(wasm::Expression* A,
+                                       wasm::Expression* B) {
+    if (A == B)
+      return true;
+    if (!A || !B)
+      return false;
     return IsCodeEquivalent(A, B);
   }
 
@@ -873,9 +939,9 @@ private:
         assert(!Into->Condition);
         // Merging into the already-default, nothing to do.
       } else {
-        Into->SwitchValues->insert(
-          Into->SwitchValues->end(),
-          Curr->SwitchValues->begin(), Curr->SwitchValues->end());
+        Into->SwitchValues->insert(Into->SwitchValues->end(),
+                                   Curr->SwitchValues->begin(),
+                                   Curr->SwitchValues->end());
       }
     } else {
       if (!Curr->Condition) {
@@ -888,11 +954,9 @@ private:
       } else {
         assert(!Into->SwitchValues);
         // Merge them, checking both.
-        Into->Condition = wasm::Builder(*Parent->Module).makeBinary(
-          wasm::OrInt32,
-          Into->Condition,
-          Curr->Condition
-        );
+        Into->Condition =
+          wasm::Builder(*Parent->Module)
+            .makeBinary(wasm::OrInt32, Into->Condition, Curr->Condition);
       }
     }
     if (!Curr->Code) {
@@ -919,7 +983,8 @@ private:
     Ret = wasm::rehash(Ret, 2);
     for (auto& Pair : Curr->BranchesOut) {
       // Hash the Block* as a pointer TODO: full hash?
-      Ret = wasm::rehash(Ret, wasm::HashType(reinterpret_cast<size_t>(Pair.first)));
+      Ret =
+        wasm::rehash(Ret, wasm::HashType(reinterpret_cast<size_t>(Pair.first)));
       // Hash the Branch info properly
       Ret = wasm::rehash(Ret, Hash(Pair.second));
     }
@@ -960,7 +1025,8 @@ void Relooper::Calculate(Block* Entry) {
   // Add incoming branches from live blocks, ignoring dead code
   for (unsigned i = 0; i < Blocks.size(); i++) {
     Block* Curr = Blocks[i];
-    if (!contains(Live.Live, Curr)) continue;
+    if (!contains(Live.Live, Curr))
+      continue;
     for (auto& iter : Curr->BranchesOut) {
       iter.first->BranchesIn.insert(Curr);
     }
@@ -977,9 +1043,11 @@ void Relooper::Calculate(Block* Entry) {
       Parent->Shapes.push_back(New);
     }
 
-    // Create a list of entries from a block. If LimitTo is provided, only results in that set
-    // will appear
-    void GetBlocksOut(Block* Source, BlockSet& Entries, BlockSet* LimitTo = nullptr) {
+    // Create a list of entries from a block. If LimitTo is provided, only
+    // results in that set will appear
+    void GetBlocksOut(Block* Source,
+                      BlockSet& Entries,
+                      BlockSet* LimitTo = nullptr) {
       for (auto& iter : Source->BranchesOut) {
         if (!LimitTo || contains(*LimitTo, iter.first)) {
           Entries.insert(iter.first);
@@ -988,10 +1056,14 @@ void Relooper::Calculate(Block* Entry) {
     }
 
     // Converts/processes all branchings to a specific target
-    void Solipsize(Block* Target, Branch::FlowType Type, Shape* Ancestor, BlockSet &From) {
+    void Solipsize(Block* Target,
+                   Branch::FlowType Type,
+                   Shape* Ancestor,
+                   BlockSet& From) {
       PrintDebug("Solipsizing branches into %d\n", Target->Id);
       DebugDump(From, "  relevant to solipsize: ");
-      for (auto iter = Target->BranchesIn.begin(); iter != Target->BranchesIn.end();) {
+      for (auto iter = Target->BranchesIn.begin();
+           iter != Target->BranchesIn.end();) {
         Block* Prior = *iter;
         if (!contains(From, Prior)) {
           iter++;
@@ -1009,7 +1081,7 @@ void Relooper::Calculate(Block* Entry) {
       }
     }
 
-    Shape* MakeSimple(BlockSet &Blocks, Block* Inner, BlockSet &NextEntries) {
+    Shape* MakeSimple(BlockSet& Blocks, Block* Inner, BlockSet& NextEntries) {
       PrintDebug("creating simple block with block #%d\n", Inner->Id);
       SimpleShape* Simple = new SimpleShape;
       Notice(Simple);
@@ -1027,9 +1099,10 @@ void Relooper::Calculate(Block* Entry) {
       return Simple;
     }
 
-    Shape* MakeLoop(BlockSet &Blocks, BlockSet& Entries, BlockSet &NextEntries) {
-      // Find the inner blocks in this loop. Proceed backwards from the entries until
-      // you reach a seen block, collecting as you go.
+    Shape*
+    MakeLoop(BlockSet& Blocks, BlockSet& Entries, BlockSet& NextEntries) {
+      // Find the inner blocks in this loop. Proceed backwards from the entries
+      // until you reach a seen block, collecting as you go.
       BlockSet InnerBlocks;
       BlockSet Queue = Entries;
       while (Queue.size() > 0) {
@@ -1123,12 +1196,14 @@ void Relooper::Calculate(Block* Entry) {
       LoopShape* Loop = new LoopShape();
       Notice(Loop);
 
-      // Solipsize the loop, replacing with break/continue and marking branches as Processed (will not affect later calculations)
-      // A. Branches to the loop entries become a continue to this shape
+      // Solipsize the loop, replacing with break/continue and marking branches
+      // as Processed (will not affect later calculations) A. Branches to the
+      // loop entries become a continue to this shape
       for (auto* Entry : Entries) {
         Solipsize(Entry, Branch::Continue, Loop, InnerBlocks);
       }
-      // B. Branches to outside the loop (a next entry) become breaks on this shape
+      // B. Branches to outside the loop (a next entry) become breaks on this
+      // shape
       for (auto* Next : NextEntries) {
         Solipsize(Next, Branch::Break, Loop, InnerBlocks);
       }
@@ -1139,29 +1214,38 @@ void Relooper::Calculate(Block* Entry) {
       return Loop;
     }
 
-    // For each entry, find the independent group reachable by it. The independent group is
-    // the entry itself, plus all the blocks it can reach that cannot be directly reached by another entry. Note that we
-    // ignore directly reaching the entry itself by another entry.
+    // For each entry, find the independent group reachable by it. The
+    // independent group is the entry itself, plus all the blocks it can reach
+    // that cannot be directly reached by another entry. Note that we ignore
+    // directly reaching the entry itself by another entry.
     //   @param Ignore - previous blocks that are irrelevant
-    void FindIndependentGroups(BlockSet &Entries, BlockBlockSetMap& IndependentGroups, BlockSet* Ignore = nullptr) {
+    void FindIndependentGroups(BlockSet& Entries,
+                               BlockBlockSetMap& IndependentGroups,
+                               BlockSet* Ignore = nullptr) {
       typedef std::map<Block*, Block*> BlockBlockMap;
 
       struct HelperClass {
         BlockBlockSetMap& IndependentGroups;
-        BlockBlockMap Ownership; // For each block, which entry it belongs to. We have reached it from there.
+        // For each block, which entry it belongs to. We have reached it from
+        // there.
+        BlockBlockMap Ownership;
 
-        HelperClass(BlockBlockSetMap& IndependentGroupsInit) : IndependentGroups(IndependentGroupsInit) {}
+        HelperClass(BlockBlockSetMap& IndependentGroupsInit)
+          : IndependentGroups(IndependentGroupsInit) {}
         void InvalidateWithChildren(Block* New) { // TODO: rename New
-          BlockList ToInvalidate; // Being in the list means you need to be invalidated
+          // Being in the list means you need to be invalidated
+          BlockList ToInvalidate;
           ToInvalidate.push_back(New);
           while (ToInvalidate.size() > 0) {
             Block* Invalidatee = ToInvalidate.front();
             ToInvalidate.pop_front();
             Block* Owner = Ownership[Invalidatee];
-            if (contains(IndependentGroups, Owner)) { // Owner may have been invalidated, do not add to IndependentGroups!
+            // Owner may have been invalidated, do not add to IndependentGroups!
+            if (contains(IndependentGroups, Owner)) {
               IndependentGroups[Owner].erase(Invalidatee);
             }
-            if (Ownership[Invalidatee]) { // may have been seen before and invalidated already
+            // may have been seen before and invalidated already
+            if (Ownership[Invalidatee]) {
               Ownership[Invalidatee] = nullptr;
               for (auto& iter : Invalidatee->BranchesOut) {
                 Block* Target = iter.first;
@@ -1180,12 +1264,14 @@ void Relooper::Calculate(Block* Entry) {
       HelperClass Helper(IndependentGroups);
 
       // We flow out from each of the entries, simultaneously.
-      // When we reach a new block, we add it as belonging to the one we got to it from.
-      // If we reach a new block that is already marked as belonging to someone, it is reachable by
-      // two entries and is not valid for any of them. Remove it and all it can reach that have been
-      // visited.
-
-      BlockList Queue; // Being in the queue means we just added this item, and we need to add its children
+      // When we reach a new block, we add it as belonging to the one we got to
+      // it from. If we reach a new block that is already marked as belonging to
+      // someone, it is reachable by two entries and is not valid for any of
+      // them. Remove it and all it can reach that have been visited.
+
+      // Being in the queue means we just added this item, and we need to add
+      // its children
+      BlockList Queue;
       for (auto* Entry : Entries) {
         Helper.Ownership[Entry] = Entry;
         IndependentGroups[Entry].insert(Entry);
@@ -1194,8 +1280,12 @@ void Relooper::Calculate(Block* Entry) {
       while (Queue.size() > 0) {
         Block* Curr = Queue.front();
         Queue.pop_front();
-        Block* Owner = Helper.Ownership[Curr]; // Curr must be in the ownership map if we are in the queue
-        if (!Owner) continue; // we have been invalidated meanwhile after being reached from two entries
+        // Curr must be in the ownership map if we are in the queue
+        Block* Owner = Helper.Ownership[Curr];
+        if (!Owner)
+          // we have been invalidated meanwhile after being reached from two
+          // entries
+          continue;
         // Add all children
         for (auto& iter : Curr->BranchesOut) {
           Block* New = iter.first;
@@ -1208,27 +1298,31 @@ void Relooper::Calculate(Block* Entry) {
             continue;
           }
           Block* NewOwner = Known->second;
-          if (!NewOwner) continue; // We reached an invalidated node
+          if (!NewOwner)
+            continue; // We reached an invalidated node
           if (NewOwner != Owner) {
-            // Invalidate this and all reachable that we have seen - we reached this from two locations
+            // Invalidate this and all reachable that we have seen - we reached
+            // this from two locations
             Helper.InvalidateWithChildren(New);
           }
           // otherwise, we have the same owner, so do nothing
         }
       }
 
-      // Having processed all the interesting blocks, we remain with just one potential issue:
-      // If a->b, and a was invalidated, but then b was later reached by someone else, we must
-      // invalidate b. To check for this, we go over all elements in the independent groups,
-      // if an element has a parent which does *not* have the same owner, we must remove it
-      // and all its children.
+      // Having processed all the interesting blocks, we remain with just one
+      // potential issue: If a->b, and a was invalidated, but then b was later
+      // reached by someone else, we must invalidate b. To check for this, we go
+      // over all elements in the independent groups, if an element has a parent
+      // which does *not* have the same owner, we must remove it and all its
+      // children.
 
       for (auto* Entry : Entries) {
-        BlockSet &CurrGroup = IndependentGroups[Entry];
+        BlockSet& CurrGroup = IndependentGroups[Entry];
         BlockList ToInvalidate;
         for (auto* Child : CurrGroup) {
           for (auto* Parent : Child->BranchesIn) {
-            if (Ignore && contains(*Ignore, Parent)) continue;
+            if (Ignore && contains(*Ignore, Parent))
+              continue;
             if (Helper.Ownership[Parent] != Helper.Ownership[Child]) {
               ToInvalidate.push_back(Child);
             }
@@ -1256,14 +1350,19 @@ void Relooper::Calculate(Block* Entry) {
 #endif
     }
 
-    Shape* MakeMultiple(BlockSet &Blocks, BlockSet& Entries, BlockBlockSetMap& IndependentGroups, BlockSet &NextEntries, bool IsCheckedMultiple) {
-      PrintDebug("creating multiple block with %d inner groups\n", IndependentGroups.size());
+    Shape* MakeMultiple(BlockSet& Blocks,
+                        BlockSet& Entries,
+                        BlockBlockSetMap& IndependentGroups,
+                        BlockSet& NextEntries,
+                        bool IsCheckedMultiple) {
+      PrintDebug("creating multiple block with %d inner groups\n",
+                 IndependentGroups.size());
       MultipleShape* Multiple = new MultipleShape();
       Notice(Multiple);
       BlockSet CurrEntries;
       for (auto& iter : IndependentGroups) {
         Block* CurrEntry = iter.first;
-        BlockSet &CurrBlocks = iter.second;
+        BlockSet& CurrBlocks = iter.second;
         PrintDebug("  multiple group with entry %d:\n", CurrEntry->Id);
         DebugDump(CurrBlocks, "    ");
         // Create inner block
@@ -1273,13 +1372,14 @@ void Relooper::Calculate(Block* Entry) {
           // Remove the block from the remaining blocks
           Blocks.erase(CurrInner);
           // Find new next entries and fix branches to them
-          for (auto iter = CurrInner->BranchesOut.begin(); iter != CurrInner->BranchesOut.end();) {
+          for (auto iter = CurrInner->BranchesOut.begin();
+               iter != CurrInner->BranchesOut.end();) {
             Block* CurrTarget = iter->first;
             auto Next = iter;
             Next++;
             if (!contains(CurrBlocks, CurrTarget)) {
               NextEntries.insert(CurrTarget);
-              Solipsize(CurrTarget, Branch::Break, Multiple, CurrBlocks); 
+              Solipsize(CurrTarget, Branch::Break, Multiple, CurrBlocks);
             }
             iter = Next; // increment carefully because Solipsize can remove us
           }
@@ -1301,10 +1401,12 @@ void Relooper::Calculate(Block* Entry) {
 
     // Main function.
     // Process a set of blocks with specified entries, returns a shape
-    // The Make* functions receive a NextEntries. If they fill it with data, those are the entries for the
-    //   ->Next block on them, and the blocks are what remains in Blocks (which Make* modify). In this way
-    //   we avoid recursing on Next (imagine a long chain of Simples, if we recursed we could blow the stack).
-    Shape* Process(BlockSet &Blocks, BlockSet& InitialEntries) {
+    // The Make* functions receive a NextEntries. If they fill it with data,
+    // those are the entries for the
+    //   ->Next block on them, and the blocks are what remains in Blocks (which
+    //   Make* modify). In this way we avoid recursing on Next (imagine a long
+    //   chain of Simples, if we recursed we could blow the stack).
+    Shape* Process(BlockSet& Blocks, BlockSet& InitialEntries) {
       PrintDebug("Process() called\n", 0);
       BlockSet* Entries = &InitialEntries;
       BlockSet TempEntries[2];
@@ -1312,24 +1414,30 @@ void Relooper::Calculate(Block* Entry) {
       BlockSet* NextEntries;
       Shape* Ret = nullptr;
       Shape* Prev = nullptr;
-      #define Make(call) \
-        Shape* Temp = call; \
-        if (Prev) Prev->Next = Temp; \
-        if (!Ret) Ret = Temp; \
-        if (!NextEntries->size()) { PrintDebug("Process() returning\n", 0); return Ret; } \
-        Prev = Temp; \
-        Entries = NextEntries; \
-        continue;
+#define Make(call)                                                             \
+  Shape* Temp = call;                                                          \
+  if (Prev)                                                                    \
+    Prev->Next = Temp;                                                         \
+  if (!Ret)                                                                    \
+    Ret = Temp;                                                                \
+  if (!NextEntries->size()) {                                                  \
+    PrintDebug("Process() returning\n", 0);                                    \
+    return Ret;                                                                \
+  }                                                                            \
+  Prev = Temp;                                                                 \
+  Entries = NextEntries;                                                       \
+  continue;
       while (1) {
         PrintDebug("Process() running\n", 0);
         DebugDump(Blocks, "  blocks : ");
         DebugDump(*Entries, "  entries: ");
 
-        CurrTempIndex = 1-CurrTempIndex;
+        CurrTempIndex = 1 - CurrTempIndex;
         NextEntries = &TempEntries[CurrTempIndex];
         NextEntries->clear();
 
-        if (Entries->size() == 0) return Ret;
+        if (Entries->size() == 0)
+          return Ret;
         if (Entries->size() == 1) {
           Block* Curr = *(Entries->begin());
           if (Curr->BranchesIn.size() == 0) {
@@ -1341,41 +1449,53 @@ void Relooper::Calculate(Block* Entry) {
         }
 
         // More than one entry, try to eliminate through a Multiple groups of
-        // independent blocks from an entry/ies. It is important to remove through
-        // multiples as opposed to looping since the former is more performant.
+        // independent blocks from an entry/ies. It is important to remove
+        // through multiples as opposed to looping since the former is more
+        // performant.
         BlockBlockSetMap IndependentGroups;
         FindIndependentGroups(*Entries, IndependentGroups);
 
         PrintDebug("Independent groups: %d\n", IndependentGroups.size());
 
         if (IndependentGroups.size() > 0) {
-          // We can handle a group in a multiple if its entry cannot be reached by another group.
-          // Note that it might be reachable by itself - a loop. But that is fine, we will create
-          // a loop inside the multiple block, which is both the performant order to do it, and
-          // preserves the property that a loop will always reach an entry.
-          for (auto iter = IndependentGroups.begin(); iter != IndependentGroups.end();) {
+          // We can handle a group in a multiple if its entry cannot be reached
+          // by another group. Note that it might be reachable by itself - a
+          // loop. But that is fine, we will create a loop inside the multiple
+          // block, which is both the performant order to do it, and preserves
+          // the property that a loop will always reach an entry.
+          for (auto iter = IndependentGroups.begin();
+               iter != IndependentGroups.end();) {
             Block* Entry = iter->first;
-            BlockSet &Group = iter->second;
+            BlockSet& Group = iter->second;
             auto curr = iter++; // iterate carefully, we may delete
-            for (auto iterBranch = Entry->BranchesIn.begin(); iterBranch != Entry->BranchesIn.end(); iterBranch++) {
+            for (auto iterBranch = Entry->BranchesIn.begin();
+                 iterBranch != Entry->BranchesIn.end();
+                 iterBranch++) {
               Block* Origin = *iterBranch;
               if (!contains(Group, Origin)) {
                 // Reached from outside the group, so we cannot handle this
-                PrintDebug("Cannot handle group with entry %d because of incoming branch from %d\n", Entry->Id, Origin->Id);
+                PrintDebug("Cannot handle group with entry %d because of "
+                           "incoming branch from %d\n",
+                           Entry->Id,
+                           Origin->Id);
                 IndependentGroups.erase(curr);
                 break;
               }
             }
           }
 
-          // As an optimization, if we have 2 independent groups, and one is a small dead end, we can handle only that dead end.
-          // The other then becomes a Next - without nesting in the code and recursion in the analysis.
+          // As an optimization, if we have 2 independent groups, and one is a
+          // small dead end, we can handle only that dead end. The other then
+          // becomes a Next - without nesting in the code and recursion in the
+          // analysis.
           // TODO: if the larger is the only dead end, handle that too
           // TODO: handle >2 groups
-          // TODO: handle not just dead ends, but also that do not branch to the NextEntries. However, must be careful
-          //       there since we create a Next, and that Next can prevent eliminating a break (since we no longer
-          //       naturally reach the same place), which may necessitate a one-time loop, which makes the unnesting
-          //       pointless.
+          // TODO: handle not just dead ends, but also that do not branch to the
+          //       NextEntries. However, must be careful
+          //       there since we create a Next, and that Next can prevent
+          //       eliminating a break (since we no longer naturally reach the
+          //       same place), which may necessitate a one-time loop, which
+          //       makes the unnesting pointless.
           if (IndependentGroups.size() == 2) {
             // Find the smaller one
             auto iter = IndependentGroups.begin();
@@ -1384,15 +1504,19 @@ void Relooper::Calculate(Block* Entry) {
             iter++;
             Block* LargeEntry = iter->first;
             int LargeSize = iter->second.size();
-            if (SmallSize != LargeSize) { // ignore the case where they are identical - keep things symmetrical there
+            // ignore the case where they are identical - keep things
+            // symmetrical there
+            if (SmallSize != LargeSize) {
               if (SmallSize > LargeSize) {
                 Block* Temp = SmallEntry;
                 SmallEntry = LargeEntry;
-                LargeEntry = Temp; // Note: we did not flip the Sizes too, they are now invalid. TODO: use the smaller size as a limit?
+                // Note: we did not flip the Sizes too, they are now invalid.
+                // TODO: use the smaller size as a limit?
+                LargeEntry = Temp;
               }
               // Check if dead end
               bool DeadEnd = true;
-              BlockSet &SmallGroup = IndependentGroups[SmallEntry];
+              BlockSet& SmallGroup = IndependentGroups[SmallEntry];
               for (auto* Curr : SmallGroup) {
                 for (auto& iter : Curr->BranchesOut) {
                   Block* Target = iter.first;
@@ -1401,23 +1525,28 @@ void Relooper::Calculate(Block* Entry) {
                     break;
                   }
                 }
-                if (!DeadEnd) break;
+                if (!DeadEnd)
+                  break;
               }
               if (DeadEnd) {
-                PrintDebug("Removing nesting by not handling large group because small group is dead end\n", 0);
+                PrintDebug("Removing nesting by not handling large group "
+                           "because small group is dead end\n",
+                           0);
                 IndependentGroups.erase(LargeEntry);
               }
             }
           }
 
-          PrintDebug("Handleable independent groups: %d\n", IndependentGroups.size());
+          PrintDebug("Handleable independent groups: %d\n",
+                     IndependentGroups.size());
 
           if (IndependentGroups.size() > 0) {
             // Some groups removable ==> Multiple
-            // This is a checked multiple if it has an entry that is an entry to this Process call, that is,
-            // if we can reach it from outside this set of blocks, then we must check the label variable
-            // to do so. Otherwise, if it is just internal blocks, those can always be jumped to forward,
-            // without using the label variable
+            // This is a checked multiple if it has an entry that is an entry to
+            // this Process call, that is, if we can reach it from outside this
+            // set of blocks, then we must check the label variable to do so.
+            // Otherwise, if it is just internal blocks, those can always be
+            // jumped to forward, without using the label variable
             bool Checked = false;
             for (auto* Entry : *Entries) {
               if (InitialEntries.count(Entry)) {
@@ -1425,7 +1554,8 @@ void Relooper::Calculate(Block* Entry) {
                 break;
               }
             }
-            Make(MakeMultiple(Blocks, *Entries, IndependentGroups, *NextEntries, Checked));
+            Make(MakeMultiple(
+              Blocks, *Entries, IndependentGroups, *NextEntries, Checked));
           }
         }
         // No independent groups, must be loopable ==> Loop
@@ -1461,10 +1591,13 @@ wasm::Expression* Relooper::Render(RelooperBuilder& Builder) {
 #ifdef RELOOPER_DEBUG
 // Debugging
 
-void Debugging::Dump(Block* Curr, const char *prefix) {
-  if (prefix) std::cout << prefix << ": ";
-  std::cout << Curr->Id << " [code " << *Curr->Code << "] [switch? " << !!Curr->SwitchCondition << "]\n";
-  for (auto iter2 = Curr->BranchesOut.begin(); iter2 != Curr->BranchesOut.end(); iter2++) {
+void Debugging::Dump(Block* Curr, const char* prefix) {
+  if (prefix)
+    std::cout << prefix << ": ";
+  std::cout << Curr->Id << " [code " << *Curr->Code << "] [switch? "
+            << !!Curr->SwitchCondition << "]\n";
+  for (auto iter2 = Curr->BranchesOut.begin(); iter2 != Curr->BranchesOut.end();
+       iter2++) {
     Block* Other = iter2->first;
     Branch* Br = iter2->second;
     std::cout << "  -> " << Other->Id << ' ';
@@ -1479,21 +1612,24 @@ void Debugging::Dump(Block* Curr, const char *prefix) {
     } else {
       std::cout << "[default] ";
     }
-    if (Br->Code) std::cout << "[phi " << *Br->Code << "] ";
+    if (Br->Code)
+      std::cout << "[phi " << *Br->Code << "] ";
     std::cout << '\n';
   }
   std::cout << '\n';
 }
 
-void Debugging::Dump(BlockSet &Blocks, const char *prefix) {
-  if (prefix) std::cout << prefix << ": ";
+void Debugging::Dump(BlockSet& Blocks, const char* prefix) {
+  if (prefix)
+    std::cout << prefix << ": ";
   for (auto* Curr : Blocks) {
     Dump(Curr);
   }
 }
 
-void Debugging::Dump(Shape* S, const char *prefix) {
-  if (prefix) std::cout << prefix << ": ";
+void Debugging::Dump(Shape* S, const char* prefix) {
+  if (prefix)
+    std::cout << prefix << ": ";
   if (!S) {
     printf(" (null)\n");
     return;
@@ -1513,7 +1649,7 @@ void Debugging::Dump(Shape* S, const char *prefix) {
   }
 }
 
-static void PrintDebug(const char *Format, ...) {
+static void PrintDebug(const char* Format, ...) {
   printf("// ");
   va_list Args;
   va_start(Args, Format);
diff --git a/src/cfg/Relooper.h b/src/cfg/Relooper.h
index 5773721cd..c38cb56b3 100644
--- a/src/cfg/Relooper.h
+++ b/src/cfg/Relooper.h
@@ -19,12 +19,16 @@ This is an optimized C++ implemention of the Relooper algorithm originally
 developed as part of Emscripten. This implementation includes optimizations
 added since the original academic paper [1] was published about it.
 
-[1] Alon Zakai. 2011. Emscripten: an LLVM-to-JavaScript compiler. In Proceedings of the ACM international conference companion on Object oriented programming systems languages and applications companion (SPLASH '11). ACM, New York, NY, USA, 301-312. DOI=10.1145/2048147.2048224 http://doi.acm.org/10.1145/2048147.2048224
+[1] Alon Zakai. 2011. Emscripten: an LLVM-to-JavaScript compiler. In Proceedings
+of the ACM international conference companion on Object oriented programming
+systems languages and applications companion (SPLASH '11). ACM, New York, NY,
+USA, 301-312. DOI=10.1145/2048147.2048224
+http://doi.acm.org/10.1145/2048147.2048224
 */
 
 #include <assert.h>
-#include <stdio.h>
 #include <stdarg.h>
+#include <stdio.h>
 #include <stdlib.h>
 
 #include <deque>
@@ -33,8 +37,8 @@ added since the original academic paper [1] was published about it.
 #include <memory>
 #include <set>
 
-#include "wasm.h"
 #include "wasm-builder.h"
+#include "wasm.h"
 
 namespace CFG {
 
@@ -42,7 +46,8 @@ class RelooperBuilder : public wasm::Builder {
   wasm::Index labelHelper;
 
 public:
-  RelooperBuilder(wasm::Module& wasm, wasm::Index labelHelper) : wasm::Builder(wasm), labelHelper(labelHelper) {}
+  RelooperBuilder(wasm::Module& wasm, wasm::Index labelHelper)
+    : wasm::Builder(wasm), labelHelper(labelHelper) {}
 
   wasm::GetLocal* makeGetLabel() {
     return makeGetLocal(labelHelper, wasm::i32);
@@ -51,15 +56,17 @@ public:
     return makeSetLocal(labelHelper, makeConst(wasm::Literal(int32_t(value))));
   }
   wasm::Binary* makeCheckLabel(wasm::Index value) {
-    return makeBinary(wasm::EqInt32, makeGetLabel(), makeConst(wasm::Literal(int32_t(value))));
+    return makeBinary(
+      wasm::EqInt32, makeGetLabel(), makeConst(wasm::Literal(int32_t(value))));
   }
 
-  // breaks are on blocks, as they can be specific, we make one wasm block per basic block
+  // breaks are on blocks, as they can be specific, we make one wasm block per
+  // basic block
   wasm::Break* makeBlockBreak(int id) {
     return wasm::Builder::makeBreak(getBlockBreakName(id));
   }
-  // continues are on shapes, as there is one per loop, and if we have more than one
-  // going there, it is irreducible control flow anyhow
+  // continues are on shapes, as there is one per loop, and if we have more than
+  // one going there, it is irreducible control flow anyhow
   wasm::Break* makeShapeContinue(int id) {
     return wasm::Builder::makeBreak(getShapeContinueName(id));
   }
@@ -78,42 +85,49 @@ struct Shape;
 // Info about a branching from one block to another
 struct Branch {
   enum FlowType {
-    Direct = 0,   // We will directly reach the right location through other means, no need for continue or break
+    Direct = 0, // We will directly reach the right location through other
+                // means, no need for continue or break
     Break = 1,
     Continue = 2
   };
-  Shape* Ancestor = nullptr; // If not NULL, this shape is the relevant one for purposes of getting to the target block. We break or continue on it
-  Branch::FlowType Type; // If Ancestor is not NULL, this says whether to break or continue
-
-  // A branch either has a condition expression if the block ends in ifs, or if the block ends in a switch, then a list of indexes, which
-  // becomes the indexes in the table of the switch. If not a switch, the condition can be any expression (or nullptr for the
-  // branch taken when no other condition is true)
-  // A condition must not have side effects, as the Relooper can reorder or eliminate condition checking.
-  // This must not have side effects.
+  // If not NULL, this shape is the relevant one for purposes of getting to the
+  // target block. We break or continue on it
+  Shape* Ancestor = nullptr;
+  // If Ancestor is not NULL, this says whether to break or continue
+  Branch::FlowType Type;
+
+  // A branch either has a condition expression if the block ends in ifs, or if
+  // the block ends in a switch, then a list of indexes, which becomes the
+  // indexes in the table of the switch. If not a switch, the condition can be
+  // any expression (or nullptr for the branch taken when no other condition is
+  // true) A condition must not have side effects, as the Relooper can reorder
+  // or eliminate condition checking. This must not have side effects.
   wasm::Expression* Condition;
-  // Switches are rare, so have just a pointer for their values. This contains the values
-  // for which the branch will be taken, or for the default it is simply not present.
+  // Switches are rare, so have just a pointer for their values. This contains
+  // the values for which the branch will be taken, or for the default it is
+  // simply not present.
   std::unique_ptr<std::vector<wasm::Index>> SwitchValues;
 
-  // If provided, code that is run right before the branch is taken. This is useful for phis.
+  // If provided, code that is run right before the branch is taken. This is
+  // useful for phis.
   wasm::Expression* Code;
 
   Branch(wasm::Expression* ConditionInit, wasm::Expression* CodeInit = nullptr);
 
-  Branch(std::vector<wasm::Index>&& ValuesInit, wasm::Expression* CodeInit = nullptr);
+  Branch(std::vector<wasm::Index>&& ValuesInit,
+         wasm::Expression* CodeInit = nullptr);
 
   // Emits code for branch
-  wasm::Expression* Render(RelooperBuilder& Builder, Block* Target, bool SetLabel);
+  wasm::Expression*
+  Render(RelooperBuilder& Builder, Block* Target, bool SetLabel);
 };
 
 // like std::set, except that begin() -> end() iterates in the
 // order that elements were added to the set (not in the order
 // of operator<(T, T))
-template<typename T>
-struct InsertOrderedSet
-{
-  std::map<T, typename std::list<T>::iterator>  Map;
-  std::list<T>                                  List;
+template<typename T> struct InsertOrderedSet {
+  std::map<T, typename std::list<T>::iterator> Map;
+  std::list<T> List;
 
   typedef typename std::list<T>::iterator iterator;
   iterator begin() { return List.begin(); }
@@ -152,9 +166,7 @@ struct InsertOrderedSet
   size_t count(const T& val) const { return Map.count(val); }
 
   InsertOrderedSet() = default;
-  InsertOrderedSet(const InsertOrderedSet& other) {
-    *this = other;
-  }
+  InsertOrderedSet(const InsertOrderedSet& other) { *this = other; }
   InsertOrderedSet& operator=(const InsertOrderedSet& other) {
     clear();
     for (auto i : other.List) {
@@ -167,11 +179,9 @@ struct InsertOrderedSet
 // like std::map, except that begin() -> end() iterates in the
 // order that elements were added to the map (not in the order
 // of operator<(Key, Key))
-template<typename Key, typename T>
-struct InsertOrderedMap
-{
-  std::map<Key, typename std::list<std::pair<Key,T>>::iterator> Map;
-  std::list<std::pair<Key,T>>                                   List;
+template<typename Key, typename T> struct InsertOrderedMap {
+  std::map<Key, typename std::list<std::pair<Key, T>>::iterator> Map;
+  std::list<std::pair<Key, T>> List;
 
   T& operator[](const Key& k) {
     auto it = Map.find(k);
@@ -184,7 +194,7 @@ struct InsertOrderedMap
     return it->second->second;
   }
 
-  typedef typename std::list<std::pair<Key,T>>::iterator iterator;
+  typedef typename std::list<std::pair<Key, T>>::iterator iterator;
   iterator begin() { return List.begin(); }
   iterator end() { return List.end(); }
 
@@ -196,9 +206,7 @@ struct InsertOrderedMap
     }
   }
 
-  void erase(iterator position) {
-    erase(position->first);
-  }
+  void erase(iterator position) { erase(position->first); }
 
   void clear() {
     Map.clear();
@@ -224,50 +232,61 @@ struct InsertOrderedMap
   bool operator==(const InsertOrderedMap& other) {
     return Map == other.Map && List == other.List;
   }
-  bool operator!=(const InsertOrderedMap& other) {
-    return !(*this == other);
-  }
+  bool operator!=(const InsertOrderedMap& other) { return !(*this == other); }
 };
 
-
 typedef InsertOrderedSet<Block*> BlockSet;
 typedef InsertOrderedMap<Block*, Branch*> BlockBranchMap;
 
 // Represents a basic block of code - some instructions that end with a
 // control flow modifier (a branch, return or throw).
 struct Block {
-  // Branches become processed after we finish the shape relevant to them. For example,
-  // when we recreate a loop, branches to the loop start become continues and are now
-  // processed. When we calculate what shape to generate from a set of blocks, we ignore
-  // processed branches.
-  // Blocks own the Branch objects they use, and destroy them when done.
+  // Branches become processed after we finish the shape relevant to them. For
+  // example, when we recreate a loop, branches to the loop start become
+  // continues and are now processed. When we calculate what shape to generate
+  // from a set of blocks, we ignore processed branches. Blocks own the Branch
+  // objects they use, and destroy them when done.
   BlockBranchMap BranchesOut;
   BlockSet BranchesIn;
   BlockBranchMap ProcessedBranchesOut;
   BlockSet ProcessedBranchesIn;
   Shape* Parent = nullptr; // The shape we are directly inside
   int Id = -1; // A unique identifier, defined when added to relooper
-  wasm::Expression* Code; // The code in this block. This can be arbitrary wasm code, including internal control flow, it should just not branch to the outside
-  wasm::Expression* SwitchCondition; // If nullptr, then this block ends in ifs (or nothing). otherwise, this block ends in a switch, done on this condition
-  bool IsCheckedMultipleEntry; // If true, we are a multiple entry, so reaching us requires setting the label variable
-
-  Block(wasm::Expression* CodeInit, wasm::Expression* SwitchConditionInit = nullptr);
+  // The code in this block. This can be arbitrary wasm code, including internal
+  // control flow, it should just not branch to the outside
+  wasm::Expression* Code;
+  // If nullptr, then this block ends in ifs (or nothing). otherwise, this block
+  // ends in a switch, done on this condition
+  wasm::Expression* SwitchCondition;
+  // If true, we are a multiple entry, so reaching us requires setting the label
+  // variable
+  bool IsCheckedMultipleEntry;
+
+  Block(wasm::Expression* CodeInit,
+        wasm::Expression* SwitchConditionInit = nullptr);
   ~Block();
 
-  // Add a branch: if the condition holds we branch (or if null, we branch if all others failed)
-  // Note that there can be only one branch from A to B (if you need multiple conditions for the branch,
-  // create a more interesting expression in the Condition).
-  // If a Block has no outgoing branches, the contents in Code must contain a terminating
-  // instruction, as the relooper doesn't know whether you want control flow to stop with
-  // an `unreachable` or a `return` or something else (if you forget to do this, control
-  // flow may continue into the block that happens to be emitted right after it).
-  // Internally, adding a branch only adds the outgoing branch. The matching incoming branch
-  // on the target is added by the Relooper itself as it works.
-  void AddBranchTo(Block* Target, wasm::Expression* Condition, wasm::Expression* Code = nullptr);
-
-  // Add a switch branch: if the switch condition is one of these values, we branch (or if the list is empty, we are the default)
-  // Note that there can be only one branch from A to B (if you need multiple values for the branch, that's what the array and default are for).
-  void AddSwitchBranchTo(Block* Target, std::vector<wasm::Index>&& Values, wasm::Expression* Code = nullptr);
+  // Add a branch: if the condition holds we branch (or if null, we branch if
+  // all others failed) Note that there can be only one branch from A to B (if
+  // you need multiple conditions for the branch, create a more interesting
+  // expression in the Condition). If a Block has no outgoing branches, the
+  // contents in Code must contain a terminating instruction, as the relooper
+  // doesn't know whether you want control flow to stop with an `unreachable` or
+  // a `return` or something else (if you forget to do this, control flow may
+  // continue into the block that happens to be emitted right after it).
+  // Internally, adding a branch only adds the outgoing branch. The matching
+  // incoming branch on the target is added by the Relooper itself as it works.
+  void AddBranchTo(Block* Target,
+                   wasm::Expression* Condition,
+                   wasm::Expression* Code = nullptr);
+
+  // Add a switch branch: if the switch condition is one of these values, we
+  // branch (or if the list is empty, we are the default) Note that there can be
+  // only one branch from A to B (if you need multiple values for the branch,
+  // that's what the array and default are for).
+  void AddSwitchBranchTo(Block* Target,
+                         std::vector<wasm::Index>&& Values,
+                         wasm::Expression* Code = nullptr);
 
   // Emit code for the block, including its contents and branchings out
   wasm::Expression* Render(RelooperBuilder& Builder, bool InLoop);
@@ -296,15 +315,16 @@ struct MultipleShape;
 struct LoopShape;
 
 struct Shape {
-  int Id = -1; // A unique identifier. Used to identify loops, labels are Lx where x is the Id. Defined when added to relooper
-  Shape* Next = nullptr; // The shape that will appear in the code right after this one
-  Shape* Natural; // The shape that control flow gets to naturally (if there is Next, then this is Next)
-
-  enum ShapeType {
-    Simple,
-    Multiple,
-    Loop
-  };
+  // A unique identifier. Used to identify loops, labels are Lx where x is the
+  // Id. Defined when added to relooper
+  int Id = -1;
+  // The shape that will appear in the code right after this one
+  Shape* Next = nullptr;
+  // The shape that control flow gets to naturally (if there is Next, then this
+  // is Next)
+  Shape* Natural;
+
+  enum ShapeType { Simple, Multiple, Loop };
   ShapeType Type;
 
   Shape(ShapeType TypeInit) : Type(TypeInit) {}
@@ -312,9 +332,15 @@ struct Shape {
 
   virtual wasm::Expression* Render(RelooperBuilder& Builder, bool InLoop) = 0;
 
-  static SimpleShape* IsSimple(Shape* It) { return It && It->Type == Simple ? (SimpleShape*)It : NULL; }
-  static MultipleShape* IsMultiple(Shape* It) { return It && It->Type == Multiple ? (MultipleShape*)It : NULL; }
-  static LoopShape* IsLoop(Shape* It) { return It && It->Type == Loop ? (LoopShape*)It : NULL; }
+  static SimpleShape* IsSimple(Shape* It) {
+    return It && It->Type == Simple ? (SimpleShape*)It : NULL;
+  }
+  static MultipleShape* IsMultiple(Shape* It) {
+    return It && It->Type == Multiple ? (MultipleShape*)It : NULL;
+  }
+  static LoopShape* IsLoop(Shape* It) {
+    return It && It->Type == Loop ? (LoopShape*)It : NULL;
+  }
 };
 
 struct SimpleShape : public Shape {
@@ -366,7 +392,7 @@ struct Relooper {
   Relooper(wasm::Module* ModuleInit);
   ~Relooper();
 
-  void AddBlock(Block* New, int Id=-1);
+  void AddBlock(Block* New, int Id = -1);
 
   // Calculates the shapes
   void Calculate(Block* Entry);
@@ -382,9 +408,9 @@ typedef InsertOrderedMap<Block*, BlockSet> BlockBlockSetMap;
 
 #ifdef RELOOPER_DEBUG
 struct Debugging {
-  static void Dump(Block* Curr, const char *prefix=NULL);
-  static void Dump(BlockSet &Blocks, const char *prefix=NULL);
-  static void Dump(Shape* S, const char *prefix=NULL);
+  static void Dump(Block* Curr, const char* prefix = NULL);
+  static void Dump(BlockSet& Blocks, const char* prefix = NULL);
+  static void Dump(Shape* S, const char* prefix = NULL);
 };
 #endif
 
diff --git a/src/cfg/cfg-traversal.h b/src/cfg/cfg-traversal.h
index 73463eaa3..abaf63c5b 100644
--- a/src/cfg/cfg-traversal.h
+++ b/src/cfg/cfg-traversal.h
@@ -30,8 +30,8 @@
 #ifndef cfg_traversal_h
 #define cfg_traversal_h
 
-#include "wasm.h"
 #include "wasm-traversal.h"
+#include "wasm.h"
 
 namespace wasm {
 
@@ -47,21 +47,23 @@ struct CFGWalker : public ControlFlowWalker<SubType, VisitorType> {
 
   BasicBlock* entry; // the entry block
 
-  BasicBlock* makeBasicBlock() { // override this with code to create a BasicBlock if necessary
-    return new BasicBlock();
-  }
+  // override this with code to create a BasicBlock if necessary
+  BasicBlock* makeBasicBlock() { return new BasicBlock(); }
 
   // internal details
 
   std::vector<std::unique_ptr<BasicBlock>> basicBlocks; // all the blocks
-  std::vector<BasicBlock*> loopTops; // blocks that are the tops of loops, i.e., have backedges to them
+  // blocks that are the tops of loops, i.e., have backedges to them
+  std::vector<BasicBlock*> loopTops;
 
   // traversal state
-  BasicBlock* currBasicBlock; // the current block in play during traversal. can be nullptr if unreachable,
-                              // but note that we don't do a deep unreachability analysis - just enough
-                              // to avoid constructing obviously-unreachable blocks (we do a full reachability
-                              // analysis on the CFG once it is constructed).
-  std::map<Expression*, std::vector<BasicBlock*>> branches; // a block or loop => its branches
+  // the current block in play during traversal. can be nullptr if unreachable,
+  // but note that we don't do a deep unreachability analysis - just enough to
+  // avoid constructing obviously-unreachable blocks (we do a full reachability
+  // analysis on the CFG once it is constructed).
+  BasicBlock* currBasicBlock;
+  // a block or loop => its branches
+  std::map<Expression*, std::vector<BasicBlock*>> branches;
   std::vector<BasicBlock*> ifStack;
   std::vector<BasicBlock*> loopStack;
 
@@ -70,27 +72,29 @@ struct CFGWalker : public ControlFlowWalker<SubType, VisitorType> {
     basicBlocks.push_back(std::unique_ptr<BasicBlock>(currBasicBlock));
   }
 
-  void startUnreachableBlock() {
-    currBasicBlock = nullptr;
-  }
+  void startUnreachableBlock() { currBasicBlock = nullptr; }
 
   static void doStartUnreachableBlock(SubType* self, Expression** currp) {
     self->startUnreachableBlock();
   }
 
   void link(BasicBlock* from, BasicBlock* to) {
-    if (!from || !to) return; // if one of them is not reachable, ignore
+    if (!from || !to)
+      return; // if one of them is not reachable, ignore
     from->out.push_back(to);
     to->in.push_back(from);
   }
 
   static void doEndBlock(SubType* self, Expression** currp) {
     auto* curr = (*currp)->cast<Block>();
-    if (!curr->name.is()) return;
+    if (!curr->name.is())
+      return;
     auto iter = self->branches.find(curr);
-    if (iter == self->branches.end()) return;
+    if (iter == self->branches.end())
+      return;
     auto& origins = iter->second;
-    if (origins.size() == 0) return;
+    if (origins.size() == 0)
+      return;
     // we have branches to here, so we need a new block
     auto* last = self->currBasicBlock;
     self->startBasicBlock();
@@ -106,19 +110,22 @@ struct CFGWalker : public ControlFlowWalker<SubType, VisitorType> {
     auto* last = self->currBasicBlock;
     self->startBasicBlock();
     self->link(last, self->currBasicBlock); // ifTrue
-    self->ifStack.push_back(last); // the block before the ifTrue
+    self->ifStack.push_back(last);          // the block before the ifTrue
   }
 
   static void doStartIfFalse(SubType* self, Expression** currp) {
     self->ifStack.push_back(self->currBasicBlock); // the ifTrue fallthrough
     self->startBasicBlock();
-    self->link(self->ifStack[self->ifStack.size() - 2], self->currBasicBlock); // before if -> ifFalse
+    self->link(self->ifStack[self->ifStack.size() - 2],
+               self->currBasicBlock); // before if -> ifFalse
   }
 
   static void doEndIf(SubType* self, Expression** currp) {
     auto* last = self->currBasicBlock;
     self->startBasicBlock();
-    self->link(last, self->currBasicBlock); // last one is ifFalse's fallthrough if there was one, otherwise it's the ifTrue fallthrough
+    // last one is ifFalse's fallthrough if there was one, otherwise it's the
+    // ifTrue fallthrough
+    self->link(last, self->currBasicBlock);
     if ((*currp)->cast<If>()->ifFalse) {
       // we just linked ifFalse, need to link ifTrue to the end
       self->link(self->ifStack.back(), self->currBasicBlock);
@@ -133,7 +140,8 @@ struct CFGWalker : public ControlFlowWalker<SubType, VisitorType> {
   static void doStartLoop(SubType* self, Expression** currp) {
     auto* last = self->currBasicBlock;
     self->startBasicBlock();
-    self->loopTops.push_back(self->currBasicBlock); // a loop with no backedges would still be counted here, but oh well
+    // a loop with no backedges would still be counted here, but oh well
+    self->loopTops.push_back(self->currBasicBlock);
     self->link(last, self->currBasicBlock);
     self->loopStack.push_back(self->currBasicBlock);
   }
@@ -157,7 +165,8 @@ struct CFGWalker : public ControlFlowWalker<SubType, VisitorType> {
 
   static void doEndBreak(SubType* self, Expression** currp) {
     auto* curr = (*currp)->cast<Break>();
-    self->branches[self->findBreakTarget(curr->name)].push_back(self->currBasicBlock); // branch to the target
+    self->branches[self->findBreakTarget(curr->name)].push_back(
+      self->currBasicBlock); // branch to the target
     if (curr->condition) {
       auto* last = self->currBasicBlock;
       self->startBasicBlock();
@@ -169,15 +178,18 @@ struct CFGWalker : public ControlFlowWalker<SubType, VisitorType> {
 
   static void doEndSwitch(SubType* self, Expression** currp) {
     auto* curr = (*currp)->cast<Switch>();
-    std::set<Name> seen; // we might see the same label more than once; do not spam branches
+    // we might see the same label more than once; do not spam branches
+    std::set<Name> seen;
     for (Name target : curr->targets) {
       if (!seen.count(target)) {
-        self->branches[self->findBreakTarget(target)].push_back(self->currBasicBlock); // branch to the target
+        self->branches[self->findBreakTarget(target)].push_back(
+          self->currBasicBlock); // branch to the target
         seen.insert(target);
       }
     }
     if (!seen.count(curr->default_)) {
-      self->branches[self->findBreakTarget(curr->default_)].push_back(self->currBasicBlock); // branch to the target
+      self->branches[self->findBreakTarget(curr->default_)].push_back(
+        self->currBasicBlock); // branch to the target
     }
     self->startUnreachableBlock();
   }
@@ -258,7 +270,8 @@ struct CFGWalker : public ControlFlowWalker<SubType, VisitorType> {
       queue.erase(iter);
       alive.insert(curr);
       for (auto* out : curr->out) {
-        if (!alive.count(out)) queue.insert(out);
+        if (!alive.count(out))
+          queue.insert(out);
       }
     }
     return alive;
@@ -271,21 +284,29 @@ struct CFGWalker : public ControlFlowWalker<SubType, VisitorType> {
         block->out.clear();
         continue;
       }
-      block->in.erase(std::remove_if(block->in.begin(), block->in.end(), [&alive](BasicBlock* other) {
-        return !alive.count(other);
-      }), block->in.end());
-      block->out.erase(std::remove_if(block->out.begin(), block->out.end(), [&alive](BasicBlock* other) {
-        return !alive.count(other);
-      }), block->out.end());
+      block->in.erase(std::remove_if(block->in.begin(),
+                                     block->in.end(),
+                                     [&alive](BasicBlock* other) {
+                                       return !alive.count(other);
+                                     }),
+                      block->in.end());
+      block->out.erase(std::remove_if(block->out.begin(),
+                                      block->out.end(),
+                                      [&alive](BasicBlock* other) {
+                                        return !alive.count(other);
+                                      }),
+                       block->out.end());
     }
   }
 
-  // TODO: utility method for optimizing cfg, removing empty blocks depending on their .content
+  // TODO: utility method for optimizing cfg, removing empty blocks depending on
+  // their .content
 
   std::map<BasicBlock*, size_t> debugIds;
 
   void generateDebugIds() {
-    if (debugIds.size() > 0) return;
+    if (debugIds.size() > 0)
+      return;
     for (auto& block : basicBlocks) {
       debugIds[block.get()] = debugIds.size();
     }
@@ -300,12 +321,14 @@ struct CFGWalker : public ControlFlowWalker<SubType, VisitorType> {
       block->contents.dump(static_cast<SubType*>(this)->getFunction());
       for (auto& in : block->in) {
         assert(debugIds.count(in) > 0);
-        assert(std::find(in->out.begin(), in->out.end(), block.get()) != in->out.end()); // must be a parallel link back
+        assert(std::find(in->out.begin(), in->out.end(), block.get()) !=
+               in->out.end()); // must be a parallel link back
       }
       for (auto& out : block->out) {
         assert(debugIds.count(out) > 0);
         std::cout << "    out: " << debugIds[out] << "\n";
-        assert(std::find(out->in.begin(), out->in.end(), block.get()) != out->in.end()); // must be a parallel link back
+        assert(std::find(out->in.begin(), out->in.end(), block.get()) !=
+               out->in.end()); // must be a parallel link back
       }
       checkDuplicates(block->in);
       checkDuplicates(block->out);
diff --git a/src/cfg/liveness-traversal.h b/src/cfg/liveness-traversal.h
index edbe52fd6..b26898460 100644
--- a/src/cfg/liveness-traversal.h
+++ b/src/cfg/liveness-traversal.h
@@ -21,12 +21,12 @@
 #ifndef liveness_traversal_h
 #define liveness_traversal_h
 
+#include "cfg-traversal.h"
+#include "ir/utils.h"
 #include "support/sorted_vector.h"
-#include "wasm.h"
 #include "wasm-builder.h"
 #include "wasm-traversal.h"
-#include "cfg-traversal.h"
-#include "ir/utils.h"
+#include "wasm.h"
 
 namespace wasm {
 
@@ -41,20 +41,19 @@ typedef SortedVector LocalSet;
 // "other" which can be used for other purposes, to mark
 // their position in a block
 struct LivenessAction {
-  enum What {
-    Get = 0,
-    Set = 1,
-    Other = 2
-  };
+  enum What { Get = 0, Set = 1, Other = 2 };
   What what;
-  Index index; // the local index read or written
+  Index index;         // the local index read or written
   Expression** origin; // the origin
   bool effective; // whether a store is actually effective, i.e., may be read
 
-  LivenessAction(What what, Index index, Expression** origin) : what(what), index(index), origin(origin), effective(false) {
+  LivenessAction(What what, Index index, Expression** origin)
+    : what(what), index(index), origin(origin), effective(false) {
     assert(what != Other);
-    if (what == Get) assert((*origin)->is<GetLocal>());
-    if (what == Set) assert((*origin)->is<SetLocal>());
+    if (what == Get)
+      assert((*origin)->is<GetLocal>());
+    if (what == Set)
+      assert((*origin)->is<SetLocal>());
   }
   LivenessAction(Expression** origin) : what(Other), origin(origin) {}
 
@@ -80,15 +79,18 @@ struct LivenessAction {
 
 // information about liveness in a basic block
 struct Liveness {
-  LocalSet start, end; // live locals at the start and end
+  LocalSet start, end;                 // live locals at the start and end
   std::vector<LivenessAction> actions; // actions occurring in this block
 
 #if LIVENESS_DEBUG
   void dump(Function* func) {
-    if (actions.empty()) return;
+    if (actions.empty())
+      return;
     std::cout << "    actions:\n";
     for (auto& action : actions) {
-      std::cout << "      " << (action.isGet() ? "get" : (action.isSet() ? "set" : "other")) << " " << func->getLocalName(action.index) << "\n";
+      std::cout << "      "
+                << (action.isGet() ? "get" : (action.isSet() ? "set" : "other"))
+                << " " << func->getLocalName(action.index) << "\n";
     }
   }
 #endif // LIVENESS_DEBUG
@@ -96,28 +98,35 @@ struct Liveness {
 
 template<typename SubType, typename VisitorType>
 struct LivenessWalker : public CFGWalker<SubType, VisitorType, Liveness> {
-  typedef typename CFGWalker<SubType, VisitorType, Liveness>::BasicBlock BasicBlock;
+  typedef
+    typename CFGWalker<SubType, VisitorType, Liveness>::BasicBlock BasicBlock;
 
   Index numLocals;
   std::unordered_set<BasicBlock*> liveBlocks;
-  std::vector<uint8_t> copies; // canonicalized - accesses should check (low, high) TODO: use a map for high N, as this tends to be sparse? or don't look at copies at all for big N?
-  std::vector<Index> totalCopies; // total # of copies for each local, with all others
+  // canonicalized - accesses should check (low, high)
+  // TODO: use a map for high N, as this tends to be sparse? or don't look at
+  // copies at all for big N?
+  std::vector<uint8_t> copies;
+  // total # of copies for each local, with all others
+  std::vector<Index> totalCopies;
 
   // cfg traversal work
 
   static void doVisitGetLocal(SubType* self, Expression** currp) {
     auto* curr = (*currp)->cast<GetLocal>();
-     // if in unreachable code, ignore
+    // if in unreachable code, ignore
     if (!self->currBasicBlock) {
       *currp = Builder(*self->getModule()).replaceWithIdenticalType(curr);
       return;
     }
-    self->currBasicBlock->contents.actions.emplace_back(LivenessAction::Get, curr->index, currp);
+    self->currBasicBlock->contents.actions.emplace_back(
+      LivenessAction::Get, curr->index, currp);
   }
 
   static void doVisitSetLocal(SubType* self, Expression** currp) {
     auto* curr = (*currp)->cast<SetLocal>();
-    // if in unreachable code, we don't need the tee (but might need the value, if it has side effects)
+    // if in unreachable code, we don't need the tee (but might need the value,
+    // if it has side effects)
     if (!self->currBasicBlock) {
       if (curr->isTee()) {
         *currp = curr->value;
@@ -126,10 +135,12 @@ struct LivenessWalker : public CFGWalker<SubType, VisitorType, Liveness> {
       }
       return;
     }
-    self->currBasicBlock->contents.actions.emplace_back(LivenessAction::Set, curr->index, currp);
+    self->currBasicBlock->contents.actions.emplace_back(
+      LivenessAction::Set, curr->index, currp);
     // if this is a copy, note it
     if (auto* get = self->getCopy(curr)) {
-      // add 2 units, so that backedge prioritization can decide ties, but not much more
+      // add 2 units, so that backedge prioritization can decide ties, but not
+      // much more
       self->addCopy(curr->index, get->index);
       self->addCopy(curr->index, get->index);
     }
@@ -137,16 +148,19 @@ struct LivenessWalker : public CFGWalker<SubType, VisitorType, Liveness> {
 
   // A simple copy is a set of a get. A more interesting copy
   // is a set of an if with a value, where one side a get.
-  // That can happen when we create an if value in simplify-locals. TODO: recurse into
-  // nested ifs, and block return values? Those cases are trickier, need to
-  // count to see if worth it.
+  // That can happen when we create an if value in simplify-locals. TODO:
+  // recurse into nested ifs, and block return values? Those cases are trickier,
+  // need to count to see if worth it.
   // TODO: an if can have two copies
   GetLocal* getCopy(SetLocal* set) {
-    if (auto* get = set->value->dynCast<GetLocal>()) return get;
+    if (auto* get = set->value->dynCast<GetLocal>())
+      return get;
     if (auto* iff = set->value->dynCast<If>()) {
-      if (auto* get = iff->ifTrue->dynCast<GetLocal>()) return get;
+      if (auto* get = iff->ifTrue->dynCast<GetLocal>())
+        return get;
       if (iff->ifFalse) {
-        if (auto* get = iff->ifFalse->dynCast<GetLocal>()) return get;
+        if (auto* get = iff->ifFalse->dynCast<GetLocal>())
+          return get;
       }
     }
     return nullptr;
@@ -162,7 +176,8 @@ struct LivenessWalker : public CFGWalker<SubType, VisitorType, Liveness> {
     std::fill(totalCopies.begin(), totalCopies.end(), 0);
     // create the CFG by walking the IR
     CFGWalker<SubType, VisitorType, Liveness>::doWalkFunction(func);
-    // ignore links to dead blocks, so they don't confuse us and we can see their stores are all ineffective
+    // ignore links to dead blocks, so they don't confuse us and we can see
+    // their stores are all ineffective
     liveBlocks = CFGWalker<SubType, VisitorType, Liveness>::findLiveBlocks();
     CFGWalker<SubType, VisitorType, Liveness>::unlinkDeadBlocks(liveBlocks);
     // flow liveness across blocks
@@ -173,24 +188,30 @@ struct LivenessWalker : public CFGWalker<SubType, VisitorType, Liveness> {
     // keep working while stuff is flowing
     std::unordered_set<BasicBlock*> queue;
     for (auto& curr : CFGWalker<SubType, VisitorType, Liveness>::basicBlocks) {
-      if (liveBlocks.count(curr.get()) == 0) continue; // ignore dead blocks
+      if (liveBlocks.count(curr.get()) == 0)
+        continue; // ignore dead blocks
       queue.insert(curr.get());
-      // do the first scan through the block, starting with nothing live at the end, and updating the liveness at the start
+      // do the first scan through the block, starting with nothing live at the
+      // end, and updating the liveness at the start
       scanLivenessThroughActions(curr->contents.actions, curr->contents.start);
     }
-    // at every point in time, we assume we already noted interferences between things already known alive at the end, and scanned back through the block using that
+    // at every point in time, we assume we already noted interferences between
+    // things already known alive at the end, and scanned back through the block
+    // using that
     while (queue.size() > 0) {
       auto iter = queue.begin();
       auto* curr = *iter;
       queue.erase(iter);
       LocalSet live;
-      if (!mergeStartsAndCheckChange(curr->out, curr->contents.end, live)) continue;
+      if (!mergeStartsAndCheckChange(curr->out, curr->contents.end, live))
+        continue;
       assert(curr->contents.end.size() < live.size());
       curr->contents.end = live;
       scanLivenessThroughActions(curr->contents.actions, live);
       // liveness is now calculated at the start. if something
       // changed, all predecessor blocks need recomputation
-      if (curr->contents.start == live) continue;
+      if (curr->contents.start == live)
+        continue;
       assert(curr->contents.start.size() < live.size());
       curr->contents.start = live;
       for (auto* in : curr->in) {
@@ -200,9 +221,13 @@ struct LivenessWalker : public CFGWalker<SubType, VisitorType, Liveness> {
   }
 
   // merge starts of a list of blocks. return
-  // whether anything changed vs an old state (which indicates further processing is necessary).
-  bool mergeStartsAndCheckChange(std::vector<BasicBlock*>& blocks, LocalSet& old, LocalSet& ret) {
-    if (blocks.size() == 0) return false;
+  // whether anything changed vs an old state (which indicates further
+  // processing is necessary).
+  bool mergeStartsAndCheckChange(std::vector<BasicBlock*>& blocks,
+                                 LocalSet& old,
+                                 LocalSet& ret) {
+    if (blocks.size() == 0)
+      return false;
     ret = blocks[0]->contents.start;
     if (blocks.size() > 1) {
       // more than one, so we must merge
@@ -213,7 +238,8 @@ struct LivenessWalker : public CFGWalker<SubType, VisitorType, Liveness> {
     return old != ret;
   }
 
-  void scanLivenessThroughActions(std::vector<LivenessAction>& actions, LocalSet& live) {
+  void scanLivenessThroughActions(std::vector<LivenessAction>& actions,
+                                  LocalSet& live) {
     // move towards the front
     for (int i = int(actions.size()) - 1; i >= 0; i--) {
       auto& action = actions[i];