s390: improve floating point and integer convertion

src/compiler/s390/instruction-selector-s390.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/base/adapters.h"
 #include "src/compiler/instruction-selector-impl.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 #include "src/s390/frames-s390.h"
 
@@ skipping 312 matching lines @@
   /* V(TruncateFloat64ToWord32) */ \
   /* V(RoundFloat64ToInt32)     */ \
   /* V(TruncateFloat32ToInt32)  */ \
   /* V(TruncateFloat32ToUint32) */ \
   /* V(TruncateFloat64ToUint32) */ \
   /* V(ChangeFloat64ToInt32)    */ \
   /* V(ChangeFloat64ToUint32)   */ \
   /* Word32 unary op */            \
   V(Word32Clz)                     \
   V(Word32Popcnt)                  \
+  V(Float64ExtractLowWord32)       \
+  V(Float64ExtractHighWord32)      \
   /* Word32 bin op */              \
   V(Int32Add)                      \
   V(Int32Sub)                      \
   V(Int32Mul)                      \
   V(Int32AddWithOverflow)          \
   V(Int32SubWithOverflow)          \
   V(Int32MulWithOverflow)          \
   V(Int32MulHigh)                  \
   V(Uint32MulHigh)                 \
   V(Int32Div)                      \
@@ skipping 1029 matching lines @@
                                                   AddOperandMode);
 }
 
 static inline bool TryMatchInt64SubWithOverflow(InstructionSelector* selector,
                                                 Node* node) {
   return TryMatchInt64OpWithOverflow<kS390_Sub64>(selector, node,
                                                   SubOperandMode);
 }
 #endif
 
+static inline bool TryMatchDoubleConstructFromInsert(
+    InstructionSelector* selector, Node* node) {
+  S390OperandGenerator g(selector);
+  Node* left = node->InputAt(0);
+  Node* right = node->InputAt(1);
+  Node* lo32 = NULL;
+  Node* hi32 = NULL;
+
+  if (node->opcode() == IrOpcode::kFloat64InsertLowWord32) {
+    lo32 = right;
+  } else if (node->opcode() == IrOpcode::kFloat64InsertHighWord32) {
+    hi32 = right;
+  } else {
+    return false;  // doesn't match
+  }
+
+  if (left->opcode() == IrOpcode::kFloat64InsertLowWord32) {
+    lo32 = left->InputAt(1);
+  } else if (left->opcode() == IrOpcode::kFloat64InsertHighWord32) {
+    hi32 = left->InputAt(1);
+  } else {
+    return false;  // doesn't match
+  }
+
+  if (!lo32 || !hi32) return false;  // doesn't match
+
+  selector->Emit(kS390_DoubleConstruct, g.DefineAsRegister(node),
+                 g.UseRegister(hi32), g.UseRegister(lo32));
+  return true;
+}
+
 #define null ([]() { return false; })
 // TODO(john.yan): place kAllowRM where available
 #define FLOAT_UNARY_OP_LIST_32(V)                                              \
   V(Float32, ChangeFloat32ToFloat64, kS390_Float32ToDouble,                    \
     OperandMode::kAllowRM, null)                                               \
   V(Float32, BitcastFloat32ToInt32, kS390_BitcastFloat32ToInt32,               \
-    OperandMode::kNone, null)                                                  \
+    OperandMode::kAllowRM, null)                                               \
   V(Float64, TruncateFloat64ToFloat32, kS390_DoubleToFloat32,                  \
     OperandMode::kNone, null)                                                  \
   V(Float64, TruncateFloat64ToWord32, kArchTruncateDoubleToI,                  \
     OperandMode::kNone, null)                                                  \
   V(Float64, RoundFloat64ToInt32, kS390_DoubleToInt32, OperandMode::kNone,     \
     null)                                                                      \
   V(Float32, TruncateFloat32ToInt32, kS390_Float32ToInt32, OperandMode::kNone, \
     null)                                                                      \
   V(Float32, TruncateFloat32ToUint32, kS390_Float32ToUint32,                   \
     OperandMode::kNone, null)                                                  \
@@ skipping 13 matching lines @@
   V(Float64, Float64RoundDown, kS390_FloorDouble, OperandMode::kNone, null)    \
   V(Float32, Float32RoundUp, kS390_CeilFloat, OperandMode::kNone, null)        \
   V(Float64, Float64RoundUp, kS390_CeilDouble, OperandMode::kNone, null)       \
   V(Float32, Float32RoundTruncate, kS390_TruncateFloat, OperandMode::kNone,    \
     null)                                                                      \
   V(Float64, Float64RoundTruncate, kS390_TruncateDouble, OperandMode::kNone,   \
     null)                                                                      \
   V(Float64, Float64RoundTiesAway, kS390_RoundDouble, OperandMode::kNone,      \
     null)                                                                      \
   V(Float32, Float32Neg, kS390_NegFloat, OperandMode::kNone, null)             \
-  V(Float64, Float64Neg, kS390_NegDouble, OperandMode::kNone, null)
+  V(Float64, Float64Neg, kS390_NegDouble, OperandMode::kNone, null)            \
+  /* TODO(john.yan): can use kAllowRM */                                       \
+  V(Word32, Float64ExtractLowWord32, kS390_DoubleExtractLowWord32,             \
+    OperandMode::kNone, null)                                                  \
+  V(Word32, Float64ExtractHighWord32, kS390_DoubleExtractHighWord32,           \
+    OperandMode::kNone, null)
 
 #define FLOAT_BIN_OP_LIST(V)                                           \
   V(Float32, Float32Add, kS390_AddFloat, OperandMode::kAllowRM, null)  \
   V(Float64, Float64Add, kS390_AddDouble, OperandMode::kAllowRM, null) \
   V(Float32, Float32Sub, kS390_SubFloat, OperandMode::kAllowRM, null)  \
   V(Float64, Float64Sub, kS390_SubDouble, OperandMode::kAllowRM, null) \
   V(Float32, Float32Mul, kS390_MulFloat, OperandMode::kAllowRM, null)  \
   V(Float64, Float64Mul, kS390_MulDouble, OperandMode::kAllowRM, null) \
   V(Float32, Float32Div, kS390_DivFloat, OperandMode::kAllowRM, null)  \
   V(Float64, Float64Div, kS390_DivDouble, OperandMode::kAllowRM, null) \
@@ skipping 71 matching lines @@
   V(Word32, Word32Ror, kS390_RotRight32,                                       \
     OperandMode::kAllowRI | OperandMode::kAllowRRR | OperandMode::kAllowRRI |  \
         OperandMode::kShift32Imm,                                              \
     null)                                                                      \
   V(Word32, Word32And, kS390_And32, And32OperandMode, null)                    \
   V(Word32, Word32Or, kS390_Or32, Or32OperandMode, null)                       \
   V(Word32, Word32Xor, kS390_Xor32, Xor32OperandMode, null)                    \
   V(Word32, Word32Shl, kS390_ShiftLeft32, Shift32OperandMode, null)            \
   V(Word32, Word32Shr, kS390_ShiftRight32, Shift32OperandMode, null)           \
   V(Word32, Word32Sar, kS390_ShiftRightArith32, Shift32OperandMode,            \
-    [&]() { return TryMatchSignExtInt16OrInt8FromWord32Sar(this, node); })
+    [&]() { return TryMatchSignExtInt16OrInt8FromWord32Sar(this, node); })     \
+  V(Word32, Float64InsertLowWord32, kS390_DoubleInsertLowWord32,               \
+    OperandMode::kAllowRRR,                                                    \
+    [&]() -> bool { return TryMatchDoubleConstructFromInsert(this, node); })   \
+  V(Word32, Float64InsertHighWord32, kS390_DoubleInsertHighWord32,             \
+    OperandMode::kAllowRRR,                                                    \
+    [&]() -> bool { return TryMatchDoubleConstructFromInsert(this, node); })
 
 #define WORD64_UNARY_OP_LIST(V)                                              \
   V(Word64, Word64Popcnt, kS390_Popcnt64, OperandMode::kNone, null)          \
   V(Word64, Word64Clz, kS390_Cntlz64, OperandMode::kNone, null)              \
   V(Word64, TruncateInt64ToInt32, kS390_Int64ToInt32, OperandMode::kNone,    \
     null)                                                                    \
   V(Word64, RoundInt64ToFloat32, kS390_Int64ToFloat32, OperandMode::kNone,   \
     null)                                                                    \
   V(Word64, RoundInt64ToFloat64, kS390_Int64ToDouble, OperandMode::kNone,    \
     null)                                                                    \
@@ skipping 768 matching lines @@
       }
       ++slot;
     }
   }
 }
 
 bool InstructionSelector::IsTailCallAddressImmediate() { return false; }
 
 int InstructionSelector::GetTempsCountForTailCallFromJSFunction() { return 3; }
 
-void InstructionSelector::VisitFloat64ExtractLowWord32(Node* node) {
-  S390OperandGenerator g(this);
-  Emit(kS390_DoubleExtractLowWord32, g.DefineAsRegister(node),
-       g.UseRegister(node->InputAt(0)));
-}
-
-void InstructionSelector::VisitFloat64ExtractHighWord32(Node* node) {
-  S390OperandGenerator g(this);
-  Emit(kS390_DoubleExtractHighWord32, g.DefineAsRegister(node),
-       g.UseRegister(node->InputAt(0)));
-}
-
-void InstructionSelector::VisitFloat64InsertLowWord32(Node* node) {
-  S390OperandGenerator g(this);
-  Node* left = node->InputAt(0);
-  Node* right = node->InputAt(1);
-  if (left->opcode() == IrOpcode::kFloat64InsertHighWord32 &&
-      CanCover(node, left)) {
-    left = left->InputAt(1);
-    Emit(kS390_DoubleConstruct, g.DefineAsRegister(node), g.UseRegister(left),
-         g.UseRegister(right));
-    return;
-  }
-  Emit(kS390_DoubleInsertLowWord32, g.DefineSameAsFirst(node),
-       g.UseRegister(left), g.UseRegister(right));
-}
-
-void InstructionSelector::VisitFloat64InsertHighWord32(Node* node) {
-  S390OperandGenerator g(this);
-  Node* left = node->InputAt(0);
-  Node* right = node->InputAt(1);
-  if (left->opcode() == IrOpcode::kFloat64InsertLowWord32 &&
-      CanCover(node, left)) {
-    left = left->InputAt(1);
-    Emit(kS390_DoubleConstruct, g.DefineAsRegister(node), g.UseRegister(right),
-         g.UseRegister(left));
-    return;
-  }
-  Emit(kS390_DoubleInsertHighWord32, g.DefineSameAsFirst(node),
-       g.UseRegister(left), g.UseRegister(right));
-}
-
 void InstructionSelector::VisitAtomicLoad(Node* node) {
   LoadRepresentation load_rep = LoadRepresentationOf(node->op());
   S390OperandGenerator g(this);
   Node* base = node->InputAt(0);
   Node* index = node->InputAt(1);
   ArchOpcode opcode = kArchNop;
   switch (load_rep.representation()) {
     case MachineRepresentation::kWord8:
       opcode = load_rep.IsSigned() ? kAtomicLoadInt8 : kAtomicLoadUint8;
       break;
@@ skipping 99 matching lines @@
 // static
 MachineOperatorBuilder::AlignmentRequirements
 InstructionSelector::AlignmentRequirements() {
   return MachineOperatorBuilder::AlignmentRequirements::
       FullUnalignedAccessSupport();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8