[turbofan] Remove Float32 truncation.

src/compiler/representation-change.h

 // Copyright 2014 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.
 
 #ifndef V8_COMPILER_REPRESENTATION_CHANGE_H_
 #define V8_COMPILER_REPRESENTATION_CHANGE_H_
 
 #include "src/compiler/js-graph.h"
 #include "src/compiler/simplified-operator.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 class Truncation final {
  public:
   // Constructors.
   static Truncation None() { return Truncation(TruncationKind::kNone); }
   static Truncation Bool() { return Truncation(TruncationKind::kBool); }
   static Truncation Word32() { return Truncation(TruncationKind::kWord32); }
   static Truncation Word64() { return Truncation(TruncationKind::kWord64); }
-  static Truncation Float32() { return Truncation(TruncationKind::kFloat32); }
   static Truncation Float64() { return Truncation(TruncationKind::kFloat64); }
   static Truncation Any() { return Truncation(TruncationKind::kAny); }
 
   static Truncation Generalize(Truncation t1, Truncation t2) {
     return Truncation(Generalize(t1.kind(), t2.kind()));
   }
 
   // Queries.
   bool IsUnused() const { return kind_ == TruncationKind::kNone; }
   bool IsUsedAsBool() const {
@@ skipping 23 matching lines @@
   bool IsLessGeneralThan(Truncation other) {
     return LessGeneral(kind(), other.kind());
   }
 
  private:
   enum class TruncationKind : uint8_t {
     kNone,
     kBool,
     kWord32,
     kWord64,
-    kFloat32,
     kFloat64,
     kAny
   };
 
   explicit Truncation(TruncationKind kind) : kind_(kind) {}
   TruncationKind kind() const { return kind_; }
 
   TruncationKind kind_;
 
   static TruncationKind Generalize(TruncationKind rep1, TruncationKind rep2);
@@ skipping 50 matching lines @@
         minus_zero_check_(minus_zero_check) {}
   static UseInfo TruncatingWord32() {
     return UseInfo(MachineRepresentation::kWord32, Truncation::Word32());
   }
   static UseInfo TruncatingWord64() {
     return UseInfo(MachineRepresentation::kWord64, Truncation::Word64());
   }
   static UseInfo Bool() {
     return UseInfo(MachineRepresentation::kBit, Truncation::Bool());
   }
-  static UseInfo TruncatingFloat32() {
-    return UseInfo(MachineRepresentation::kFloat32, Truncation::Float32());
+  static UseInfo Float32() {
+    return UseInfo(MachineRepresentation::kFloat32, Truncation::Any());

[Jarin, 2016/10/12 18:04:01]

It might be better to say kFloat64; otherwise float32 use from of
float64-or-undefined value (such as read from a double or float typed array)
will force tagged representation.

[mvstanton, 2016/10/13 13:25:48]

Per our offline discussion, I'll go ahead and land it like this. Looks like
asm.js depends on this behavior.

   }
   static UseInfo TruncatingFloat64() {
     return UseInfo(MachineRepresentation::kFloat64, Truncation::Float64());
   }
   static UseInfo PointerInt() {
     return kPointerSize == 4 ? TruncatingWord32() : TruncatingWord64();
   }
   static UseInfo AnyTagged() {
     return UseInfo(MachineRepresentation::kTagged, Truncation::Any());
   }
@@ skipping 147 matching lines @@
   Factory* factory() const { return isolate()->factory(); }
   SimplifiedOperatorBuilder* simplified() { return jsgraph()->simplified(); }
   MachineOperatorBuilder* machine() { return jsgraph()->machine(); }
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_REPRESENTATION_CHANGE_H_