This patch much improves our tracking of whether function is...

src/ia32/codegen-ia32.cc

 // Copyright 2006-2009 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 1634 matching lines @@
       right_side.Unuse();
       left_side.Unuse();
       dest->Split(cc);
     }
   }
 }
 
 
 class CallFunctionStub: public CodeStub {
  public:
-  explicit CallFunctionStub(int argc) : argc_(argc) { }
+  CallFunctionStub(int argc, InlineCacheInLoop in_loop)
+      : argc_(argc), in_loop_(in_loop) { }
 
   void Generate(MacroAssembler* masm);
 
  private:
   int argc_;
+  InlineCacheInLoop in_loop_;
 
 #ifdef DEBUG
   void Print() { PrintF("CallFunctionStub (args %d)\n", argc_); }
 #endif
 
   Major MajorKey() { return CallFunction; }
   int MinorKey() { return argc_; }
+  InlineCacheInLoop InLoop() { return in_loop_; }
 };
 
 
 // Call the function just below TOS on the stack with the given
 // arguments. The receiver is the TOS.
 void CodeGenerator::CallWithArguments(ZoneList<Expression*>* args,
                                       int position) {
   // Push the arguments ("left-to-right") on the stack.
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     Load(args->at(i));
   }
 
   // Record the position for debugging purposes.
   CodeForSourcePosition(position);
 
   // Use the shared code stub to call the function.
-  CallFunctionStub call_function(arg_count);
+  InlineCacheInLoop in_loop = loop_nesting() > 0 ? IN_LOOP : NOT_IN_LOOP;
+  CallFunctionStub call_function(arg_count, in_loop);
   Result answer = frame_->CallStub(&call_function, arg_count + 1);
   // Restore context and replace function on the stack with the
   // result of the stub invocation.
   frame_->RestoreContextRegister();
   frame_->SetElementAt(0, &answer);
 }
 
 
 class DeferredStackCheck: public DeferredCode {
  public:
@@ skipping 2513 matching lines @@
   frame_->SetElementAt(arg_count + 1, &scratch);
 
   // We can reuse the result register now.
   frame_->Spill(result.reg());
   __ mov(result.reg(),
          FieldOperand(result.reg(), FixedArray::kHeaderSize + kPointerSize));
   frame_->SetElementAt(arg_count, &result);
 
   // Call the function.
   CodeForSourcePosition(node->position());
-  CallFunctionStub call_function(arg_count);
+  InlineCacheInLoop in_loop = loop_nesting() > 0 ? IN_LOOP : NOT_IN_LOOP;
+  CallFunctionStub call_function(arg_count, in_loop);
   result = frame_->CallStub(&call_function, arg_count + 1);
 
   // Restore the context and overwrite the function on the stack with
   // the result.
   frame_->RestoreContextRegister();
   frame_->SetElementAt(0, &result);
 }
 
 
 void CodeGenerator::GenerateIsSmi(ZoneList<Expression*>* args) {
@@ skipping 343 matching lines @@
     frame_->Push(&temp);
   }
 
   // Push the arguments ("left-to-right").
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     Load(args->at(i));
   }
 
   if (function == NULL) {
-    // Call the JS runtime function.  Pass 0 as the loop nesting depth
-    // because we do not handle runtime calls specially in loops.
-    Result answer = frame_->CallCallIC(RelocInfo::CODE_TARGET, arg_count, 0);
+    // Call the JS runtime function.
+    Result answer = frame_->CallCallIC(RelocInfo::CODE_TARGET,
+                                       arg_count,
+                                       loop_nesting_);
     frame_->RestoreContextRegister();
     frame_->SetElementAt(0, &answer);
   } else {
     // Call the C runtime function.
     Result answer = frame_->CallRuntime(function, arg_count);
     frame_->Push(&answer);
   }
 }
 
 
@@ skipping 791 matching lines @@
       // TODO(1241834): Make sure that it is safe to ignore the
       // distinction between expressions in a typeof and not in a
       // typeof. If there is a chance that reference errors can be
       // thrown below, we must distinguish between the two kinds of
       // loads (typeof expression loads must not throw a reference
       // error).
       Variable* var = expression_->AsVariableProxy()->AsVariable();
       bool is_global = var != NULL;
       ASSERT(!is_global || var->is_global());
 
-      if (is_global || cgen_->scope()->is_global_scope()) {
-        // Do not inline the inobject property case for loads from the
-        // global object or loads in toplevel code.
+      // Do not inline the inobject property case for loads from the global
+      // object.  Also do not inline for unoptimized code.  This saves time
+      // in the code generator.  Unoptimized code is toplevel code or code
+      // that is not in a loop.
+      if (is_global ||
+          cgen_->scope()->is_global_scope() ||
+          cgen_->loop_nesting() == 0) {
         Comment cmnt(masm, "[ Load from named Property");
         cgen_->frame()->Push(GetName());
 
         RelocInfo::Mode mode = is_global
                                ? RelocInfo::CODE_TARGET_CONTEXT
                                : RelocInfo::CODE_TARGET;
         Result answer = cgen_->frame()->CallLoadIC(mode);
         // A test eax instruction following the call signals that the
         // inobject property case was inlined.  Ensure that there is not
         // a test eax instruction here.
@@ skipping 1858 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal