[WIP] EqualStub and NotEqualStub.

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 87 matching lines @@
 }
 
 Node* CodeStubAssembler::ExternalConstant(ExternalReference address) {
   return raw_assembler_->ExternalConstant(address);
 }
 
 Node* CodeStubAssembler::Float64Constant(double value) {
   return raw_assembler_->Float64Constant(value);
 }
 
+Node* CodeStubAssembler::BooleanMapConstant() {
+  return HeapConstant(isolate()->factory()->boolean_map());
+}
+
 Node* CodeStubAssembler::HeapNumberMapConstant() {
   return HeapConstant(isolate()->factory()->heap_number_map());
 }
 
 Node* CodeStubAssembler::Parameter(int value) {
   return raw_assembler_->Parameter(value);
 }
 
 
 void CodeStubAssembler::Return(Node* value) {
@@ skipping 97 matching lines @@
 Node* CodeStubAssembler::LoadObjectField(Node* object, int offset) {
   return raw_assembler_->Load(MachineType::AnyTagged(), object,
                               IntPtrConstant(offset - kHeapObjectTag));
 }
 
 Node* CodeStubAssembler::LoadHeapNumberValue(Node* object) {
   return Load(MachineType::Float64(), object,
               IntPtrConstant(HeapNumber::kValueOffset - kHeapObjectTag));
 }
 
+Node* CodeStubAssembler::LoadMapBitField(Node* map) {
+  return Load(MachineType::Uint8(), map,
+              IntPtrConstant(Map::kBitFieldOffset - kHeapObjectTag));
+}
+
 Node* CodeStubAssembler::LoadMapInstanceType(Node* map) {
   return Load(MachineType::Uint8(), map,
               IntPtrConstant(Map::kInstanceTypeOffset - kHeapObjectTag));
 }
 
 Node* CodeStubAssembler::LoadFixedArrayElementSmiIndex(Node* object,
                                                        Node* smi_index,
                                                        int additional_offset) {
   int const kSmiShiftBits = kSmiShiftSize + kSmiTagSize;
   Node* header_size = IntPtrConstant(additional_offset +
@@ skipping 284 matching lines @@
                                                           Label* if_false) {
   Label if_greaterthanorequal(this), if_notgreaterthanorequal(this);
   Branch(Float64GreaterThanOrEqual(a, b), &if_greaterthanorequal,
          &if_notgreaterthanorequal);
   Bind(&if_greaterthanorequal);
   Goto(if_true);
   Bind(&if_notgreaterthanorequal);
   Goto(if_false);
 }
 
+void CodeStubAssembler::BranchIfWord32Equal(Node* a, Node* b, Label* if_true,
+                                            Label* if_false) {
+  Label if_equal(this), if_notequal(this);
+  Branch(Word32Equal(a, b), &if_equal, &if_notequal);
+  Bind(&if_equal);
+  Goto(if_true);
+  Bind(&if_notequal);
+  Goto(if_false);
+}
+
 Node* CodeStubAssembler::CallN(CallDescriptor* descriptor, Node* code_target,
                                Node** args) {
   CallPrologue();
   Node* return_value = raw_assembler_->CallN(descriptor, code_target, args);
   CallEpilogue();
   return return_value;
 }
 
 
 Node* CodeStubAssembler::TailCallN(CallDescriptor* descriptor,
@@ skipping 388 matching lines @@
       }
     }
   }
 
   bound_ = true;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8