apply -BaselineMode for -regexDebug dump

-regexDebug tests dump instruction offsets which are based on C++
`sizeof(struct ...)`. The results vary on different arch/compiler, thus
do not suit baseline based tests.

Add a common switch `-BaselineMode` to test harnesses. Change Regex code to
not dump real instruction offsets in this mode in order to do baseline
diff.

lib/Common/ConfigFlagsList.h

@@ -756,6 +756,7 @@ FLAGNR(Boolean, AssertIgnore          , "Ignores asserts if set", false)
 FLAGNR(Boolean, AsyncDebugging, "Enable async debugging feature (default: false)", DEFAULT_CONFIG_AsyncDebugging)
 FLAGNR(Number,  BailOnNoProfileLimit,   "The limit of bailout on no profile info before triggering a rejit", DEFAULT_CONFIG_BailOnNoProfileLimit)
 FLAGNR(Number,  BailOnNoProfileRejitLimit, "The limit of bailout on no profile info before we disable the bailouts", DEFAULT_CONFIG_BailOnNoProfileRejitLimit)
+FLAGNR(Boolean, BaselineMode          , "Dump only stable content that can be used for baseline comparison", false)
 FLAGNR(String,  DumpOnCrash           , "generate heap dump on asserts or unhandled exception if set", nullptr)
 FLAGNR(String,  FullMemoryDump        , "Will perform a full memory dump when -DumpOnCrash is supplied.", nullptr)
 #ifdef BAILOUT_INJECTION

lib/Parser/RegexRuntime.cpp

@@ -325,6 +325,18 @@ namespace UnifiedRegex
             ResetGroup(i);
     }
 
+#if ENABLE_REGEX_CONFIG_OPTIONS
+    bool Inst::IsBaselineMode()
+    {
+        return Js::Configuration::Global.flags.BaselineMode;
+    }
+
+    Label Inst::GetPrintLabel(Label label)
+    {
+        return IsBaselineMode() ? (Label)0xFFFF : label;
+    }
+#endif
+
     // ----------------------------------------------------------------------
     // Mixins
     // ----------------------------------------------------------------------
@@ -657,7 +669,7 @@ namespace UnifiedRegex
 #if ENABLE_REGEX_CONFIG_OPTIONS
     void JumpMixin::Print(DebugWriter* w, const char16* litbuf) const
     {
-        w->Print(_u("targetLabel: L%04x"), targetLabel);
+        w->Print(_u("targetLabel: L%04x"), Inst::GetPrintLabel(targetLabel));
     }
 #endif
 
@@ -673,21 +685,22 @@ namespace UnifiedRegex
     {
         w->Print(_u("loopId: %d, repeats: "), loopId);
         repeats.Print(w);
-        w->Print(_u(", exitLabel: L%04x, hasOuterLoops: %s, hasInnerNondet: %s"), exitLabel, hasOuterLoops ? _u("true") : _u("false"), hasInnerNondet ? _u("true") : _u("false"));
+        w->Print(_u(", exitLabel: L%04x, hasOuterLoops: %s, hasInnerNondet: %s"),
+            Inst::GetPrintLabel(exitLabel), hasOuterLoops ? _u("true") : _u("false"), hasInnerNondet ? _u("true") : _u("false"));
     }
 #endif
 
 #if ENABLE_REGEX_CONFIG_OPTIONS
     void RepeatLoopMixin::Print(DebugWriter* w, const char16* litbuf) const
     {
-        w->Print(_u("beginLabel: L%04x"), beginLabel);
+        w->Print(_u("beginLabel: L%04x"), Inst::GetPrintLabel(beginLabel));
     }
 #endif
 
 #if ENABLE_REGEX_CONFIG_OPTIONS
     void TryMixin::Print(DebugWriter* w, const char16* litbuf) const
     {
-        w->Print(_u("failLabel: L%04x"), failLabel);
+        w->Print(_u("failLabel: L%04x"), Inst::GetPrintLabel(failLabel));
     }
 #endif
 
@@ -3825,7 +3838,8 @@ namespace UnifiedRegex
 #if ENABLE_REGEX_CONFIG_OPTIONS
     int BeginAssertionInst::Print(DebugWriter* w, Label label, const Char* litbuf) const
     {
-        w->Print(_u("L%04x: BeginAssertion(isNegation: %s, nextLabel: L%04x, "), label, isNegation ? _u("true") : _u("false"), nextLabel);
+        w->Print(_u("L%04x: BeginAssertion(isNegation: %s, nextLabel: L%04x, "),
+            label, isNegation ? _u("true") : _u("false"), GetPrintLabel(nextLabel));
         BodyGroupsMixin::Print(w, litbuf);
         w->PrintEOL(_u(")"));
         return sizeof(*this);
@@ -5009,6 +5023,7 @@ namespace UnifiedRegex
 #if ENABLE_REGEX_CONFIG_OPTIONS
     void Program::Print(DebugWriter* w)
     {
+        const bool isBaselineMode = Js::Configuration::Global.flags.BaselineMode;
         w->PrintEOL(_u("Program {"));
         w->Indent();
         w->PrintEOL(_u("source:       %s"), source);
@@ -5034,8 +5049,9 @@ namespace UnifiedRegex
                 }
                 uint8* instsLim = rep.insts.insts + rep.insts.instsLen;
                 uint8* curr = rep.insts.insts;
+                int i = 0;
                 while (curr != instsLim)
-                    curr += ((Inst*)curr)->Print(w, (Label)(curr - rep.insts.insts), rep.insts.litbuf);
+                    curr += ((Inst*)curr)->Print(w, (Label)(isBaselineMode ? i++ : curr - rep.insts.insts), rep.insts.litbuf);
                 w->Unindent();
                 w->PrintEOL(_u("}"));
             }

lib/Parser/RegexRuntime.h

@@ -633,6 +633,8 @@ namespace UnifiedRegex
         void FreeBody(ArenaAllocator* rtAllocator) {}
 
 #if ENABLE_REGEX_CONFIG_OPTIONS
+        static bool IsBaselineMode();
+        static Label GetPrintLabel(Label label);
         virtual int Print(DebugWriter*w, Label label, const Char* litbuf) const = 0;
 #endif
     };

test/Regex/BoiHardFail.amd64.baseline

@@ -1,1681 +0,0 @@
-REGEX AST /^token/ {
-    Concat()
-    {
-        BOL()
-        MatchLiteral("token")
-    }
-}
-REGEX ANNOTATED AST /^token/ {
-    Concat()
-    <
-        features: {BOL,MatchLiteral,Concat}
-        firstSet: [\x00-\uffff]
-        followSet: [\x00-\uffff]
-        prevConsumes: [0]
-        thisConsumes: [5]
-        followConsumes: [0]
-        isThisIrrefutable: false
-        isFollowIrrefutable: true
-        isWord: false
-        isThisWillNotProgress: true
-        isThisWillNotRegress: true
-        isPrevWillNotProgress: false
-        isPrevWillNotRegress: true
-        isDeterministic: true
-        isNotInLoop: true
-        isNotNegated: true
-        isAtLeastOnce: true
-        hasInitialHardFailBOI: true
-    >
-    {
-        BOL()
-        <
-            features: {BOL}
-            firstSet: [\x00-\uffff]
-            followSet: [t]
-            prevConsumes: [0]
-            thisConsumes: [0]
-            followConsumes: [5]
-            isThisIrrefutable: false
-            isFollowIrrefutable: false
-            isWord: false
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: true
-        >
-        MatchLiteral("token")
-        <
-            features: {MatchLiteral}
-            firstSet: [t] (exact)
-            followSet: [\x00-\uffff]
-            prevConsumes: [0]
-            thisConsumes: [5]
-            followConsumes: [0]
-            isThisIrrefutable: false
-            isFollowIrrefutable: true
-            isWord: true
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: false
-        >
-    }
-}
-REGEX PROGRAM /^token/ 
-Program {
-    source:       ^token
-    flags:        
-    numGroups:    1
-    numLoops:     0
-    instructions: {
-               BOITest(hardFail: true)
-        L0000: MatchLiteral(literal: "token")
-        L0018: Succ()
-    }
-}
-REGEX AST /(\w)?^token/ {
-    Concat()
-    {
-        Loop([0-1], greedy)
-        {
-            DefineGroup(1)
-            {
-                MatchSet(positive, [0-9A-Z_a-z])
-            }
-        }
-        BOL()
-        MatchLiteral("token")
-    }
-}
-REGEX ANNOTATED AST /(\w)?^token/ {
-    Concat()
-    <
-        features: {BOL,MatchLiteral,Concat,DefineGroup,Loop,MatchSet}
-        firstSet: [\x00-\uffff]
-        followSet: [\x00-\uffff]
-        prevConsumes: [0]
-        thisConsumes: [5-6]
-        followConsumes: [0]
-        isThisIrrefutable: false
-        isFollowIrrefutable: true
-        isWord: false
-        isThisWillNotProgress: true
-        isThisWillNotRegress: false
-        isPrevWillNotProgress: false
-        isPrevWillNotRegress: true
-        isDeterministic: false
-        isNotInLoop: true
-        isNotNegated: true
-        isAtLeastOnce: true
-        hasInitialHardFailBOI: false
-    >
-    {
-        Loop([0-1], greedy)
-        <
-            features: {DefineGroup,Loop,MatchSet}
-            firstSet: [0-9A-Z_a-z]
-            followSet: [\x00-\uffff]
-            prevConsumes: [0]
-            thisConsumes: [0-1]
-            followConsumes: [5]
-            isThisIrrefutable: true
-            isFollowIrrefutable: false
-            isWord: false
-            isThisWillNotProgress: true
-            isThisWillNotRegress: false
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: false
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: false
-        >
-        {
-            DefineGroup(1)
-            <
-                features: {DefineGroup,MatchSet}
-                firstSet: [0-9A-Z_a-z] (exact)
-                followSet: [\x00-\uffff]
-                prevConsumes: [0]
-                thisConsumes: [1]
-                followConsumes: [5]
-                isThisIrrefutable: false
-                isFollowIrrefutable: false
-                isWord: true
-                isThisWillNotProgress: true
-                isThisWillNotRegress: true
-                isPrevWillNotProgress: false
-                isPrevWillNotRegress: false
-                isDeterministic: true
-                isNotInLoop: false
-                isNotNegated: true
-                isAtLeastOnce: false
-                hasInitialHardFailBOI: false
-            >
-            {
-                MatchSet(positive, [0-9A-Z_a-z])
-                <
-                    features: {MatchSet}
-                    firstSet: [0-9A-Z_a-z] (exact)
-                    followSet: [\x00-\uffff]
-                    prevConsumes: [0]
-                    thisConsumes: [1]
-                    followConsumes: [5]
-                    isThisIrrefutable: false
-                    isFollowIrrefutable: false
-                    isWord: true
-                    isThisWillNotProgress: true
-                    isThisWillNotRegress: true
-                    isPrevWillNotProgress: false
-                    isPrevWillNotRegress: false
-                    isDeterministic: true
-                    isNotInLoop: false
-                    isNotNegated: true
-                    isAtLeastOnce: false
-                    hasInitialHardFailBOI: false
-                >
-            }
-        }
-        BOL()
-        <
-            features: {BOL}
-            firstSet: [\x00-\uffff]
-            followSet: [t]
-            prevConsumes: [0-1]
-            thisConsumes: [0]
-            followConsumes: [5]
-            isThisIrrefutable: false
-            isFollowIrrefutable: false
-            isWord: false
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: false
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: false
-        >
-        MatchLiteral("token")
-        <
-            features: {MatchLiteral}
-            firstSet: [t] (exact)
-            followSet: [\x00-\uffff]
-            prevConsumes: [0-1]
-            thisConsumes: [5]
-            followConsumes: [0]
-            isThisIrrefutable: false
-            isFollowIrrefutable: true
-            isWord: true
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: false
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: false
-        >
-    }
-}
-REGEX PROGRAM /(\w)?^token/ 
-Program {
-    source:       (\w)?^token
-    flags:        
-    numGroups:    2
-    numLoops:     0
-    instructions: {
-        L0000: SyncToLiteralAndBackup(literal: "token" (with full map Boyer-Moore scanner), backup: [0-1])
-        L0458: TryMatchSet(set: [0-9A-Z_a-z], failLabel: L04b8)
-        L0498: DefineGroupFixed(groupId: 1, length: 1, noNeedToSave: false)
-        L04b8: BOITest(hardFail: false)
-        L04d0: MatchLiteral(literal: "token")
-        L04e8: Succ()
-    }
-}
-REGEX AST /token/ {
-    MatchLiteral("token")
-}
-REGEX ANNOTATED AST /token/ {
-    MatchLiteral("token")
-    <
-        features: {MatchLiteral}
-        firstSet: [t] (exact)
-        followSet: [\x00-\uffff]
-        prevConsumes: [0]
-        thisConsumes: [5]
-        followConsumes: [0]
-        isThisIrrefutable: false
-        isFollowIrrefutable: true
-        isWord: true
-        isThisWillNotProgress: true
-        isThisWillNotRegress: true
-        isPrevWillNotProgress: false
-        isPrevWillNotRegress: true
-        isDeterministic: true
-        isNotInLoop: true
-        isNotNegated: true
-        isAtLeastOnce: true
-        hasInitialHardFailBOI: false
-    >
-}
-REGEX PROGRAM /token/ 
-Program {
-    source:       token
-    flags:        
-    numGroups:    1
-    numLoops:     0
-    instructions: {
-        L0000: SyncToLiteralAndConsume(literal: "token" (with full map Boyer-Moore scanner))
-        L0450: Succ()
-    }
-}
-REGEX AST /^^token/ {
-    Concat()
-    {
-        BOL()
-        BOL()
-        MatchLiteral("token")
-    }
-}
-REGEX ANNOTATED AST /^^token/ {
-    Concat()
-    <
-        features: {BOL,MatchLiteral,Concat}
-        firstSet: [\x00-\uffff]
-        followSet: [\x00-\uffff]
-        prevConsumes: [0]
-        thisConsumes: [5]
-        followConsumes: [0]
-        isThisIrrefutable: false
-        isFollowIrrefutable: true
-        isWord: false
-        isThisWillNotProgress: true
-        isThisWillNotRegress: true
-        isPrevWillNotProgress: false
-        isPrevWillNotRegress: true
-        isDeterministic: true
-        isNotInLoop: true
-        isNotNegated: true
-        isAtLeastOnce: true
-        hasInitialHardFailBOI: true
-    >
-    {
-        BOL()
-        <
-            features: {BOL}
-            firstSet: [\x00-\uffff]
-            followSet: [\x00-\uffff]
-            prevConsumes: [0]
-            thisConsumes: [0]
-            followConsumes: [5]
-            isThisIrrefutable: false
-            isFollowIrrefutable: false
-            isWord: false
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: true
-        >
-        BOL()
-        <
-            features: {BOL}
-            firstSet: [\x00-\uffff]
-            followSet: [t]
-            prevConsumes: [0]
-            thisConsumes: [0]
-            followConsumes: [5]
-            isThisIrrefutable: false
-            isFollowIrrefutable: false
-            isWord: false
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: true
-        >
-        MatchLiteral("token")
-        <
-            features: {MatchLiteral}
-            firstSet: [t] (exact)
-            followSet: [\x00-\uffff]
-            prevConsumes: [0]
-            thisConsumes: [5]
-            followConsumes: [0]
-            isThisIrrefutable: false
-            isFollowIrrefutable: true
-            isWord: true
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: false
-        >
-    }
-}
-REGEX PROGRAM /^^token/ 
-Program {
-    source:       ^^token
-    flags:        
-    numGroups:    1
-    numLoops:     0
-    instructions: {
-               BOITest(hardFail: true)
-        L0000: MatchLiteral(literal: "token")
-        L0018: Succ()
-    }
-}
-REGEX AST /token^/ {
-    Concat()
-    {
-        MatchLiteral("token")
-        BOL()
-    }
-}
-REGEX ANNOTATED AST /token^/ {
-    Concat()
-    <
-        features: {BOL,MatchLiteral,Concat}
-        firstSet: [t] (exact)
-        followSet: [\x00-\uffff]
-        prevConsumes: [0]
-        thisConsumes: [5]
-        followConsumes: [0]
-        isThisIrrefutable: false
-        isFollowIrrefutable: true
-        isWord: false
-        isThisWillNotProgress: true
-        isThisWillNotRegress: true
-        isPrevWillNotProgress: false
-        isPrevWillNotRegress: true
-        isDeterministic: true
-        isNotInLoop: true
-        isNotNegated: true
-        isAtLeastOnce: true
-        hasInitialHardFailBOI: false
-    >
-    {
-        MatchLiteral("token")
-        <
-            features: {MatchLiteral}
-            firstSet: [t] (exact)
-            followSet: [\x00-\uffff]
-            prevConsumes: [0]
-            thisConsumes: [5]
-            followConsumes: [0]
-            isThisIrrefutable: false
-            isFollowIrrefutable: false
-            isWord: true
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: false
-        >
-        BOL()
-        <
-            features: {BOL}
-            firstSet: [\x00-\uffff]
-            followSet: [\x00-\uffff]
-            prevConsumes: [5]
-            thisConsumes: [0]
-            followConsumes: [0]
-            isThisIrrefutable: false
-            isFollowIrrefutable: true
-            isWord: false
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: false
-        >
-    }
-}
-REGEX PROGRAM /token^/ 
-Program {
-    source:       token^
-    flags:        
-    numGroups:    1
-    numLoops:     0
-    instructions: {
-        L0000: SyncToLiteralAndConsume(literal: "token" (with full map Boyer-Moore scanner))
-        L0450: BOITest(hardFail: true)
-        L0468: Succ()
-    }
-}
-REGEX AST /token^token/ {
-    Concat()
-    {
-        MatchLiteral("token")
-        BOL()
-        MatchLiteral("token")
-    }
-}
-REGEX ANNOTATED AST /token^token/ {
-    Concat()
-    <
-        features: {BOL,MatchLiteral,Concat}
-        firstSet: [t] (exact)
-        followSet: [\x00-\uffff]
-        prevConsumes: [0]
-        thisConsumes: [10]
-        followConsumes: [0]
-        isThisIrrefutable: false
-        isFollowIrrefutable: true
-        isWord: false
-        isThisWillNotProgress: true
-        isThisWillNotRegress: true
-        isPrevWillNotProgress: false
-        isPrevWillNotRegress: true
-        isDeterministic: true
-        isNotInLoop: true
-        isNotNegated: true
-        isAtLeastOnce: true
-        hasInitialHardFailBOI: false
-    >
-    {
-        MatchLiteral("token")
-        <
-            features: {MatchLiteral}
-            firstSet: [t] (exact)
-            followSet: [\x00-\uffff]
-            prevConsumes: [0]
-            thisConsumes: [5]
-            followConsumes: [5]
-            isThisIrrefutable: false
-            isFollowIrrefutable: false
-            isWord: true
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: false
-        >
-        BOL()
-        <
-            features: {BOL}
-            firstSet: [\x00-\uffff]
-            followSet: [t]
-            prevConsumes: [5]
-            thisConsumes: [0]
-            followConsumes: [5]
-            isThisIrrefutable: false
-            isFollowIrrefutable: false
-            isWord: false
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: false
-        >
-        MatchLiteral("token")
-        <
-            features: {MatchLiteral}
-            firstSet: [t] (exact)
-            followSet: [\x00-\uffff]
-            prevConsumes: [5]
-            thisConsumes: [5]
-            followConsumes: [0]
-            isThisIrrefutable: false
-            isFollowIrrefutable: true
-            isWord: true
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: false
-        >
-    }
-}
-REGEX PROGRAM /token^token/ 
-Program {
-    source:       token^token
-    flags:        
-    numGroups:    1
-    numLoops:     0
-    instructions: {
-        L0000: SyncToLiteralAndConsume(literal: "token" (with full map Boyer-Moore scanner))
-        L0450: BOITest(hardFail: true)
-        L0468: MatchLiteral(literal: "token")
-        L0480: Succ()
-    }
-}
-REGEX AST /^token|^abc/ {
-    Alt()
-    {
-        Concat()
-        {
-            BOL()
-            MatchLiteral("token")
-        }
-        Concat()
-        {
-            BOL()
-            MatchLiteral("abc")
-        }
-    }
-}
-REGEX ANNOTATED AST /^token|^abc/ {
-    Alt()
-    <
-        features: {BOL,MatchLiteral,Concat,Alt}
-        firstSet: [\x00-\uffff]
-        followSet: [\x00-\uffff]
-        prevConsumes: [0]
-        thisConsumes: [3-5]
-        followConsumes: [0]
-        isThisIrrefutable: false
-        isFollowIrrefutable: true
-        isWord: false
-        isThisWillNotProgress: true
-        isThisWillNotRegress: false
-        isPrevWillNotProgress: false
-        isPrevWillNotRegress: true
-        isDeterministic: false
-        isNotInLoop: true
-        isNotNegated: true
-        isAtLeastOnce: true
-        hasInitialHardFailBOI: false
-    >
-    {
-        Concat()
-        <
-            features: {BOL,MatchLiteral,Concat}
-            firstSet: [\x00-\uffff]
-            followSet: [\x00-\uffff]
-            prevConsumes: [0]
-            thisConsumes: [5]
-            followConsumes: [0]
-            isThisIrrefutable: false
-            isFollowIrrefutable: true
-            isWord: false
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: false
-            hasInitialHardFailBOI: false
-        >
-        {
-            BOL()
-            <
-                features: {BOL}
-                firstSet: [\x00-\uffff]
-                followSet: [t]
-                prevConsumes: [0]
-                thisConsumes: [0]
-                followConsumes: [5]
-                isThisIrrefutable: false
-                isFollowIrrefutable: false
-                isWord: false
-                isThisWillNotProgress: true
-                isThisWillNotRegress: true
-                isPrevWillNotProgress: false
-                isPrevWillNotRegress: true
-                isDeterministic: true
-                isNotInLoop: true
-                isNotNegated: true
-                isAtLeastOnce: false
-                hasInitialHardFailBOI: false
-            >
-            MatchLiteral("token")
-            <
-                features: {MatchLiteral}
-                firstSet: [t] (exact)
-                followSet: [\x00-\uffff]
-                prevConsumes: [0]
-                thisConsumes: [5]
-                followConsumes: [0]
-                isThisIrrefutable: false
-                isFollowIrrefutable: true
-                isWord: true
-                isThisWillNotProgress: true
-                isThisWillNotRegress: true
-                isPrevWillNotProgress: false
-                isPrevWillNotRegress: true
-                isDeterministic: true
-                isNotInLoop: true
-                isNotNegated: true
-                isAtLeastOnce: false
-                hasInitialHardFailBOI: false
-            >
-        }
-        Concat()
-        <
-            features: {BOL,MatchLiteral,Concat}
-            firstSet: [\x00-\uffff]
-            followSet: [\x00-\uffff]
-            prevConsumes: [0]
-            thisConsumes: [3]
-            followConsumes: [0]
-            isThisIrrefutable: false
-            isFollowIrrefutable: true
-            isWord: false
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: false
-            hasInitialHardFailBOI: false
-        >
-        {
-            BOL()
-            <
-                features: {BOL}
-                firstSet: [\x00-\uffff]
-                followSet: [a]
-                prevConsumes: [0]
-                thisConsumes: [0]
-                followConsumes: [3]
-                isThisIrrefutable: false
-                isFollowIrrefutable: false
-                isWord: false
-                isThisWillNotProgress: true
-                isThisWillNotRegress: true
-                isPrevWillNotProgress: false
-                isPrevWillNotRegress: true
-                isDeterministic: true
-                isNotInLoop: true
-                isNotNegated: true
-                isAtLeastOnce: false
-                hasInitialHardFailBOI: false
-            >
-            MatchLiteral("abc")
-            <
-                features: {MatchLiteral}
-                firstSet: [a] (exact)
-                followSet: [\x00-\uffff]
-                prevConsumes: [0]
-                thisConsumes: [3]
-                followConsumes: [0]
-                isThisIrrefutable: false
-                isFollowIrrefutable: true
-                isWord: true
-                isThisWillNotProgress: true
-                isThisWillNotRegress: true
-                isPrevWillNotProgress: false
-                isPrevWillNotRegress: true
-                isDeterministic: true
-                isNotInLoop: true
-                isNotNegated: true
-                isAtLeastOnce: false
-                hasInitialHardFailBOI: false
-            >
-        }
-    }
-}
-REGEX PROGRAM /^token|^abc/ 
-Program {
-    source:       ^token|^abc
-    flags:        
-    numGroups:    1
-    numLoops:     0
-    instructions: {
-        L0000: Try(failLabel: L0060)
-        L0018: BOITest(hardFail: false)
-        L0030: MatchLiteral(literal: "token")
-        L0048: Jump(targetLabel: L0090)
-        L0060: BOITest(hardFail: false)
-        L0078: MatchLiteral(literal: "abc")
-        L0090: Succ()
-    }
-}
-REGEX AST /(?!token)^abc/ {
-    Concat()
-    {
-        Assertion(negative)
-        {
-            MatchLiteral("token")
-        }
-        BOL()
-        MatchLiteral("abc")
-    }
-}
-REGEX ANNOTATED AST /(?!token)^abc/ {
-    Concat()
-    <
-        features: {BOL,MatchLiteral,Concat,Assertion}
-        firstSet: [\x00-\uffff]
-        followSet: [\x00-\uffff]
-        prevConsumes: [0]
-        thisConsumes: [3]
-        followConsumes: [0]
-        isThisIrrefutable: false
-        isFollowIrrefutable: true
-        isWord: false
-        isThisWillNotProgress: true
-        isThisWillNotRegress: true
-        isPrevWillNotProgress: false
-        isPrevWillNotRegress: true
-        isDeterministic: true
-        isNotInLoop: true
-        isNotNegated: true
-        isAtLeastOnce: true
-        hasInitialHardFailBOI: true
-    >
-    {
-        Assertion(negative)
-        <
-            features: {MatchLiteral,Assertion}
-            firstSet: [\x00-\uffff]
-            followSet: [\x00-\uffff]
-            prevConsumes: [0]
-            thisConsumes: [0]
-            followConsumes: [3]
-            isThisIrrefutable: false
-            isFollowIrrefutable: false
-            isWord: false
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: false
-        >
-        {
-            MatchLiteral("token")
-            <
-                features: {MatchLiteral}
-                firstSet: [t] (exact)
-                followSet: [\x00-\uffff]
-                prevConsumes: [0]
-                thisConsumes: [5]
-                followConsumes: [0-inf]
-                isThisIrrefutable: false
-                isFollowIrrefutable: true
-                isWord: true
-                isThisWillNotProgress: true
-                isThisWillNotRegress: true
-                isPrevWillNotProgress: false
-                isPrevWillNotRegress: true
-                isDeterministic: true
-                isNotInLoop: true
-                isNotNegated: false
-                isAtLeastOnce: true
-                hasInitialHardFailBOI: false
-            >
-        }
-        BOL()
-        <
-            features: {BOL}
-            firstSet: [\x00-\uffff]
-            followSet: [a]
-            prevConsumes: [0]
-            thisConsumes: [0]
-            followConsumes: [3]
-            isThisIrrefutable: false
-            isFollowIrrefutable: false
-            isWord: false
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: true
-        >
-        MatchLiteral("abc")
-        <
-            features: {MatchLiteral}
-            firstSet: [a] (exact)
-            followSet: [\x00-\uffff]
-            prevConsumes: [0]
-            thisConsumes: [3]
-            followConsumes: [0]
-            isThisIrrefutable: false
-            isFollowIrrefutable: true
-            isWord: true
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: false
-        >
-    }
-}
-REGEX PROGRAM /(?!token)^abc/ 
-Program {
-    source:       (?!token)^abc
-    flags:        
-    numGroups:    1
-    numLoops:     0
-    instructions: {
-        L0000: BeginAssertion(isNegation: true, nextLabel: L0048, minBodyGroupId: 1, maxBodyGroupId: -1)
-        L0020: MatchLiteral(literal: "token")
-        L0038: EndAssertion()
-        L0048: BOITest(hardFail: true)
-        L0060: MatchLiteral(literal: "abc")
-        L0078: Succ()
-    }
-}
-REGEX AST /(?=^abc)/ {
-    Assertion(positive)
-    {
-        Concat()
-        {
-            BOL()
-            MatchLiteral("abc")
-        }
-    }
-}
-REGEX ANNOTATED AST /(?=^abc)/ {
-    Assertion(positive)
-    <
-        features: {BOL,MatchLiteral,Concat,Assertion}
-        firstSet: [\x00-\uffff]
-        followSet: [\x00-\uffff]
-        prevConsumes: [0]
-        thisConsumes: [0]
-        followConsumes: [0]
-        isThisIrrefutable: false
-        isFollowIrrefutable: true
-        isWord: false
-        isThisWillNotProgress: true
-        isThisWillNotRegress: true
-        isPrevWillNotProgress: false
-        isPrevWillNotRegress: true
-        isDeterministic: true
-        isNotInLoop: true
-        isNotNegated: true
-        isAtLeastOnce: true
-        hasInitialHardFailBOI: true
-    >
-    {
-        Concat()
-        <
-            features: {BOL,MatchLiteral,Concat}
-            firstSet: [\x00-\uffff]
-            followSet: [\x00-\uffff]
-            prevConsumes: [0]
-            thisConsumes: [3]
-            followConsumes: [0-inf]
-            isThisIrrefutable: false
-            isFollowIrrefutable: true
-            isWord: false
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: true
-        >
-        {
-            BOL()
-            <
-                features: {BOL}
-                firstSet: [\x00-\uffff]
-                followSet: [a]
-                prevConsumes: [0]
-                thisConsumes: [0]
-                followConsumes: [3-inf]
-                isThisIrrefutable: false
-                isFollowIrrefutable: false
-                isWord: false
-                isThisWillNotProgress: true
-                isThisWillNotRegress: true
-                isPrevWillNotProgress: false
-                isPrevWillNotRegress: true
-                isDeterministic: true
-                isNotInLoop: true
-                isNotNegated: true
-                isAtLeastOnce: true
-                hasInitialHardFailBOI: true
-            >
-            MatchLiteral("abc")
-            <
-                features: {MatchLiteral}
-                firstSet: [a] (exact)
-                followSet: [\x00-\uffff]
-                prevConsumes: [0]
-                thisConsumes: [3]
-                followConsumes: [0-inf]
-                isThisIrrefutable: false
-                isFollowIrrefutable: true
-                isWord: true
-                isThisWillNotProgress: true
-                isThisWillNotRegress: true
-                isPrevWillNotProgress: false
-                isPrevWillNotRegress: true
-                isDeterministic: true
-                isNotInLoop: true
-                isNotNegated: true
-                isAtLeastOnce: true
-                hasInitialHardFailBOI: false
-            >
-        }
-    }
-}
-REGEX PROGRAM /(?=^abc)/ 
-Program {
-    source:       (?=^abc)
-    flags:        
-    numGroups:    1
-    numLoops:     0
-    instructions: {
-        L0000: BeginAssertion(isNegation: false, nextLabel: L0060, minBodyGroupId: 1, maxBodyGroupId: -1)
-        L0020: BOITest(hardFail: true)
-        L0038: MatchLiteral(literal: "abc")
-        L0050: EndAssertion()
-        L0060: Succ()
-    }
-}
-REGEX AST /(^token)/ {
-    DefineGroup(1)
-    {
-        Concat()
-        {
-            BOL()
-            MatchLiteral("token")
-        }
-    }
-}
-REGEX ANNOTATED AST /(^token)/ {
-    DefineGroup(1)
-    <
-        features: {BOL,MatchLiteral,Concat,DefineGroup}
-        firstSet: [\x00-\uffff]
-        followSet: [\x00-\uffff]
-        prevConsumes: [0]
-        thisConsumes: [5]
-        followConsumes: [0]
-        isThisIrrefutable: false
-        isFollowIrrefutable: true
-        isWord: false
-        isThisWillNotProgress: true
-        isThisWillNotRegress: true
-        isPrevWillNotProgress: false
-        isPrevWillNotRegress: true
-        isDeterministic: true
-        isNotInLoop: true
-        isNotNegated: true
-        isAtLeastOnce: true
-        hasInitialHardFailBOI: true
-    >
-    {
-        Concat()
-        <
-            features: {BOL,MatchLiteral,Concat}
-            firstSet: [\x00-\uffff]
-            followSet: [\x00-\uffff]
-            prevConsumes: [0]
-            thisConsumes: [5]
-            followConsumes: [0]
-            isThisIrrefutable: false
-            isFollowIrrefutable: true
-            isWord: false
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: true
-        >
-        {
-            BOL()
-            <
-                features: {BOL}
-                firstSet: [\x00-\uffff]
-                followSet: [t]
-                prevConsumes: [0]
-                thisConsumes: [0]
-                followConsumes: [5]
-                isThisIrrefutable: false
-                isFollowIrrefutable: false
-                isWord: false
-                isThisWillNotProgress: true
-                isThisWillNotRegress: true
-                isPrevWillNotProgress: false
-                isPrevWillNotRegress: true
-                isDeterministic: true
-                isNotInLoop: true
-                isNotNegated: true
-                isAtLeastOnce: true
-                hasInitialHardFailBOI: true
-            >
-            MatchLiteral("token")
-            <
-                features: {MatchLiteral}
-                firstSet: [t] (exact)
-                followSet: [\x00-\uffff]
-                prevConsumes: [0]
-                thisConsumes: [5]
-                followConsumes: [0]
-                isThisIrrefutable: false
-                isFollowIrrefutable: true
-                isWord: true
-                isThisWillNotProgress: true
-                isThisWillNotRegress: true
-                isPrevWillNotProgress: false
-                isPrevWillNotRegress: true
-                isDeterministic: true
-                isNotInLoop: true
-                isNotNegated: true
-                isAtLeastOnce: true
-                hasInitialHardFailBOI: false
-            >
-        }
-    }
-}
-REGEX PROGRAM /(^token)/ 
-Program {
-    source:       (^token)
-    flags:        
-    numGroups:    2
-    numLoops:     0
-    instructions: {
-               BOITest(hardFail: true)
-        L0000: MatchLiteral(literal: "token")
-        L0018: DefineGroupFixed(groupId: 1, length: 5, noNeedToSave: true)
-        L0038: Succ()
-    }
-}
-REGEX AST /(^a)+/ {
-    Loop([1-inf], greedy)
-    {
-        DefineGroup(1)
-        {
-            Concat()
-            {
-                BOL()
-                MatchChar('a')
-            }
-        }
-    }
-}
-REGEX ANNOTATED AST /(^a)+/ {
-    Loop([1-inf], greedy)
-    <
-        features: {BOL,MatchChar,Concat,DefineGroup,Loop}
-        firstSet: [\x00-\uffff]
-        followSet: [\x00-\uffff]
-        prevConsumes: [0]
-        thisConsumes: [1-inf]
-        followConsumes: [0]
-        isThisIrrefutable: false
-        isFollowIrrefutable: true
-        isWord: false
-        isThisWillNotProgress: true
-        isThisWillNotRegress: false
-        isPrevWillNotProgress: false
-        isPrevWillNotRegress: true
-        isDeterministic: false
-        isNotInLoop: true
-        isNotNegated: true
-        isAtLeastOnce: true
-        hasInitialHardFailBOI: false
-    >
-    {
-        DefineGroup(1)
-        <
-            features: {BOL,MatchChar,Concat,DefineGroup}
-            firstSet: [\x00-\uffff]
-            followSet: [\x00-\uffff]
-            prevConsumes: [0-inf]
-            thisConsumes: [1]
-            followConsumes: [0-inf]
-            isThisIrrefutable: false
-            isFollowIrrefutable: true
-            isWord: false
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: false
-            isDeterministic: true
-            isNotInLoop: false
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: false
-        >
-        {
-            Concat()
-            <
-                features: {BOL,MatchChar,Concat}
-                firstSet: [\x00-\uffff]
-                followSet: [\x00-\uffff]
-                prevConsumes: [0-inf]
-                thisConsumes: [1]
-                followConsumes: [0-inf]
-                isThisIrrefutable: false
-                isFollowIrrefutable: true
-                isWord: false
-                isThisWillNotProgress: true
-                isThisWillNotRegress: true
-                isPrevWillNotProgress: false
-                isPrevWillNotRegress: false
-                isDeterministic: true
-                isNotInLoop: false
-                isNotNegated: true
-                isAtLeastOnce: true
-                hasInitialHardFailBOI: false
-            >
-            {
-                BOL()
-                <
-                    features: {BOL}
-                    firstSet: [\x00-\uffff]
-                    followSet: [a]
-                    prevConsumes: [0-inf]
-                    thisConsumes: [0]
-                    followConsumes: [1-inf]
-                    isThisIrrefutable: false
-                    isFollowIrrefutable: false
-                    isWord: false
-                    isThisWillNotProgress: true
-                    isThisWillNotRegress: true
-                    isPrevWillNotProgress: false
-                    isPrevWillNotRegress: false
-                    isDeterministic: true
-                    isNotInLoop: false
-                    isNotNegated: true
-                    isAtLeastOnce: true
-                    hasInitialHardFailBOI: false
-                >
-                MatchChar('a')
-                <
-                    features: {MatchChar}
-                    firstSet: [a] (exact)
-                    followSet: [\x00-\uffff]
-                    prevConsumes: [0-inf]
-                    thisConsumes: [1]
-                    followConsumes: [0-inf]
-                    isThisIrrefutable: false
-                    isFollowIrrefutable: true
-                    isWord: true
-                    isThisWillNotProgress: true
-                    isThisWillNotRegress: true
-                    isPrevWillNotProgress: false
-                    isPrevWillNotRegress: false
-                    isDeterministic: true
-                    isNotInLoop: false
-                    isNotNegated: true
-                    isAtLeastOnce: true
-                    hasInitialHardFailBOI: false
-                >
-            }
-        }
-    }
-}
-REGEX PROGRAM /(^a)+/ 
-Program {
-    source:       (^a)+
-    flags:        
-    numGroups:    2
-    numLoops:     1
-    instructions: {
-        L0000: SyncToCharAndBackup(c: 'a', backup: [0-inf])
-        L0020: BeginLoopFixedGroupLastIteration(loopId: 0, repeats: [1-inf], exitLabel: L0098, hasOuterLoops: false, hasInnerNondet: false, length: 1, groupId: 1, noNeedToSave: true)
-        L0050: BOITest(hardFail: false)
-        L0068: MatchChar(c: 'a')
-        L0080: RepeatLoopFixedGroupLastIteration(beginLabel: L0020)
-        L0098: Succ()
-    }
-}
-REGEX AST /(?=^)/ {
-    Assertion(positive)
-    {
-        BOL()
-    }
-}
-REGEX ANNOTATED AST /(?=^)/ {
-    Assertion(positive)
-    <
-        features: {BOL,Assertion}
-        firstSet: [\x00-\uffff]
-        followSet: [\x00-\uffff]
-        prevConsumes: [0]
-        thisConsumes: [0]
-        followConsumes: [0]
-        isThisIrrefutable: false
-        isFollowIrrefutable: true
-        isWord: false
-        isThisWillNotProgress: true
-        isThisWillNotRegress: true
-        isPrevWillNotProgress: false
-        isPrevWillNotRegress: true
-        isDeterministic: true
-        isNotInLoop: true
-        isNotNegated: true
-        isAtLeastOnce: true
-        hasInitialHardFailBOI: true
-    >
-    {
-        BOL()
-        <
-            features: {BOL}
-            firstSet: [\x00-\uffff]
-            followSet: [\x00-\uffff]
-            prevConsumes: [0]
-            thisConsumes: [0]
-            followConsumes: [0-inf]
-            isThisIrrefutable: false
-            isFollowIrrefutable: true
-            isWord: false
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: true
-        >
-    }
-}
-REGEX PROGRAM /(?=^)/ 
-Program {
-    source:       (?=^)
-    flags:        
-    numGroups:    1
-    numLoops:     0
-    instructions: {
-        L0000: BeginAssertion(isNegation: false, nextLabel: L0048, minBodyGroupId: 1, maxBodyGroupId: -1)
-        L0020: BOITest(hardFail: true)
-        L0038: EndAssertion()
-        L0048: Succ()
-    }
-}
-REGEX AST /(^)/ {
-    DefineGroup(1)
-    {
-        BOL()
-    }
-}
-REGEX ANNOTATED AST /(^)/ {
-    DefineGroup(1)
-    <
-        features: {BOL,DefineGroup}
-        firstSet: [\x00-\uffff]
-        followSet: [\x00-\uffff]
-        prevConsumes: [0]
-        thisConsumes: [0]
-        followConsumes: [0]
-        isThisIrrefutable: false
-        isFollowIrrefutable: true
-        isWord: false
-        isThisWillNotProgress: true
-        isThisWillNotRegress: true
-        isPrevWillNotProgress: false
-        isPrevWillNotRegress: true
-        isDeterministic: true
-        isNotInLoop: true
-        isNotNegated: true
-        isAtLeastOnce: true
-        hasInitialHardFailBOI: true
-    >
-    {
-        BOL()
-        <
-            features: {BOL}
-            firstSet: [\x00-\uffff]
-            followSet: [\x00-\uffff]
-            prevConsumes: [0]
-            thisConsumes: [0]
-            followConsumes: [0]
-            isThisIrrefutable: false
-            isFollowIrrefutable: true
-            isWord: false
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: true
-        >
-    }
-}
-REGEX PROGRAM /(^)/ 
-Program {
-    source:       (^)
-    flags:        
-    numGroups:    2
-    numLoops:     0
-    instructions: {
-               BOITest(hardFail: true)
-        L0000: DefineGroupFixed(groupId: 1, length: 0, noNeedToSave: true)
-        L0020: Succ()
-    }
-}
-REGEX AST /(^)+/ {
-    Loop([1-inf], greedy)
-    {
-        DefineGroup(1)
-        {
-            BOL()
-        }
-    }
-}
-REGEX ANNOTATED AST /(^)+/ {
-    Loop([1-inf], greedy)
-    <
-        features: {BOL,DefineGroup,Loop}
-        firstSet: [\x00-\uffff]
-        followSet: [\x00-\uffff]
-        prevConsumes: [0]
-        thisConsumes: [0]
-        followConsumes: [0]
-        isThisIrrefutable: false
-        isFollowIrrefutable: true
-        isWord: false
-        isThisWillNotProgress: true
-        isThisWillNotRegress: false
-        isPrevWillNotProgress: false
-        isPrevWillNotRegress: true
-        isDeterministic: false
-        isNotInLoop: true
-        isNotNegated: true
-        isAtLeastOnce: true
-        hasInitialHardFailBOI: false
-    >
-    {
-        DefineGroup(1)
-        <
-            features: {BOL,DefineGroup}
-            firstSet: [\x00-\uffff]
-            followSet: [\x00-\uffff]
-            prevConsumes: [0]
-            thisConsumes: [0]
-            followConsumes: [0]
-            isThisIrrefutable: false
-            isFollowIrrefutable: false
-            isWord: false
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: false
-            isDeterministic: true
-            isNotInLoop: false
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: false
-        >
-        {
-            BOL()
-            <
-                features: {BOL}
-                firstSet: [\x00-\uffff]
-                followSet: [\x00-\uffff]
-                prevConsumes: [0]
-                thisConsumes: [0]
-                followConsumes: [0]
-                isThisIrrefutable: false
-                isFollowIrrefutable: false
-                isWord: false
-                isThisWillNotProgress: true
-                isThisWillNotRegress: true
-                isPrevWillNotProgress: false
-                isPrevWillNotRegress: false
-                isDeterministic: true
-                isNotInLoop: false
-                isNotNegated: true
-                isAtLeastOnce: true
-                hasInitialHardFailBOI: false
-            >
-        }
-    }
-}
-REGEX PROGRAM /(^)+/ 
-Program {
-    source:       (^)+
-    flags:        
-    numGroups:    2
-    numLoops:     1
-    instructions: {
-        L0000: BeginLoop(loopId: 0, repeats: [1-inf], exitLabel: L0080, hasOuterLoops: false, hasInnerNondet: false, minBodyGroupId: 1, maxBodyGroupId: 1, greedy: true)
-        L0030: BOITest(hardFail: false)
-        L0048: DefineGroupFixed(groupId: 1, length: 0, noNeedToSave: false)
-        L0068: RepeatLoop(beginLabel: L0000)
-        L0080: Succ()
-    }
-}
-REGEX AST /(?!^)/ {
-    Assertion(negative)
-    {
-        BOL()
-    }
-}
-REGEX ANNOTATED AST /(?!^)/ {
-    Assertion(negative)
-    <
-        features: {BOL,Assertion}
-        firstSet: [\x00-\uffff]
-        followSet: [\x00-\uffff]
-        prevConsumes: [0]
-        thisConsumes: [0]
-        followConsumes: [0]
-        isThisIrrefutable: false
-        isFollowIrrefutable: true
-        isWord: false
-        isThisWillNotProgress: true
-        isThisWillNotRegress: true
-        isPrevWillNotProgress: false
-        isPrevWillNotRegress: true
-        isDeterministic: true
-        isNotInLoop: true
-        isNotNegated: true
-        isAtLeastOnce: true
-        hasInitialHardFailBOI: false
-    >
-    {
-        BOL()
-        <
-            features: {BOL}
-            firstSet: [\x00-\uffff]
-            followSet: [\x00-\uffff]
-            prevConsumes: [0]
-            thisConsumes: [0]
-            followConsumes: [0-inf]
-            isThisIrrefutable: false
-            isFollowIrrefutable: true
-            isWord: false
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: true
-            isNotNegated: false
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: false
-        >
-    }
-}
-REGEX PROGRAM /(?!^)/ 
-Program {
-    source:       (?!^)
-    flags:        
-    numGroups:    1
-    numLoops:     0
-    instructions: {
-        L0000: BeginAssertion(isNegation: true, nextLabel: L0048, minBodyGroupId: 1, maxBodyGroupId: -1)
-        L0020: BOITest(hardFail: false)
-        L0038: EndAssertion()
-        L0048: Succ()
-    }
-}
-REGEX AST /(?:^abc)+?/ {
-    Loop([1-inf], non-greedy)
-    {
-        Concat()
-        {
-            BOL()
-            MatchLiteral("abc")
-        }
-    }
-}
-REGEX ANNOTATED AST /(?:^abc)+?/ {
-    Loop([1-inf], non-greedy)
-    <
-        features: {BOL,MatchLiteral,Concat,Loop}
-        firstSet: [\x00-\uffff]
-        followSet: [\x00-\uffff]
-        prevConsumes: [0]
-        thisConsumes: [3-inf]
-        followConsumes: [0]
-        isThisIrrefutable: false
-        isFollowIrrefutable: true
-        isWord: false
-        isThisWillNotProgress: false
-        isThisWillNotRegress: true
-        isPrevWillNotProgress: false
-        isPrevWillNotRegress: true
-        isDeterministic: false
-        isNotInLoop: true
-        isNotNegated: true
-        isAtLeastOnce: true
-        hasInitialHardFailBOI: false
-    >
-    {
-        Concat()
-        <
-            features: {BOL,MatchLiteral,Concat}
-            firstSet: [\x00-\uffff]
-            followSet: [\x00-\uffff]
-            prevConsumes: [0-inf]
-            thisConsumes: [3]
-            followConsumes: [0-inf]
-            isThisIrrefutable: false
-            isFollowIrrefutable: true
-            isWord: false
-            isThisWillNotProgress: true
-            isThisWillNotRegress: true
-            isPrevWillNotProgress: false
-            isPrevWillNotRegress: true
-            isDeterministic: true
-            isNotInLoop: false
-            isNotNegated: true
-            isAtLeastOnce: true
-            hasInitialHardFailBOI: false
-        >
-        {
-            BOL()
-            <
-                features: {BOL}
-                firstSet: [\x00-\uffff]
-                followSet: [a]
-                prevConsumes: [0-inf]
-                thisConsumes: [0]
-                followConsumes: [3-inf]
-                isThisIrrefutable: false
-                isFollowIrrefutable: false
-                isWord: false
-                isThisWillNotProgress: true
-                isThisWillNotRegress: true
-                isPrevWillNotProgress: false
-                isPrevWillNotRegress: true
-                isDeterministic: true
-                isNotInLoop: false
-                isNotNegated: true
-                isAtLeastOnce: true
-                hasInitialHardFailBOI: false
-            >
-            MatchLiteral("abc")
-            <
-                features: {MatchLiteral}
-                firstSet: [a] (exact)
-                followSet: [\x00-\uffff]
-                prevConsumes: [0-inf]
-                thisConsumes: [3]
-                followConsumes: [0-inf]
-                isThisIrrefutable: false
-                isFollowIrrefutable: true
-                isWord: true
-                isThisWillNotProgress: true
-                isThisWillNotRegress: true
-                isPrevWillNotProgress: false
-                isPrevWillNotRegress: true
-                isDeterministic: true
-                isNotInLoop: false
-                isNotNegated: true
-                isAtLeastOnce: true
-                hasInitialHardFailBOI: false
-            >
-        }
-    }
-}
-REGEX PROGRAM /(?:^abc)+?/ 
-Program {
-    source:       (?:^abc)+?
-    flags:        
-    numGroups:    1
-    numLoops:     1
-    instructions: {
-        L0000: SyncToLiteralAndBackup(literal: "abc" (with linear map Boyer-Moore scanner), backup: [0-inf])
-        L0050: BeginLoop(loopId: 0, repeats: [1-inf], exitLabel: L00c8, hasOuterLoops: false, hasInnerNondet: false, minBodyGroupId: 1, maxBodyGroupId: -1, greedy: false)
-        L0080: BOITest(hardFail: true)
-        L0098: MatchLiteral(literal: "abc")
-        L00b0: RepeatLoop(beginLabel: L0050)
-        L00c8: Succ()
-    }
-}

test/Regex/BoiHardFail.baseline

@@ -81,7 +81,7 @@ Program {
     instructions: {
                BOITest(hardFail: true)
         L0000: MatchLiteral(literal: "token")
-        L0010: Succ()
+        L0001: Succ()
     }
 }
 REGEX AST /(\w)?^token/ {
@@ -240,11 +240,11 @@ Program {
     numLoops:     0
     instructions: {
         L0000: SyncToLiteralAndBackup(literal: "token" (with full map Boyer-Moore scanner), backup: [0-1])
-        L0444: TryMatchSet(set: [0-9A-Z_a-z], failLabel: L0488)
-        L0474: DefineGroupFixed(groupId: 1, length: 1, noNeedToSave: false)
-        L0488: BOITest(hardFail: false)
-        L0494: MatchLiteral(literal: "token")
-        L04a4: Succ()
+        L0001: TryMatchSet(set: [0-9A-Z_a-z], failLabel: Lffff)
+        L0002: DefineGroupFixed(groupId: 1, length: 1, noNeedToSave: false)
+        L0003: BOITest(hardFail: false)
+        L0004: MatchLiteral(literal: "token")
+        L0005: Succ()
     }
 }
 REGEX AST /token/ {
@@ -281,7 +281,7 @@ Program {
     numLoops:     0
     instructions: {
         L0000: SyncToLiteralAndConsume(literal: "token" (with full map Boyer-Moore scanner))
-        L043c: Succ()
+        L0001: Succ()
     }
 }
 REGEX AST /^^token/ {
@@ -389,7 +389,7 @@ Program {
     instructions: {
                BOITest(hardFail: true)
         L0000: MatchLiteral(literal: "token")
-        L0010: Succ()
+        L0001: Succ()
     }
 }
 REGEX AST /token^/ {
@@ -474,8 +474,8 @@ Program {
     numLoops:     0
     instructions: {
         L0000: SyncToLiteralAndConsume(literal: "token" (with full map Boyer-Moore scanner))
-        L043c: BOITest(hardFail: true)
-        L0448: Succ()
+        L0001: BOITest(hardFail: true)
+        L0002: Succ()
     }
 }
 REGEX AST /token^token/ {
@@ -582,9 +582,9 @@ Program {
     numLoops:     0
     instructions: {
         L0000: SyncToLiteralAndConsume(literal: "token" (with full map Boyer-Moore scanner))
-        L043c: BOITest(hardFail: true)
-        L0448: MatchLiteral(literal: "token")
-        L0458: Succ()
+        L0001: BOITest(hardFail: true)
+        L0002: MatchLiteral(literal: "token")
+        L0003: Succ()
     }
 }
 REGEX AST /^token|^abc/ {
@@ -764,13 +764,13 @@ Program {
     numGroups:    1
     numLoops:     0
     instructions: {
-        L0000: Try(failLabel: L0034)
-        L000c: BOITest(hardFail: false)
-        L0018: MatchLiteral(literal: "token")
-        L0028: Jump(targetLabel: L0050)
-        L0034: BOITest(hardFail: false)
-        L0040: MatchLiteral(literal: "abc")
-        L0050: Succ()
+        L0000: Try(failLabel: Lffff)
+        L0001: BOITest(hardFail: false)
+        L0002: MatchLiteral(literal: "token")
+        L0003: Jump(targetLabel: Lffff)
+        L0004: BOITest(hardFail: false)
+        L0005: MatchLiteral(literal: "abc")
+        L0006: Succ()
     }
 }
 REGEX AST /(?!token)^abc/ {
@@ -902,12 +902,12 @@ Program {
     numGroups:    1
     numLoops:     0
     instructions: {
-        L0000: BeginAssertion(isNegation: true, nextLabel: L0030, minBodyGroupId: 1, maxBodyGroupId: -1)
-        L0018: MatchLiteral(literal: "token")
-        L0028: EndAssertion()
-        L0030: BOITest(hardFail: true)
-        L003c: MatchLiteral(literal: "abc")
-        L004c: Succ()
+        L0000: BeginAssertion(isNegation: true, nextLabel: Lffff, minBodyGroupId: 1, maxBodyGroupId: -1)
+        L0001: MatchLiteral(literal: "token")
+        L0002: EndAssertion()
+        L0003: BOITest(hardFail: true)
+        L0004: MatchLiteral(literal: "abc")
+        L0005: Succ()
     }
 }
 REGEX AST /(?=^abc)/ {
@@ -1017,11 +1017,11 @@ Program {
     numGroups:    1
     numLoops:     0
     instructions: {
-        L0000: BeginAssertion(isNegation: false, nextLabel: L003c, minBodyGroupId: 1, maxBodyGroupId: -1)
-        L0018: BOITest(hardFail: true)
-        L0024: MatchLiteral(literal: "abc")
-        L0034: EndAssertion()
-        L003c: Succ()
+        L0000: BeginAssertion(isNegation: false, nextLabel: Lffff, minBodyGroupId: 1, maxBodyGroupId: -1)
+        L0001: BOITest(hardFail: true)
+        L0002: MatchLiteral(literal: "abc")
+        L0003: EndAssertion()
+        L0004: Succ()
     }
 }
 REGEX AST /(^token)/ {
@@ -1133,8 +1133,8 @@ Program {
     instructions: {
                BOITest(hardFail: true)
         L0000: MatchLiteral(literal: "token")
-        L0010: DefineGroupFixed(groupId: 1, length: 5, noNeedToSave: true)
-        L0024: Succ()
+        L0001: DefineGroupFixed(groupId: 1, length: 5, noNeedToSave: true)
+        L0002: Succ()
     }
 }
 REGEX AST /(^a)+/ {
@@ -1271,11 +1271,11 @@ Program {
     numLoops:     1
     instructions: {
         L0000: SyncToCharAndBackup(c: 'a', backup: [0-inf])
-        L0014: BeginLoopFixedGroupLastIteration(loopId: 0, repeats: [1-inf], exitLabel: L0060, hasOuterLoops: false, hasInnerNondet: false, length: 1, groupId: 1, noNeedToSave: true)
-        L003c: BOITest(hardFail: false)
-        L0048: MatchChar(c: 'a')
-        L0054: RepeatLoopFixedGroupLastIteration(beginLabel: L0014)
-        L0060: Succ()
+        L0001: BeginLoopFixedGroupLastIteration(loopId: 0, repeats: [1-inf], exitLabel: Lffff, hasOuterLoops: false, hasInnerNondet: false, length: 1, groupId: 1, noNeedToSave: true)
+        L0002: BOITest(hardFail: false)
+        L0003: MatchChar(c: 'a')
+        L0004: RepeatLoopFixedGroupLastIteration(beginLabel: Lffff)
+        L0005: Succ()
     }
 }
 REGEX AST /(?=^)/ {
@@ -1337,10 +1337,10 @@ Program {
     numGroups:    1
     numLoops:     0
     instructions: {
-        L0000: BeginAssertion(isNegation: false, nextLabel: L002c, minBodyGroupId: 1, maxBodyGroupId: -1)
-        L0018: BOITest(hardFail: true)
-        L0024: EndAssertion()
-        L002c: Succ()
+        L0000: BeginAssertion(isNegation: false, nextLabel: Lffff, minBodyGroupId: 1, maxBodyGroupId: -1)
+        L0001: BOITest(hardFail: true)
+        L0002: EndAssertion()
+        L0003: Succ()
     }
 }
 REGEX AST /(^)/ {
@@ -1404,7 +1404,7 @@ Program {
     instructions: {
                BOITest(hardFail: true)
         L0000: DefineGroupFixed(groupId: 1, length: 0, noNeedToSave: true)
-        L0014: Succ()
+        L0001: Succ()
     }
 }
 REGEX AST /(^)+/ {
@@ -1492,11 +1492,11 @@ Program {
     numGroups:    2
     numLoops:     1
     instructions: {
-        L0000: BeginLoop(loopId: 0, repeats: [1-inf], exitLabel: L0054, hasOuterLoops: false, hasInnerNondet: false, minBodyGroupId: 1, maxBodyGroupId: 1, greedy: true)
-        L0028: BOITest(hardFail: false)
-        L0034: DefineGroupFixed(groupId: 1, length: 0, noNeedToSave: false)
-        L0048: RepeatLoop(beginLabel: L0000)
-        L0054: Succ()
+        L0000: BeginLoop(loopId: 0, repeats: [1-inf], exitLabel: Lffff, hasOuterLoops: false, hasInnerNondet: false, minBodyGroupId: 1, maxBodyGroupId: 1, greedy: true)
+        L0001: BOITest(hardFail: false)
+        L0002: DefineGroupFixed(groupId: 1, length: 0, noNeedToSave: false)
+        L0003: RepeatLoop(beginLabel: Lffff)
+        L0004: Succ()
     }
 }
 REGEX AST /(?!^)/ {
@@ -1558,10 +1558,10 @@ Program {
     numGroups:    1
     numLoops:     0
     instructions: {
-        L0000: BeginAssertion(isNegation: true, nextLabel: L002c, minBodyGroupId: 1, maxBodyGroupId: -1)
-        L0018: BOITest(hardFail: false)
-        L0024: EndAssertion()
-        L002c: Succ()
+        L0000: BeginAssertion(isNegation: true, nextLabel: Lffff, minBodyGroupId: 1, maxBodyGroupId: -1)
+        L0001: BOITest(hardFail: false)
+        L0002: EndAssertion()
+        L0003: Succ()
     }
 }
 REGEX AST /(?:^abc)+?/ {
@@ -1672,10 +1672,10 @@ Program {
     numLoops:     1
     instructions: {
         L0000: SyncToLiteralAndBackup(literal: "abc" (with linear map Boyer-Moore scanner), backup: [0-inf])
-        L0040: BeginLoop(loopId: 0, repeats: [1-inf], exitLabel: L0090, hasOuterLoops: false, hasInnerNondet: false, minBodyGroupId: 1, maxBodyGroupId: -1, greedy: false)
-        L0068: BOITest(hardFail: true)
-        L0074: MatchLiteral(literal: "abc")
-        L0084: RepeatLoop(beginLabel: L0040)
-        L0090: Succ()
+        L0001: BeginLoop(loopId: 0, repeats: [1-inf], exitLabel: Lffff, hasOuterLoops: false, hasInnerNondet: false, minBodyGroupId: 1, maxBodyGroupId: -1, greedy: false)
+        L0002: BOITest(hardFail: true)
+        L0003: MatchLiteral(literal: "abc")
+        L0004: RepeatLoop(beginLabel: Lffff)
+        L0005: Succ()
     }
 }

test/Regex/rlexe.xml

@@ -153,15 +153,7 @@
       <files>BoiHardFail.js</files>
       <baseline>BoiHardFail.baseline</baseline>
       <compile-flags>-regexDebug</compile-flags>
-      <tags>exclude_fre,exclude_apollo,exclude_amd64,exclude_serialized</tags>
-    </default>
-  </test>
-  <test>
-    <default>
-      <files>BoiHardFail.js</files>
-      <baseline>BoiHardFail.amd64.baseline</baseline>
-      <compile-flags>-regexDebug</compile-flags>
-      <tags>exclude_fre,exclude_apollo,exclude_x86,exclude_arm,exclude_serialized</tags>
+      <tags>exclude_fre,exclude_apollo,exclude_serialized</tags>
     </default>
   </test>
   <test>

test/runtests.cmd

@@ -362,7 +362,7 @@ goto :main
   )
 
   if "%_Binary%" == "-binary:ch.exe" (
-    set EXTRA_CC_FLAGS=%EXTRA_CC_FLAGS% -WERExceptionSupport -ExtendedErrorStackForTestHost
+    set EXTRA_CC_FLAGS=%EXTRA_CC_FLAGS% -WERExceptionSupport -ExtendedErrorStackForTestHost -BaselineMode
   )
 
   if "%_TESTCONFIG%"=="interpreted" (

test/runtests.py

@@ -194,7 +194,8 @@ class TestVariant(object):
     def __init__(self, name, compile_flags=[]):
         self.name = name
         self.compile_flags = \
-            ['-WERExceptionSupport', '-ExtendedErrorStackForTestHost'] + compile_flags
+            ['-WERExceptionSupport', '-ExtendedErrorStackForTestHost',
+             '-BaselineMode'] + compile_flags
         self.tags = tags.copy()
         self.not_tags = not_tags.union(
             ['{}_{}'.format(x, name) for x in ('fails','exclude')])