Experimental: defer the per-function and per-loop calls to the runtime...

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 1309 matching lines @@
   // Use the shared code stub to call the function.
   CallFunctionStub call_function(arg_count);
   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:
+  DeferredStackCheck(CodeGenerator* generator)
+      : DeferredCode(generator) {
+    set_comment("[ DeferredStackCheck");
+  }
+
+  virtual void Generate();
+};
+
+
+void DeferredStackCheck::Generate() {
+  StackCheckStub stub;

[Kasper Lund, 2009/01/22 14:04:46]

Maybe move this to just before it's used (CallStub)?

[Kevin Millikin (Chromium), 2009/01/22 14:07:50]

NP.

+  enter()->Bind();
+  // The stack check can trigger the debugger.  Before calling it, all
+  // values including constants must be spilled to the frame.
+  generator()->frame()->SpillAll();
+  Result ignored = generator()->frame()->CallStub(&stub, 0);
+  exit()->Jump();
+}
+
+
 void CodeGenerator::CheckStack() {
   if (FLAG_check_stack) {
-    JumpTarget stack_is_ok(this);
-    StackCheckStub stub;
+    DeferredStackCheck* deferred = new DeferredStackCheck(this);
     ExternalReference stack_guard_limit =
         ExternalReference::address_of_stack_guard_limit();
     __ cmp(esp, Operand::StaticVariable(stack_guard_limit));
-    stack_is_ok.Branch(above_equal, taken);
-    // The stack check can trigger the debugger.  Before calling it, all
-    // values including constants must be spilled to the frame.
-    frame_->SpillAll();
-    frame_->CallStub(&stub, 0);
-    stack_is_ok.Bind();
+    deferred->enter()->Branch(below, not_taken);
+    deferred->exit()->Bind();
   }
 }
 
 
 void CodeGenerator::VisitStatements(ZoneList<Statement*>* statements) {
   ASSERT(!in_spilled_code());
   for (int i = 0; has_valid_frame() && i < statements->length(); i++) {
     Visit(statements->at(i));
   }
 }
@@ skipping 1405 matching lines @@
   } else {
     frame_->Push(node->handle());
   }
 }
 
 
 class DeferredRegExpLiteral: public DeferredCode {
  public:
   DeferredRegExpLiteral(CodeGenerator* generator, RegExpLiteral* node)
       : DeferredCode(generator), node_(node) {
-    set_comment("[ RegExpDeferred");
+    set_comment("[ DeferredRegExpLiteral");
   }
   virtual void Generate();
  private:
   RegExpLiteral* node_;
 };
 
 
 void DeferredRegExpLiteral::Generate() {
   // The argument is actually passed in ecx.
   enter()->Bind();
@@ skipping 48 matching lines @@
 
 // This deferred code stub will be used for creating the boilerplate
 // by calling Runtime_CreateObjectLiteral.
 // Each created boilerplate is stored in the JSFunction and they are
 // therefore context dependent.
 class DeferredObjectLiteral: public DeferredCode {
  public:
   DeferredObjectLiteral(CodeGenerator* generator,
                         ObjectLiteral* node)
       : DeferredCode(generator), node_(node) {
-    set_comment("[ ObjectLiteralDeferred");
+    set_comment("[ DeferredObjectLiteral");
   }
   virtual void Generate();
  private:
   ObjectLiteral* node_;
 };
 
 
 void DeferredObjectLiteral::Generate() {
   // The argument is actually passed in ecx.
   enter()->Bind();
@@ skipping 916 matching lines @@
 class DeferredCountOperation: public DeferredCode {
  public:
   DeferredCountOperation(CodeGenerator* generator,
                          bool is_postfix,
                          bool is_increment,
                          int result_offset)
       : DeferredCode(generator),
         is_postfix_(is_postfix),
         is_increment_(is_increment),
         result_offset_(result_offset) {
-    set_comment("[ CountOperationDeferred");
+    set_comment("[ DeferredCountOperation");
   }
 
   virtual void Generate();
 
  private:
   bool is_postfix_;
   bool is_increment_;
   int result_offset_;
 };
 
@@ skipping 2324 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal