Shorten live ranges of argument subexpressions.

src/arm/lithium-arm.cc

Index: src/arm/lithium-arm.cc
diff --git a/src/arm/lithium-arm.cc b/src/arm/lithium-arm.cc
index 9c792316f5e12977ad14e9b151efd7def671e060..b4b69a01d757d91f25a92cac3570d1e1a9de6670 100644
--- a/src/arm/lithium-arm.cc
+++ b/src/arm/lithium-arm.cc
@@ -288,7 +288,8 @@ void LCallGlobal::PrintDataTo(StringStream* stream) const {
 
 
 void LCallKnownGlobal::PrintDataTo(StringStream* stream) const {
-  stream->Add("#%d / ", arity());
+  LUnaryOperation::PrintDataTo(stream);
+  stream->Add(" #%d / ", arity());
 }
 
 
@@ -1353,7 +1354,7 @@ LInstruction* LChunkBuilder::DoGlobalReceiver(HGlobalReceiver* instr) {
 
 LInstruction* LChunkBuilder::DoCallConstantFunction(
     HCallConstantFunction* instr) {
-  argument_count_ -= instr->argument_count();
+  DecrementArgumentCount(instr->argument_count());
   return MarkAsCall(DefineFixed(new LCallConstantFunction, r0), instr);
 }
 
@@ -1384,46 +1385,47 @@ LInstruction* LChunkBuilder::DoUnaryMathOperation(HUnaryMathOperation* instr) {
 
 LInstruction* LChunkBuilder::DoCallKeyed(HCallKeyed* instr) {
   ASSERT(instr->key()->representation().IsTagged());
-  argument_count_ -= instr->argument_count();
+  DecrementArgumentCount(instr->argument_count());
   UseFixed(instr->key(), r2);
   return MarkAsCall(DefineFixed(new LCallKeyed, r0), instr);
 }
 
 
 LInstruction* LChunkBuilder::DoCallNamed(HCallNamed* instr) {
-  argument_count_ -= instr->argument_count();
+  DecrementArgumentCount(instr->argument_count());
   return MarkAsCall(DefineFixed(new LCallNamed, r0), instr);
 }
 
 
 LInstruction* LChunkBuilder::DoCallGlobal(HCallGlobal* instr) {
-  argument_count_ -= instr->argument_count();
+  DecrementArgumentCount(instr->argument_count());
   return MarkAsCall(DefineFixed(new LCallGlobal, r0), instr);
 }
 
 
 LInstruction* LChunkBuilder::DoCallKnownGlobal(HCallKnownGlobal* instr) {
-  argument_count_ -= instr->argument_count();
+  LOperand* receiver = UseFixed(instr->receiver(), r0);
+  DecrementArgumentCount(instr->argument_count());
   return MarkAsCall(DefineFixed(new LCallKnownGlobal, r0), instr);
 }
 
 
 LInstruction* LChunkBuilder::DoCallNew(HCallNew* instr) {
   LOperand* constructor = UseFixed(instr->constructor(), r1);
-  argument_count_ -= instr->argument_count();
+  DecrementArgumentCount(instr->argument_count());
   LInstruction* result = new LCallNew(constructor);
   return MarkAsCall(DefineFixed(result, r0), instr);
 }
 
 
 LInstruction* LChunkBuilder::DoCallFunction(HCallFunction* instr) {
-  argument_count_ -= instr->argument_count();
+  DecrementArgumentCount(instr->argument_count());
   return MarkAsCall(DefineFixed(new LCallFunction, r0), instr);
 }
 
 
 LInstruction* LChunkBuilder::DoCallRuntime(HCallRuntime* instr) {
-  argument_count_ -= instr->argument_count();
+  DecrementArgumentCount(instr->argument_count());
   return MarkAsCall(DefineFixed(new LCallRuntime, r0), instr);
 }
 
@@ -2000,7 +2002,7 @@ LInstruction* LChunkBuilder::DoUnknownOSRValue(HUnknownOSRValue* instr) {
 
 
 LInstruction* LChunkBuilder::DoCallStub(HCallStub* instr) {
-  argument_count_ -= instr->argument_count();
+  DecrementArgumentCount(instr->argument_count());
   return MarkAsCall(DefineFixed(new LCallStub, r0), instr);
 }
 
@@ -2081,7 +2083,8 @@ LInstruction* LChunkBuilder::DoEnterInlined(HEnterInlined* instr) {
   HEnvironment* inner = outer->CopyForInlining(instr->closure(),
                                                instr->function(),
                                                false,
-                                               undefined);
+                                               undefined,
+                                               NULL);
   current_block_->UpdateEnvironment(inner);
   chunk_->AddInlinedClosure(instr->closure());
   return NULL;