More optimizations cleanup.

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 741 matching lines @@
     __ sarl(EBX, ECX);
     __ cmpl(EAX, EBX);
     __ j(NOT_EQUAL, &slow_case, Assembler::kNearJump);  // Overflow.
 
     __ shll(EAX, ECX);  // Shift for result now we know there is no overflow.
     // EAX is the correctly tagged Smi.
     __ jmp(&done);
     __ Bind(&slow_case);
     __ pushl(EAX);
     __ pushl(EDX);
-    CodeGenerator::GenerateBinaryOperatorCall(node->id(),
-                                              node->token_index(),
-                                              node->Name());
+    const int number_of_arguments = 2;
+    const Array& no_optional_argument_names = Array::Handle();
+    GenerateCheckedInstanceCalls(node,
+                                 node->left(),
+                                 node->id(),
+                                 node->token_index(),
+                                 number_of_arguments,
+                                 no_optional_argument_names);
     shift_generated = true;
   }
   __ Bind(&done);
 }
 
 
+// Implement Token::kSUB and Token::kBIT_NOT.
+void OptimizingCodeGenerator::GenerateSmiUnaryOp(UnaryOpNode* node) {
+  const ICData& ic_data = node->ICDataAtId(node->id());
+  ASSERT(ic_data.NumberOfArgumentsChecked() == 1);
+  DeoptReasonId deopt_reason_id = ic_data.NumberOfChecks() == 0 ?
+      kDeoptNoTypeFeedback : kDeoptUnaryOp;
+  DeoptimizationBlob* deopt_blob =
+      AddDeoptimizationBlob(node, EAX, deopt_reason_id);
+  CodeGenInfo info(node->operand());
+  VisitLoadOne(node->operand(), EAX);
+  if (ic_data.NumberOfChecks() == 0) {
+    // No type feedback.
+    __ jmp(deopt_blob->label());
+    return;
+  }
+  ASSERT(ic_data.NumberOfChecks() == 1);
+  __ testl(EAX, Immediate(kSmiTagMask));
+  __ j(NOT_ZERO, deopt_blob->label());
+  if (node->kind() == Token::kSUB) {
+    __ negl(EAX);
+    __ j(OVERFLOW, deopt_blob->label());
+  } else {
+    ASSERT(node->kind() == Token::kBIT_NOT);
+    __ notl(EAX);
+    __ andl(EAX, Immediate(~kSmiTagMask));  // Remove inverted smi-tag.
+  }
+  if (CodeGenerator::IsResultNeeded(node)) {
+    if (IsResultInEaxRequested(node)) {
+      node->info()->set_result_returned_in_eax(true);
+    } else {
+      __ pushl(EAX);
+    }
+  }
+}
+
+
 // 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.
 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) ||
@@ skipping 423 matching lines @@
   // instead of calling the operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     if (FLAG_enable_type_checks) {
       CodeGenerator::VisitBinaryOpNode(node);
       return;
     }
     GenerateLogicalBinaryOp(node);
     return;
   }
 
-  ObjectStore* object_store = Isolate::Current()->object_store();
+  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_)) {
     GenerateSmiBinaryOp(node);
     return;
   }
 
   if (AtIdNodeHasReceiverClass(node, node->id(), double_class_)) {
     GenerateDoubleBinaryOp(node);
     return;
   }
 
-  if (AtIdNodeHasReceiverClass(node,
-                               node->id(),
-                               Class::Handle(object_store->mint_class()))) {
+  const Class& mint_class =
+      Class::Handle(Isolate::Current()->object_store()->mint_class());
+  if (AtIdNodeHasReceiverClass(node, node->id(), mint_class)) {
     GenerateMintBinaryOp(node, false);
     return;
   }
 
-  if (NodeHasBothReceiverClasses(node,
-      smi_class_, Class::Handle(object_store->mint_class()))) {
+  if (NodeHasBothReceiverClasses(node, smi_class_, mint_class)) {
     GenerateMintBinaryOp(node, true);
     return;
   }
 
-  // TODO(srdjan): Handle "+" for strings.
+  // TODO(srdjan): Implement "+" for Strings.
   // Type feedback tells this is not a Smi or Double operation.
   TraceNotOpt(node,
-      "BinaryOp: type feedback tells this is not a Smi or Double op");
-  CodeGenerator::VisitBinaryOpNode(node);
+      "BinaryOp: type feedback tells this is not a Smi, Mint or Double op");
+  node->left()->Visit(this);
+  node->right()->Visit(this);
+  const int number_of_arguments = 2;
+  const Array& no_optional_argument_names = Array::Handle();
+  GenerateCheckedInstanceCalls(node,
+                               node->left(),
+                               node->id(),
+                               node->token_index(),
+                               number_of_arguments,
+                               no_optional_argument_names);
+  if (IsResultNeeded(node)) {
+    __ pushl(EAX);
+  }
   return;
 }
 
 
 void OptimizingCodeGenerator::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
   if (FLAG_enable_type_checks) {
     classes_for_locals_->SetLocalType(node->local(), Class::ZoneHandle());
     CodeGenerator::VisitIncrOpLocalNode(node);
     return;
   }
@@ skipping 921 matching lines @@
       __ j(condition, &is_true);
       __ PushObject(bool_false);
       __ jmp(&done);
       __ Bind(&is_true);
       __ PushObject(bool_true);
       __ Bind(&done);
     }
     return;
   }
 
+  if (Token::IsInstanceofOperator(node->kind())) {
+    VisitLoadOne(node->left(), EAX);
+    ASSERT(node->right()->IsTypeNode());
+    GenerateInstanceOf(node->id(),
+                       node->token_index(),
+                       node->right()->AsTypeNode()->type(),
+                       (node->kind() == Token::kISNOT));
+    if (!IsResultNeeded(node)) {
+      __ popl(EAX);  // Pop the result of the instanceof operation.
+    }
+    return;
+  }
+
   if (AtIdNodeHasReceiverClass(node, node->id(), smi_class_)) {
     if (GenerateSmiComparison(node)) {
+      // The comparison was handled, code was emitted.
       return;
     }
     // Fall through if condition is not supported.
   } else if (AtIdNodeHasReceiverClass(node, node->id(), double_class_)) {
     // Double comparison
     if (GenerateDoubleComparison(node)) {
       return;
     }
   } else if ((node->kind() == Token::kEQ) || (node->kind() == Token::kNE)) {
     // Equality, not-equality comparison of any other type.
     if (GenerateEqualityComparison(node)) {
       return;
     }
   }
 
   // Fall through here if a comparison was not implemented.
+  // TODO(srdjan): Implement for Strings.
   CodeGenerator::VisitComparisonNode(node);
 }
 
 
 void OptimizingCodeGenerator::VisitLoadIndexedNode(LoadIndexedNode* node) {
   const char* kMessage = "Inline indexed access";
   ObjectStore* object_store = Isolate::Current()->object_store();
   const Class& object_array_class =
       Class::ZoneHandle(object_store->array_class());
   const Class& immutable_object_array_class =
@@ skipping 296 matching lines @@
     const ICData& ic_data,
     const Function& null_target,
     GrowableArray<const Class*>* classes,
     GrowableArray<const Function*>* targets) {
   ASSERT(classes != NULL);
   ASSERT(targets != NULL);
   // Check if we can add Smi class in front.
   Class& smi_test_class = Class::Handle();
   Function& smi_target = Function::ZoneHandle();
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
-    ic_data.GetOneClassCheckAt(i, &smi_test_class, &smi_target);
+    GrowableArray<const Class*> test_classes;
+    ic_data.GetCheckAt(i, &test_classes, &smi_target);
+    smi_test_class = test_classes[0]->raw();
     if (smi_test_class.raw() == smi_class_.raw()) {
       classes->Add(&Class::ZoneHandle(smi_class_.raw()));
       targets->Add(&Function::ZoneHandle(smi_target.raw()));
       break;
     }
   }
   // Add all classes except Smi.
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     Function& target = Function::ZoneHandle();
     Class& cls = Class::ZoneHandle();
-    ic_data.GetOneClassCheckAt(i, &cls, &target);
+    GrowableArray<const Class*> test_classes;
+    ic_data.GetCheckAt(i, &test_classes, &target);
+    cls = test_classes[0]->raw();
     ASSERT(!cls.IsNullClass());
     if (cls.raw() != smi_class_.raw()) {
       ASSERT(!cls.IsNull());
       ASSERT(!target.IsNull());
       classes->Add(&cls);
       targets->Add(&target);
     }
   }
   // Do not add a target that has not been compiled yet.
   if (!null_target.IsNull() && null_target.HasCode()) {
     ASSERT(null_target.IsZoneHandle());
     classes->Add(&Class::ZoneHandle(Object::null_class()));
     targets->Add(&null_target);
   }
 }
 
 
 // Use ICData in 'node' to issues checks and calls.
+// IC data can contain one or more argument checks.
 void OptimizingCodeGenerator::GenerateCheckedInstanceCalls(
     AstNode* node,
     AstNode* receiver,
     intptr_t node_id,
     intptr_t token_index,
     intptr_t num_args,
     const Array& optional_arguments_names) {
   ASSERT(node != NULL);
   ASSERT(receiver != NULL);
   ASSERT(num_args > 0);
   const ICData& ic_data = node->ICDataAtId(node_id);
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback means node was never executed. However that can be
     // a common case especially in case of large switch statements.
     // Use a special inline cache call which can help us decide when to
     // re-optimize this optiumized function.
     GenerateInlineCacheCall(
         node_id, token_index, ic_data, num_args, optional_arguments_names);
     return;
   }
-  ASSERT(ic_data.NumberOfArgumentsChecked() == 1);
 
   Function& target_for_null = Function::ZoneHandle();
   ObjectStore* object_store = Isolate::Current()->object_store();
   int num_optional_args =
       optional_arguments_names.IsNull() ? 0 : optional_arguments_names.Length();
   target_for_null = Resolver::ResolveDynamicForReceiverClass(
       Class::Handle(object_store->object_class()),
       String::Handle(ic_data.FunctionName()),
       num_args,
       num_optional_args);
   GrowableArray<const Class*> classes;
   GrowableArray<const Function*> targets;
+  // Make Smi class the first one, if it is in the list.
   NormalizeClassChecks(ic_data, target_for_null, &classes, &targets);
   ASSERT(!classes.is_empty());
   ASSERT(classes.length() == targets.length());
   intptr_t start_ix = 0;
 
   Label done;
   __ movl(EAX, Address(ESP, (num_args - 1) * kWordSize));  // Load receiver.
   if (classes[0]->raw() == smi_class_.raw()) {
     start_ix++;
     // Smi test is needed.
@@ skipping 181 matching lines @@
 }
 
 
 void OptimizingCodeGenerator::VisitReturnNode(ReturnNode* node) {
   if ((node->inlined_finally_list_length() > 0) || FLAG_enable_type_checks) {
     CodeGenerator::VisitReturnNode(node);
     return;
   }
   ASSERT(!IsResultNeeded(node));
   ASSERT(node->value() != NULL);
-  VisitLoadOne(node->value(), EAX);
+  CodeGenInfo value_info(node->value());
+  value_info.set_request_result_in_eax(true);
+  node->value()->Visit(this);
+  if (!value_info.result_returned_in_eax()) {
+    __ popl(EAX);
+  }
   GenerateReturnEpilog();
 }
 
 
 void OptimizingCodeGenerator::VisitSequenceNode(SequenceNode* node_sequence) {
   // TODO(srdjan): Allow limited forwarding of types across sequence nodes.
   classes_for_locals_->Clear();
   const intptr_t num_context_variables = (node_sequence->scope() != NULL) ?
       node_sequence->scope()->num_context_variables() : 0;
   if (FLAG_enable_type_checks || (num_context_variables > 0)) {
@@ skipping 34 matching lines @@
 }
 
 
 void OptimizingCodeGenerator::VisitTryCatchNode(TryCatchNode* node) {
   // TODO(srdjan): Set classes for locals.
   classes_for_locals_->Clear();
   CodeGenerator::VisitTryCatchNode(node);
 }
 
 
+void OptimizingCodeGenerator::VisitUnaryOpNode(UnaryOpNode* node) {
+  if (FLAG_enable_type_checks) {
+    CodeGenerator::VisitUnaryOpNode(node);
+    return;
+  }
+  // TODO(srdjan): Jump directly to labels instead of returning a boolean.
+  if (node->kind() == Token::kNOT) {
+    // Only a true bool returns false, everything else is true.
+    CodeGenInfo info(node->operand());
+    VisitLoadOne(node->operand(), EDX);
+    Label done;
+    __ LoadObject(EAX, Bool::ZoneHandle(Bool::True()));
+    __ cmpl(EDX, EAX);
+    __ j(NOT_EQUAL, &done, Assembler::kNearJump);
+    __ LoadObject(EAX, Bool::ZoneHandle(Bool::False()));
+    __ Bind(&done);
+    if (CodeGenerator::IsResultNeeded(node)) {
+      if (IsResultInEaxRequested(node)) {
+        node->info()->set_result_returned_in_eax(true);
+      } else {
+        __ pushl(EAX);
+      }
+    }
+    return;
+  }
+
+  if ((node->kind() == Token::kSUB) || (node->kind() == Token::kBIT_NOT)) {
+    if (AtIdNodeHasOnlyClass(node, node->id(), smi_class_)) {
+      const ICData& ic_data = node->ICDataAtId(node->id());
+      ASSERT(ic_data.NumberOfArgumentsChecked() == 1);
+      GenerateSmiUnaryOp(node);
+      return;
+    }
+  }
+  // TODO(srdjan): Implement unary kSUB (negate) for doubles and Mint.
+  CodeGenerator::VisitUnaryOpNode(node);
+}
+
+
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32