[compiler] Introduce code stubs for abstract equality.

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 187 matching lines @@
 Node* CodeStubAssembler::StoreNoWriteBarrier(MachineRepresentation rep,
                                              Node* base, Node* index,
                                              Node* value) {
   return raw_assembler_->Store(rep, base, index, value, kNoWriteBarrier);
 }
 
 Node* CodeStubAssembler::Projection(int index, Node* value) {
   return raw_assembler_->Projection(index, value);
 }
 
+Node* CodeStubAssembler::LoadMap(Node* object) {
+  return LoadObjectField(object, HeapObject::kMapOffset);
+}
+
 Node* CodeStubAssembler::LoadInstanceType(Node* object) {
-  return LoadMapInstanceType(LoadObjectField(object, HeapObject::kMapOffset));
+  return LoadMapInstanceType(LoadMap(object));
 }
 
 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,
@@ skipping 76 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