ARM: Implement DoInstanceOfKnownGlobal stub

src/arm/lithium-codegen-arm.cc

 // Copyright 2011 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 1570 matching lines @@
   __ mov(r0, Operand(Factory::true_value()), LeaveCC, eq);
 }
 
 
 void LCodeGen::DoInstanceOfAndBranch(LInstanceOfAndBranch* instr) {
   Abort("DoInstanceOfAndBranch unimplemented.");
 }
 
 
 void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) {
-  Abort("DoInstanceOfKnownGlobal unimplemented.");
+  class DeferredInstanceOfKnownGlobal: public LDeferredCode {
+   public:
+    DeferredInstanceOfKnownGlobal(LCodeGen* codegen,
+                                  LInstanceOfKnownGlobal* instr)
+        : LDeferredCode(codegen), instr_(instr) { }
+    virtual void Generate() {
+      codegen()->DoDeferredLInstanceOfKnownGlobal(instr_, &map_check_);
+    }
+
+    Label* map_check() { return &map_check_; }
+
+   private:
+    LInstanceOfKnownGlobal* instr_;
+    Label map_check_;
+  };
+
+  DeferredInstanceOfKnownGlobal* deferred;
+  deferred = new DeferredInstanceOfKnownGlobal(this, instr);
+
+  Label done, false_result;
+  Register object = ToRegister(instr->input());
+  Register temp = ToRegister(instr->temp());
+  Register result = ToRegister(instr->result());
+
+  ASSERT(object.is(r0));
+  ASSERT(result.is(r0));
+
+  // A Smi is not instance of anything.
+  __ BranchOnSmi(object, &false_result);
+
+  // 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.
+  Label cache_miss;
+  Register map = temp;
+  __ ldr(map, FieldMemOperand(object, HeapObject::kMapOffset));
+  __ bind(deferred->map_check());  // Label for calculating code patching.
+  // We use Factory::the_hole_value() on purpose to force relocation to be

[Søren Thygesen Gjesse, 2011/01/13 15:14:36]

Extend comment with "instead of loading from the root array" (I assume that is
what you mean).

[Alexandre, 2011/01/14 17:53:40]

It is. Updated.
On 2011/01/13 15:14:36, Søren Gjesse wrote:

+  // able to later patch with the cached map.
+  __ mov(ip, Operand(Factory::the_hole_value()));
+  __ cmp(map, Operand(ip));
+  __ b(ne, &cache_miss);
+  // We use Factory::the_hole_value() on purpose to force relocation to be

[Søren Thygesen Gjesse, 2011/01/13 15:14:36]

Ditto.

[Alexandre, 2011/01/14 17:53:40]

Done.

+  // able to later patch with true or false.
+  __ mov(ip, 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);
+  // Null is not instance of anything.
+  __ LoadRoot(ip, Heap::kNullValueRootIndex);
+  __ cmp(object, Operand(ip));
+  __ b(eq, &false_result);
+
+  // String values is not instance of anything.
+  Condition is_string = masm_->IsObjectStringType(object, temp);
+  __ b(is_string, &false_result);
+
+  // Go to the deferred code.
+  __ b(deferred->entry());
+
+  __ bind(&false_result);
+  __ LoadRoot(result, Heap::kFalseValueRootIndex);
+
+  // Here result has either true or false. Deferred code also produces true or
+  // false object.
+  __ bind(deferred->exit());
+  __ bind(&done);
+}
+
+
+void LCodeGen::DoDeferredLInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr,
+                                                Label* map_check) {
+  Register result = ToRegister(instr->result());
+
+  InstanceofStub::Flags flags = InstanceofStub::kNoFlags;
+  flags = static_cast<InstanceofStub::Flags>(
+      flags | InstanceofStub::kArgsInRegisters);
+  flags = static_cast<InstanceofStub::Flags>(
+      flags | InstanceofStub::kCallSiteInlineCheck);
+  flags = static_cast<InstanceofStub::Flags>(
+      flags | InstanceofStub::kReturnTrueFalseObject);
+  InstanceofStub stub(flags);
+
+  __ PushSafepointRegisters();
+
+  // Get the temp register reserved by the instruction. This needs to be r4 as
+  // its slot of the pushing of safepoint registers is used to communicate the
+  // offset to the location of the map check.
+  Register temp = ToRegister(instr->temp());
+  ASSERT(temp.is(r4));
+  __ mov(InstanceofStub::right(), Operand(instr->function()));
+  static const int kAdditionalDelta = 4;  // 3 instructions + 1 for reloc info.

[Søren Thygesen Gjesse, 2011/01/13 15:14:36]

I think the 4 here is 4 instructions Call always generates two instructions, and
the reloc info goes in the constant pool later.

Regarding the constant pool I am quite sure that we need to block the constant
pool for for these 4 instructions. Otherwise we might potentially get a constant
pool inside this sequence and the calculation of the patch site will be wrong.

[Alexandre, 2011/01/14 17:53:40]

The +1 was referring to the additional instruction used to load the target in
Call. (which is relocated here.)
You are right about blocking the constant pool here.
Changed the comment and blocked constant pool emission.
On 2011/01/13 15:14:36, Søren Gjesse wrote:

+  int delta = masm_->InstructionsGeneratedSince(map_check) + kAdditionalDelta;
+  Label before_push_delta;
+  __ bind(&before_push_delta);
+  __ mov(temp, Operand(delta * kPointerSize));

[Søren Thygesen Gjesse, 2011/01/13 15:14:36]

On IA32 we have EspIndexForPushAll, and I think we need something like that
here, maybe a macro assembler instruction like StoreToSafePointRegister to work
in correspondance with PushSafepointRegisters/PopSafepointRegisters.
karlklose@chromium.org is also working on the safepoint stuff adding saving of
doubles, see http://codereview.chromium.org/6164005/.

[Alexandre, 2011/01/14 17:53:40]

Added SafepointRegisterSlot  and  StoreToSafepointRegister helpers.
This is not optimal as it only use an offset from sp...
On 2011/01/13 15:14:36, Søren Gjesse wrote:

+  __ str(temp, MemOperand(sp, temp.code() * kPointerSize));
+  __ Call(stub.GetCode(), RelocInfo::CODE_TARGET);
+  ASSERT_EQ(kAdditionalDelta,
+            masm_->InstructionsGeneratedSince(&before_push_delta));
+  RecordSafepointWithRegisters(
+      instr->pointer_map(), 0, Safepoint::kNoDeoptimizationIndex);
+  // Put the result value into the result register slot and
+  // restore all registers.
+  __ str(r0, MemOperand(sp, result.code() * kPointerSize));
+
+  __ PopSafepointRegisters();
 }
 
 
 static Condition ComputeCompareCondition(Token::Value op) {
   switch (op) {
     case Token::EQ_STRICT:
     case Token::EQ:
       return eq;
     case Token::LT:
       return lt;
@@ skipping 1228 matching lines @@
 
 
 void LCodeGen::DoOsrEntry(LOsrEntry* instr) {
   Abort("DoOsrEntry unimplemented.");
 }
 
 
 #undef __
 
 } }  // namespace v8::internal