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 545 matching lines @@
   if (node->info() != NULL) {
     const Class* cls = NULL;
     classes_for_locals_->GetLocalClass(node->local(), &cls);
     if (cls != NULL) {
       node->info()->set_is_class(cls);
     }
   }
 }
 
 
+void OptimizingCodeGenerator::HandleResult(AstNode* node, Register result_reg) {
+  if (CodeGenerator::IsResultNeeded(node)) {
+    if (IsResultInEaxRequested(node)) {
+      if (result_reg != EAX) {
+        __ movl(EAX, result_reg);
+      }
+      node->info()->set_result_returned_in_eax(true);
+    } else {
+      __ pushl(result_reg);
+    }
+  }
+}
+
+
 void OptimizingCodeGenerator::VisitStoreLocalNode(StoreLocalNode* node) {
   if (FLAG_enable_type_checks) {
     CodeGenerator::VisitStoreLocalNode(node);
     classes_for_locals_->SetLocalType(node->local(), Class::ZoneHandle());
     return;
   }
   CodeGenInfo value_info(node->value());
   value_info.set_request_result_in_eax(true);
   node->value()->Visit(this);
   if (value_info.is_temp()) {
@@ skipping 12 matching lines @@
       CodeGenerator::GenerateStoreVariable(node->local(), EAX, EDX);
     } else {
       UNIMPLEMENTED();  // Cannot handle other temporary types yet.
     }
   } else {
     if (!value_info.result_returned_in_eax()) {
       __ popl(EAX);
     }
     CodeGenerator::GenerateStoreVariable(node->local(), EAX, EDX);
   }
-  if (IsResultNeeded(node)) {
-    __ pushl(EAX);
-  }
+  HandleResult(node, EAX);
   classes_for_locals_->SetLocalType(node->local(), *value_info.is_class());
 }
 
 
 static bool NodeHasBothReceiverClasses(AstNode* node,
                                        const Class& cls1,
                                        const Class& cls2) {
   ASSERT(node != NULL);
   ASSERT(!cls1.IsNull() && !cls2.IsNull());
   const ICData& ic_data = node->ICDataAtId(node->id());
@@ skipping 191 matching lines @@
   __ 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);
-    }
-  }
+  HandleResult(node, EAX);
 }
 
 
 void OptimizingCodeGenerator::GenerateDoubleUnaryOp(UnaryOpNode* node) {
   const Register kOperandRegister = ECX;
   const Register kTempRegister = EBX;
   const Register kResultRegister = EAX;
   const ICData& ic_data = node->ICDataAtId(node->id());
   DeoptReasonId deopt_reason_id = ic_data.NumberOfChecks() == 0 ?
       kDeoptNoTypeFeedback : kDeoptUnaryOp;
@@ skipping 22 matching lines @@
   __ popl(kOperandRegister);
   __ movsd(XMM0, FieldAddress(kOperandRegister, Double::value_offset()));
   __ xorps(XMM1, XMM1);  // 0.0 -> XMM1.
   __ subsd(XMM1, XMM0);
   __ movsd(FieldAddress(kResultRegister, Double::value_offset()), XMM1);
   if (CodeGenerator::IsResultNeeded(node)) {
     if (node->info() != NULL) {
       node->info()->set_is_temp(true);
       node->info()->set_is_class(&double_class_);
     }
-    if (IsResultInEaxRequested(node)) {
-      ASSERT(kResultRegister == EAX);
-      node->info()->set_result_returned_in_eax(true);
-    } else {
-      __ pushl(kResultRegister);
-    }
+    HandleResult(node, 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;
@@ skipping 105 matching lines @@
   } else {
     // Unhandled node kind.
     TraceNotOpt(node, kOptMessage);
     node->left()->Visit(this);
     node->right()->Visit(this);
     CodeGenerator::GenerateBinaryOperatorCall(node->id(),
                                               node->token_index(),
                                               node->Name());
   }
   __ Bind(&done);
-  if (CodeGenerator::IsResultNeeded(node)) {
-    if (IsResultInEaxRequested(node)) {
-      node->info()->set_result_returned_in_eax(true);
-    } else {
-      __ pushl(EAX);
-    }
-  }
+  HandleResult(node, EAX);
 }
 
 
 // Supports some mixed Smi/Mint operations.
 // For BIT_AND operation with one operand being Smi, we can throw away
 // any Mint bits above the Smi range.
 // 'allow_smi' is true if Smi and Mint classes have been encountered.
 void OptimizingCodeGenerator::GenerateMintBinaryOp(BinaryOpNode* node,
                                                    bool allow_smi) {
   const char* kOptMessage = "Inline Mint binop.";
@@ skipping 28 matching lines @@
     __ 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);
-    if (CodeGenerator::IsResultNeeded(node)) {
-      __ pushl(EAX);
-    }
+    HandleResult(node, EAX);
     return;
   }
   if ((kind == Token::kSHL) && allow_smi) {
     GenerateSmiShiftBinaryOp(node);
-    if (CodeGenerator::IsResultNeeded(node)) {
-      __ pushl(EAX);
-    }
+    HandleResult(node, EAX);
     return;
   }
   TraceNotOpt(node, kOptMessage);
   CodeGenerator::VisitBinaryOpNode(node);
 }
 
 
 // Conservative approach:
 // - true if both nodes are LoadLocalNodes with the same index.
 static bool AreNodesOfSameType(AstNode* a, AstNode* b) {
@@ skipping 127 matching lines @@
       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)) {
       if (node->info() != NULL) {
         node->info()->set_is_temp(true);
         node->info()->set_is_class(&double_class_);
       }
-      if (IsResultInEaxRequested(node)) {
-        __ movl(EAX, result_register);
-        node->info()->set_result_returned_in_eax(true);
-      } else {
-        __ pushl(result_register);
-      }
+      HandleResult(node, result_register);
     }
     return;
   }
 
   TraceNotOpt(node, kOptMessage);
   CodeGenerator::VisitBinaryOpNode(node);
 }
 
 
 static bool NodeInfoHasLabels(AstNode* node) {
@@ skipping 62 matching lines @@
   if (NodeInfoHasLabels(node)) {
     node->info()->set_labels_used(true);
   } else {
     Label done;
     __ Bind(&return_true_object);
     __ LoadObject(EAX, bool_true);
     __ jmp(&done, Assembler::kNearJump);
     __ Bind(&return_false_object);
     __ LoadObject(EAX, bool_false);
     __ Bind(&done);
-    if (IsResultNeeded(node)) {
-      __ pushl(EAX);
-    }
+    HandleResult(node, EAX);
   }
 }
 
 
 void OptimizingCodeGenerator::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded, therefore inline them
   // instead of calling the operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     if (FLAG_enable_type_checks) {
       CodeGenerator::VisitBinaryOpNode(node);
@@ skipping 48 matching lines @@
   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);
-  }
+  HandleResult(node, 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 356 matching lines @@
     return;
   }
 
   VisitLoadOne(node->receiver(), EBX);
   InlineInstanceGetter(node,
                        node->id(),
                        node->receiver(),
                        node->field_name(),
                        EBX);
   // Result is in EAX.
-  if (CodeGenerator::IsResultNeeded(node)) {
-    __ pushl(EAX);
-  }
+  HandleResult(node, EAX);
 }
 
 
 // Helper struct to pass arguments to 'GenerateInstanceSetter'.
 struct InstanceSetterArgs {
   const Class* cls;
   const Function* target;
   const String* field_name;
   Register recv_reg;
   Register value_reg;
@@ skipping 124 matching lines @@
     return;
   }
   // Value in EAX survives and will be stored on stack if result is needed.
   InlineInstanceSetter(node,
                        node->id(),
                        node->receiver(),
                        node->field_name(),
                        EDX,
                        EAX);
 
-  if (CodeGenerator::IsResultNeeded(node)) {
-    __ pushl(EAX);
-  }
+  HandleResult(node, EAX);
 }
 
 
 // Return false if condition is not supported.
 static bool SupportedTokenKindToSmiCondition(Token::Kind kind,
                                              Condition* condition) {
   switch (kind) {
     case Token::kEQ:
       *condition = EQUAL;
       return true;
@@ skipping 464 matching lines @@
 
     // 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);
-    }
+    HandleResult(node, 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));
   ASSERT(!growable_array_class.IsNull());
@@ skipping 18 matching lines @@
     __ movl(EBX, FieldAddress(EDX, Object::class_offset()));
     __ CompareObject(EBX, growable_array_class);
     __ j(NOT_EQUAL, deopt_blob->label());  // Array is not GrowableObjectArray.
     // Range check: deoptimize if out of bounds.
     __ cmpl(EAX, FieldAddress(EDX, length_offset));
     __ j(ABOVE_EQUAL, deopt_blob->label());
     __ movl(EDX, FieldAddress(EDX, array_offset));  // backingArray.
     // Note that EAX is Smi, i.e, times 2.
     ASSERT(kSmiTagShift == 1);
     __ movl(EAX, FieldAddress(EDX, EAX, TIMES_2, sizeof(RawArray)));
-    if (CodeGenerator::IsResultNeeded(node)) {
-      __ pushl(EAX);
-    }
+    HandleResult(node, EAX);
     return;
   } else {
     // E.g., HashMap.
     TraceNotOpt(node, kMessage);
   }
   CodeGenerator::VisitLoadIndexedNode(node);
 }
 
 
 void OptimizingCodeGenerator::VisitStoreIndexedNode(StoreIndexedNode* node) {
@@ skipping 30 matching lines @@
     // Check class of index.
     __ testl(EBX, Immediate(kSmiTagMask));
     __ j(NOT_ZERO, deopt_blob->label());  // Index not Smi -> deopt.
     // Range check.
     __ cmpl(EBX, FieldAddress(EAX, Array::length_offset()));
     __ j(ABOVE_EQUAL, deopt_blob->label());  // Range error -> deopt.
     ASSERT(kSmiTagShift == 1);
     __ StoreIntoObject(EAX,
                        FieldAddress(EAX, EBX, TIMES_2, sizeof(RawArray)),
                        ECX);
-    if (CodeGenerator::IsResultNeeded(node)) {
-      __ pushl(ECX);
-    }
+    HandleResult(node, ECX);
     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));
   ASSERT(!growable_array_class.IsNull());
   if (AtIdNodeHasReceiverClass(node, node->id(), growable_array_class)) {
@@ skipping 21 matching lines @@
     __ j(NOT_ZERO, deopt_blob->label());  // Index not Smi -> deopt.
     // Range check: deoptimize if out of bounds.
     __ cmpl(EBX, FieldAddress(EAX, length_offset));
     __ j(ABOVE_EQUAL, deopt_blob->label());
     __ movl(EDX, FieldAddress(EAX, array_offset));  // backingArray.
     // Note that EAX is Smi, i.e, times 2.
     ASSERT(kSmiTagShift == 1);
     __ StoreIntoObject(EDX,
                        FieldAddress(EDX, EBX, TIMES_2, sizeof(RawArray)),
                        ECX);
-    if (CodeGenerator::IsResultNeeded(node)) {
-      __ pushl(ECX);
-    }
+    HandleResult(node, ECX);
     return;
   }
   node->index_expr()->Visit(this);
   node->value()->Visit(this);
   GenerateStoreIndexed(node->id(), node->token_index(), IsResultNeeded(node));
 }
 
 
 void OptimizingCodeGenerator::VisitForNode(ForNode* node) {
   if (FLAG_enable_type_checks) {
@@ skipping 322 matching lines @@
     // Instance call is inlined.
   } else {
     GenerateCheckedInstanceCalls(node,
                                  node->receiver(),
                                  node->id(),
                                  node->token_index(),
                                  number_of_arguments,
                                  node->arguments()->names());
   }
   // Result is in EAX.
-  if (IsResultNeeded(node)) {
-    __ pushl(EAX);
-  }
+  HandleResult(node, EAX);
 }
 
 
 // Returns true if an instance call was replaced with its intrinsic.
 // Returns result in EAX.
 bool OptimizingCodeGenerator::TryInlineInstanceCall(InstanceCallNode* node) {
   const ZoneGrowableArray<const Class*>* classes = CollectedClassesAtNode(node);
   if ((classes != NULL) && (classes->length() == 1)) {
     const int num_arguments = node->arguments()->length() + 1;
     const int num_named_arguments = node->arguments()->names().IsNull() ?
@@ skipping 77 matching lines @@
   if (TryInlineStaticCall(node)) {
     // Static method is inlined, result is in EAX.
   } else {
     __ LoadObject(ECX, node->function());
     __ LoadObject(EDX, ArgumentsDescriptor(node->arguments()->length(),
                                            node->arguments()->names()));
     GenerateCall(node->token_index(), &StubCode::CallStaticFunctionLabel());
   }
   __ addl(ESP, Immediate(node->arguments()->length() * kWordSize));
   // Result is in EAX.
-  if (IsResultNeeded(node)) {
-    __ pushl(EAX);
-  }
+  HandleResult(node, EAX);
 }
 
 
 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);
@@ skipping 29 matching lines @@
 
 
 void OptimizingCodeGenerator::VisitStoreInstanceFieldNode(
     StoreInstanceFieldNode* node) {
   if (FLAG_enable_type_checks) {
     CodeGenerator::VisitStoreInstanceFieldNode(node);
     return;
   }
   VisitLoadTwo(node->instance(), node->value(), EDX, EAX);
   __ StoreIntoObject(EDX, FieldAddress(EDX, node->field().Offset()), EAX);
-  if (IsResultNeeded(node)) {
-    // The result is the input value.
-    __ pushl(EAX);
-  }
+  // The result is the input value.
+  HandleResult(node, EAX);
 }
 
 
 void OptimizingCodeGenerator::VisitCatchClauseNode(CatchClauseNode* node) {
   // TODO(srdjan): Set classes for locals.
   classes_for_locals_->Clear();
   CodeGenerator::VisitCatchClauseNode(node);
 }
 
 
@@ skipping 13 matching lines @@
   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);
-      }
-    }
+    HandleResult(node, EAX);
     return;
   }
 
   if ((node->kind() == Token::kSUB) || (node->kind() == Token::kBIT_NOT)) {
     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