DeclareContextSlot took an extra completely random argument from the...

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 384 matching lines @@
     } else {
       // If a property with this name does not already exist on the
       // global object add the property locally.  We take special
       // precautions to always add it as a local property even in case
       // of callbacks in the prototype chain (this rules out using
       // SetProperty).  Also, we must use the handle-based version to
       // avoid GC issues.
       IgnoreAttributesAndSetLocalProperty(global, name, value, attributes);
     }
   }
-  // Done.
+
   return Heap::undefined_value();
 }
 
 
 static Object* Runtime_DeclareContextSlot(Arguments args) {
   HandleScope scope;
-  ASSERT(args.length() == 5);
+  ASSERT(args.length() == 4);
 
-  // args[0] is result (TOS)
-  CONVERT_ARG_CHECKED(Context, context, 1);
-  Handle<String> name(String::cast(args[2]));
+  CONVERT_ARG_CHECKED(Context, context, 0);
+  Handle<String> name(String::cast(args[1]));
   PropertyAttributes mode =
-      static_cast<PropertyAttributes>(Smi::cast(args[3])->value());
+      static_cast<PropertyAttributes>(Smi::cast(args[2])->value());
   ASSERT(mode == READ_ONLY || mode == NONE);
-  Handle<Object> initial_value(args[4]);
+  Handle<Object> initial_value(args[3]);
 
   // Declarations are always done in the function context.
   context = Handle<Context>(context->fcontext());
 
   int index;
   PropertyAttributes attributes;
   ContextLookupFlags flags = DONT_FOLLOW_CHAINS;
   Handle<Object> context_obj =
       context->Lookup(name, flags, &index, &attributes);
 
@@ skipping 18 matching lines @@
         if (((attributes & READ_ONLY) == 0) ||
             context->get(index)->IsTheHole()) {
           context->set(index, *initial_value);
         }
       } else {
         // Slow case: The property is not in the FixedArray part of the context.
         Handle<JSObject> context_ext = Handle<JSObject>::cast(context_obj);
         SetProperty(context_ext, name, initial_value, mode);
       }
     }
-    return args[0];  // return TOS
+
+  } else {
+    // The property is not in the function context. It needs to be
+    // "declared" in the function context's extension context, or in the
+    // global context.
+    Handle<JSObject> context_ext;
+    if (context->extension() != NULL) {
+      // The function context's extension context exists - use it.
+      context_ext = Handle<JSObject>(context->extension());
+    } else {
+      // The function context's extension context does not exists - allocate
+      // it.
+      context_ext = Factory::NewJSObject(Top::context_extension_function());
+      // And store it in the extension slot.
+      context->set_extension(*context_ext);
+    }
+    ASSERT(*context_ext != NULL);
+
+    // Declare the property by setting it to the initial value if provided,
+    // or undefined, and use the correct mode (e.g. READ_ONLY attribute for
+    // constant declarations).
+    ASSERT(!context_ext->HasLocalProperty(*name));
+    Handle<Object> value(Heap::undefined_value());
+    if (*initial_value != NULL) value = initial_value;
+    SetProperty(context_ext, name, value, mode);
+    ASSERT(context_ext->GetLocalPropertyAttribute(*name) == mode);
   }
 
-  // The property is not in the function context. It needs to be "declared"
-  // in the function context's extension context, or in the global context.
-  Handle<JSObject> context_ext;
-  if (context->extension() != NULL) {
-    // The function context's extension context exists - use it.
-    context_ext = Handle<JSObject>(context->extension());
-  } else {
-    // The function context's extension context does not exists - allocate it.
-    context_ext = Factory::NewJSObject(Top::context_extension_function());
-    // And store it in the extension slot.
-    context->set_extension(*context_ext);
-  }
-  ASSERT(*context_ext != NULL);
-
-  // Declare the property by setting it to the initial value if provided,
-  // or undefined, and use the correct mode (e.g. READ_ONLY attribute for
-  // constant declarations).
-  ASSERT(!context_ext->HasLocalProperty(*name));
-  Handle<Object> value(Heap::undefined_value());
-  if (*initial_value != NULL) value = initial_value;
-  SetProperty(context_ext, name, value, mode);
-  ASSERT(context_ext->GetLocalPropertyAttribute(*name) == mode);
-  return args[0];  // return TOS
+  return Heap::undefined_value();
 }
 
 
 static Object* Runtime_InitializeVarGlobal(Arguments args) {
   NoHandleAllocation nha;
 
   // Determine if we need to assign to the variable if it already
   // exists (based on the number of arguments).
   RUNTIME_ASSERT(args.length() == 1 || args.length() == 2);
   bool assign = args.length() == 2;
@@ skipping 4561 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