Implement two-argument check inline cache.

vm/code_generator_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"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/code_generator.h"
 
 #include "lib/error.h"
@@ skipping 408 matching lines @@
     __ pushl(Address(EBP, variable.index() * kWordSize));
   }
 }
 
 
 void CodeGenerator::GenerateInstanceCall(
     intptr_t node_id,
     intptr_t token_index,
     const String& function_name,
     int num_arguments,
-    const Array& optional_arguments_names) {
+    const Array& optional_arguments_names,
+    intptr_t num_args_checked) {
+  ASSERT(num_args_checked > 0);  // At least receiver check is necessary.
   // Set up the function name and number of arguments (including the receiver)
   // to the InstanceCall stub which will resolve the correct entrypoint for
   // the operator and call it.
-  ICData ic_data(function_name, 1);
+  ICData ic_data(function_name, num_args_checked);
   __ LoadObject(ECX, Array::ZoneHandle(ic_data.data()));
   __ LoadObject(EDX, ArgumentsDescriptor(num_arguments,
                                          optional_arguments_names));
-  ExternalLabel target_label(
-      "InlineCache", StubCode::InlineCacheEntryPoint());
+  uword label_address = 0;
+  switch (num_args_checked) {
+    case 1:
+      label_address = StubCode::OneArgCheckInlineCacheEntryPoint();
+      break;
+    case 2:
+      label_address = StubCode::TwoArgsCheckInlineCacheEntryPoint();
+      break;
+    default:
+      UNIMPLEMENTED();
+  }
+  ExternalLabel target_label("InlineCache", label_address);
 
   __ call(&target_label);
   AddCurrentDescriptor(PcDescriptors::kIcCall,
                        node_id,
                        token_index);
   __ addl(ESP, Immediate(num_arguments * kWordSize));
 }
 
 
 // Call to generate entry code:
@@ skipping 594 matching lines @@
 
 
 // Expects array and index on stack and returns result in EAX.
 void CodeGenerator::GenerateLoadIndexed(intptr_t node_id,
                                         intptr_t token_index) {
   // Invoke the [] operator on the receiver object with the index as argument.
   const String& operator_name =
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kINDEX)));
   const int kNumArguments = 2;  // Receiver and index.
   const Array& kNoArgumentNames = Array::Handle();
+  const int kNumArgumentsChecked = 1;
   GenerateInstanceCall(node_id,
                        token_index,
                        operator_name,
                        kNumArguments,
-                       kNoArgumentNames);
+                       kNoArgumentNames,
+                       kNumArgumentsChecked);
 }
 
 
 void CodeGenerator::VisitLoadIndexedNode(LoadIndexedNode* node) {
   node->array()->Visit(this);
   // Now compute the index.
   node->index_expr()->Visit(this);
   MarkDeoptPoint(node->id(), node->token_index());
   GenerateLoadIndexed(node->id(), node->token_index());
   // Result is in EAX.
@@ skipping 20 matching lines @@
     __ pushl(ECX);  // Restore arguments.
     __ pushl(EDX);
     __ pushl(EAX);
   }
   // Invoke the []= operator on the receiver object with index and
   // value as arguments.
   const String& operator_name =
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kASSIGN_INDEX)));
   const int kNumArguments = 3;  // Receiver, index and value.
   const Array& kNoArgumentNames = Array::Handle();
+  const int kNumArgumentsChecked = 1;
   GenerateInstanceCall(node_id,
                        token_index,
                        operator_name,
                        kNumArguments,
-                       kNoArgumentNames);
+                       kNoArgumentNames,
+                       kNumArgumentsChecked);
 }
 
 
 void CodeGenerator::VisitStoreIndexedNode(StoreIndexedNode* node) {
   // Compute the receiver object and pass as first argument to call.
   node->array()->Visit(this);
   // Now compute the index.
   node->index_expr()->Visit(this);
   // Finally compute the value to assign.
   node->value()->Visit(this);
@@ skipping 67 matching lines @@
   }
   MarkDeoptPoint(node->id(), node->token_index());
   String& operator_name = String::ZoneHandle();
   if (node->kind() == Token::kSUB) {
     operator_name = String::NewSymbol(Token::Str(Token::kNEGATE));
   } else {
     operator_name = String::NewSymbol(node->Name());
   }
   const int kNumberOfArguments = 1;
   const Array& kNoArgumentNames = Array::Handle();
+  const int kNumArgumentsChecked = 1;
   GenerateInstanceCall(node->id(),
                        node->token_index(),
                        operator_name,
                        kNumberOfArguments,
-                       kNoArgumentNames);
+                       kNoArgumentNames,
+                       kNumArgumentsChecked);
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   MarkDeoptPoint(node->id(), node->token_index());
   GenerateLoadVariable(EAX, node->local());
@@ skipping 602 matching lines @@
       __ jmp(&null_done, Assembler::kNearJump);
       __ Bind(&load_true);
       __ LoadObject(EAX, bool_true);
       __ jmp(&null_done, Assembler::kNearJump);
       __ Bind(&non_null_compare);
     }
     // Do '==' first then negate if necessary,
     const String& operator_name = String::ZoneHandle(String::NewSymbol("=="));
     const int kNumberOfArguments = 2;
     const Array& kNoArgumentNames = Array::Handle();
+    const int kNumArgumentsChecked = 1;
     GenerateInstanceCall(node->id(),
                          node->token_index(),
                          operator_name,
                          kNumberOfArguments,
-                         kNoArgumentNames);
+                         kNoArgumentNames,
+                         kNumArgumentsChecked);
 
     // Result is in EAX. No need to negate if result is not needed.
     if ((node->kind() == Token::kNE) && IsResultNeeded(node)) {
       // Negate result.
       Label load_true, done;
       __ LoadObject(EDX, bool_false);
       __ cmpl(EAX, EDX);
       __ j(EQUAL, &load_true, Assembler::kNearJump);
       __ movl(EAX, EDX);  // false.
       __ jmp(&done, Assembler::kNearJump);
@@ skipping 242 matching lines @@
 
 
 // Expect receiver(left operand) and right operand on stack.
 // Return result in EAX.
 void CodeGenerator::GenerateBinaryOperatorCall(intptr_t node_id,
                                                intptr_t token_index,
                                                const char* name) {
   const String& operator_name = String::ZoneHandle(String::NewSymbol(name));
   const int kNumberOfArguments = 2;
   const Array& kNoArgumentNames = Array::Handle();
+  const int kNumArgumentsChecked = 2;
   GenerateInstanceCall(node_id,
                        token_index,
                        operator_name,
                        kNumberOfArguments,
-                       kNoArgumentNames);
+                       kNoArgumentNames,
+                       kNumArgumentsChecked);
 }
 
 
 void CodeGenerator::VisitBinaryOpNode(BinaryOpNode* node) {
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // Operators "&&" and "||" cannot be overloaded, therefore inline them
     // instead of calling the operator.
     GenerateLogicalAndOrOp(node);
     return;
   }
@@ skipping 78 matching lines @@
 
 void CodeGenerator::VisitInstanceCallNode(InstanceCallNode* node) {
   const int number_of_arguments = node->arguments()->length() + 1;
   // Compute the receiver object and pass it as first argument to call.
   node->receiver()->Visit(this);
   // Now compute rest of the arguments to the call.
   node->arguments()->Visit(this);
   // Some method may be inlined using type feedback, therefore this may be a
   // deoptimization point.
   MarkDeoptPoint(node->id(), node->token_index());
-
+  const int kNumArgumentsChecked = 1;
   GenerateInstanceCall(node->id(),
                        node->token_index(),
                        node->function_name(),
                        number_of_arguments,
-                       node->arguments()->names());
+                       node->arguments()->names(),
+                       kNumArgumentsChecked);
   // Result is in EAX.
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::VisitStaticCallNode(StaticCallNode* node) {
   node->arguments()->Visit(this);
   __ LoadObject(ECX, node->function());
@@ skipping 229 matching lines @@
 }
 
 
 // Expects receiver on stack, returns result in EAX..
 void CodeGenerator::GenerateInstanceGetterCall(intptr_t node_id,
                                                intptr_t token_index,
                                                const String& field_name) {
   const String& getter_name = String::ZoneHandle(Field::GetterName(field_name));
   const int kNumberOfArguments = 1;
   const Array& kNoArgumentNames = Array::Handle();
+  const int kNumArgumentsChecked = 1;
   GenerateInstanceCall(node_id,
                        token_index,
                        getter_name,
                        kNumberOfArguments,
-                       kNoArgumentNames);
+                       kNoArgumentNames,
+                       kNumArgumentsChecked);
 }
 
 
 // Call to the instance getter.
 void CodeGenerator::VisitInstanceGetterNode(InstanceGetterNode* node) {
   node->receiver()->Visit(this);
   MarkDeoptPoint(node->id(), node->token_index());
   GenerateInstanceGetterCall(node->id(),
                              node->token_index(),
                              node->field_name());
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 // Expects receiver and value on stack.
 void CodeGenerator::GenerateInstanceSetterCall(intptr_t node_id,
                                                intptr_t token_index,
                                                const String& field_name) {
   const String& setter_name = String::ZoneHandle(Field::SetterName(field_name));
   const int kNumberOfArguments = 2;  // receiver + value.
   const Array& kNoArgumentNames = Array::Handle();
+  const int kNumArgumentsChecked = 1;
   GenerateInstanceCall(node_id,
                        token_index,
                        setter_name,
                        kNumberOfArguments,
-                       kNoArgumentNames);
+                       kNoArgumentNames,
+                       kNumArgumentsChecked);
 }
 
 
 // The call to the instance setter implements the assignment to a field.
 // The result of the assignment to a field is the value being stored.
 void CodeGenerator::VisitInstanceSetterNode(InstanceSetterNode* node) {
   // Compute the receiver object and pass it as first argument to call.
   node->receiver()->Visit(this);
   node->value()->Visit(this);
   MarkDeoptPoint(node->id(), node->token_index());
@@ skipping 258 matching lines @@
                         message_buffer, kMessageBufferSize,
                         format, args);
   va_end(args);
   Isolate::Current()->long_jump_base()->Jump(1, message_buffer);
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32