Implement fast load and call of arguments in the presence of eval....

src/ia32/codegen-ia32.cc

 // Copyright 2010 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 4713 matching lines @@
     JumpTarget slow;
     JumpTarget done;
 
     // Generate fast-case code for variables that might be shadowed by
     // eval-introduced variables.  Eval is used a lot without
     // introducing variables.  In those cases, we do not want to
     // perform a runtime call for all variables in the scope
     // containing the eval.
     if (slot->var()->mode() == Variable::DYNAMIC_GLOBAL) {
       result = LoadFromGlobalSlotCheckExtensions(slot, typeof_state, &slow);
-      // If there was no control flow to slow, we can exit early.
-      if (!slow.is_linked()) return result;
       done.Jump(&result);
 
     } else if (slot->var()->mode() == Variable::DYNAMIC_LOCAL) {
       Slot* potential_slot = slot->var()->local_if_not_shadowed()->slot();
-      // Only generate the fast case for locals that rewrite to slots.
-      // This rules out argument loads because eval forces arguments
-      // access to be through the arguments object.
+      Expression* rewrite = slot->var()->local_if_not_shadowed()->rewrite();
       if (potential_slot != NULL) {
+        // Generate fast case for locals that rewrite to slots.
         // Allocate a fresh register to use as a temp in
         // ContextSlotOperandCheckExtensions and to hold the result
         // value.
         result = allocator()->Allocate();
         ASSERT(result.is_valid());
         __ mov(result.reg(),
                ContextSlotOperandCheckExtensions(potential_slot,
                                                  result,
                                                  &slow));
         if (potential_slot->var()->mode() == Variable::CONST) {
           __ cmp(result.reg(), Factory::the_hole_value());
           done.Branch(not_equal, &result);
           __ mov(result.reg(), Factory::undefined_value());
         }
-        // There is always control flow to slow from
-        // ContextSlotOperandCheckExtensions so we have to jump around
-        // it.
         done.Jump(&result);
+      } else if (rewrite != NULL) {
+        // Generate fast case for argument loads.
+        Property* property = rewrite->AsProperty();
+        if (property != NULL) {
+          VariableProxy* obj_proxy = property->obj()->AsVariableProxy();
+          Literal* key_literal = property->key()->AsLiteral();
+          if (obj_proxy != NULL &&
+              key_literal != NULL &&
+              obj_proxy->IsArguments() &&
+              key_literal->handle()->IsSmi()) {
+            // Load arguments object if there are no eval-introduced
+            // variables. Then load the argument from the arguments
+            // object using keyed load.
+            Result arguments = allocator()->Allocate();
+            ASSERT(arguments.is_valid());
+            __ mov(arguments.reg(),
+                   ContextSlotOperandCheckExtensions(obj_proxy->var()->slot(),
+                                                     arguments,
+                                                     &slow));
+            frame_->Push(&arguments);
+            frame_->Push(key_literal->handle());
+            result = EmitKeyedLoad();
+            done.Jump(&result);
+          }
+        }
       }
     }
 
     slow.Bind();
     // A runtime call is inevitable.  We eagerly sync frame elements
     // to memory so that we can push the arguments directly into place
     // on top of the frame.
     frame()->SyncRange(0, frame()->element_count() - 1);
     frame()->EmitPush(esi);
     frame()->EmitPush(Immediate(slot->var()->name()));
@@ skipping 986 matching lines @@
                                        arg_count,
                                        loop_nesting());
     frame_->RestoreContextRegister();
     frame_->Push(&result);
 
   } else if (var != NULL && var->slot() != NULL &&
              var->slot()->type() == Slot::LOOKUP) {
     // ----------------------------------
     // JavaScript examples:
     //
-    //  with (obj) foo(1, 2, 3)  // foo is in obj
+    //  with (obj) foo(1, 2, 3)  // foo may be in obj.
     //
     //  function f() {};
     //  function g() {
     //    eval(...);
-    //    f();  // f could be in extension object
+    //    f();  // f could be in extension object.
     //  }
     // ----------------------------------
 
     JumpTarget slow;
     JumpTarget done;
 
     // Generate fast-case code for variables that might be shadowed by
     // eval-introduced variables.  Eval is used a lot without
     // introducing variables.  In those cases, we do not want to
     // perform a runtime call for all variables in the scope
     // containing the eval.
-    Result function;
     if (var->mode() == Variable::DYNAMIC_GLOBAL) {
-      function = LoadFromGlobalSlotCheckExtensions(var->slot(),
-                                                   NOT_INSIDE_TYPEOF,
-                                                   &slow);
+      Result function = LoadFromGlobalSlotCheckExtensions(var->slot(),
+                                                          NOT_INSIDE_TYPEOF,
+                                                          &slow);
       frame_->Push(&function);
       LoadGlobalReceiver();
       done.Jump();
 
     } else if (var->mode() == Variable::DYNAMIC_LOCAL) {
       Slot* potential_slot = var->local_if_not_shadowed()->slot();
-      // Only generate the fast case for locals that rewrite to slots.
-      // This rules out argument loads because eval forces arguments
-      // access to be through the arguments object.
+      Expression* rewrite = var->local_if_not_shadowed()->rewrite();
       if (potential_slot != NULL) {
+        // Generate fast case for locals that rewrite to slots.
         // Allocate a fresh register to use as a temp in
         // ContextSlotOperandCheckExtensions and to hold the result
         // value.
-        function = allocator()->Allocate();
+        Result function = allocator()->Allocate();
         ASSERT(function.is_valid());
         __ mov(function.reg(),
                ContextSlotOperandCheckExtensions(potential_slot,
                                                  function,
                                                  &slow));
         JumpTarget push_function_and_receiver;
         if (potential_slot->var()->mode() == Variable::CONST) {
           __ cmp(function.reg(), Factory::the_hole_value());
           push_function_and_receiver.Branch(not_equal, &function);
           __ mov(function.reg(), Factory::undefined_value());
         }
         push_function_and_receiver.Bind(&function);
         frame_->Push(&function);
         LoadGlobalReceiver();
         done.Jump();
+      } else if (rewrite != NULL) {
+        // Generate fast case for calls of an argument function.
+        Property* property = rewrite->AsProperty();
+        if (property != NULL) {
+          VariableProxy* obj_proxy = property->obj()->AsVariableProxy();
+          Literal* key_literal = property->key()->AsLiteral();
+          if (obj_proxy != NULL &&
+              key_literal != NULL &&
+              obj_proxy->IsArguments() &&
+              key_literal->handle()->IsSmi()) {
+            // Load arguments object if there are no eval-introduced
+            // variables. Then load the argument from the arguments
+            // object using keyed load.
+            Result arguments = allocator()->Allocate();
+            ASSERT(arguments.is_valid());
+            __ mov(arguments.reg(),
+                   ContextSlotOperandCheckExtensions(obj_proxy->var()->slot(),
+                                                     arguments,
+                                                     &slow));
+            frame_->Push(&arguments);
+            frame_->Push(key_literal->handle());
+            Result value = EmitKeyedLoad();
+            frame_->Push(&value);
+            LoadGlobalReceiver();
+            done.Jump();
+          }
+        }
       }
     }
 
     slow.Bind();
     // Enter the runtime system to load the function from the context.
     // Sync the frame so we can push the arguments directly into
     // place.
     frame_->SyncRange(0, frame_->element_count() - 1);
     frame_->EmitPush(esi);
     frame_->EmitPush(Immediate(var->name()));
@@ skipping 7465 matching lines @@
 
   // Call the runtime; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ bind(&runtime);
   __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
 }
 
 #undef __
 
 } }  // namespace v8::internal