Fast-codegen: Added support for arguments in functions.

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 582 matching lines @@
       if (slot != NULL && slot->type() == Slot::CONTEXT) {
         if (FLAG_trace_bailout) {
           PrintF("function has context-allocated parameters");
         }
         return NORMAL;
       }
     }
   }
 
   if (scope->arguments() != NULL) {
-    if (FLAG_trace_bailout) PrintF("function uses 'arguments'\n");
-    return NORMAL;
+    // if (FLAG_trace_bailout) PrintF("function uses 'arguments'\n");
+    // return NORMAL;

[William Hesse, 2009/11/12 09:56:49]

Remove.

[Lasse Reichstein, 2009/11/13 08:54:37]

Done.

   }
 
   has_supported_syntax_ = true;
   VisitDeclarations(scope->declarations());
   if (!has_supported_syntax_) return NORMAL;
 
   VisitStatements(fun->body());
   return has_supported_syntax_ ? FAST : NORMAL;
 }
 
@@ skipping 170 matching lines @@
 }
 
 
 void CodeGenSelector::VisitSlot(Slot* expr) {
   UNREACHABLE();
 }
 
 
 void CodeGenSelector::VisitVariableProxy(VariableProxy* expr) {
   Expression* rewrite = expr->var()->rewrite();
-  // A rewrite of NULL indicates a global variable.
+  // A rewrite of NULL indicates a global variable or explict arguments access.

[William Hesse, 2009/11/12 09:56:49]

Lie!

[Lasse Reichstein, 2009/11/13 08:54:37]

Truthified.

   if (rewrite != NULL) {
     // Non-global.
     Slot* slot = rewrite->AsSlot();
-    if (slot == NULL) {
-      // This is a variable rewritten to an explicit property access
-      // on the arguments object.
-      BAILOUT("non-global/non-slot variable reference");
-    }
-
-    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");
+    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();

[William Hesse, 2009/11/12 09:56:49]

Put a comment, indicating what this code is for.

[Lasse Reichstein, 2009/11/13 08:54:37]

Added

+      ASSERT_NOT_NULL(property);
+      ASSERT_NE(Expression::kUninitialized, context_);
+      Visit(property);
+      property->set_context(context_);

[Kevin Millikin (Chromium), 2009/11/12 14:23:13]

I'm surprised that this works.

For a variable in a scope, all proxies should point to the same variable and
thus the rewrite is shared.  At codegen time, you will just get whatever is the
last context set in the selector, right?

I would think that we do not (ever) set the context or other code gen state on
rewrites, but instead on the proxy itself.  Then in the case of visiting a
variable proxy at code gen time, compile it based on the proxy's state.

     }
   }
 }
 
 
 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