[turbofan] Introduce TruncateTaggedToWord32 simplified operator.

src/compiler/wasm-compiler.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/wasm-compiler.h"
 
 #include "src/isolate-inl.h"
 
 #include "src/base/platform/elapsed-timer.h"
 #include "src/base/platform/platform.h"
@@ skipping 1121 matching lines @@
               Binop(wasm::kExprF64Mul, right, Float64Constant(1.0)),
               Binop(wasm::kExprF64Mul, left, Float64Constant(1.0)))));
 }
 
 
 Node* WasmGraphBuilder::BuildI32SConvertF32(Node* input) {
   MachineOperatorBuilder* m = jsgraph()->machine();
   if (module_ && module_->asm_js()) {
     // asm.js must use the wacky JS semantics.
     input = graph()->NewNode(m->ChangeFloat32ToFloat64(), input);
-    return graph()->NewNode(
-        m->TruncateFloat64ToInt32(TruncationMode::kJavaScript), input);
+    return graph()->NewNode(m->TruncateFloat64ToWord32(), input);
   }
 
   // Truncation of the input value is needed for the overflow check later.
   Node* trunc = Unop(wasm::kExprF32Trunc, input);
   Node* result = graph()->NewNode(m->TruncateFloat32ToInt32(), trunc);
 
   // Convert the result back to f64. If we end up at a different value than the
   // truncated input value, then there has been an overflow and we trap.
   Node* check = Unop(wasm::kExprF32SConvertI32, result);
   Node* overflow = Binop(wasm::kExprF32Ne, trunc, check);
   trap_->AddTrapIfTrue(wasm::kTrapFloatUnrepresentable, overflow);
 
   return result;
 }
 
 
 Node* WasmGraphBuilder::BuildI32SConvertF64(Node* input) {
   MachineOperatorBuilder* m = jsgraph()->machine();
   if (module_ && module_->asm_js()) {
     // asm.js must use the wacky JS semantics.
-    return graph()->NewNode(
-        m->TruncateFloat64ToInt32(TruncationMode::kJavaScript), input);
+    return graph()->NewNode(m->TruncateFloat64ToWord32(), input);
   }
   // Truncation of the input value is needed for the overflow check later.
   Node* trunc = Unop(wasm::kExprF64Trunc, input);
   Node* result = graph()->NewNode(m->ChangeFloat64ToInt32(), trunc);
 
   // Convert the result back to f64. If we end up at a different value than the
   // truncated input value, then there has been an overflow and we trap.
   Node* check = Unop(wasm::kExprF64SConvertI32, result);
   Node* overflow = Binop(wasm::kExprF64Ne, trunc, check);
   trap_->AddTrapIfTrue(wasm::kTrapFloatUnrepresentable, overflow);
 
   return result;
 }
 
 
 Node* WasmGraphBuilder::BuildI32UConvertF32(Node* input) {
   MachineOperatorBuilder* m = jsgraph()->machine();
   if (module_ && module_->asm_js()) {
     // asm.js must use the wacky JS semantics.
     input = graph()->NewNode(m->ChangeFloat32ToFloat64(), input);
-    return graph()->NewNode(
-        m->TruncateFloat64ToInt32(TruncationMode::kJavaScript), input);
+    return graph()->NewNode(m->TruncateFloat64ToWord32(), input);
   }
 
   // Truncation of the input value is needed for the overflow check later.
   Node* trunc = Unop(wasm::kExprF32Trunc, input);
   Node* result = graph()->NewNode(m->TruncateFloat32ToUint32(), trunc);
 
   // Convert the result back to f32. If we end up at a different value than the
   // truncated input value, then there has been an overflow and we trap.
   Node* check = Unop(wasm::kExprF32UConvertI32, result);
   Node* overflow = Binop(wasm::kExprF32Ne, trunc, check);
   trap_->AddTrapIfTrue(wasm::kTrapFloatUnrepresentable, overflow);
 
   return result;
 }
 
 
 Node* WasmGraphBuilder::BuildI32UConvertF64(Node* input) {
   MachineOperatorBuilder* m = jsgraph()->machine();
   if (module_ && module_->asm_js()) {
     // asm.js must use the wacky JS semantics.
-    return graph()->NewNode(
-        m->TruncateFloat64ToInt32(TruncationMode::kJavaScript), input);
+    return graph()->NewNode(m->TruncateFloat64ToWord32(), input);
   }
   // Truncation of the input value is needed for the overflow check later.
   Node* trunc = Unop(wasm::kExprF64Trunc, input);
   Node* result = graph()->NewNode(m->TruncateFloat64ToUint32(), trunc);
 
   // Convert the result back to f64. If we end up at a different value than the
   // truncated input value, then there has been an overflow and we trap.
   Node* check = Unop(wasm::kExprF64UConvertI32, result);
   Node* overflow = Binop(wasm::kExprF64Ne, trunc, check);
   trap_->AddTrapIfTrue(wasm::kTrapFloatUnrepresentable, overflow);
@@ skipping 780 matching lines @@
   Node* merge = graph()->NewNode(common->Merge(2), if_true, if_false);
   Node* phi = graph()->NewNode(common->Phi(MachineRepresentation::kTagged, 2),
                                vtrue, vfalse, merge);
   return phi;
 }
 
 Node* WasmGraphBuilder::BuildChangeFloat64ToTagged(Node* value) {
   MachineOperatorBuilder* machine = jsgraph()->machine();
   CommonOperatorBuilder* common = jsgraph()->common();
 
-  Node* const value32 = graph()->NewNode(
-      machine->TruncateFloat64ToInt32(TruncationMode::kRoundToZero), value);
+  Node* value32 = graph()->NewNode(machine->RoundFloat64ToInt32(), value);
   Node* check_same = graph()->NewNode(
       machine->Float64Equal(), value,
       graph()->NewNode(machine->ChangeInt32ToFloat64(), value32));
   Node* branch_same =
       graph()->NewNode(common->Branch(), check_same, graph()->start());
 
   Node* if_smi = graph()->NewNode(common->IfTrue(), branch_same);
   Node* vsmi;
   Node* if_box = graph()->NewNode(common->IfFalse(), branch_same);
   Node* vbox;
@@ skipping 210 matching lines @@
                                wasm::LocalType type) {
   // Do a JavaScript ToNumber.
   Node* num = BuildJavaScriptToNumber(node, context, *effect_, *control_);
 
   // Change representation.
   SimplifiedOperatorBuilder simplified(jsgraph()->zone());
   num = BuildChangeTaggedToFloat64(num);
 
   switch (type) {
     case wasm::kAstI32: {
-      num = graph()->NewNode(jsgraph()->machine()->TruncateFloat64ToInt32(
-                                 TruncationMode::kJavaScript),
+      num = graph()->NewNode(jsgraph()->machine()->TruncateFloat64ToWord32(),
                              num);
       break;
     }
     case wasm::kAstI64:
       // TODO(titzer): JS->i64 has no good solution right now. Using 32 bits.
-      num = graph()->NewNode(jsgraph()->machine()->TruncateFloat64ToInt32(
-                                 TruncationMode::kJavaScript),
+      num = graph()->NewNode(jsgraph()->machine()->TruncateFloat64ToWord32(),
                              num);
       if (jsgraph()->machine()->Is64()) {
         // We cannot change an int32 to an int64 on a 32 bit platform. Instead
         // we will split the parameter node later.
         num = graph()->NewNode(jsgraph()->machine()->ChangeInt32ToInt64(), num);
       }
       break;
     case wasm::kAstF32:
       num = graph()->NewNode(jsgraph()->machine()->TruncateFloat64ToFloat32(),
                              num);
@@ skipping 710 matching lines @@
   // TODO(bradnelson): Improve histogram handling of size_t.
   isolate->counters()->wasm_compile_function_peak_memory_bytes()->AddSample(
       static_cast<int>(zone.allocation_size()));
   return code;
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8