Improve the generated code for the instanceof operator.

src/codegen-ia32.cc

 // Copyright 2006-2008 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 876 matching lines @@
 }
 
 
 class ToBooleanStub: public CodeStub {
  public:
   ToBooleanStub() { }
 
   void Generate(MacroAssembler* masm);
 
  private:
-
   Major MajorKey() { return ToBoolean; }
-
   int MinorKey() { return 0; }
-
-  const char* GetName() { return "ToBooleanStub"; }
-
-#ifdef DEBUG
-  void Print() {
-    PrintF("ToBooleanStub\n");
-  }
-#endif
 };
 
 
 // ECMA-262, section 9.2, page 30: ToBoolean(). Pop the top of stack and
 // convert it to a boolean in the condition code register or jump to
 // 'false_target'/'true_target' as appropriate.
 void Ia32CodeGenerator::ToBoolean(Label* true_target, Label* false_target) {
   Comment cmnt(masm_, "[ ToBoolean");
 
   // The value to convert should be popped from the stack.
@@ skipping 550 matching lines @@
   bool strict_;
 
   Major MajorKey() { return Compare; }
 
   int MinorKey() {
     // Encode the three parameters in a unique 16 bit value.
     ASSERT(static_cast<int>(cc_) < (1 << 15));
     return (static_cast<int>(cc_) << 1) | (strict_ ? 1 : 0);
   }
 
-  const char* GetName() { return "CompareStub"; }
-
 #ifdef DEBUG
   void Print() {
     PrintF("CompareStub (cc %d), (strict %s)\n",
            static_cast<int>(cc_),
            strict_ ? "true" : "false");
   }
 #endif
 };
 
 
@@ skipping 87 matching lines @@
 
 class CallFunctionStub: public CodeStub {
  public:
   explicit CallFunctionStub(int argc) : argc_(argc) { }
 
   void Generate(MacroAssembler* masm);
 
  private:
   int argc_;
 
-  const char* GetName() { return "CallFunctionStub"; }
-
 #ifdef DEBUG
   void Print() { PrintF("CallFunctionStub (args %d)\n", argc_); }
 #endif
 
   Major MajorKey() { return CallFunction; }
   int MinorKey() { return argc_; }
 };
 
 
 // Call the function just below TOS on the stack with the given
@@ skipping 1914 matching lines @@
   explicit RevertToNumberStub(bool is_increment)
      :  is_increment_(is_increment) { }
 
  private:
   bool is_increment_;
 
   Major MajorKey() { return RevertToNumber; }
   int MinorKey() { return is_increment_ ? 1 : 0; }
   void Generate(MacroAssembler* masm);
 
-  const char* GetName() { return "RevertToNumberStub"; }
-
 #ifdef DEBUG
   void Print() {
     PrintF("RevertToNumberStub (is_increment %s)\n",
            is_increment_ ? "true" : "false");
   }
 #endif
 };
 
 
 class CounterOpStub: public CodeStub {
  public:
   CounterOpStub(int result_offset, bool is_postfix, bool is_increment)
      :  result_offset_(result_offset),
         is_postfix_(is_postfix),
         is_increment_(is_increment) { }
 
  private:
   int result_offset_;
   bool is_postfix_;
   bool is_increment_;
 
   Major MajorKey() { return CounterOp; }
   int MinorKey() {
     return ((result_offset_ << 2) |
             (is_postfix_ ? 2 : 0) |
             (is_increment_ ? 1 : 0));
   }
   void Generate(MacroAssembler* masm);
 
-  const char* GetName() { return "CounterOpStub"; }
-
 #ifdef DEBUG
   void Print() {
     PrintF("CounterOpStub (result_offset %d), (is_postfix %s),"
            " (is_increment %s)\n",
            result_offset_,
            is_postfix_ ? "true" : "false",
            is_increment_ ? "true" : "false");
   }
 #endif
 };
@@ skipping 180 matching lines @@
     }
   }
 }
 
 
 void Ia32CodeGenerator::VisitThisFunction(ThisFunction* node) {
   __ push(FunctionOperand());
 }
 
 
+class InstanceofStub: public CodeStub {
+ public:
+  InstanceofStub() { }
+
+  void Generate(MacroAssembler* masm);
+
+ private:
+  Major MajorKey() { return Instanceof; }
+  int MinorKey() { return 0; }
+};
+
+
 void Ia32CodeGenerator::VisitCompareOperation(CompareOperation* node) {
   Comment cmnt(masm_, "[ CompareOperation");
 
   // Get the expressions from the node.
   Expression* left = node->left();
   Expression* right = node->right();
   Token::Value op = node->op();
 
   // NOTE: To make null checks efficient, we check if either left or
   // right is the literal 'null'. If so, we optimize the code by
@@ skipping 160 matching lines @@
     case Token::IN: {
       Load(left);
       Load(right);
       __ InvokeBuiltin(Builtins::IN, CALL_FUNCTION);
       __ push(eax);  // push the result
       return;
     }
     case Token::INSTANCEOF: {
       Load(left);
       Load(right);
-      __ InvokeBuiltin(Builtins::INSTANCE_OF, CALL_FUNCTION);
-      __ push(eax);  // push the result
+      InstanceofStub stub;
+      __ CallStub(&stub);
+      __ test(eax, Operand(eax));
+      cc_reg_ = zero;
       return;
     }
     default:
       UNREACHABLE();
   }
 
   // Optimize for the case where (at least) one of the expressions
   // is a literal small integer.
   if (IsInlineSmi(left->AsLiteral())) {
     Load(right);
@@ skipping 1333 matching lines @@
   __ pop(esi);
   __ pop(edi);
   __ add(Operand(esp), Immediate(2 * kPointerSize));  // remove markers
 
   // Restore frame pointer and return.
   __ pop(ebp);
   __ ret(0);
 }
 
 
+void InstanceofStub::Generate(MacroAssembler* masm) {
+  // Get the object - go slow case if it's a smi.
+  Label slow;
+  __ mov(eax, Operand(esp, 2 * kPointerSize));  // 2 ~ return address, function
+  __ test(eax, Immediate(kSmiTagMask));
+  __ j(zero, &slow, not_taken);
+
+  // Check that the left hand is a JS object.
+  __ mov(eax, FieldOperand(eax, HeapObject::kMapOffset));  // ebx - object map
+  __ movzx_b(ecx, FieldOperand(eax, Map::kInstanceTypeOffset));  // ecx - type
+  __ cmp(ecx, FIRST_JS_OBJECT_TYPE);
+  __ j(less, &slow, not_taken);
+  __ cmp(ecx, LAST_JS_OBJECT_TYPE);
+  __ j(greater, &slow, not_taken);
+
+  // Get the prototype of the function.
+  __ mov(edx, Operand(esp, 1 * kPointerSize));  // 1 ~ return address
+  __ TryGetFunctionPrototype(edx, ebx, ecx, &slow);
+
+  // Register mapping: eax is object map and ebx is function prototype.
+  __ mov(ecx, FieldOperand(eax, Map::kPrototypeOffset));
+
+  // Loop through the prototype chain looking for the function prototype.
+  Label loop, is_instance, is_not_instance;
+  __ bind(&loop);
+  __ cmp(ecx, Operand(ebx));
+  __ j(equal, &is_instance);
+  __ cmp(Operand(ecx), Immediate(Factory::null_value()));
+  __ j(equal, &is_not_instance);
+  __ mov(ecx, FieldOperand(ecx, HeapObject::kMapOffset));
+  __ mov(ecx, FieldOperand(ecx, Map::kPrototypeOffset));
+  __ jmp(&loop);
+
+  __ bind(&is_instance);
+  __ Set(eax, Immediate(0));
+  __ ret(2 * kPointerSize);
+
+  __ bind(&is_not_instance);
+  __ Set(eax, Immediate(Smi::FromInt(1)));
+  __ ret(2 * kPointerSize);
+
+  // Slow-case: Go through the JavaScript implementation.
+  __ bind(&slow);
+  __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
+}
+
+
 #undef __
 
 // -----------------------------------------------------------------------------
 // CodeGenerator interfaces
 
 // MakeCode() is just a wrapper for CodeGenerator::MakeCode()
 // so we don't have to expose the entire CodeGenerator class in
 // the .h file.
 Handle<Code> CodeGenerator::MakeCode(FunctionLiteral* fun,
                                      Handle<Script> script,
                                      bool is_eval) {
   Handle<Code> code = Ia32CodeGenerator::MakeCode(fun, script, is_eval);
   if (!code.is_null()) {
     Counters::total_compiled_code_size.Increment(code->instruction_size());
   }
   return code;
 }
 
 
 } }  // namespace v8::internal