[compiler] Introduce code stubs for string relational comparisons.

src/compiler/code-stub-assembler.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/code-stub-assembler.h"
 
 #include <ostream>
 
 #include "src/code-factory.h"
 #include "src/compiler/graph.h"
@@ skipping 153 matching lines @@
 Node* CodeStubAssembler::SmiEqual(Node* a, Node* b) { return WordEqual(a, b); }
 
 Node* CodeStubAssembler::SmiLessThan(Node* a, Node* b) {
   return IntPtrLessThan(a, b);
 }
 
 Node* CodeStubAssembler::SmiLessThanOrEqual(Node* a, Node* b) {
   return IntPtrLessThanOrEqual(a, b);
 }
 
+Node* CodeStubAssembler::SmiMin(Node* a, Node* b) {
+  // TODO(bmeurer): Consider using Select once available.
+  Variable min(this, MachineRepresentation::kTagged);
+  Label if_a(this), if_b(this), join(this);
+  BranchIfSmiLessThan(a, b, &if_a, &if_b);
+  Bind(&if_a);
+  min.Bind(a);
+  Goto(&join);
+  Bind(&if_b);
+  min.Bind(b);
+  Goto(&join);
+  Bind(&join);
+  return min.value();
+}
+
 #define DEFINE_CODE_STUB_ASSEMBER_BINARY_OP(name)   \
   Node* CodeStubAssembler::name(Node* a, Node* b) { \
     return raw_assembler_->name(a, b);              \
   }
 CODE_STUB_ASSEMBLER_BINARY_OP_LIST(DEFINE_CODE_STUB_ASSEMBER_BINARY_OP)
 #undef DEFINE_CODE_STUB_ASSEMBER_BINARY_OP
 
 Node* CodeStubAssembler::WordShl(Node* value, int shift) {
   return raw_assembler_->WordShl(value, IntPtrConstant(shift));
 }
@@ skipping 233 matching lines @@
   return LoadMapInstanceType(LoadObjectField(object, HeapObject::kMapOffset));
 }
 
 Node* CodeStubAssembler::BitFieldDecode(Node* word32, uint32_t shift,
                                         uint32_t mask) {
   return raw_assembler_->Word32Shr(
       raw_assembler_->Word32And(word32, raw_assembler_->Int32Constant(mask)),
       raw_assembler_->Int32Constant(shift));
 }
 
+void CodeStubAssembler::BranchIfInt32LessThan(Node* a, Node* b, Label* if_true,

[epertoso, 2016/03/04 09:22:25]

Do we really need this? If so, it seems to me that we should directly use
if_true and if_false in the Branch instruction anyway.

[Benedikt Meurer, 2016/03/04 09:25:38]

That's not correct because of edge-split-form, and you (currently) need a
dedicated Block for the IfTrue/IfFalse and another one for the Merge. You cannot
directly refer to a Merge block from a Branch.

[epertoso, 2016/03/04 09:35:16]

Oh, I see what you mean. You use if_less and if_greater also with
BranchIfSmiLessThan. My bad.

+                                              Label* if_false) {
+  Label if_lessthan(this), if_notlessthan(this);
+  Branch(Int32LessThan(a, b), &if_lessthan, &if_notlessthan);
+  Bind(&if_lessthan);
+  Goto(if_true);
+  Bind(&if_notlessthan);
+  Goto(if_false);
+}
+
 void CodeStubAssembler::BranchIfSmiLessThan(Node* a, Node* b, Label* if_true,
                                             Label* if_false) {
   Label if_lessthan(this), if_notlessthan(this);
   Branch(SmiLessThan(a, b), &if_lessthan, &if_notlessthan);
   Bind(&if_lessthan);
   Goto(if_true);
   Bind(&if_notlessthan);
   Goto(if_false);
 }
 
@@ skipping 465 matching lines @@
       }
     }
   }
 
   bound_ = true;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8