Disable "arguments" implementation. It was too optimistic in its assumptions.

src/compiler.cc

 // Copyright 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 580 matching lines @@
     for (int i = 0, len = scope->num_parameters(); i < len; i++) {
       Slot* slot = scope->parameter(i)->slot();
       if (slot != NULL && slot->type() == Slot::CONTEXT) {
         if (FLAG_trace_bailout) {
           PrintF("function has context-allocated parameters");
         }
         return NORMAL;
       }
     }
   }
 

[fschneider, 2009/11/13 12:49:32]

Should we also bailout here?

  if (scope->arguments() != NULL) {
    if (FLAG_trace_bailout) PrintF("function uses 'arguments'\n");
    return NORMAL;
  }

[Lasse Reichstein, 2009/11/13 13:06:12]

We should, yes. Well spotted.

   has_supported_syntax_ = true;
   VisitDeclarations(scope->declarations());
   if (!has_supported_syntax_) return NORMAL;
 
   VisitStatements(fun->body());
   return has_supported_syntax_ ? FAST : NORMAL;
 }
 
 
 #define BAILOUT(reason)                         \
@@ skipping 140 matching lines @@
   BAILOUT("TryFinallyStatement");
 }
 
 
 void CodeGenSelector::VisitDebuggerStatement(DebuggerStatement* stmt) {
   // Debugger statement is supported.
 }
 
 
 void CodeGenSelector::VisitFunctionLiteral(FunctionLiteral* expr) {
+  if (expr->scope()->arguments() != NULL) {
+    BAILOUT("FunctionLiteral uses arguments");
+  }

[Lasse Reichstein, 2009/11/13 13:06:12]

And removed this. The first location was the correct one.

   if (!expr->AllowsLazyCompilation()) {
     BAILOUT("FunctionLiteral does not allow lazy compilation");
   }
 }
 
 
 void CodeGenSelector::VisitFunctionBoilerplateLiteral(
     FunctionBoilerplateLiteral* expr) {
   BAILOUT("FunctionBoilerplateLiteral");
 }
@@ skipping 20 matching lines @@
     // Non-global.
     Slot* slot = rewrite->AsSlot();
     if (slot != NULL) {
       Slot::Type type = slot->type();
       // When LOOKUP slots are enabled, some currently dead code
       // implementing unary typeof will become live.
       if (type == Slot::LOOKUP) {
         BAILOUT("Lookup slot");
       }
     } else {
-      Property* property = rewrite->AsProperty();
-      // In the presence of an arguments object, parameter variables
-      // are rewritten into property accesses on that object.
-      ASSERT_NOT_NULL(property);
-      ASSERT_NE(Expression::kUninitialized, context_);
-      Visit(property);
-      property->set_context(context_);
+      BAILOUT("non-global/non-slot variable reference");

[fschneider, 2009/11/13 12:49:32]

Are there any other cases than argument access here? 
If no, more informative would be:

  BAILOUT("access to arguments object");

[Lasse Reichstein, 2009/11/13 13:06:12]

Not currently, AFAIK.
This is what it said before I removed it. 
Will fix.

     }
   }
 }
 
 
 void CodeGenSelector::VisitLiteral(Literal* expr) {
   /* Nothing to do. */
 }
 
 
@@ skipping 287 matching lines @@
 
 void CodeGenSelector::VisitThisFunction(ThisFunction* expr) {
   BAILOUT("ThisFunction");
 }
 
 #undef BAILOUT
 #undef CHECK_BAILOUT
 
 
 } }  // namespace v8::internal