- Fixed performance regression caused by ComputeContextSlotReceiver....

src/runtime.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 910 matching lines @@
     int number_of_literals = fun->NumberOfLiterals();
     Handle<FixedArray> literals =
         Factory::NewFixedArray(number_of_literals, TENURED);
     if (number_of_literals > 0) {
       // Insert the object, regexp and array functions in the literals
       // array prefix.  These are the functions that will be used when
       // creating object, regexp and array literals.
       literals->set(JSFunction::kLiteralGlobalContextIndex,
                     context->global_context());
     }
-    target->set_literals(*literals);
+    target->set_literals(*literals, SKIP_WRITE_BARRIER);
   }
 
   target->set_context(*context);
   return *target;
 }
 
 
 static Object* CharCodeAt(String* subject, Object* index) {
   uint32_t i = 0;
   if (!Array::IndexFromObject(index, &i)) return Heap::nan_value();
@@ skipping 2185 matching lines @@
   CONVERT_CHECKED(JSFunction, callee, args[0]);
 
   // Compute the frame holding the arguments.
   JavaScriptFrameIterator it;
   it.AdvanceToArgumentsFrame();
   JavaScriptFrame* frame = it.frame();
 
   const int length = frame->GetProvidedParametersCount();
   Object* result = Heap::AllocateArgumentsObject(callee, length);
   if (result->IsFailure()) return result;
-  FixedArray* array = FixedArray::cast(JSObject::cast(result)->elements());
-  ASSERT(array->length() == length);
-  WriteBarrierMode mode = array->GetWriteBarrierMode();
-  for (int i = 0; i < length; i++) {
-    array->set(i, frame->GetParameter(i), mode);
+  if (length > 0) {
+    Object* obj =  Heap::AllocateFixedArray(length);
+    if (obj->IsFailure()) return obj;
+    FixedArray* array = FixedArray::cast(obj);
+    ASSERT(array->length() == length);
+    WriteBarrierMode mode = array->GetWriteBarrierMode();
+    for (int i = 0; i < length; i++) {
+      array->set(i, frame->GetParameter(i), mode);
+    }
+    JSObject::cast(result)->set_elements(array);
   }
   return result;
 }
 
 
 static Object* Runtime_NewArgumentsFast(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 3);
 
   JSFunction* callee = JSFunction::cast(args[0]);
   Object** parameters = reinterpret_cast<Object**>(args[1]);
   const int length = Smi::cast(args[2])->value();
 
   Object* result = Heap::AllocateArgumentsObject(callee, length);
   if (result->IsFailure()) return result;
-  FixedArray* array = FixedArray::cast(JSObject::cast(result)->elements());
-  ASSERT(array->length() == length);
-  WriteBarrierMode mode = array->GetWriteBarrierMode();
-  for (int i = 0; i < length; i++) {
-    array->set(i, *--parameters, mode);
+  ASSERT(Heap::InNewSpace(result));
+
+  // Allocate the elements if needed.
+  if (length > 0) {
+    // Allocate the fixed array.
+    Object* obj = Heap::AllocateRawFixedArray(length);
+    if (obj->IsFailure()) return obj;
+    reinterpret_cast<Array*>(obj)->set_map(Heap::fixed_array_map());
+    FixedArray* array = FixedArray::cast(obj);
+    array->set_length(length);
+    WriteBarrierMode mode = array->GetWriteBarrierMode();
+    for (int i = 0; i < length; i++) {
+      array->set(i, *--parameters, mode);
+    }
+    JSObject::cast(result)->set_elements(FixedArray::cast(obj),
+                                         SKIP_WRITE_BARRIER);
   }
   return result;
 }
 
 
 static Object* Runtime_NewClosure(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 2);
   CONVERT_ARG_CHECKED(JSFunction, boilerplate, 0);
   CONVERT_ARG_CHECKED(Context, context, 1);
@@ skipping 187 matching lines @@
   ASSERT(!x->IsTheHole() || (attributes & READ_ONLY) != 0);
   USE(attributes);
   return x->IsTheHole() ? Heap::undefined_value() : x;
 }
 
 
 static Object* ComputeContextSlotReceiver(Object* holder) {
   // If the "property" we were looking for is a local variable or an
   // argument in a context, the receiver is the global object; see
   // ECMA-262, 3rd., 10.1.6 and 10.2.3.
+  // Contexts and Globals are most common.

[Kasper Lund, 2008/10/23 14:51:33]

I would change Globals to 'global objects', but that's just silly me.

   HeapObject* object = HeapObject::cast(holder);

[Kasper Lund, 2008/10/23 14:51:33]

You should be able to get rid of the 'object' variable. It isn't really that
useful. Sorry for leaving that crud in there in the first place.

+  if (holder->IsContext()) {
+    return Context::cast(holder)->global()->global_receiver();
+  }
+  if (object->IsGlobalObject()) {
+    // If the holder is a global object, we have to be careful to wrap
+    // it in its proxy if necessary.
+    return GlobalObject::cast(object)->global_receiver();
+  }
+
   Context* top = Top::context();
-  if (holder->IsContext()) return top->global()->global_receiver();
-
   // TODO(125): Find a better - and faster way - of checking for
   // arguments and context extension objects. This kinda sucks.
   JSFunction* context_extension_function =
       top->global_context()->context_extension_function();
   JSObject* arguments_boilerplate =
       top->global_context()->arguments_boilerplate();
   JSFunction* arguments_function =
       JSFunction::cast(arguments_boilerplate->map()->constructor());
   // If the holder is an arguments object or a context extension then the
   // receiver is also the global object;
   Object* constructor = HeapObject::cast(holder)->map()->constructor();
   if (constructor == context_extension_function ||
       constructor == arguments_function) {
     return Top::context()->global()->global_receiver();
   }
 
-  // If the holder is a global object, we have to be careful to wrap
-  // it in its proxy if necessary.
-  if (object->IsGlobalObject()) {
-    return GlobalObject::cast(object)->global_receiver();
-  } else {
-    return object;
-  }
+  return object;
 }
 
 
 static ObjPair LoadContextSlotHelper(Arguments args, bool throw_error) {
   HandleScope scope;
   ASSERT(args.length() == 2);
 
   if (!args[0]->IsContext()) return MakePair(IllegalOperation(), NULL);
   Handle<Context> context = args.at<Context>(0);
   Handle<String> name(String::cast(args[1]));
@@ skipping 1487 matching lines @@
 
   if (sinfo->number_of_context_slots() > Context::MIN_CONTEXT_SLOTS) {
     index = ScopeInfo<>::ContextSlotIndex(*code, Heap::arguments_symbol(),
                                           NULL);
     if (index != -1) {
       return Handle<Object>(function_context->get(index));
     }
   }
 
   const int length = frame->GetProvidedParametersCount();
-  Handle<Object> arguments = Factory::NewArgumentsObject(function, length);
-  FixedArray* array = FixedArray::cast(JSObject::cast(*arguments)->elements());
-  ASSERT(array->length() == length);
+  Handle<JSObject> arguments = Factory::NewArgumentsObject(function, length);
+  Handle<FixedArray> array = Factory::NewFixedArray(length);
   WriteBarrierMode mode = array->GetWriteBarrierMode();
   for (int i = 0; i < length; i++) {
     array->set(i, frame->GetParameter(i), mode);
   }
+  arguments->set_elements(*array);
   return arguments;
 }
 
 
 // Evaluate a piece of JavaScript in the context of a stack frame for
 // debugging. This is acomplished by creating a new context which in its
 // extension part has all the parameters and locals of the function on the
 // stack frame. A function which calls eval with the code to evaluate is then
 // compiled in this context and called in this context. As this context
 // replaces the context of the function on the stack frame a new (empty)
@@ skipping 591 matching lines @@
 
 void Runtime::PerformGC(Object* result) {
   Failure* failure = Failure::cast(result);
   // Try to do a garbage collection; ignore it if it fails. The C
   // entry stub will throw an out-of-memory exception in that case.
   Heap::CollectGarbage(failure->requested(), failure->allocation_space());
 }
 
 
 } }  // namespace v8::internal