[turbofan] Support for %_DoubleHi, %_DoubleLo and %_ConstructDouble.

src/compiler/machine-operator.cc

 // 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.
 
 #include "src/compiler/machine-operator.h"
 
 #include "src/base/lazy-instance.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 
@@ skipping 150 matching lines @@
   struct Name##Operator FINAL : public Operator {                              \
     Name##Operator()                                                           \
         : Operator(IrOpcode::k##Name, Operator::kPure | properties, #Name,     \
                    value_input_count, 0, control_input_count, output_count, 0, \
                    0) {}                                                       \
   };                                                                           \
   Name##Operator k##Name;
   PURE_OP_LIST(PURE)
 #undef PURE
 
+  template <int kLocation>
+  struct Float64ExtractWord32Operator FINAL : public Operator1<int> {
+    Float64ExtractWord32Operator()
+        : Operator1<int>(IrOpcode::kFloat64ExtractWord32, Operator::kPure,
+                         "Float64ExtractWord32", 1, 0, 0, 1, 0, 0, kLocation) {}
+  };
+  Float64ExtractWord32Operator<0> kFloat64ExtractWord32Operator0;
+  Float64ExtractWord32Operator<1> kFloat64ExtractWord32Operator1;
+
+  template <int kLocation>
+  struct Float64InsertWord32Operator FINAL : public Operator1<int> {
+    Float64InsertWord32Operator()
+        : Operator1<int>(IrOpcode::kFloat64InsertWord32, Operator::kPure,
+                         "Float64InsertWord32", 2, 0, 0, 1, 0, 0, kLocation) {}
+  };
+  Float64InsertWord32Operator<0> kFloat64InsertWord32Operator0;
+  Float64InsertWord32Operator<1> kFloat64InsertWord32Operator1;
+
 #define LOAD(Type)                                                             \
   struct Load##Type##Operator FINAL : public Operator1<LoadRepresentation> {   \
     Load##Type##Operator()                                                     \
         : Operator1<LoadRepresentation>(                                       \
               IrOpcode::kLoad, Operator::kNoThrow | Operator::kNoWrite,        \
               "Load", 2, 1, 1, 1, 1, 0, k##Type) {}                            \
   };                                                                           \
   struct CheckedLoad##Type##Operator FINAL                                     \
       : public Operator1<CheckedLoadRepresentation> {                          \
     CheckedLoad##Type##Operator()                                              \
@@ skipping 50 matching lines @@
 }
 
 
 #define PURE(Name, properties, value_input_count, control_input_count, \
              output_count)                                             \
   const Operator* MachineOperatorBuilder::Name() { return &cache_.k##Name; }
 PURE_OP_LIST(PURE)
 #undef PURE
 
 
+const Operator* MachineOperatorBuilder::Float64ExtractWord32(int location) {
+  switch (location) {
+    case 0:
+      return &cache_.kFloat64ExtractWord32Operator0;
+    case 1:
+      return &cache_.kFloat64ExtractWord32Operator1;
+  }
+  UNREACHABLE();
+  return nullptr;
+}
+
+
+const Operator* MachineOperatorBuilder::Float64InsertWord32(int location) {
+  switch (location) {
+    case 0:
+      return &cache_.kFloat64InsertWord32Operator0;
+    case 1:
+      return &cache_.kFloat64InsertWord32Operator1;
+  }
+  UNREACHABLE();
+  return nullptr;
+}
+
+
 const Operator* MachineOperatorBuilder::Load(LoadRepresentation rep) {
   switch (rep) {
 #define LOAD(Type) \
   case k##Type:    \
     return &cache_.kLoad##Type;
     MACHINE_TYPE_LIST(LOAD)
 #undef LOAD
     default:
       break;
   }
@@ skipping 59 matching lines @@
   }
   // Uncached.
   return new (zone_) Operator1<CheckedStoreRepresentation>(
       IrOpcode::kCheckedStore, Operator::kNoRead | Operator::kNoThrow,
       "CheckedStore", 4, 1, 1, 0, 1, 0, rep);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8