[turbofan] Change TruncateFloat32ToUint64 to TryTruncateFloat32ToUint64.

TryTruncateFloat32ToUint64 converts a float32 to a uint64. Additionally it
provides an optional second return value which indicates whether the conversion
succeeded (i.e. float32 value was within uint64 range) or not.

I implemented the new operator on x64, arm64, and mips64. @v8-ppc-ports, can you
please take care of the ppc64 implementation of the second output?

Additionally I fixed a bug on x64 and mips64 in the implementation of
TryTruncateFloat64ToUint64. Cases where the input value was between -1 and 0
were handled incorrectly.

R=titzer@chromium.org, v8-arm-ports@googlegroups.com, v8-mips-ports@googlegroups.com

Review URL: https://codereview.chromium.org/1512023002

Cr-Commit-Position: refs/heads/master@{#32796}

src/compiler/arm64/code-generator-arm64.cc

@@ -1058,6 +1058,11 @@ void CodeGenerator::AssembleArchInstruction(Instruction* instr) {
       break;
     case kArm64Float32ToUint64:
       __ Fcvtzu(i.OutputRegister64(), i.InputFloat32Register(0));
+      if (i.OutputCount() > 1) {
+        __ Fcmp(i.InputFloat32Register(0), 0.0);
+        __ Ccmp(i.OutputRegister(0), -1, ZFlag, ge);
+        __ Cset(i.OutputRegister(1), ne);
+      }
       break;
     case kArm64Float64ToUint64:
       __ Fcvtzu(i.OutputRegister64(), i.InputDoubleRegister(0));

src/compiler/arm64/instruction-selector-arm64.cc

@@ -1270,8 +1270,20 @@ void InstructionSelector::VisitTryTruncateFloat64ToInt64(Node* node) {
 }
 
 
-void InstructionSelector::VisitTruncateFloat32ToUint64(Node* node) {
-  VisitRR(this, kArm64Float32ToUint64, node);
+void InstructionSelector::VisitTryTruncateFloat32ToUint64(Node* node) {
+  Arm64OperandGenerator g(this);
+
+  InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0))};
+  InstructionOperand outputs[2];
+  size_t output_count = 0;
+  outputs[output_count++] = g.DefineAsRegister(node);
+
+  Node* success_output = NodeProperties::FindProjection(node, 1);
+  if (success_output) {
+    outputs[output_count++] = g.DefineAsRegister(success_output);
+  }
+
+  Emit(kArm64Float32ToUint64, output_count, outputs, 1, inputs);
 }
 
 

src/compiler/instruction-selector.cc

@@ -831,8 +831,8 @@ void InstructionSelector::VisitNode(Node* node) {
       return MarkAsWord64(node), VisitTryTruncateFloat32ToInt64(node);
     case IrOpcode::kTryTruncateFloat64ToInt64:
       return MarkAsWord64(node), VisitTryTruncateFloat64ToInt64(node);
-    case IrOpcode::kTruncateFloat32ToUint64:
-      return MarkAsWord64(node), VisitTruncateFloat32ToUint64(node);
+    case IrOpcode::kTryTruncateFloat32ToUint64:
+      return MarkAsWord64(node), VisitTryTruncateFloat32ToUint64(node);
     case IrOpcode::kTryTruncateFloat64ToUint64:
       return MarkAsWord64(node), VisitTryTruncateFloat64ToUint64(node);
     case IrOpcode::kChangeInt32ToInt64:
@@ -1094,7 +1094,7 @@ void InstructionSelector::VisitTryTruncateFloat64ToInt64(Node* node) {
 }
 
 
-void InstructionSelector::VisitTruncateFloat32ToUint64(Node* node) {
+void InstructionSelector::VisitTryTruncateFloat32ToUint64(Node* node) {
   UNIMPLEMENTED();
 }
 
@@ -1214,6 +1214,7 @@ void InstructionSelector::VisitProjection(Node* node) {
     case IrOpcode::kInt32SubWithOverflow:
     case IrOpcode::kTryTruncateFloat32ToInt64:
     case IrOpcode::kTryTruncateFloat64ToInt64:
+    case IrOpcode::kTryTruncateFloat32ToUint64:
     case IrOpcode::kTryTruncateFloat64ToUint64:
       if (ProjectionIndexOf(node->op()) == 0u) {
         Emit(kArchNop, g.DefineSameAsFirst(node), g.Use(value));

src/compiler/machine-operator.cc

@@ -143,7 +143,7 @@ CheckedStoreRepresentation CheckedStoreRepresentationOf(Operator const* op) {
   V(ChangeFloat64ToUint32, Operator::kNoProperties, 1, 0, 1)                  \
   V(TryTruncateFloat32ToInt64, Operator::kNoProperties, 1, 0, 2)              \
   V(TryTruncateFloat64ToInt64, Operator::kNoProperties, 1, 0, 2)              \
-  V(TruncateFloat32ToUint64, Operator::kNoProperties, 1, 0, 1)                \
+  V(TryTruncateFloat32ToUint64, Operator::kNoProperties, 1, 0, 2)             \
   V(TryTruncateFloat64ToUint64, Operator::kNoProperties, 1, 0, 2)             \
   V(ChangeInt32ToFloat64, Operator::kNoProperties, 1, 0, 1)                   \
   V(RoundInt64ToFloat32, Operator::kNoProperties, 1, 0, 1)                    \

src/compiler/machine-operator.h

@@ -212,7 +212,7 @@ class MachineOperatorBuilder final : public ZoneObject {
   const Operator* ChangeFloat64ToUint32();  // narrowing
   const Operator* TryTruncateFloat32ToInt64();
   const Operator* TryTruncateFloat64ToInt64();
-  const Operator* TruncateFloat32ToUint64();
+  const Operator* TryTruncateFloat32ToUint64();
   const Operator* TryTruncateFloat64ToUint64();
   const Operator* ChangeInt32ToFloat64();
   const Operator* ChangeInt32ToInt64();

src/compiler/mips64/code-generator-mips64.cc

@@ -1153,8 +1153,10 @@ void CodeGenerator::AssembleArchInstruction(Instruction* instr) {
     }
     case kMips64TruncUlS: {
       FPURegister scratch = kScratchDoubleReg;
+      Register result = instr->OutputCount() > 1 ? i.OutputRegister(1) : no_reg;
       // TODO(plind): Fix wrong param order of Trunc_ul_s() macro-asm function.
-      __ Trunc_ul_s(i.InputDoubleRegister(0), i.OutputRegister(), scratch);
+      __ Trunc_ul_s(i.InputDoubleRegister(0), i.OutputRegister(), scratch,
+                    result);
       break;
     }
     case kMips64TruncUlD: {

src/compiler/mips64/instruction-selector-mips64.cc

@@ -881,8 +881,19 @@ void InstructionSelector::VisitTryTruncateFloat64ToInt64(Node* node) {
 }
 
 
-void InstructionSelector::VisitTruncateFloat32ToUint64(Node* node) {
-  VisitRR(this, kMips64TruncUlS, node);
+void InstructionSelector::VisitTryTruncateFloat32ToUint64(Node* node) {
+  Mips64OperandGenerator g(this);
+  InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0))};
+  InstructionOperand outputs[2];
+  size_t output_count = 0;
+  outputs[output_count++] = g.DefineAsRegister(node);
+
+  Node* success_output = NodeProperties::FindProjection(node, 1);
+  if (success_output) {
+    outputs[output_count++] = g.DefineAsRegister(success_output);
+  }
+
+  Emit(kMips64TruncUlS, output_count, outputs, 1, inputs);
 }
 
 

src/compiler/opcodes.h

@@ -268,7 +268,7 @@
   V(ChangeFloat64ToUint32)      \
   V(TryTruncateFloat32ToInt64)  \
   V(TryTruncateFloat64ToInt64)  \
-  V(TruncateFloat32ToUint64)    \
+  V(TryTruncateFloat32ToUint64) \
   V(TryTruncateFloat64ToUint64) \
   V(ChangeInt32ToFloat64)       \
   V(ChangeInt32ToInt64)         \

src/compiler/ppc/instruction-selector-ppc.cc

@@ -949,7 +949,11 @@ void InstructionSelector::VisitTryTruncateFloat64ToInt64(Node* node) {
 }
 
 
-void InstructionSelector::VisitTruncateFloat32ToUint64(Node* node) {
+void InstructionSelector::VisitTryTruncateFloat32ToUint64(Node* node) {
+  if (NodeProperties::FindProjection(node, 1)) {
+    // TODO(ppc): implement the second return value.
+    UNIMPLEMENTED();
+  }
   VisitRR(this, kPPC_DoubleToUint64, node);
 }
 

src/compiler/raw-machine-assembler.h

@@ -443,7 +443,12 @@ class RawMachineAssembler {
     return AddNode(machine()->TryTruncateFloat64ToInt64(), a);
   }
   Node* TruncateFloat32ToUint64(Node* a) {
-    return AddNode(machine()->TruncateFloat32ToUint64(), a);
+    // TODO(ahaas): Remove this function as soon as it is not used anymore in
+    // WebAssembly.
+    return AddNode(machine()->TryTruncateFloat32ToUint64(), a);
+  }
+  Node* TryTruncateFloat32ToUint64(Node* a) {
+    return AddNode(machine()->TryTruncateFloat32ToUint64(), a);
   }
   Node* TruncateFloat64ToUint64(Node* a) {
     // TODO(ahaas): Remove this function as soon as it is not used anymore in

src/compiler/typer.cc

@@ -2135,7 +2135,7 @@ Type* Typer::Visitor::TypeTryTruncateFloat64ToInt64(Node* node) {
 }
 
 
-Type* Typer::Visitor::TypeTruncateFloat32ToUint64(Node* node) {
+Type* Typer::Visitor::TypeTryTruncateFloat32ToUint64(Node* node) {
   return Type::Internal();
 }
 

src/compiler/verifier.cc

@@ -919,7 +919,7 @@ void Verifier::Visitor::Check(Node* node) {
     case IrOpcode::kChangeFloat64ToUint32:
     case IrOpcode::kTryTruncateFloat32ToInt64:
     case IrOpcode::kTryTruncateFloat64ToInt64:
-    case IrOpcode::kTruncateFloat32ToUint64:
+    case IrOpcode::kTryTruncateFloat32ToUint64:
     case IrOpcode::kTryTruncateFloat64ToUint64:
     case IrOpcode::kFloat64ExtractLowWord32:
     case IrOpcode::kFloat64ExtractHighWord32:

src/compiler/x64/code-generator-x64.cc

@@ -1068,6 +1068,19 @@ void CodeGenerator::AssembleArchInstruction(Instruction* instr) {
       }
       break;
     case kSSEFloat32ToUint64: {
+      Label done;
+      Label success;
+      if (instr->OutputCount() > 1) {
+        __ Set(i.OutputRegister(1), 0);
+        __ xorps(kScratchDoubleReg, kScratchDoubleReg);
+
+        if (instr->InputAt(0)->IsDoubleRegister()) {
+          __ Ucomiss(kScratchDoubleReg, i.InputDoubleRegister(0));
+        } else {
+          __ Ucomiss(kScratchDoubleReg, i.InputOperand(0));
+        }
+        __ j(above, &done);
+      }
       // There does not exist a Float32ToUint64 instruction, so we have to use
       // the Float32ToInt64 instruction.
       if (instr->InputAt(0)->IsDoubleRegister()) {
@@ -1078,8 +1091,7 @@ void CodeGenerator::AssembleArchInstruction(Instruction* instr) {
       // Check if the result of the Float32ToInt64 conversion is positive, we
       // are already done.
       __ testq(i.OutputRegister(), i.OutputRegister());
-      Label done;
-      __ j(positive, &done);
+      __ j(positive, &success);
       // The result of the first conversion was negative, which means that the
       // input value was not within the positive int64 range. We subtract 2^64
       // and convert it again to see if it is within the uint64 range.
@@ -1099,10 +1111,27 @@ void CodeGenerator::AssembleArchInstruction(Instruction* instr) {
       // earlier.
       __ Set(kScratchRegister, 0x8000000000000000);
       __ orq(i.OutputRegister(), kScratchRegister);
+      __ bind(&success);
+      if (instr->OutputCount() > 1) {
+        __ Set(i.OutputRegister(1), 1);
+      }
       __ bind(&done);
       break;
     }
     case kSSEFloat64ToUint64: {
+      Label done;
+      Label success;
+      if (instr->OutputCount() > 1) {
+        __ Set(i.OutputRegister(1), 0);
+        __ xorps(kScratchDoubleReg, kScratchDoubleReg);
+
+        if (instr->InputAt(0)->IsDoubleRegister()) {
+          __ Ucomisd(kScratchDoubleReg, i.InputDoubleRegister(0));
+        } else {
+          __ Ucomisd(kScratchDoubleReg, i.InputOperand(0));
+        }
+        __ j(above, &done);
+      }
       // There does not exist a Float64ToUint64 instruction, so we have to use
       // the Float64ToInt64 instruction.
       if (instr->InputAt(0)->IsDoubleRegister()) {
@@ -1110,14 +1139,9 @@ void CodeGenerator::AssembleArchInstruction(Instruction* instr) {
       } else {
         __ Cvttsd2siq(i.OutputRegister(), i.InputOperand(0));
       }
-      if (instr->OutputCount() > 1) {
-        __ Set(i.OutputRegister(1), 0);
-      }
       // Check if the result of the Float64ToInt64 conversion is positive, we
       // are already done.
       __ testq(i.OutputRegister(), i.OutputRegister());
-      Label done;
-      Label success;
       __ j(positive, &success);
       // The result of the first conversion was negative, which means that the
       // input value was not within the positive int64 range. We subtract 2^64

src/compiler/x64/instruction-selector-x64.cc

@@ -865,9 +865,19 @@ void InstructionSelector::VisitTryTruncateFloat64ToInt64(Node* node) {
 }
 
 
-void InstructionSelector::VisitTruncateFloat32ToUint64(Node* node) {
+void InstructionSelector::VisitTryTruncateFloat32ToUint64(Node* node) {
   X64OperandGenerator g(this);
-  Emit(kSSEFloat32ToUint64, g.DefineAsRegister(node), g.Use(node->InputAt(0)));
+  InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0))};
+  InstructionOperand outputs[2];
+  size_t output_count = 0;
+  outputs[output_count++] = g.DefineAsRegister(node);
+
+  Node* success_output = NodeProperties::FindProjection(node, 1);
+  if (success_output) {
+    outputs[output_count++] = g.DefineAsRegister(success_output);
+  }
+
+  Emit(kSSEFloat32ToUint64, output_count, outputs, 1, inputs);
 }
 
 

src/mips64/macro-assembler-mips64.cc

@@ -1638,8 +1638,8 @@ void MacroAssembler::Trunc_ul_d(FPURegister fd, FPURegister fs,
 
 
 void MacroAssembler::Trunc_ul_s(FPURegister fd, FPURegister fs,
-                                FPURegister scratch) {
-  Trunc_ul_s(fs, t8, scratch);
+                                FPURegister scratch, Register result) {
+  Trunc_ul_s(fs, t8, scratch, result);
   dmtc1(t8, fd);
 }
 
@@ -1702,9 +1702,12 @@ void MacroAssembler::Trunc_ul_d(FPURegister fd, Register rs,
   DCHECK(!fd.is(scratch));
   DCHECK(!AreAliased(rs, result, at));
 
+  Label simple_convert, done, fail;
   if (result.is_valid()) {
     mov(result, zero_reg);
     Move(kDoubleRegZero, 0.0);
+    // If fd < 0 or unordered, then the conversion fails.
+    BranchF(&fail, &fail, lt, fd, kDoubleRegZero);
   }
 
   // Load 2^63 into scratch as its double representation.
@@ -1713,9 +1716,7 @@ void MacroAssembler::Trunc_ul_d(FPURegister fd, Register rs,
 
   // Test if scratch > fd.
   // If fd < 2^63 we can convert it normally.
-  // If fd is unordered the conversion fails.
-  Label simple_convert, done, fail;
-  BranchF(&simple_convert, &fail, lt, fd, scratch);
+  BranchF(&simple_convert, nullptr, lt, fd, scratch);
 
   // First we subtract 2^63 from fd, then trunc it to rs
   // and add 2^63 to rs.
@@ -1732,9 +1733,12 @@ void MacroAssembler::Trunc_ul_d(FPURegister fd, Register rs,
 
   bind(&done);
   if (result.is_valid()) {
-    // Conversion is failed if the result is negative or unordered.
-    BranchF(&fail, &fail, lt, scratch, kDoubleRegZero);
-    li(result, Operand(1));
+    // Conversion is failed if the result is negative.
+    addiu(at, zero_reg, -1);
+    dsrl(at, at, 1);  // Load 2^62.
+    dmfc1(result, scratch);
+    xor_(result, result, at);
+    Slt(result, zero_reg, result);
   }
 
   bind(&fail);
@@ -1742,18 +1746,25 @@ void MacroAssembler::Trunc_ul_d(FPURegister fd, Register rs,
 
 
 void MacroAssembler::Trunc_ul_s(FPURegister fd, Register rs,
-                                FPURegister scratch) {
+                                FPURegister scratch, Register result) {
   DCHECK(!fd.is(scratch));
-  DCHECK(!rs.is(at));
+  DCHECK(!AreAliased(rs, result, at));
+
+  Label simple_convert, done, fail;
+  if (result.is_valid()) {
+    mov(result, zero_reg);
+    Move(kDoubleRegZero, 0.0);
+    // If fd < 0 or unordered, then the conversion fails.
+    BranchF32(&fail, &fail, lt, fd, kDoubleRegZero);
+  }
 
   // Load 2^63 into scratch as its float representation.
   li(at, 0x5f000000);
-  dmtc1(at, scratch);
+  mtc1(at, scratch);
 
   // Test if scratch > fd.
   // If fd < 2^63 we can convert it normally.
-  Label simple_convert, done;
-  BranchF32(&simple_convert, NULL, lt, fd, scratch);
+  BranchF32(&simple_convert, nullptr, lt, fd, scratch);
 
   // First we subtract 2^63 from fd, then trunc it to rs
   // and add 2^63 to rs.
@@ -1769,6 +1780,16 @@ void MacroAssembler::Trunc_ul_s(FPURegister fd, Register rs,
   dmfc1(rs, scratch);
 
   bind(&done);
+  if (result.is_valid()) {
+    // Conversion is failed if the result is negative or unordered.
+    addiu(at, zero_reg, -1);
+    dsrl(at, at, 1);  // Load 2^62.
+    dmfc1(result, scratch);
+    xor_(result, result, at);
+    Slt(result, zero_reg, result);
+  }
+
+  bind(&fail);
 }
 
 

src/mips64/macro-assembler-mips64.h

@@ -843,8 +843,10 @@ class MacroAssembler: public Assembler {
                   Register result = no_reg);
 
   // Convert single to unsigned long.
-  void Trunc_ul_s(FPURegister fd, FPURegister fs, FPURegister scratch);
-  void Trunc_ul_s(FPURegister fd, Register rs, FPURegister scratch);
+  void Trunc_ul_s(FPURegister fd, FPURegister fs, FPURegister scratch,
+                  Register result = no_reg);
+  void Trunc_ul_s(FPURegister fd, Register rs, FPURegister scratch,
+                  Register result = no_reg);
 
   void Trunc_w_d(FPURegister fd, FPURegister fs);
   void Round_w_d(FPURegister fd, FPURegister fs);

test/cctest/compiler/test-representation-change.cc

@@ -61,7 +61,7 @@ class RepresentationChangerTester : public HandleAndZoneScope,
   void CheckFloat32Constant(Node* n, float expected) {
     CHECK_EQ(IrOpcode::kFloat32Constant, n->opcode());
     float fval = OpParameter<float>(n->op());
-    CHECK_EQ(expected, fval);
+    CheckDoubleEq(expected, fval);
   }
 
   void CheckHeapConstant(Node* n, HeapObject* expected) {

test/cctest/compiler/test-run-machops.cc

@@ -5527,7 +5527,7 @@ TEST(RunTryTruncateFloat64ToInt64WithCheck) {
 
 TEST(RunTruncateFloat32ToUint64) {
   BufferedRawMachineAssemblerTester<uint64_t> m(MachineType::Float32());
-  m.Return(m.TruncateFloat32ToUint64(m.Parameter(0)));
+  m.Return(m.TryTruncateFloat32ToUint64(m.Parameter(0)));
 
   FOR_UINT64_INPUTS(i) {
     float input = static_cast<float>(*i);
@@ -5543,6 +5543,28 @@ TEST(RunTruncateFloat32ToUint64) {
 }
 
 
+TEST(RunTryTruncateFloat32ToUint64WithCheck) {
+  int64_t success = 0;
+  BufferedRawMachineAssemblerTester<uint64_t> m(MachineType::Float32());
+  Node* trunc = m.TryTruncateFloat32ToUint64(m.Parameter(0));
+  Node* val = m.Projection(0, trunc);
+  Node* check = m.Projection(1, trunc);
+  m.StoreToPointer(&success, MachineType::Int64(), check);
+  m.Return(val);
+
+  FOR_FLOAT32_INPUTS(i) {
+    if (*i < 18446744073709551616.0 && *i >= 0.0) {
+      // Conversions within this range should succeed.
+      CHECK_EQ(static_cast<uint64_t>(*i), m.Call(*i));
+      CHECK_NE(0, success);
+    } else {
+      m.Call(*i);
+      CHECK_EQ(0, success);
+    }
+  }
+}
+
+
 TEST(RunTryTruncateFloat64ToUint64WithoutCheck) {
   BufferedRawMachineAssemblerTester<uint64_t> m(MachineType::Float64());
   m.Return(m.TruncateFloat64ToUint64(m.Parameter(0)));

test/cctest/compiler/value-helper.h

@@ -59,41 +59,109 @@ class ValueHelper {
   }
 
   static std::vector<float> float32_vector() {
-    static const float kValues[] = {
-        -std::numeric_limits<float>::infinity(), -2.70497e+38f, -1.4698e+37f,
-        -1.22813e+35f,                           -1.20555e+35f, -1.34584e+34f,
-        -1.0079e+32f,                            -6.49364e+26f, -3.06077e+25f,
-        -1.46821e+25f,                           -1.17658e+23f, -1.9617e+22f,
-        -2.7357e+20f,                            -1.48708e+13f, -1.89633e+12f,
-        -4.66622e+11f,                           -2.22581e+11f, -1.45381e+10f,
-        -1.3956e+09f,                            -1.32951e+09f, -1.30721e+09f,
-        -1.19756e+09f,                           -9.26822e+08f, -6.35647e+08f,
-        -4.00037e+08f,                           -1.81227e+08f, -5.09256e+07f,
-        -964300.0f,                              -192446.0f,    -28455.0f,
-        -27194.0f,                               -26401.0f,     -20575.0f,
-        -17069.0f,                               -9167.0f,      -960.178f,
-        -113.0f,                                 -62.0f,        -15.0f,
-        -7.0f,                                   -0.0256635f,   -4.60374e-07f,
-        -3.63759e-10f,                           -4.30175e-14f, -5.27385e-15f,
-        -1.48084e-15f,                           -1.05755e-19f, -3.2995e-21f,
-        -1.67354e-23f,                           -1.11885e-23f, -1.78506e-30f,
-        -5.07594e-31f,                           -3.65799e-31f, -1.43718e-34f,
-        -1.27126e-38f,                           -0.0f,         0.0f,
-        1.17549e-38f,                            1.56657e-37f,  4.08512e-29f,
-        3.31357e-28f,                            6.25073e-22f,  4.1723e-13f,
-        1.44343e-09f,                            5.27004e-08f,  9.48298e-08f,
-        5.57888e-07f,                            4.89988e-05f,  0.244326f,
-        12.4895f,                                19.0f,         47.0f,
-        106.0f,                                  538.324f,      564.536f,
-        819.124f,                                7048.0f,       12611.0f,
-        19878.0f,                                20309.0f,      797056.0f,
-        1.77219e+09f,                            1.51116e+11f,  4.18193e+13f,
-        3.59167e+16f,                            3.38211e+19f,  2.67488e+20f,
-        1.78831e+21f,                            9.20914e+21f,  8.35654e+23f,
-        1.4495e+24f,                             5.94015e+25f,  4.43608e+30f,
-        2.44502e+33f,                            2.61152e+33f,  1.38178e+37f,
-        1.71306e+37f,                            3.31899e+38f,  3.40282e+38f,
-        std::numeric_limits<float>::infinity()};
+    static const float nan = std::numeric_limits<float>::quiet_NaN();
+    static const float kValues[] = {-std::numeric_limits<float>::infinity(),
+                                    -2.70497e+38f,
+                                    -1.4698e+37f,
+                                    -1.22813e+35f,
+                                    -1.20555e+35f,
+                                    -1.34584e+34f,
+                                    -1.0079e+32f,
+                                    -6.49364e+26f,
+                                    -3.06077e+25f,
+                                    -1.46821e+25f,
+                                    -1.17658e+23f,
+                                    -1.9617e+22f,
+                                    -2.7357e+20f,
+                                    -1.48708e+13f,
+                                    -1.89633e+12f,
+                                    -4.66622e+11f,
+                                    -2.22581e+11f,
+                                    -1.45381e+10f,
+                                    -1.3956e+09f,
+                                    -1.32951e+09f,
+                                    -1.30721e+09f,
+                                    -1.19756e+09f,
+                                    -9.26822e+08f,
+                                    -6.35647e+08f,
+                                    -4.00037e+08f,
+                                    -1.81227e+08f,
+                                    -5.09256e+07f,
+                                    -964300.0f,
+                                    -192446.0f,
+                                    -28455.0f,
+                                    -27194.0f,
+                                    -26401.0f,
+                                    -20575.0f,
+                                    -17069.0f,
+                                    -9167.0f,
+                                    -960.178f,
+                                    -113.0f,
+                                    -62.0f,
+                                    -15.0f,
+                                    -7.0f,
+                                    -0.0256635f,
+                                    -4.60374e-07f,
+                                    -3.63759e-10f,
+                                    -4.30175e-14f,
+                                    -5.27385e-15f,
+                                    -1.48084e-15f,
+                                    -1.05755e-19f,
+                                    -3.2995e-21f,
+                                    -1.67354e-23f,
+                                    -1.11885e-23f,
+                                    -1.78506e-30f,
+                                    -5.07594e-31f,
+                                    -3.65799e-31f,
+                                    -1.43718e-34f,
+                                    -1.27126e-38f,
+                                    -0.0f,
+                                    0.0f,
+                                    1.17549e-38f,
+                                    1.56657e-37f,
+                                    4.08512e-29f,
+                                    3.31357e-28f,
+                                    6.25073e-22f,
+                                    4.1723e-13f,
+                                    1.44343e-09f,
+                                    5.27004e-08f,
+                                    9.48298e-08f,
+                                    5.57888e-07f,
+                                    4.89988e-05f,
+                                    0.244326f,
+                                    12.4895f,
+                                    19.0f,
+                                    47.0f,
+                                    106.0f,
+                                    538.324f,
+                                    564.536f,
+                                    819.124f,
+                                    7048.0f,
+                                    12611.0f,
+                                    19878.0f,
+                                    20309.0f,
+                                    797056.0f,
+                                    1.77219e+09f,
+                                    1.51116e+11f,
+                                    4.18193e+13f,
+                                    3.59167e+16f,
+                                    3.38211e+19f,
+                                    2.67488e+20f,
+                                    1.78831e+21f,
+                                    9.20914e+21f,
+                                    8.35654e+23f,
+                                    1.4495e+24f,
+                                    5.94015e+25f,
+                                    4.43608e+30f,
+                                    2.44502e+33f,
+                                    2.61152e+33f,
+                                    1.38178e+37f,
+                                    1.71306e+37f,
+                                    3.31899e+38f,
+                                    3.40282e+38f,
+                                    std::numeric_limits<float>::infinity(),
+                                    nan,
+                                    -nan};
     return std::vector<float>(&kValues[0], &kValues[arraysize(kValues)]);
   }
 
@@ -103,6 +171,7 @@ class ValueHelper {
                                     0.25,
                                     0.375,
                                     0.5,
+                                    -0.5,
                                     1.25,
                                     -1.75,
                                     2,