X64 Crankshaft: Implement LValueOf and (dummy) LArgumentsObject.

src/ia32/lithium-ia32.cc

 // Copyright 2011 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 1956 matching lines @@
 
 LInstruction* LChunkBuilder::DoCallStub(HCallStub* instr) {
   LOperand* context = UseFixed(instr->context(), esi);
   argument_count_ -= instr->argument_count();
   LCallStub* result = new LCallStub(context);
   return MarkAsCall(DefineFixed(result, eax), instr);
 }
 
 
 LInstruction* LChunkBuilder::DoArgumentsObject(HArgumentsObject* instr) {
-  // There are no real uses of the arguments object (we bail out in all other
-  // cases).
+  // There are no real uses of the arguments object.
+  // arguments.length and element access are supported directly on
+  // stack arguments, and any real arguments object use causes a bailout.
+  // So this value is never used.
   return NULL;

[Lasse Reichstein, 2011/02/18 11:50:55]

What is the "value" that is never used?
Is this function never called, or is its return value never used (and if so, how
do we know that)?
If it's never called, it should either assert that, or do a bailout if it ever
got called anyway.
If the return value isn't used, why are we calling the function?

[William Hesse, 2011/02/18 12:06:21]

A HValue, HArgumentsObject is created to represent the arguments object.  Once
we figure it out, we will use this object.  Currently, we don't compile any uses
of it in Crankshaft, so the HValue turns into zero lithium instructions.  The
way to create zero lithium instructions for an HValue is to return null from
DoH...().
In the long run, this should be implemented or HArgumentsObject should be
removed.


On 2011/02/18 11:50:55, Lasse Reichstein wrote:

 }
 
 
 LInstruction* LChunkBuilder::DoAccessArgumentsAt(HAccessArgumentsAt* instr) {
   LOperand* arguments = UseRegister(instr->arguments());
   LOperand* length = UseTempRegister(instr->length());
   LOperand* index = Use(instr->index());
   LAccessArgumentsAt* result = new LAccessArgumentsAt(arguments, length, index);
   return AssignEnvironment(DefineAsRegister(result));
 }
@@ skipping 69 matching lines @@
 LInstruction* LChunkBuilder::DoLeaveInlined(HLeaveInlined* instr) {
   HEnvironment* outer = current_block_->last_environment()->outer();
   current_block_->UpdateEnvironment(outer);
   return NULL;
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32