don't create a simple if it would have a multiple that causes label variable usage

lib/Target/JSBackend/Relooper.cpp

diff --git a/lib/Target/JSBackend/Relooper.cpp b/lib/Target/JSBackend/Relooper.cpp
index c74a634..baa2447 100644
--- a/lib/Target/JSBackend/Relooper.cpp
+++ b/lib/Target/JSBackend/Relooper.cpp
@@ -859,7 +859,7 @@
 #endif
     }
 
-    void CalculateNextEntriesForMultiple(BlockSet &Blocks, BlockSet& Entries, BlockBlockSetMap& IndependentGroups, Shape *Prev, BlockSet &NextEntries) {
+    void CalculateNextEntriesForMultiple(BlockSet& Entries, BlockBlockSetMap& IndependentGroups, BlockSet &NextEntries) {
       // Any entry that is not an independent group is a next entry
       for (auto Entry : Entries) {
         if (!contains(IndependentGroups, Entry)) {
@@ -1005,7 +1005,29 @@
             Make(MakeEmulated(Blocks, Curr, *NextEntries));
           }
           if (Curr->BranchesIn.size() == 0) {
-            // One entry, no looping ==> Simple
+            // One entry, no looping ==> Simple. Unless we might cause
+            // multiple next entries, which can happen if the next block is
+            // going to be a Multiple. If we need a one-time loop for the
+            // Multiple, we should do it now, to not break fusing.
+            if (Curr->BranchesOut.size() > 1) {
+              // Look for a block we can put at the very end, reachable via a break in a one-time loop.
+              // If there is one, then we can check if it would be dangerous to make a Multiple after this Simple.
+              Block *Last = FindLastBlock(Blocks);
+              if (Last) {
+                // Check what would happen if we made a Multiple after us
+                BlockSet TempEntries;
+                for (auto iter : Curr->BranchesOut) {
+                  TempEntries.insert(iter.first);
+                }
+                BlockBlockSetMap IndependentGroups;
+                FindIndependentGroups(TempEntries, IndependentGroups);
+                BlockSet PossibleNextEntries;
+                CalculateNextEntriesForMultiple(TempEntries, IndependentGroups, PossibleNextEntries);
+                if (PossibleNextEntries.size() > 1) {
+                  Make(MakeOneTimeLoop(Blocks, *Entries, Last, *NextEntries));
+                }
+              }
+            }
             Make(MakeSimple(Blocks, Curr, *NextEntries));
           }
           // One entry, looping ==> Loop
@@ -1087,7 +1109,7 @@
             // Some groups removable, probably we should do a Multiple. But, if it
             // would cause multiple next entries, then we should try to avoid that
             BlockSet PossibleNextEntries;
-            CalculateNextEntriesForMultiple(Blocks, *Entries, IndependentGroups, Prev, PossibleNextEntries);
+            CalculateNextEntriesForMultiple(*Entries, IndependentGroups, PossibleNextEntries);
             if (PossibleNextEntries.size() > 1) {
               // Look for a block we can put at the very end, reachable via a break in a one-time loop
               Block *Last = FindLastBlock(Blocks);