[liftoff][x64] Use cmov for the select opcode

cmov is often much faster than branches (in particular if the branches
cannot be predicted). It also has a much more predictable performance,
and is shorter.
This CL uses cmov on x64 for now. Other platforms (maybe using other
instructions than cmov) can be added later.

R=thibaudm@chromium.org

Bug: v8:10740
Change-Id: Ifab3d570b8eea784376e1f768d6ba3828efcc01a
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2315978Reviewed-by: Thibaud Michaud <thibaudm@chromium.org>
Commit-Queue: Clemens Backes <clemensb@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69027}

src/wasm/baseline/arm/liftoff-assembler-arm.h

@@ -2177,6 +2177,13 @@ void LiftoffAssembler::emit_f64_set_cond(Condition cond, Register dst,
   }
 }
 
+bool LiftoffAssembler::emit_select(LiftoffRegister dst, Register condition,
+                                   LiftoffRegister true_value,
+                                   LiftoffRegister false_value,
+                                   ValueType type) {
+  return false;
+}
+
 void LiftoffAssembler::LoadTransform(LiftoffRegister dst, Register src_addr,
                                      Register offset_reg, uint32_t offset_imm,
                                      LoadType type,

src/wasm/baseline/arm64/liftoff-assembler-arm64.h

@@ -1436,6 +1436,13 @@ void LiftoffAssembler::emit_f64_set_cond(Condition cond, Register dst,
   }
 }
 
+bool LiftoffAssembler::emit_select(LiftoffRegister dst, Register condition,
+                                   LiftoffRegister true_value,
+                                   LiftoffRegister false_value,
+                                   ValueType type) {
+  return false;
+}
+
 void LiftoffAssembler::LoadTransform(LiftoffRegister dst, Register src_addr,
                                      Register offset_reg, uint32_t offset_imm,
                                      LoadType type,

src/wasm/baseline/ia32/liftoff-assembler-ia32.h

@@ -2332,6 +2332,13 @@ void LiftoffAssembler::emit_f64_set_cond(Condition cond, Register dst,
   liftoff::EmitFloatSetCond<&Assembler::ucomisd>(this, cond, dst, lhs, rhs);
 }
 
+bool LiftoffAssembler::emit_select(LiftoffRegister dst, Register condition,
+                                   LiftoffRegister true_value,
+                                   LiftoffRegister false_value,
+                                   ValueType type) {
+  return false;
+}
+
 namespace liftoff {
 template <void (Assembler::*avx_op)(XMMRegister, XMMRegister, XMMRegister),
           void (Assembler::*sse_op)(XMMRegister, XMMRegister)>

src/wasm/baseline/liftoff-assembler.h

@@ -745,6 +745,12 @@ class LiftoffAssembler : public TurboAssembler {
   inline void emit_f64_set_cond(Condition condition, Register dst,
                                 DoubleRegister lhs, DoubleRegister rhs);
 
+  // Optional select support: Returns false if generic code (via branches)
+  // should be emitted instead.
+  inline bool emit_select(LiftoffRegister dst, Register condition,
+                          LiftoffRegister true_value,
+                          LiftoffRegister false_value, ValueType type);
+
   inline void LoadTransform(LiftoffRegister dst, Register src_addr,
                             Register offset_reg, uint32_t offset_imm,
                             LoadType type, LoadTransformationKind transform,

src/wasm/baseline/liftoff-compiler.cc

@@ -1801,19 +1801,19 @@ class LiftoffCompiler {
     LiftoffRegister true_value = __ PopToRegister(pinned);
     LiftoffRegister dst = __ GetUnusedRegister(true_value.reg_class(),
                                                {true_value, false_value}, {});
+    if (!__ emit_select(dst, condition, true_value, false_value, type)) {
+      // Emit generic code (using branches) instead.
+      Label cont;
+      Label case_false;
+      __ emit_cond_jump(kEqual, &case_false, kWasmI32, condition);
+      if (dst != true_value) __ Move(dst, true_value, type);
+      __ emit_jump(&cont);
+
+      __ bind(&case_false);
+      if (dst != false_value) __ Move(dst, false_value, type);
+      __ bind(&cont);
+    }
     __ PushRegister(type, dst);
-
-    // Now emit the actual code to move either {true_value} or {false_value}
-    // into {dst}.
-    Label cont;
-    Label case_false;
-    __ emit_cond_jump(kEqual, &case_false, kWasmI32, condition);
-    if (dst != true_value) __ Move(dst, true_value, type);
-    __ emit_jump(&cont);
-
-    __ bind(&case_false);
-    if (dst != false_value) __ Move(dst, false_value, type);
-    __ bind(&cont);
   }
 
   void BrImpl(Control* target) {

src/wasm/baseline/mips/liftoff-assembler-mips.h

@@ -1569,6 +1569,13 @@ void LiftoffAssembler::emit_f64_set_cond(Condition cond, Register dst,
   bind(&cont);
 }
 
+bool LiftoffAssembler::emit_select(LiftoffRegister dst, Register condition,
+                                   LiftoffRegister true_value,
+                                   LiftoffRegister false_value,
+                                   ValueType type) {
+  return false;
+}
+
 void LiftoffAssembler::LoadTransform(LiftoffRegister dst, Register src_addr,
                                      Register offset_reg, uint32_t offset_imm,
                                      LoadType type,

src/wasm/baseline/mips64/liftoff-assembler-mips64.h

@@ -1404,6 +1404,13 @@ void LiftoffAssembler::emit_f64_set_cond(Condition cond, Register dst,
   bind(&cont);
 }
 
+bool LiftoffAssembler::emit_select(LiftoffRegister dst, Register condition,
+                                   LiftoffRegister true_value,
+                                   LiftoffRegister false_value,
+                                   ValueType type) {
+  return false;
+}
+
 void LiftoffAssembler::LoadTransform(LiftoffRegister dst, Register src_addr,
                                      Register offset_reg, uint32_t offset_imm,
                                      LoadType type,

src/wasm/baseline/ppc/liftoff-assembler-ppc.h

@@ -549,6 +549,13 @@ void LiftoffAssembler::emit_f64_set_cond(Condition cond, Register dst,
   bailout(kUnsupportedArchitecture, "emit_f64_set_cond");
 }
 
+bool LiftoffAssembler::emit_select(LiftoffRegister dst, Register condition,
+                                   LiftoffRegister true_value,
+                                   LiftoffRegister false_value,
+                                   ValueType type) {
+  return false;
+}
+
 void LiftoffAssembler::LoadTransform(LiftoffRegister dst, Register src_addr,
                                      Register offset_reg, uint32_t offset_imm,
                                      LoadType type,

src/wasm/baseline/s390/liftoff-assembler-s390.h

@@ -553,6 +553,13 @@ void LiftoffAssembler::emit_f64_set_cond(Condition cond, Register dst,
   bailout(kUnsupportedArchitecture, "emit_f64_set_cond");
 }
 
+bool LiftoffAssembler::emit_select(LiftoffRegister dst, Register condition,
+                                   LiftoffRegister true_value,
+                                   LiftoffRegister false_value,
+                                   ValueType type) {
+  return false;
+}
+
 void LiftoffAssembler::LoadTransform(LiftoffRegister dst, Register src_addr,
                                      Register offset_reg, uint32_t offset_imm,
                                      LoadType type,

src/wasm/baseline/x64/liftoff-assembler-x64.h

@@ -2040,6 +2040,33 @@ void LiftoffAssembler::emit_f64_set_cond(Condition cond, Register dst,
                                                       rhs);
 }
 
+bool LiftoffAssembler::emit_select(LiftoffRegister dst, Register condition,
+                                   LiftoffRegister true_value,
+                                   LiftoffRegister false_value,
+                                   ValueType type) {
+  if (type != kWasmI32 && type != kWasmI64) return false;
+
+  testl(condition, condition);
+
+  if (type == kWasmI32) {
+    if (dst == false_value) {
+      cmovl(not_zero, dst.gp(), true_value.gp());
+    } else {
+      if (dst != true_value) movl(dst.gp(), true_value.gp());
+      cmovl(zero, dst.gp(), false_value.gp());
+    }
+  } else {
+    if (dst == false_value) {
+      cmovq(not_zero, dst.gp(), true_value.gp());
+    } else {
+      if (dst != true_value) movq(dst.gp(), true_value.gp());
+      cmovq(zero, dst.gp(), false_value.gp());
+    }
+  }
+
+  return true;
+}
+
 // TODO(fanchenk): Distinguish mov* if data bypass delay matter.
 namespace liftoff {
 template <void (Assembler::*avx_op)(XMMRegister, XMMRegister, XMMRegister),