Some minor cleanup.

vm/stub_code_ia32.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
 #include "vm/object_store.h"
@@ skipping 1495 matching lines @@
 
   // Remove the stub frame as we are about to return.
   __ LeaveFrame();
   __ ret();
 }
 
 
 
 // Generate inline cache check for 'num_args'.
 //  ECX: Inline cache data object.
-//  EDX: Arguments array.
+//  EDX: Arguments descriptor array.
 //  TOS(0): return address
 // Control flow:
 // - If receiver is null -> jump to IC miss.
 // - If receiver is Smi -> load Smi class.
 // - If receiver is not-Smi -> load receiver's class.
 // - Check if 'num_args' (including receiver) match any IC data group.
 // - Match found -> jump to target.
 // - Match not found -> jump to IC miss.
 void StubCode::GenerateNArgsCheckInlineCacheStub(Assembler* assembler,
                                                  intptr_t num_args) {
@@ skipping 10 matching lines @@
     __ pushl(EBX);  // Argument for runtime: function object.
     __ CallRuntimeFromStub(kOptimizeInvokedFunctionRuntimeEntry);
     __ popl(EBX);  // Remove argument.
     __ popl(EDX);  // Restore arguments array.
     __ popl(ECX);  // Restore inline cache data object.
     __ LeaveFrame();
     __ Bind(&not_yet_hot);
   }
 
   ASSERT(num_args > 0);
-  // Get receiver.
+  // Get receiver (first read number of arguments from argument descriptor array
+  // and then access the receiver from the stack).
   __ movl(EAX, FieldAddress(EDX, Array::data_offset()));
   __ movl(EAX, Address(ESP, EAX, TIMES_2, 0));  // EAX (argument_count) is Smi.
 
   Label get_class, ic_miss;
   __ call(&get_class);
   // EAX: receiver's class
   // ECX: IC data array.
 
 #if defined(DEBUG)
   { Label ok;
@@ skipping 48 matching lines @@
     __ cmpl(EAX, EDI);  // Match?
     __ j(EQUAL, &found, Assembler::kNearJump);
     __ Bind(&no_match);
     // Each test entry has (1 + num_args) array elements.
     __ addl(EBX, Immediate(kWordSize * (1 + num_args)));  // Next element.
     __ cmpl(EDI, raw_null);   // Done?
     __ j(NOT_EQUAL, &loop, Assembler::kNearJump);
   }
 
   __ Bind(&ic_miss);
-  // Get receiver, again.
+  // Compute address of arguments (first read number of arguments from argument
+  // descriptor array and then compute address on the stack).
   __ movl(EAX, FieldAddress(EDX, Array::data_offset()));
   __ leal(EAX, Address(ESP, EAX, TIMES_2, 0));  // EAX is Smi.
   __ EnterFrame(0);
   __ pushl(EDX);  // Preserve arguments array.
   __ pushl(ECX);  // Preserve IC data array
   __ pushl(raw_null);  // Setup space on stack for result (target code object).
-  __ movl(EDX, FieldAddress(EDX, Array::data_offset()));
   // Push call arguments.
   for (intptr_t i = 0; i < num_args; i++) {
     __ movl(EDX, Address(EAX, -kWordSize * i));
     __ pushl(EDX);
   }
   if (num_args == 1) {
     __ CallRuntimeFromStub(kInlineCacheMissHandlerOneArgRuntimeEntry);
   } else if (num_args == 2) {
     __ CallRuntimeFromStub(kInlineCacheMissHandlerTwoArgsRuntimeEntry);
   } else {
@@ skipping 195 matching lines @@
   __ j(EQUAL, &not_found, Assembler::kNearJump);
   __ movl(ECX, FieldAddress(ECX, Type::type_class_offset()));
   __ cmpl(EDX, ECX);
   __ j(NOT_EQUAL, &super_loop, Assembler::kNearJump);
   __ jmp(&found, Assembler::kNearJump);
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32