Add equality type parameter to HCompareObjectAndBranch

src/code-stubs-hydrogen.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 68 matching lines @@
   CompilationInfo* info() { return &info_; }
   HydrogenCodeStub* stub() { return info_.code_stub(); }
   HContext* context() { return context_; }
   Isolate* isolate() { return info_.isolate(); }
 
   class ArrayContextChecker {
    public:
     ArrayContextChecker(HGraphBuilder* builder, HValue* constructor,
                         HValue* array_function)
         : checker_(builder) {
-      checker_.If<HCompareObjectEqAndBranch, HValue*>(constructor,
-                                                      array_function);
+      checker_.If<HCompareObjectAndBranch, HValue*>(constructor,
+                                                    array_function);
       checker_.Then();
     }
 
     ~ArrayContextChecker() {
       checker_.ElseDeopt();
       checker_.End();
     }
    private:
     IfBuilder checker_;
   };
@@ skipping 128 matching lines @@
 
   virtual HValue* BuildCodeInitializedStub() {
     UNIMPLEMENTED();
     return NULL;
   }
 
   virtual HValue* BuildCodeUninitializedStub() {
     // Force a deopt that falls back to the runtime.
     HValue* undefined = graph()->GetConstantUndefined();
     IfBuilder builder(this);
-    builder.IfNot<HCompareObjectEqAndBranch, HValue*>(undefined, undefined);
+    builder.IfNot<HCompareObjectAndBranch, HValue*>(undefined, undefined);
     builder.Then();
     builder.ElseDeopt();
     return undefined;
   }
 
   Stub* casted_stub() { return static_cast<Stub*>(stub()); }
 };
 
 
 Handle<Code> HydrogenCodeStub::GenerateLightweightMissCode(Isolate* isolate) {
@@ skipping 95 matching lines @@
   AllocationSiteMode alloc_site_mode = casted_stub()->allocation_site_mode();
   FastCloneShallowArrayStub::Mode mode = casted_stub()->mode();
   int length = casted_stub()->length();
 
   HInstruction* allocation_site =
       AddInstruction(new(zone) HLoadKeyed(GetParameter(0),
                                           GetParameter(1),
                                           NULL,
                                           FAST_ELEMENTS));
   IfBuilder checker(this);
-  checker.IfNot<HCompareObjectEqAndBranch, HValue*>(allocation_site, undefined);
+  checker.IfNot<HCompareObjectAndBranch, HValue*>(allocation_site, undefined);
   checker.Then();
 
   HObjectAccess access = HObjectAccess::ForAllocationSiteTransitionInfo();
   HInstruction* boilerplate = AddLoad(allocation_site, access);
   if (mode == FastCloneShallowArrayStub::CLONE_ANY_ELEMENTS) {
     HValue* elements = AddLoadElements(boilerplate);
 
     IfBuilder if_fixed_cow(this);
     if_fixed_cow.If<HCompareMap>(elements, factory->fixed_cow_array_map());
     if_fixed_cow.Then();
@@ skipping 48 matching lines @@
   Zone* zone = this->zone();
   HValue* undefined = graph()->GetConstantUndefined();
 
   HInstruction* boilerplate =
       AddInstruction(new(zone) HLoadKeyed(GetParameter(0),
                                           GetParameter(1),
                                           NULL,
                                           FAST_ELEMENTS));
 
   IfBuilder checker(this);
-  checker.IfNot<HCompareObjectEqAndBranch, HValue*>(boilerplate, undefined);
+  checker.IfNot<HCompareObjectAndBranch, HValue*>(boilerplate, undefined);
   checker.And();
 
   int size = JSObject::kHeaderSize + casted_stub()->length() * kPointerSize;
   HValue* boilerplate_size =
       AddInstruction(new(zone) HInstanceSize(boilerplate));
   HValue* size_in_words =
       AddInstruction(new(zone) HConstant(size >> kPointerSizeLog2));
   checker.If<HCompareNumericAndBranch>(boilerplate_size,
                                        size_in_words, Token::EQ);
   checker.Then();
@@ skipping 455 matching lines @@
   Handle<Map> placeholder_map = isolate()->factory()->meta_map();
   AddInstruction(HCheckMaps::New(
       receiver, placeholder_map, zone(), top_info()));
 
   HValue* cell = Add<HConstant>(placeholder_cell, Representation::Tagged());
   HObjectAccess access(HObjectAccess::ForCellPayload(isolate()));
   HValue* cell_contents = Add<HLoadNamedField>(cell, access);
 
   if (stub->is_constant()) {
     IfBuilder builder(this);
-    builder.If<HCompareObjectEqAndBranch>(cell_contents, value);
+    builder.If<HCompareObjectAndBranch>(cell_contents, value);
     builder.Then();
     builder.ElseDeopt();
     builder.End();
   } else {
     // Load the payload of the global parameter cell. A hole indicates that the
     // property has been deleted and that the store must be handled by the
     // runtime.
     IfBuilder builder(this);
     HValue* hole_value = Add<HConstant>(hole, Representation::Tagged());
-    builder.If<HCompareObjectEqAndBranch>(cell_contents, hole_value);
+    builder.If<HCompareObjectAndBranch>(cell_contents, hole_value);
     builder.Then();
     builder.Deopt();
     builder.Else();
     Add<HStoreNamedField>(cell, access, value);
     builder.End();
   }
 
   return value;
 }
 
@@ skipping 31 matching lines @@
   return value;
 }
 
 
 Handle<Code> ElementsTransitionAndStoreStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 } }  // namespace v8::internal