[wasm] Int64Lowering of FXXXConvertI64 instructions.

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/platform.h"
 
@@ skipping 525 matching lines @@
       break;
     case wasm::kExprI64GtU:
       op = m->Uint64LessThan();
       std::swap(left, right);
       break;
     case wasm::kExprI64GeU:
       op = m->Uint64LessThanOrEqual();
       std::swap(left, right);
       break;
 
-// kExprI32ConvertI64:
-// kExprI64SConvertI32:
-// kExprI64UConvertI32:
-
-// kExprF64ReinterpretI64:
-// kExprI64ReinterpretF64:
-
-// kExprI64Clz:
-// kExprI64Ctz:
-// kExprI64Popcnt:
-
-// kExprF32SConvertI64:
-// kExprF32UConvertI64:
-// kExprF64SConvertI64:
-// kExprF64UConvertI64:
-// kExprI64SConvertF32:
-// kExprI64SConvertF64:
-// kExprI64UConvertF32:
-// kExprI64UConvertF64:
 #if WASM_64
     // Opcodes only supported on 64-bit platforms.
     // TODO(titzer): query the machine operator builder here instead of #ifdef.
     case wasm::kExprI64Add:
       op = m->Int64Add();
       break;
     case wasm::kExprI64Sub:
       op = m->Int64Sub();
       break;
     case wasm::kExprI64Mul:
@@ skipping 245 matching lines @@
     }
     case wasm::kExprF64NearestInt: {
       if (!m->Float64RoundTiesEven().IsSupported())
         return BuildF64NearestInt(input);
       op = m->Float64RoundTiesEven().op();
       break;
     }
     case wasm::kExprI32ConvertI64:
       op = m->TruncateInt64ToInt32();
       break;
+    // kExprI32ConvertI64:
+    // kExprI64SConvertI32:
+    // kExprI64UConvertI32:
+
+    // kExprF64ReinterpretI64:
+    // kExprI64ReinterpretF64:
+
+    // kExprI64Clz:
+    // kExprI64Ctz:
+    // kExprI64Popcnt:
+
+    // kExprF32SConvertI64:
+    case wasm::kExprF32SConvertI64:
+      if (kPointerSize == 4) {
+        return BuildF32SConvertI64(input);
+      }
+      op = m->RoundInt64ToFloat32();
+      break;
+    // kExprF32UConvertI64:
+    case wasm::kExprF32UConvertI64:
+      if (kPointerSize == 4) {
+        return BuildF32UConvertI64(input);
+      }
+      op = m->RoundUint64ToFloat32();
+      break;
+    // kExprF64SConvertI64:
+    case wasm::kExprF64SConvertI64:
+      if (kPointerSize == 4) {
+        return BuildF64SConvertI64(input);
+      }
+      op = m->RoundInt64ToFloat64();
+      break;
+    // kExprF64UConvertI64:
+    case wasm::kExprF64UConvertI64:
+      if (kPointerSize == 4) {
+        return BuildF64UConvertI64(input);
+      }
+      op = m->RoundUint64ToFloat64();
+      break;
+// kExprI64SConvertF32:
+// kExprI64SConvertF64:
+// kExprI64UConvertF32:
+// kExprI64UConvertF64:
+
 #if WASM_64
     // Opcodes only supported on 64-bit platforms.
     // TODO(titzer): query the machine operator builder here instead of #ifdef.
     case wasm::kExprI64SConvertI32:
       op = m->ChangeInt32ToInt64();
       break;
     case wasm::kExprI64UConvertI32:
       op = m->ChangeUint32ToUint64();
       break;
-    case wasm::kExprF32SConvertI64:
-      op = m->RoundInt64ToFloat32();
-      break;
-    case wasm::kExprF32UConvertI64:
-      op = m->RoundUint64ToFloat32();
-      break;
-    case wasm::kExprF64SConvertI64:
-      op = m->RoundInt64ToFloat64();
-      break;
-    case wasm::kExprF64UConvertI64:
-      op = m->RoundUint64ToFloat64();
-      break;
     case wasm::kExprI64SConvertF32: {
       Node* trunc = graph()->NewNode(m->TryTruncateFloat32ToInt64(), input);
       Node* result =
           graph()->NewNode(jsgraph()->common()->Projection(0), trunc);
       Node* overflow =
           graph()->NewNode(jsgraph()->common()->Projection(1), trunc);
       trap_->ZeroCheck64(kTrapFloatUnrepresentable, overflow);
       return result;
     }
     case wasm::kExprI64SConvertF64: {
@@ skipping 533 matching lines @@
                        jsgraph()->Int64Constant(0x00000000ffffffff)),
                  Binop(wasm::kExprI64And, result,
                        jsgraph()->Int64Constant(0x00000000ffffffff)));
 
   return result;
 }
 
 Node* WasmGraphBuilder::BuildF32Trunc(Node* input) {
   MachineType type = MachineType::Float32();
   ExternalReference ref =
-      ExternalReference::f32_trunc_wrapper_function(jsgraph()->isolate());
+      ExternalReference::wasm_f32_trunc(jsgraph()->isolate());
   return BuildRoundingInstruction(input, ref, type);
 }
 
 Node* WasmGraphBuilder::BuildF32Floor(Node* input) {
   MachineType type = MachineType::Float32();
   ExternalReference ref =
-      ExternalReference::f32_floor_wrapper_function(jsgraph()->isolate());
+      ExternalReference::wasm_f32_floor(jsgraph()->isolate());
   return BuildRoundingInstruction(input, ref, type);
 }
 
 Node* WasmGraphBuilder::BuildF32Ceil(Node* input) {
   MachineType type = MachineType::Float32();
   ExternalReference ref =
-      ExternalReference::f32_ceil_wrapper_function(jsgraph()->isolate());
+      ExternalReference::wasm_f32_ceil(jsgraph()->isolate());
   return BuildRoundingInstruction(input, ref, type);
 }
 
 Node* WasmGraphBuilder::BuildF32NearestInt(Node* input) {
   MachineType type = MachineType::Float32();
   ExternalReference ref =
-      ExternalReference::f32_nearest_int_wrapper_function(jsgraph()->isolate());
+      ExternalReference::wasm_f32_nearest_int(jsgraph()->isolate());
   return BuildRoundingInstruction(input, ref, type);
 }
 
 Node* WasmGraphBuilder::BuildF64Trunc(Node* input) {
   MachineType type = MachineType::Float64();
   ExternalReference ref =
-      ExternalReference::f64_trunc_wrapper_function(jsgraph()->isolate());
+      ExternalReference::wasm_f64_trunc(jsgraph()->isolate());
   return BuildRoundingInstruction(input, ref, type);
 }
 
 Node* WasmGraphBuilder::BuildF64Floor(Node* input) {
   MachineType type = MachineType::Float64();
   ExternalReference ref =
-      ExternalReference::f64_floor_wrapper_function(jsgraph()->isolate());
+      ExternalReference::wasm_f64_floor(jsgraph()->isolate());
   return BuildRoundingInstruction(input, ref, type);
 }
 
 Node* WasmGraphBuilder::BuildF64Ceil(Node* input) {
   MachineType type = MachineType::Float64();
   ExternalReference ref =
-      ExternalReference::f64_ceil_wrapper_function(jsgraph()->isolate());
+      ExternalReference::wasm_f64_ceil(jsgraph()->isolate());
   return BuildRoundingInstruction(input, ref, type);
 }
 
 Node* WasmGraphBuilder::BuildF64NearestInt(Node* input) {
   MachineType type = MachineType::Float64();
   ExternalReference ref =
-      ExternalReference::f64_nearest_int_wrapper_function(jsgraph()->isolate());
+      ExternalReference::wasm_f64_nearest_int(jsgraph()->isolate());
   return BuildRoundingInstruction(input, ref, type);
 }
 
 Node* WasmGraphBuilder::BuildRoundingInstruction(Node* input,
                                                  ExternalReference ref,
                                                  MachineType type) {
   // We do truncation by calling a C function which calculates the truncation
   // for us. The input is passed to the C function as a double* to avoid double
   // parameters. For this we reserve a slot on the stack, store the parameter in
   // that slot, pass a pointer to the slot to the C function, and after calling
@@ skipping 18 matching lines @@
 
   const Operator* load_op = jsgraph()->machine()->Load(type);
 
   Node* load =
       graph()->NewNode(load_op, stack_slot_param, jsgraph()->Int32Constant(0),
                        *effect_, *control_);
   *effect_ = load;
   return load;
 }
 
+Node* WasmGraphBuilder::BuildF32SConvertI64(Node* input) {
+  ExternalReference ref =
+      ExternalReference::wasm_int64_to_float32(jsgraph()->isolate());
+  MachineRepresentation parameter_representation =

[titzer, 2016/02/25 17:04:33]

You can shorten this code up a bit by inlining the parameter_representation and
result_type locals.

[ahaas, 2016/02/25 18:29:18]

Done.

+      MachineRepresentation::kWord64;
+  MachineType result_type = MachineType::Float32();
+
+  return BuildConversionInstruction(input, ref, parameter_representation,
+                                    result_type);
+}
+
+Node* WasmGraphBuilder::BuildF32UConvertI64(Node* input) {
+  ExternalReference ref =
+      ExternalReference::wasm_uint64_to_float32(jsgraph()->isolate());
+  MachineRepresentation parameter_representation =
+      MachineRepresentation::kWord64;
+  MachineType result_type = MachineType::Float32();
+
+  return BuildConversionInstruction(input, ref, parameter_representation,
+                                    result_type);
+}
+
+Node* WasmGraphBuilder::BuildF64SConvertI64(Node* input) {
+  ExternalReference ref =
+      ExternalReference::wasm_int64_to_float64(jsgraph()->isolate());
+  MachineRepresentation parameter_representation =
+      MachineRepresentation::kWord64;
+  MachineType result_type = MachineType::Float64();
+
+  return BuildConversionInstruction(input, ref, parameter_representation,
+                                    result_type);
+}
+
+Node* WasmGraphBuilder::BuildF64UConvertI64(Node* input) {
+  ExternalReference ref =
+      ExternalReference::wasm_uint64_to_float64(jsgraph()->isolate());
+  MachineRepresentation parameter_representation =
+      MachineRepresentation::kWord64;
+  MachineType result_type = MachineType::Float64();
+
+  return BuildConversionInstruction(input, ref, parameter_representation,
+                                    result_type);
+}
+
+Node* WasmGraphBuilder::BuildConversionInstruction(
+    Node* input, ExternalReference ref,
+    MachineRepresentation parameter_representation,
+    const MachineType result_type) {
+  Node* stack_slot_param = graph()->NewNode(
+      jsgraph()->machine()->StackSlot(parameter_representation));
+  Node* stack_slot_result = graph()->NewNode(
+      jsgraph()->machine()->StackSlot(result_type.representation()));
+  const Operator* store_op = jsgraph()->machine()->Store(
+      StoreRepresentation(parameter_representation, kNoWriteBarrier));
+  *effect_ =
+      graph()->NewNode(store_op, stack_slot_param, jsgraph()->Int32Constant(0),
+                       input, *effect_, *control_);
+  Signature<MachineType>::Builder sig_builder(jsgraph()->zone(), 0, 2);
+  sig_builder.AddParam(MachineType::Pointer());
+  sig_builder.AddParam(MachineType::Pointer());
+  Node* function = graph()->NewNode(jsgraph()->common()->ExternalConstant(ref));
+  Node* args[] = {function, stack_slot_param, stack_slot_result};
+  BuildCCall(sig_builder.Build(), args);
+  const Operator* load_op = jsgraph()->machine()->Load(result_type);
+  Node* load =
+      graph()->NewNode(load_op, stack_slot_result, jsgraph()->Int32Constant(0),
+                       *effect_, *control_);
+  *effect_ = load;
+  return load;
+}
+
 Node* WasmGraphBuilder::BuildCCall(MachineSignature* sig, Node** args) {
   const size_t params = sig->parameter_count();
   const size_t extra = 2;  // effect and control inputs.
   const size_t count = 1 + params + extra;
 
   // Reallocate the buffer to make space for extra inputs.
   args = Realloc(args, count);
 
   // Add effect and control inputs.
   args[params + 1] = *effect_;
@@ skipping 745 matching lines @@
         module_env->module->GetName(function.name_offset));
   }
 
   return code;
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8