[arm64] Implement Float(32|64)(Min|Max) using fcsel.

src/compiler/instruction-selector-impl.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_INSTRUCTION_SELECTOR_IMPL_H_
 #define V8_COMPILER_INSTRUCTION_SELECTOR_IMPL_H_
 
 #include "src/compiler/instruction.h"
 #include "src/compiler/instruction-selector.h"
 #include "src/compiler/linkage.h"
@@ skipping 241 matching lines @@
                     BasicBlock* false_block)
       : mode_(kFlags_branch),
         condition_(condition),
         true_block_(true_block),
         false_block_(false_block) {
     DCHECK_NOT_NULL(true_block);
     DCHECK_NOT_NULL(false_block);
   }
 
   // Creates a new flags continuation from the given condition and result node.
-  FlagsContinuation(FlagsCondition condition, Node* result)
-      : mode_(kFlags_set), condition_(condition), result_(result) {
+  FlagsContinuation(FlagsCondition condition, Node* result,
+                    FlagsMode mode = kFlags_set)
+      : mode_(mode), condition_(condition), result_(result) {
     DCHECK_NOT_NULL(result);
   }
 
   bool IsNone() const { return mode_ == kFlags_none; }
   bool IsBranch() const { return mode_ == kFlags_branch; }
   bool IsSet() const { return mode_ == kFlags_set; }
+  bool IsSelect() const { return mode_ == kFlags_select; }
   FlagsCondition condition() const {
     DCHECK(!IsNone());
     return condition_;
   }
   Node* result() const {
-    DCHECK(IsSet());
+    DCHECK(IsSet() || IsSelect());
     return result_;
   }
   BasicBlock* true_block() const {
     DCHECK(IsBranch());
     return true_block_;
   }
   BasicBlock* false_block() const {
     DCHECK(IsBranch());
     return false_block_;
   }
@@ skipping 53 matching lines @@
     opcode |= FlagsModeField::encode(mode_);
     if (mode_ != kFlags_none) {
       opcode |= FlagsConditionField::encode(condition_);
     }
     return opcode;
   }
 
  private:
   FlagsMode mode_;
   FlagsCondition condition_;
-  Node* result_;             // Only valid if mode_ == kFlags_set.
-  BasicBlock* true_block_;   // Only valid if mode_ == kFlags_branch.
-  BasicBlock* false_block_;  // Only valid if mode_ == kFlags_branch.
+  Node* result_;             // Valid if mode_ == kFlags_set or kFlags_select.
+  BasicBlock* true_block_;   // Valid if mode_ == kFlags_branch.
+  BasicBlock* false_block_;  // Valid if mode_ == kFlags_branch.
 };
 
 
 // An internal helper class for generating the operands to calls.
 // TODO(bmeurer): Get rid of the CallBuffer business and make
 // InstructionSelector::VisitCall platform independent instead.
 struct CallBuffer {
   CallBuffer(Zone* zone, const CallDescriptor* descriptor,
              FrameStateDescriptor* frame_state);
 
@@ skipping 14 matching lines @@
                : (frame_state_descriptor->GetTotalSize() +
                   1);  // Include deopt id.
   }
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_SELECTOR_IMPL_H_