A64: Implement patchable inline code for InstanceOfKnownGlobal.

src/a64/lithium-codegen-a64.cc

 // Copyright 2013 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 2706 matching lines @@
 }
 
 
 void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) {
   class DeferredInstanceOfKnownGlobal: public LDeferredCode {
    public:
     DeferredInstanceOfKnownGlobal(LCodeGen* codegen,
                                   LInstanceOfKnownGlobal* instr)
         : LDeferredCode(codegen), instr_(instr) { }
     virtual void Generate() {
-      codegen()->DoDeferredInstanceOfKnownGlobal(instr_, &map_check_);
+      codegen()->DoDeferredInstanceOfKnownGlobal(instr_);
     }
     virtual LInstruction* instr() { return instr_; }
-    Label* map_check() { return &map_check_; }
    private:
     LInstanceOfKnownGlobal* instr_;
-    Label map_check_;
   };
 
   DeferredInstanceOfKnownGlobal* deferred =
       new(zone()) DeferredInstanceOfKnownGlobal(this, instr);
 
-  Label return_false, cache_miss;
+  Label map_check, return_false, cache_miss, done;
   Register object = ToRegister(instr->value());
   Register result = ToRegister(instr->result());
+  // x4 is expected in the associated deferred code and stub.
+  Register map_check_site = x4;
+  Register map = x5;
 
   // This instruction is marked as call. We can clobber any register.
   ASSERT(instr->IsMarkedAsCall());
 
   // We must take into account that object is in x11.
   ASSERT(object.Is(x11));
   Register scratch = x10;
 
   // A Smi is not instance of anything.
   __ JumpIfSmi(object, &return_false);
 
-  TODO_UNIMPLEMENTED("patchable inline check");
+  // This is the inlined call site instanceof cache. The two occurences of the
+  // hole value will be patched to the last map/result pair generated by the
+  // instanceof stub.
+  __ Ldr(map, FieldMemOperand(object, HeapObject::kMapOffset));
+  {
+    // Below we use Factory::the_hole_value() on purpose instead of loading from
+    // the root array to force relocation and later be able to patch with a
+    // custom value.
+    InstructionAccurateScope scope(masm(), 5);
+    __ bind(&map_check);
+    // Will be patched with the cached map.
+    Handle<Cell> cell = factory()->NewCell(factory()->the_hole_value());
+    __ LoadRelocated(scratch, Operand(Handle<Object>(cell)));
+    __ ldr(scratch, FieldMemOperand(scratch, PropertyCell::kValueOffset));
+    __ cmp(map, Operand(scratch));
+    __ b(&cache_miss, ne);
+    // The address of this instruction is computed relative to the map check
+    // above, so check the size of the code generated.
+    ASSERT(masm()->InstructionsGeneratedSince(&map_check) == 4);
+    // Will be patched with the cached result.
+    __ LoadRelocated(result, Operand(factory()->the_hole_value()));
+  }
+  __ B(&done);
 
   // The inlined call site cache did not match.
   // Check null and string before calling the deferred code.
   __ Bind(&cache_miss);
+  // Compute the address of the map check. It must not be clobbered until the
+  // InstanceOfStub has used it.
+  __ Adr(map_check_site, &map_check);
   // Null is not instance of anything.
   __ JumpIfRoot(object, Heap::kNullValueRootIndex, &return_false);
 
   // String values are not instances of anything.
   // Return false if the object is a string. Otherwise, jump to the deferred
   // code.
   // Note that we can't jump directly to deferred code from
   // IsObjectJSStringType, because it uses tbz for the jump and the deferred
   // code can be out of range.
   __ IsObjectJSStringType(object, scratch, NULL, &return_false);
   __ B(deferred->entry());
 
   __ Bind(&return_false);
   __ LoadRoot(result, Heap::kFalseValueRootIndex);
 
   // Here result is either true or false.
   __ Bind(deferred->exit());
+  __ Bind(&done);
 }
 
 
 void LCodeGen::DoInstanceSize(LInstanceSize* instr) {
   Register object = ToRegister(instr->object());
   Register result = ToRegister(instr->result());
   __ Ldr(result, FieldMemOperand(object, HeapObject::kMapOffset));
   __ Ldrb(result, FieldMemOperand(result, Map::kInstanceSizeOffset));
 }
 
 
-void LCodeGen::DoDeferredInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr,
-                                               Label* map_check) {
+void LCodeGen::DoDeferredInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) {
   Register result = ToRegister(instr->result());
   ASSERT(result.Is(x0));  // InstanceofStub returns its result in x0.
-  InstanceofStub::Flags flags = InstanceofStub::kArgsInRegisters;
+  InstanceofStub::Flags flags = InstanceofStub::kNoFlags;
+  flags = static_cast<InstanceofStub::Flags>(
+      flags | InstanceofStub::kArgsInRegisters);
+  flags = static_cast<InstanceofStub::Flags>(
+      flags | InstanceofStub::kReturnTrueFalseObject);
+  flags = static_cast<InstanceofStub::Flags>(
+      flags | InstanceofStub::kCallSiteInlineCheck);
 
   PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
 
   // Prepare InstanceofStub arguments.
   ASSERT(ToRegister(instr->value()).Is(InstanceofStub::left()));
   __ LoadHeapObject(InstanceofStub::right(), instr->function());
 
   InstanceofStub stub(flags);
   CallCodeGeneric(stub.GetCode(isolate()),
                   RelocInfo::CODE_TARGET,
                   instr,
                   RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);
   LEnvironment* env = instr->GetDeferredLazyDeoptimizationEnvironment();
   safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index());
 
-  // TODO(all): This could be integrated into InstanceofStub.
-  __ LoadTrueFalseRoots(x1, x2);
-  ASSERT(Smi::FromInt(0) == 0);
-  __ Cmp(result, 0);
-  __ Csel(result, x1, x2, eq);
-
   // Put the result value into the result register slot.
   __ StoreToSafepointRegisterSlot(result, result);
 }
 
 
 void LCodeGen::DoInstructionGap(LInstructionGap* instr) {
   DoGap(instr);
 }
 
 
@@ skipping 2675 matching lines @@
   __ Bind(&out_of_object);
   __ Ldr(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
   // Index is equal to negated out of object property index plus 1.
   __ Sub(result, result, Operand::UntagSmiAndScale(index, kPointerSizeLog2));
   __ Ldr(result, FieldMemOperand(result,
                                  FixedArray::kHeaderSize - kPointerSize));
   __ Bind(&done);
 }
 
 } }  // namespace v8::internal