In the code generator, avoid loading the arguments object to the...

src/codegen-ia32.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 643 matching lines @@
     // was allocated and copied into above. If the address was not
     // saved to TOS, we push ecx onto the stack.
 
     // Store the arguments object.
     // This must happen after context initialization because
     // the arguments object may be stored in the context
     if (arguments_object_allocated) {
       ASSERT(scope->arguments() != NULL);
       ASSERT(scope->arguments_shadow() != NULL);
       Comment cmnt(masm_, "[ store arguments object");
-      {
-        Reference target(this, scope->arguments());
-        if (!arguments_object_saved) {
-          __ push(Operand(ecx));
+      { Reference shadow_ref(this, scope->arguments_shadow());
+        { Reference arguments_ref(this, scope->arguments());
+          // If the newly-allocated arguments object is already on the
+          // stack, we make use of the property that references representing
+          // variables take up no space on the expression stack (ie, it
+          // doesn't matter that the stored value is actually below the
+          // reference).
+          ASSERT(arguments_ref.size() == 0);
+          ASSERT(shadow_ref.size() == 0);
+
+          // If the newly-allocated argument object is not already on the
+          // stack, we rely on the property that loading a
+          // (zero-sized) reference will not clobber the ecx register.
+          if (!arguments_object_saved) {
+            __ push(ecx);
+          }
+          SetValue(&arguments_ref);
         }
-        SetValue(&target);
+        SetValue(&shadow_ref);
       }
-      // The value of arguments must also be stored in .arguments.
-      // TODO(1241813): This code can probably be improved by fusing it with
-      // the code that stores the arguments object above.
-      {
-        Reference target(this, scope->arguments_shadow());
-        Load(scope->arguments());
-        SetValue(&target);
-      }
+      __ pop(eax);  // Value is no longer needed.
     }
 
     // Generate code to 'execute' declarations and initialize
     // functions (source elements). In case of an illegal
     // redeclaration we need to handle that instead of processing the
     // declarations.
     if (scope->HasIllegalRedeclaration()) {
       Comment cmnt(masm_, "[ illegal redeclarations");
       scope->VisitIllegalRedeclaration(this);
     } else {
@@ skipping 4751 matching lines @@
                                      bool is_eval) {
   Handle<Code> code = Ia32CodeGenerator::MakeCode(fun, script, is_eval);
   if (!code.is_null()) {
     Counters::total_compiled_code_size.Increment(code->instruction_size());
   }
   return code;
 }
 
 
 } }  // namespace v8::internal