Add (debug) printing when IC is used in optimized code (must eliminate it).

runtime/vm/opt_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/opt_code_generator.h"
 
 #include "vm/assembler_macros.h"
@@ skipping 637 matching lines @@
       return false;
     }
     if (classes[0]->raw() != cls.raw()) {
       return false;
     }
   }
   return true;
 }
 
 
+// IC data may have only one check, and it has to contain the two classes in
+// specified order.
+static bool AtIdNodeHasTwoClasses(AstNode* node,
+                                  intptr_t id,
+                                  const Class& cls0,
+                                  const Class& cls1) {
+  ASSERT(node != NULL);
+  ASSERT(!cls0.IsNull() && !cls1.IsNull());

[hausner, 2011/12/20 21:50:08]

You could move this assertion after line 670 to make debug builds a wee bit
faster. 

[srdjan, 2011/12/20 21:55:05]

Yes, but I want to catch mistakes at call site earlier (values for cls1 and
cls2), even if we return false.

+  const ICData& ic_data = node->ICDataAtId(id);
+  ASSERT(ic_data.NumberOfArgumentsChecked() == 2);
+  if (ic_data.NumberOfChecks() != 1) {
+    return false;
+  }
+  Function& target = Function::Handle();
+  GrowableArray<const Class*> classes;
+  ic_data.GetCheckAt(0, &classes, &target);
+  if ((cls0.raw() == classes[0]->raw()) && (cls1.raw() == classes[1]->raw())) {
+    return true;
+  }
+  return false;
+}
+
+
 static bool AtIdNodeHasOnlyClass(AstNode* node, intptr_t id, const Class& cls) {
   ASSERT(node != NULL);
   ASSERT(!cls.IsNull());
   const ICData& ic_data = node->ICDataAtId(id);
   if ((ic_data.NumberOfArgumentsChecked() != 1) ||
       (ic_data.NumberOfChecks() != 1)) {
     return false;
   }
   Class& target_cls = Class::Handle();
   Function& target = Function::Handle();
@@ skipping 183 matching lines @@
     if (IsResultInEaxRequested(node)) {
       ASSERT(kResultRegister == EAX);
       node->info()->set_result_returned_in_eax(true);
     } else {
       __ pushl(kResultRegister);
     }
   }
 }
 
 
-// TODO(srdjan): Expand inline caches to detect Smi/double operations, so that
-// we do not have to call the instance method, and therefore could guarantee
-// that the result is a Smi at the end.
+// Handles only Smi & Smi.
 void OptimizingCodeGenerator::GenerateSmiBinaryOp(BinaryOpNode* node) {
   const char* kOptMessage = "Inlines BinaryOp for Smi";
   Label done;
   const Token::Kind kind = node->kind();
   if ((kind == Token::kADD) ||
       (kind == Token::kSUB) ||
       (kind == Token::kMUL) ||
       (kind == Token::kTRUNCDIV) ||
       (kind == Token::kBIT_AND) ||
       (kind == Token::kBIT_OR) ||
       (kind == Token::kBIT_XOR)) {
     TraceOpt(node, kOptMessage);
     // Check if both arguments are expected to be Smi.
     const ICData& ic_data = node->ICDataAtId(node->id());
     ASSERT(ic_data.NumberOfArgumentsChecked() == 2);
     ASSERT(ic_data.NumberOfChecks() > 0);
     Function& target = Function::Handle();
     GrowableArray<const Class*> classes;
     ic_data.GetCheckAt(0, &classes, &target);
-    const bool both_args_expected_smi =
-        (ic_data.NumberOfChecks() == 1) &&
-        (classes[0]->raw() == smi_class_.raw()) &&
-        (classes[1]->raw() == smi_class_.raw());
-
+    ASSERT(ic_data.NumberOfChecks() == 1);
+    ASSERT((classes[0]->raw() == smi_class_.raw()) &&
+        (classes[1]->raw() == smi_class_.raw()));
     CodeGenInfo left_info(node->left());
     CodeGenInfo right_info(node->right());
     VisitLoadTwo(node->left(), node->right(), EAX, EDX);
-    Label* overflow_label = NULL;
     Label two_smis, call_operator;
-    if (both_args_expected_smi) {
-      DeoptimizationBlob* deopt_blob =
-          AddDeoptimizationBlob(node, ECX, EDX, kDeoptSmiBinaryOp);
-      overflow_label = deopt_blob->label();
-      __ movl(ECX, EAX);  // Save if overflow (needs original value).
+    DeoptimizationBlob* deopt_blob =
+        AddDeoptimizationBlob(node, ECX, EDX, kDeoptSmiBinaryOp);
+    __ movl(ECX, EAX);  // Save if overflow (needs original value).
 
-      if (left_info.IsClass(smi_class_) || right_info.IsClass(smi_class_)) {
-        if (!left_info.IsClass(smi_class_) || !right_info.IsClass(smi_class_)) {
-          // One of the type is not known (statically) to be Smi. Check it.
-          Register test_reg = left_info.IsClass(smi_class_) ? EDX : EAX;
-          __ testl(test_reg, Immediate(kSmiTagMask));
-          __ j(NOT_ZERO, deopt_blob->label());
-        }
-      } else {
-        // Type feedback says both types are Smi, but static type analysis
-        // does not know if any of them is Smi, therefore check.
-        __ orl(EAX, EDX);
-        __ testl(EAX, Immediate(kSmiTagMask));
+    if (left_info.IsClass(smi_class_) || right_info.IsClass(smi_class_)) {
+      if (!left_info.IsClass(smi_class_) || !right_info.IsClass(smi_class_)) {
+        // One of the type is not known (statically) to be Smi. Check it.
+        Register test_reg = left_info.IsClass(smi_class_) ? EDX : EAX;
+        __ testl(test_reg, Immediate(kSmiTagMask));
         __ j(NOT_ZERO, deopt_blob->label());
-        __ movl(EAX, ECX);
-      }
-      if (node->info() != NULL) {
-        node->info()->set_is_class(&smi_class_);
       }
     } else {
-      overflow_label = &call_operator;
-      __ movl(ECX, EAX);
+      // Type feedback says both types are Smi, but static type analysis
+      // does not know if any of them is Smi, therefore check.
       __ orl(EAX, EDX);
       __ testl(EAX, Immediate(kSmiTagMask));
-      __ j(ZERO, &two_smis, Assembler::kNearJump);
-
-      // Operator is called either if one of the arguments is not Smi or
-      // if we hit an overflow in an arithmetic operation.
-      __ Bind(&call_operator);
-      // Restore arguments on stack, and dispatch to operator, thus preventing
-      // deoptimization in case of smi/non-smi operations. At exit we do not
-      // know the result is Smi or not.
-      // TODO(srdjan): Handle type feedback for both arguments instead of for
-      // receiver only, deoptimize if the type changes.
-      __ pushl(ECX);
-      __ pushl(EDX);
-      GenerateBinaryOperatorCall(node->id(),
-                                 node->token_index(),
-                                 node->Name());
-      __ jmp(&done);
-      __ Bind(&two_smis);
-      // Restore left operand. EAX will be 'destroyed', ECX holds the left
-      // argument, which may be needed for deoptimization.
+      __ j(NOT_ZERO, deopt_blob->label());
       __ movl(EAX, ECX);
     }
+    if (node->info() != NULL) {
+      node->info()->set_is_class(&smi_class_);
+    }
     switch (kind) {
       case Token::kADD: {
         __ addl(EAX, EDX);
-        __ j(OVERFLOW, overflow_label);
+        __ j(OVERFLOW, deopt_blob->label());
         break;
       }
       case Token::kSUB: {
         __ subl(EAX, EDX);
-        __ j(OVERFLOW, overflow_label);
+        __ j(OVERFLOW, deopt_blob->label());
         break;
       }
       case Token::kMUL: {
         __ SmiUntag(EAX);
         __ imull(EAX, EDX);
-        __ j(OVERFLOW, overflow_label);
+        __ j(OVERFLOW, deopt_blob->label());
         break;
       }
       case Token::kBIT_AND: {
         // No overflow check.
         __ andl(EAX, EDX);
         break;
       }
       case Token::kBIT_OR: {
         // No overflow check.
         __ orl(EAX, EDX);
         break;
       }
       case Token::kBIT_XOR: {
         // No overflow check.
         __ xorl(EAX, EDX);
         break;
       }
       case Token::kTRUNCDIV: {
         // Handle divide by zero in runtime.
         __ cmpl(EDX, Immediate(0));
-        __ j(EQUAL, overflow_label);
+        __ j(EQUAL, deopt_blob->label());
         // Preserve left & right in case of 'overflow'.
         __ pushl(EDX);
         __ pushl(ECX);
         // Move right to ECX, left is in EAX.
         __ movl(ECX, EDX);
         __ SmiUntag(ECX);
         __ SmiUntag(EAX);
         // Sign extend EAX -> EDX:EAX.
         __ cdq();
         __ idivl(ECX);  // Result in EAX.
         __ popl(ECX);
         __ popl(EDX);
         // Check the corner case of dividing the 'MIN_SMI' with -1, in which
         // case we cannot tag the result.
         __ cmpl(EAX, Immediate(0x40000000));
-        __ j(EQUAL, overflow_label);
+        __ j(EQUAL, deopt_blob->label());
         __ SmiTag(EAX);
         break;
       }
       default:
         UNREACHABLE();
     }
   } else if ((kind == Token::kSHL) || (kind == Token::kSAR)) {
     GenerateSmiShiftBinaryOp(node);
   } else {
     // Unhandled node kind.
@@ skipping 298 matching lines @@
 
   const ICData& ic_data = node->ICDataAtId(node->id());
   if (ic_data.NumberOfChecks() == 0) {
     VisitLoadTwo(node->left(), node->right(), EAX, EDX);
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, EAX, EDX, kDeoptNoTypeFeedback);
     __ jmp(deopt_blob->label());
     return;
   }
 
-  if (AtIdNodeHasReceiverClass(node, node->id(), smi_class_)) {
+  if (AtIdNodeHasTwoClasses(node, node->id(), smi_class_, smi_class_)) {
     GenerateSmiBinaryOp(node);
     return;
   }
 
   if (AtIdNodeHasReceiverClass(node, node->id(), double_class_)) {
     GenerateDoubleBinaryOp(node);
     return;
   }
 
   const Class& mint_class =
@@ skipping 1687 matching lines @@
     }
   }
   // TODO(srdjan): Implement unary kSUB (negate) Mint.
   CodeGenerator::VisitUnaryOpNode(node);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32