Emit mustprogress and add --fast-math for loop optimizations/vectorization (#198)

* Emit mustprogress on lowered functions to unlock loop optimizations

Every ts function lowered to LLVM carried no function attributes at
all, including mustprogress. Without it, LLVM's -O2/-O3 loop passes
(LICM, unrolling, vectorization) must stay conservative since they
can't assume a loop terminates or has an observable side effect.
Verified with an isolated integer-bounded reduction loop that -O3
neither unrolled nor vectorized it despite a clean, SCEV-friendly
shape; after this change the attribute is correctly emitted and the
full 681-test suite (compile + JIT) still passes unchanged.

Fast-math flags (needed for FP-reduction vectorization) are
intentionally left out of this change since they'd change IEEE-754
semantics and should be an explicit opt-in, not bundled here.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* fast math attribute support

---------

Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>

Author: ASDAlexander77

tslang/include/TypeScript/DataStructs.h

@@ -26,6 +26,7 @@ struct CompileOptions
     std::string outputFolder;
     bool appendGCtorsToMethod;
     bool strictNullChecks;
+    bool enableFastMath;
 };
 
 #endif // TYPESCRIPT_DATASTRUCT_H_

tslang/lib/TypeScript/LowerToLLVM.cpp

@@ -337,8 +337,9 @@ class IsNaNOpLowering : public TsLlvmPattern<mlir_ts::IsNaNOp>
 
         TypeHelper th(rewriter.getContext());
 
-        // icmp
-        auto cmpValue = rewriter.create<LLVM::FCmpOp>(loc, th.getLLVMBoolType(), LLVM::FCmpPredicate::one,
+        // uno (unordered) self-compare is true iff the value is NaN; `one` here would
+        // be constant false (ordered && x != x can never hold for a self-compare).
+        auto cmpValue = rewriter.create<LLVM::FCmpOp>(loc, th.getLLVMBoolType(), LLVM::FCmpPredicate::uno,
                                                       transformed.getArg(), transformed.getArg());
         rewriter.replaceOp(op, ValueRange{cmpValue});
         return success();
@@ -1132,6 +1133,14 @@ struct FuncOpLowering : public TsLlvmPattern<mlir_ts::FuncOp>
 
         SmallVector<mlir::Attribute> funcAttrs;
 
+        // mustprogress licenses standard -O2/-O3 loop transforms (LICM, unrolling,
+        // vectorization of provably-finite loops) that otherwise stay conservative
+        // without proof the loop can't spin forever with no observable effect. Every
+        // ts loop with a call/store in its body already satisfies the (weaker)
+        // mustprogress contract; a body-less `while(true){}` is the only case this
+        // attribute changes the meaning of, same as in C/C++/Rust.
+        funcAttrs.push_back(ATTR("mustprogress"));
+
         if (funcOp.getPersonality().has_value() && funcOp.getPersonality().value())
         {
             LLVMRTTIHelperVC rttih(funcOp, rewriter, typeConverter, tsLlvmContext->compileOptions);
@@ -3035,7 +3044,10 @@ struct LogicalBinaryOpLowering : public TsLlvmPattern<mlir_ts::LogicalBinaryOp>
             break;
         case SyntaxKind::ExclamationEqualsToken:
         case SyntaxKind::ExclamationEqualsEqualsToken:
-            value = logicOp<arith::CmpIPredicate::ne, arith::CmpFPredicate::ONE>(logicalBinaryOp, op, op1, opType1, op2, opType2,
+            // UNE, not ONE: JS `!=`/`!==` is the negation of `==`, so NaN != x must be
+            // true. ONE (ordered) yields false when either side is NaN, and `x != x`
+            // (the idiomatic NaN test) folds to constant false.
+            value = logicOp<arith::CmpIPredicate::ne, arith::CmpFPredicate::UNE>(logicalBinaryOp, op, op1, opType1, op2, opType2,
                                                                    rewriter);
             break;
         case SyntaxKind::GreaterThanToken:

tslang/test/tester/CMakeLists.txt

@@ -105,7 +105,11 @@ file(REMOVE
     "${CMAKE_CURRENT_BINARY_DIR}/compile.bat"  "${CMAKE_CURRENT_BINARY_DIR}/jit.bat"
     "${CMAKE_CURRENT_BINARY_DIR}/compiled.bat" "${CMAKE_CURRENT_BINARY_DIR}/jitd.bat"
     "${CMAKE_CURRENT_BINARY_DIR}/compile.sh"   "${CMAKE_CURRENT_BINARY_DIR}/jit.sh"
-    "${CMAKE_CURRENT_BINARY_DIR}/compiled.sh"  "${CMAKE_CURRENT_BINARY_DIR}/jitd.sh")
+    "${CMAKE_CURRENT_BINARY_DIR}/compiled.sh"  "${CMAKE_CURRENT_BINARY_DIR}/jitd.sh"
+    "${CMAKE_CURRENT_BINARY_DIR}/compilefm.bat" "${CMAKE_CURRENT_BINARY_DIR}/jitfm.bat"
+    "${CMAKE_CURRENT_BINARY_DIR}/compiledfm.bat" "${CMAKE_CURRENT_BINARY_DIR}/jitdfm.bat"
+    "${CMAKE_CURRENT_BINARY_DIR}/compilefm.sh"  "${CMAKE_CURRENT_BINARY_DIR}/jitfm.sh"
+    "${CMAKE_CURRENT_BINARY_DIR}/compiledfm.sh" "${CMAKE_CURRENT_BINARY_DIR}/jitdfm.sh")
 
 ######## enable testing ############
 # open __build\tslang   
@@ -443,6 +447,7 @@ add_test(NAME test-compile-reference-null-bug COMMAND test-runner "${PROJECT_SOU
 add_test(NAME test-compile-reference-index-bug COMMAND test-runner "${PROJECT_SOURCE_DIR}/test/tester/tests/00reference_index_bug.ts")
 add_test(NAME test-compile-uint-compare-bug COMMAND test-runner "${PROJECT_SOURCE_DIR}/test/tester/tests/00uint_compare_bug.ts")
 add_test(NAME test-compile-gc-malloc-cse-o3 COMMAND test-runner "${PROJECT_SOURCE_DIR}/test/tester/tests/gc_malloc_cse_o3.ts")
+add_test(NAME test-compile-fast-math COMMAND test-runner -fast-math "${PROJECT_SOURCE_DIR}/test/tester/tests/fast_math.ts")
 
 add_test(NAME test-jit-00-print COMMAND test-runner -jit "${PROJECT_SOURCE_DIR}/test/tester/tests/00print.ts")
 add_test(NAME test-jit-00-assert COMMAND test-runner -jit "${PROJECT_SOURCE_DIR}/test/tester/tests/00assert.ts")
@@ -774,6 +779,7 @@ add_test(NAME test-jit-reference-null-bug COMMAND test-runner -jit "${PROJECT_SO
 add_test(NAME test-jit-reference-index-bug COMMAND test-runner -jit "${PROJECT_SOURCE_DIR}/test/tester/tests/00reference_index_bug.ts")
 add_test(NAME test-jit-uint-compare-bug COMMAND test-runner -jit "${PROJECT_SOURCE_DIR}/test/tester/tests/00uint_compare_bug.ts")
 add_test(NAME test-jit-gc-malloc-cse-o3 COMMAND test-runner -jit "${PROJECT_SOURCE_DIR}/test/tester/tests/gc_malloc_cse_o3.ts")
+add_test(NAME test-jit-fast-math COMMAND test-runner -jit -fast-math "${PROJECT_SOURCE_DIR}/test/tester/tests/fast_math.ts")
 
 # tesing include
 add_test(NAME test-compile-include-global-var COMMAND test-runner "${PROJECT_SOURCE_DIR}/test/tester/tests/include_global_var.ts" "${PROJECT_SOURCE_DIR}/test/tester/tests/define_global_var.ts")

tslang/test/tester/test-runner.cpp

@@ -99,17 +99,32 @@ auto tslang_opt = "--di --opt_level=0 --no-default-lib";
 #define COMPILE_NAME "compiled"
 #endif
 
+auto fastMath = false;
 auto tslang_opt_ext = std::string("");
 
+// -fast-math tests get their own cached script (jitfm/compilefm) because the
+// plain jit/compile scripts are shared across all parallel single-file tests
+// and embed tslang_opt_ext at creation time - reusing the same file name would
+// let whichever runner created it first decide the flags for everyone.
+std::string jitBatName()
+{
+    return std::string(JIT_NAME) + (fastMath ? "fm" : "") + BAT_NAME;
+}
+
+std::string compileBatName()
+{
+    return std::string(COMPILE_NAME) + (fastMath ? "fm" : "") + BAT_NAME;
+}
+
 void createJitBatchFile()
 {
-#ifdef WIN32    
-    if (exists(JIT_NAME BAT_NAME))
+#ifdef WIN32
+    if (exists(jitBatName()))
     {
         return;
     }
 
-    std::ofstream batFile(JIT_NAME BAT_NAME);
+    std::ofstream batFile(jitBatName());
     batFile << "echo off" << std::endl;
     batFile << "set FILENAME=%1" << std::endl;
     batFile << "set FILEPATH=%2" << std::endl;
@@ -119,12 +134,12 @@ void createJitBatchFile()
             << std::endl;
     batFile.close();
 #else
-    if (exists(JIT_NAME BAT_NAME))
+    if (exists(jitBatName()))
     {
         return;
     }
 
-    std::ofstream batFile(JIT_NAME BAT_NAME);
+    std::ofstream batFile(jitBatName());
     batFile << "FILENAME=$1" << std::endl;
     batFile << "FILEPATH=$2" << std::endl;
     batFile << "TSLANGEXEPATH=" << TEST_TSLANG_EXEPATH << std::endl;
@@ -136,13 +151,13 @@ void createJitBatchFile()
 
 void createCompileBatchFile()
 {
-#ifdef WIN32     
-    if (exists(COMPILE_NAME BAT_NAME))
+#ifdef WIN32
+    if (exists(compileBatName()))
     {
         return;
     }
 
-    std::ofstream batFile(COMPILE_NAME BAT_NAME);
+    std::ofstream batFile(compileBatName());
     batFile << "echo off" << std::endl;
     batFile << "set FILENAME=%1" << std::endl;
     batFile << "set FILEPATH=%2" << std::endl;
@@ -169,12 +184,12 @@ void createCompileBatchFile()
     batFile << "echo on" << std::endl;
     batFile.close();
 #else
-    if (exists(COMPILE_NAME BAT_NAME))
+    if (exists(compileBatName()))
     {
         return;
     }
 
-    std::ofstream batFile(COMPILE_NAME BAT_NAME);
+    std::ofstream batFile(compileBatName());
     batFile << "FILENAME=$1" << std::endl;
     batFile << "FILEPATH=$2" << std::endl;
     batFile << "LINKER_OPTS=$3" << std::endl;
@@ -207,12 +222,12 @@ void createBatchFile()
 
 void buildJitExecCommand(std::stringstream &ss, std::string fileNameNoExt, std::string file)
 {
-    ss << RUN_CMD << JIT_NAME BAT_NAME << " " << fileNameNoExt << " " << file;
+    ss << RUN_CMD << jitBatName() << " " << fileNameNoExt << " " << file;
 }
 
 void buildCompileExecCommand(std::stringstream &ss, std::string fileNameNoExt, std::string file)
 {
-    ss << RUN_CMD << COMPILE_NAME BAT_NAME << " " << fileNameNoExt << " " << file;
+    ss << RUN_CMD << compileBatName() << " " << fileNameNoExt << " " << file;
     if (sharedLib)
     {
         ss << SHARED_LIB_OPT;
@@ -664,6 +679,11 @@ void readParams(int argc, char **argv, std::vector<std::string> &files)
         {
             opt = false;
         }
+        else if (std::string(argv[index]) == "-fast-math")
+        {
+            fastMath = true;
+            tslang_opt_ext += " --fast-math";
+        }
         else if (exists(argv[index]))
         {
             files.push_back(argv[index]);

tslang/test/tester/tests/02numbers.ts

@@ -202,8 +202,12 @@ function testComma() {
     assert(y.length == 4, "y");
 }
 
+// NaN is the only value not strictly equal to itself: `NaN !== NaN` is true and
+// `NaN === NaN` is false per ECMAScript. The previous form
+// `(x !== x) === (x === x)` is always false in conforming JS and only passed
+// while `!==` was mis-lowered to an ordered (ONE) float compare.
 function isnan(x: number) {
-    return (x !== x) === (x === x);
+    return x !== x;
 }
 
 function mydiv(x: number, y: number) {

tslang/test/tester/tests/fast_math.ts

@@ -0,0 +1,85 @@
+// Run by test-compile-fast-math / test-jit-fast-math with the extra --fast-math
+// compiler flag (see test-runner -fast-math). Verifies that the relaxed
+// floating-point mode keeps the language semantics it promises to keep:
+//
+// 1. FP loop reductions still compute correct results. All values below are
+//    exact multiples of 0.125, so every partial sum is exactly representable
+//    and reassociation (the transform --fast-math licenses, and what the -O3
+//    vectorizer uses to turn the loop into SIMD lanes) cannot change the
+//    result - exact equality asserts stay valid.
+// 2. NaN and Infinity semantics survive: --fast-math deliberately omits
+//    nnan/ninf, so `x !== x` NaN checks and Infinity arithmetic keep working.
+// 3. Plain counted integer loops are unaffected.
+
+function isnan(x: number) {
+    return x !== x;
+}
+
+function fpReduction(n: int): number {
+    let arr: number[] = [];
+    for (let i = 0; i < n; i++) {
+        arr.push((i % 10) * 0.125);
+    }
+
+    let sum: number = 0.0;
+    for (let i = 0; i < n; i++) {
+        sum = sum + arr[i];
+    }
+
+    return sum;
+}
+
+function dotProduct(n: int): number {
+    let a: number[] = [];
+    let b: number[] = [];
+    for (let i = 0; i < n; i++) {
+        a.push((i % 8) * 0.25);
+        b.push(((i + 1) % 4) * 0.5);
+    }
+
+    let sum: number = 0.0;
+    for (let i = 0; i < n; i++) {
+        sum = sum + a[i] * b[i];
+    }
+
+    return sum;
+}
+
+function intTriangle(n: int): int {
+    let s: int = 0;
+    for (let i: int = 1; i <= n; i++) {
+        s = s + i;
+    }
+
+    return s;
+}
+
+function testNaNAndInfinity() {
+    const zero: number = fpReduction(10) - 5.625; // 0.0, computed at runtime
+    const nan = zero / zero;
+    assert(nan !== nan, "NaN !== NaN must stay true under --fast-math");
+    assert(!(nan === nan), "NaN === NaN must stay false under --fast-math");
+    assert(isnan(nan), "isnan(0/0)");
+    assert(!isnan(1.5), "!isnan(1.5)");
+    assert(!isnan(zero), "!isnan(0)");
+
+    const inf = 1.0 / zero;
+    assert(!isnan(inf), "Infinity is not NaN");
+    assert(inf > 1.0e308, "Infinity compares greater than any finite double");
+    assert(1.0 / inf === 0.0, "1/Infinity === 0");
+    assert(-inf < -1.0e308, "-Infinity stays representable");
+}
+
+function main() {
+    // per 10 elements: (0+1+...+9)*0.125 = 5.625; 100 groups
+    assert(fpReduction(1000) === 562.5, "fp sum reduction");
+
+    // per 8 elements the products sum to exactly 5.0; 100 cycles
+    assert(dotProduct(800) === 500.0, "fp dot product");
+
+    assert(intTriangle(1000) === 500500, "integer counted loop");
+
+    testNaNAndInfinity();
+
+    print("done.");
+}

tslang/tslang/opts.cpp

@@ -25,8 +25,9 @@ extern cl::opt<bool> enableBuiltins;
 extern cl::opt<bool> noDefaultLib;
 extern cl::opt<std::string> outputFilename;
 extern cl::opt<bool> appendGCtorsToMethod;
-extern cl::opt<bool> strictNullChecks; 
+extern cl::opt<bool> strictNullChecks;
 extern cl::opt<bool> embedExportDeclarationsAction;
+extern cl::opt<bool> enableFastMath;
 
 // obj
 extern cl::opt<std::string> TargetTriple;
@@ -57,6 +58,7 @@ CompileOptions prepareOptions()
     compileOptions.isDLL = emitAction == Action::BuildDll;
     compileOptions.appendGCtorsToMethod = appendGCtorsToMethod.getValue();
     compileOptions.strictNullChecks = strictNullChecks.getValue();
+    compileOptions.enableFastMath = enableFastMath.getValue();
     if (
         TheTriple.getArch() == llvm::Triple::UnknownArch
         || TheTriple.getArch() == llvm::Triple::aarch64        // AArch64 (little endian): aarch64