More optimizations

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 612 matching lines @@
       }
       if (cls1_found && cls2_found) {
         return true;
       }
     }
   }
   return false;
 }
 
 
-// Look only at the first class in all check groups.
+// Look only at the first class in all check groups. Returns true if all
+// receiver classes are 'cls'.
 static bool AtIdNodeHasReceiverClass(AstNode* node,
                                      intptr_t id,
                                      const Class& cls) {
   ASSERT(node != NULL);
   ASSERT(!cls.IsNull());
   const ICData& ic_data = node->ICDataAtId(id);
   if (ic_data.NumberOfChecks() == 0) {
     return false;
   }
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
@@ skipping 27 matching lines @@
   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();
-  ic_data.GetOneClassCheckAt(0, &target_cls, &target);
-  return target_cls.raw() == cls.raw();
-}
-
-
-
 // SHL: Implement with slow case so that it works both with Smi and Mint types.
 // Result is in EAX. Mangles ECX, EBX, EDX.
 void OptimizingCodeGenerator::GenerateSmiShiftBinaryOp(BinaryOpNode* node) {
   if (node->kind() == Token::kSAR) {
     // TODO(srdjan): Implement for Mint?
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, EAX, ECX, kDeoptSAR);
     // EAX: value to shift, ECX: amount to shift.
     VisitLoadTwo(node->left(), node->right(), EAX, ECX);
     // Check if both Smi.
     __ movl(EBX, EAX);
     __ orl(EBX, ECX);
     __ testl(EBX, Immediate(kSmiTagMask));
     __ j(NOT_ZERO, deopt_blob->label());
     Immediate count_limit = Immediate(0x1F);
     __ SmiUntag(ECX);
     __ cmpl(ECX, count_limit);
     Label shift_count_ok;
     __ j(LESS_EQUAL, &shift_count_ok, Assembler::kNearJump);
     __ movl(ECX, count_limit);
     __ Bind(&shift_count_ok);
     // Shift amount must be in ECX.
     __ SmiUntag(EAX);  // Value.
     __ sarl(EAX, ECX);
     __ SmiTag(EAX);
     return;
   }
   ASSERT(node->kind() == Token::kSHL);
-  Label done;
-  bool shift_generated = false;
   if (node->right()->IsLiteralNode() &&
       node->right()->AsLiteralNode()->literal().IsSmi()) {
+    Label done;
     // Shift count is a Smi literal.
     Smi& smi = Smi::Handle();
     smi ^= node->right()->AsLiteralNode()->literal().raw();
     if (smi.Value() < Smi::kBits) {
       Label slow_case;
       VisitLoadOne(node->left(), EAX);
       __ testl(EAX, Immediate(kSmiTagMask));
       __ j(NOT_ZERO, &slow_case, Assembler::kNearJump);  // left not smi
       // Overflow test.
       __ movl(EBX, EAX);
       Immediate imm(smi.Value());
       __ shll(EBX, imm);
       __ sarl(EBX, imm);
       __ cmpl(EAX, EBX);
       __ j(NOT_EQUAL, &slow_case, Assembler::kNearJump);  // Overflow.
       __ shll(EAX, imm);  // Shift for result now we know there is no overflow.
       __ jmp(&done);
       __ Bind(&slow_case);
       __ pushl(EAX);
       __ pushl(Immediate(reinterpret_cast<int32_t>(smi.raw())));
-      CodeGenerator::GenerateBinaryOperatorCall(node->id(),
-                                                node->token_index(),
-                                                node->Name());
-      shift_generated = true;
+      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);
+      __ Bind(&done);
+      return;
     }
   }
 
-  if (!shift_generated) {
-    Label slow_case;
-    VisitLoadTwo(node->left(), node->right(), EAX, EDX);
-    // TODO(srdjan): Better code for count being a Smi literal.
-    // EAX: value, EDX: shift amount. Preserve them for slow case.
-    // Fast case only if both ar Smi.
-    __ movl(EBX, EAX);
-    __ orl(EBX, EDX);
-    __ testl(EBX, Immediate(kSmiTagMask));
-    __ j(NOT_ZERO, &slow_case, Assembler::kNearJump);
-    // Check if count too large for handling it inlined.
-    __ cmpl(EDX, Immediate(reinterpret_cast<int32_t>(Smi::New(Smi::kBits))));
-    __ j(ABOVE_EQUAL, &slow_case, Assembler::kNearJump);
-    // Shift amount must be in ECX.
-    __ movl(ECX, EDX);
-    __ movl(EBX, EAX);
-    __ SmiUntag(ECX);
-    // Overflow test.
-    __ shll(EBX, ECX);
-    __ sarl(EBX, ECX);
-    __ cmpl(EAX, EBX);
-    __ j(NOT_EQUAL, &slow_case, Assembler::kNearJump);  // Overflow.
+  Label slow_case, done;
+  VisitLoadTwo(node->left(), node->right(), EAX, EDX);
+  // TODO(srdjan): Better code for count being a Smi literal.
+  // EAX: value, EDX: shift amount. Preserve them for slow case.
+  // Fast case only if both ar Smi.
+  __ movl(EBX, EAX);
+  __ orl(EBX, EDX);
+  __ testl(EBX, Immediate(kSmiTagMask));
+  __ j(NOT_ZERO, &slow_case, Assembler::kNearJump);
+  // Check if count too large for handling it inlined.
+  __ cmpl(EDX, Immediate(reinterpret_cast<int32_t>(Smi::New(Smi::kBits))));
+  __ j(ABOVE_EQUAL, &slow_case, Assembler::kNearJump);
+  // Shift amount must be in ECX.
+  __ movl(ECX, EDX);
+  __ movl(EBX, EAX);
+  __ SmiUntag(ECX);
+  // Overflow test.
+  __ shll(EBX, ECX);
+  __ 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);
-    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;
-  }
+  __ 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);
+  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);
   __ 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;
@@ skipping 70 matching lines @@
       ASSERT(kResultRegister == EAX);
       node->info()->set_result_returned_in_eax(true);
     } else {
       __ pushl(kResultRegister);
     }
   }
 }
 
 
 // Handles only Smi & Smi.
+// TODO(srdjan): Certain operations always overflow, and thus cause
+// deoptimization. We need to mark those places and handle them.
 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) ||
@@ skipping 144 matching lines @@
     // Load lower Mint word, convert to Smi. It is OK to loose bits.
     __ movl(EAX, FieldAddress(EAX, Mint::value_offset()));
     __ SmiTag(EAX);
 
     __ Bind(&is_smi);
     __ andl(EAX, EDX);
     __ jmp(&done);
     __ Bind(&slow_case);
     __ pushl(EAX);
     __ pushl(EDX);
-    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);
     __ Bind(&done);
     if (CodeGenerator::IsResultNeeded(node)) {
       __ pushl(EAX);
     }
     return;
   }
   if ((kind == Token::kSHL) && allow_smi) {
     GenerateSmiShiftBinaryOp(node);
     if (CodeGenerator::IsResultNeeded(node)) {
       __ pushl(EAX);
@@ skipping 23 matching lines @@
                                                  Label* is_smi,
                                                  Label* not_double_or_smi) {
   __ testl(reg, Immediate(kSmiTagMask));
   __ j(ZERO, is_smi);
   __ movl(temp, FieldAddress(reg, Object::class_offset()));
   __ CompareObject(temp, double_class_);
   __ j(NOT_EQUAL, not_double_or_smi);
 }
 
 
-// TODO(srdjan): Detect double/Smi operation and remove extra code to
-// always check for Smi on the right hand side.
 // Result of the computation is a newly allocated double object or
 // a temporary object if the parent node specifies a CodeGenInfo for this node
 // and therefore knows how to handle a temporary. A temporary object cannot
 // be used for long living values (e.g., the ones stored on stack or into other
 // objects).
-void OptimizingCodeGenerator::GenerateDoubleBinaryOp(BinaryOpNode* node) {
+// Implement for combinations: Double/Double, Double/Smi, Smi/Double, as
+// the result is always double.
+// TODO(srdjan): Implement Smi/Smi for kDIV (result also double).
+void OptimizingCodeGenerator::GenerateDoubleBinaryOp(BinaryOpNode* node,
+                                                     bool receiver_can_be_smi) {
   const char* kOptMessage = "Inlines BinaryOp for Doubles";
   const Token::Kind kind = node->kind();
   if ((kind == Token::kADD) ||
       (kind == Token::kSUB) ||
       (kind == Token::kMUL) ||
       (kind == Token::kDIV)) {
     TraceOpt(node, kOptMessage);
     // All four register below must be different.
     const Register kLeftRegister = EAX;
     const Register kRightRegister = EDX;
@@ skipping 21 matching lines @@
       result_register = kLeftRegister;
     } else if (right_info.IsClass(double_class_) && right_info.is_temp()) {
       result_register = kRightRegister;
     } else {
       result_register = kAllocatedRegister;
       // Use inlined temporary double object.
       const Double& double_object =
           Double::ZoneHandle(Double::New(0.0, Heap::kOld));
       __ LoadObject(result_register, double_object);
     }
-    Label is_smi, extract_left;
+
     DeoptimizationBlob* deopt_blob = NULL;
     Label* deopt_lbl = NULL;
+    // Deoptimization can only occur if one of arguments is not double.
     if (!left_info.IsClass(double_class_) ||
         !right_info.IsClass(double_class_)) {
       deopt_blob = AddDeoptimizationBlob(node,
                                          kLeftRegister,
                                          kRightRegister,
                                          kDeoptDoubleBinaryOp);
       deopt_lbl = deopt_blob->label();
     }
 
+    if (receiver_can_be_smi) {
+      // Only deoptimize if both argument are Smi.
+      __ movl(kTempRegister, kLeftRegister);
+      __ orl(kTempRegister, kRightRegister);
+      __ testl(kTempRegister, Immediate(kSmiTagMask));
+      __ j(ZERO, deopt_lbl);
+    }
+
     bool nodes_of_same_type = AreNodesOfSameType(node->left(), node->right());
     if (!left_info.IsClass(double_class_)) {
-      CheckIfDoubleOrSmi(kLeftRegister, kTempRegister, deopt_lbl, deopt_lbl);
-      // Fall through for double. Jump to 'deopt' if not double.
+      Label is_smi, done;
+      CheckIfDoubleOrSmi(kLeftRegister, kTempRegister, &is_smi, deopt_lbl);
+      // Fall through for double. Jump to 'is_smi' if double, jump to
+      // 'deopt' if neither smi nor double.
+      __ movsd(XMM0, FieldAddress(kLeftRegister, Double::value_offset()));
+      __ jmp(&done);
+      __ Bind(&is_smi);
+      __ SmiUntag(kLeftRegister);
+      __ cvtsi2sd(XMM0, kLeftRegister);
+      __ Bind(&done);
+    } else {
+      __ movsd(XMM0, FieldAddress(kLeftRegister, Double::value_offset()));
     }
     if (!right_info.IsClass(double_class_) && !nodes_of_same_type) {
+      Label is_smi, done;
       CheckIfDoubleOrSmi(kRightRegister, kTempRegister, &is_smi, deopt_lbl);
       // Fall through for double. Jump to 'is_smi' if double, jump to
       // 'deopt' if neither smi nor double.
       __ movsd(XMM1, FieldAddress(kRightRegister, Double::value_offset()));
-      __ jmp(&extract_left);
+      __ jmp(&done);
       __ Bind(&is_smi);
       __ SmiUntag(kRightRegister);
       __ cvtsi2sd(XMM1, kRightRegister);
-      __ Bind(&extract_left);
+      __ Bind(&done);
     } else {
       __ movsd(XMM1, FieldAddress(kRightRegister, Double::value_offset()));
     }
-    __ movsd(XMM0, FieldAddress(kLeftRegister, Double::value_offset()));
 
     switch (kind) {
       case Token::kADD: __ addsd(XMM0, XMM1); break;
       case Token::kSUB: __ subsd(XMM0, XMM1); break;
       case Token::kMUL: __ mulsd(XMM0, XMM1); break;
       case Token::kDIV: __ divsd(XMM0, XMM1); break;
       default: UNREACHABLE();
     }
     __ movsd(FieldAddress(result_register, Double::value_offset()), XMM0);
     if (CodeGenerator::IsResultNeeded(node)) {
@@ skipping 116 matching lines @@
     __ jmp(deopt_blob->label());
     return;
   }
 
   if (AtIdNodeHasTwoClasses(node, node->id(), smi_class_, smi_class_)) {
     GenerateSmiBinaryOp(node);
     return;
   }
 
   if (AtIdNodeHasReceiverClass(node, node->id(), double_class_)) {
-    GenerateDoubleBinaryOp(node);
+    const bool receiver_can_be_smi = false;
+    GenerateDoubleBinaryOp(node, receiver_can_be_smi);
+    return;
+  }
+
+  if (AtIdNodeHasTwoClasses(node, node->id(), smi_class_, double_class_)) {
+    const bool receiver_can_be_smi = true;
+    GenerateDoubleBinaryOp(node, receiver_can_be_smi);
     return;
   }
 
   const Class& mint_class =
       Class::Handle(Isolate::Current()->object_store()->mint_class());
   if (AtIdNodeHasReceiverClass(node, node->id(), mint_class)) {
     GenerateMintBinaryOp(node, false);
     return;
   }
 
@@ skipping 997 matching lines @@
 }
 
 
 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 =
       Class::ZoneHandle(object_store->immutable_array_class());
-  if (AtIdNodeHasOnlyClass(node, node->id(), object_array_class) ||
-      AtIdNodeHasOnlyClass(node, node->id(), immutable_object_array_class)) {
+  if (AtIdNodeHasReceiverClass(node, node->id(), object_array_class) ||
+      AtIdNodeHasReceiverClass(node, node->id(),
+          immutable_object_array_class)) {
     VisitLoadTwo(node->array(), node->index_expr(), EBX, EDX);
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, EBX, EDX, kDeoptLoadIndexedFixedArray);
     const Class& test_class =
-        AtIdNodeHasOnlyClass(node, node->id(), object_array_class) ?
+        AtIdNodeHasReceiverClass(node, node->id(), object_array_class) ?
             object_array_class : immutable_object_array_class;
     // Type checks of array.
     __ testl(EBX, Immediate(kSmiTagMask));  // Deoptimize if Smi.
     __ j(ZERO, deopt_blob->label());
     __ movl(EAX, FieldAddress(EBX, Object::class_offset()));
     __ CompareObject(EAX, test_class);
     __ j(NOT_EQUAL, deopt_blob->label());
 
     // Type check of index.
     __ testl(EDX, Immediate(kSmiTagMask));
     __ j(NOT_ZERO, deopt_blob->label());
     // Range check.
     __ cmpl(EDX, FieldAddress(EBX, Array::length_offset()));
     __ j(ABOVE_EQUAL, deopt_blob->label());
     // Note that EDX is Smi, i.e, times 2.
     ASSERT(kSmiTagShift == 1);
     __ movl(EAX, FieldAddress(EBX, EDX, TIMES_2, sizeof(RawArray)));
     if (CodeGenerator::IsResultNeeded(node)) {
       __ pushl(EAX);
     }
     TraceOpt(node, kMessage);
     return;
   }
 
   const String& growable_object_array_class_name = String::Handle(
       String::NewSymbol(kGrowableArrayClassName));
   const Class& growable_array_class = Class::ZoneHandle(
       Library::Handle(Library::CoreImplLibrary()).
           LookupClass(growable_object_array_class_name));
-  if (AtIdNodeHasOnlyClass(node, node->id(), growable_array_class)) {
+  if (AtIdNodeHasReceiverClass(node, node->id(), growable_array_class)) {
     const String& growable_array_length_field_name =
         String::Handle(String::NewSymbol(kGrowableArrayLengthFieldName));
     const String& growable_array_array_field_name =
         String::Handle(String::NewSymbol(kGrowableArrayArrayFieldName));
     intptr_t length_offset = GetFieldOffset(growable_array_class,
                                             growable_array_length_field_name);
     intptr_t array_offset = GetFieldOffset(growable_array_class,
                                            growable_array_array_field_name);
     VisitLoadTwo(node->array(), node->index_expr(), EDX, EAX);
     DeoptimizationBlob* deopt_blob =
@@ skipping 37 matching lines @@
   const Class& object_array_class =
       Class::ZoneHandle(object_store->array_class());
   const ICData& ic_data = node->ICDataAtId(node->id());
   if (ic_data.NumberOfChecks() == 0) {
     VisitLoadTwo(node->index_expr(), node->value(), EBX, ECX);
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, EBX, ECX, kDeoptNoTypeFeedback);
     __ jmp(deopt_blob->label());
     return;
   }
-  if (AtIdNodeHasOnlyClass(node, node->id(), object_array_class)) {
+  if (AtIdNodeHasReceiverClass(node, node->id(), object_array_class)) {
     VisitLoadTwo(node->index_expr(), node->value(), EBX, ECX);
     DeoptimizationBlob* deopt_blob =
         AddDeoptimizationBlob(node, EAX, EBX, ECX, kDeoptStoreIndexed);
     __ popl(EAX);  // array.
     // ECX: value, EBX:index, EAX: array.
     // Check type of array.
     __ testl(EAX, Immediate(kSmiTagMask));
     __ j(ZERO, deopt_blob->label());  // Array is smi -> deopt.
     __ movl(EDX, FieldAddress(EAX, Object::class_offset()));
     __ CompareObject(EDX, object_array_class);
@@ skipping 372 matching lines @@
                                                  node->function_name(),
                                                  num_arguments,
                                                  num_named_arguments));
     Recognizer::Kind recognized = Recognizer::RecognizeKind(target);
     if (FLAG_trace_optimization) {
       OS::Print("Monomorphic inline candidate: %s -> %s\n",
           target.ToFullyQualifiedCString(),
           Recognizer::KindToCString(recognized));
     }
     if ((recognized == Recognizer::kIntegerToDouble) &&
-        AtIdNodeHasOnlyClass(node, node->id(), smi_class_)) {
+        AtIdNodeHasReceiverClass(node, node->id(), smi_class_)) {
       // TODO(srdjan): Check if we could use temporary double instead of
       // allocating a new object every time.
       const Code& stub =
           Code::Handle(StubCode::GetAllocationStubForClass(double_class_));
       const ExternalLabel label(double_class_.ToCString(), stub.EntryPoint());
       GenerateCall(node->token_index(), &label);
       // EAX is double object.
       DeoptimizationBlob* deopt_blob =
           AddDeoptimizationBlob(node, EBX, kDeoptIntegerToDouble);
       __ popl(EBX);  // Receiver
       __ testl(EBX, Immediate(kSmiTagMask));
       __ j(NOT_ZERO, deopt_blob->label());  // Deoptimize if not Smi.
       __ SmiUntag(EBX);
       __ cvtsi2sd(XMM0, EBX);
       __ movsd(FieldAddress(EAX, Double::value_offset()), XMM0);
       return true;
     }
 
     if ((recognized == Recognizer::kDoubleToDouble) &&
-        AtIdNodeHasOnlyClass(node, node->id(), double_class_)) {
+        AtIdNodeHasReceiverClass(node, node->id(), double_class_)) {
       DeoptimizationBlob* deopt_blob =
           AddDeoptimizationBlob(node, EAX, kDeoptDoubleToDouble);
       __ popl(EAX);
       CheckIfDoubleOrSmi(EAX, EBX, deopt_blob->label(), deopt_blob->label());
       return true;
     }
   }
   return false;
 }
 
@@ skipping 133 matching lines @@
       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_)) {
+    if (AtIdNodeHasReceiverClass(node, node->id(), smi_class_)) {
       const ICData& ic_data = node->ICDataAtId(node->id());
       ASSERT(ic_data.NumberOfArgumentsChecked() == 1);
       GenerateSmiUnaryOp(node);
       return;
     }
   }
   if (node->kind() == Token::kSUB) {
     if (AtIdNodeHasReceiverClass(node, node->id(), double_class_)) {
       const ICData& ic_data = node->ICDataAtId(node->id());
       ASSERT(ic_data.NumberOfArgumentsChecked() == 1);
       GenerateDoubleUnaryOp(node);
       return;
     }
   }
   // TODO(srdjan): Implement unary kSUB (negate) Mint.
   CodeGenerator::VisitUnaryOpNode(node);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32