Allocate inlined temporary double objects only if the parent node supports 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 12 matching lines @@
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, intrinsify);
 DECLARE_FLAG(bool, trace_functions);
 
 
 // Property list to be used in CodeGenInfo. Each property has a setter
 // and a getter of specified type and name.
 // (name, type, default)
 #define PROPERTY_LIST(V)                                                       \
   V(is_temp, bool, false)                                                      \
+  V(allow_temp, bool, false)                                                   \
   V(true_label, Label*, NULL)                                                  \
   V(false_label, Label*, NULL)                                                 \
   V(labels_used, bool, false)                                                  \
   V(request_result_in_eax, bool, false)                                        \
   V(result_returned_in_eax, bool, false)                                       \
   V(fallthrough_label, Label*, NULL)                                           \
   V(is_class, const Class*, &Class::ZoneHandle())                              \
 
 
 // Class holding information being passed from source to destination.
@@ skipping 534 matching lines @@
 }
 
 
 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_allow_temp(true);
   value_info.set_request_result_in_eax(true);
   node->value()->Visit(this);
   if (value_info.is_temp()) {
     if (value_info.IsClass(double_class_)) {
       if (value_info.result_returned_in_eax()) {
         __ pushl(EAX);
       }
       const Code& stub =
           Code::Handle(StubCode::GetAllocationStubForClass(double_class_));
       const ExternalLabel label(double_class_.ToCString(), stub.EntryPoint());
@@ skipping 276 matching lines @@
   __ pushl(kOperandRegister);
   GenerateCall(node->token_index(), &label);
   ASSERT(kResultRegister == EAX);
   __ 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);
+      // TODO(srdjan): Enable once we use a temporary object.
+      // node->info()->set_is_temp(true);
       node->info()->set_is_class(&double_class_);
     }
     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.
@@ skipping 236 matching lines @@
       (kind == Token::kMUL) ||
       (kind == Token::kDIV)) {
     TraceOpt(node, kOptMessage);
     // All four register below must be different.
     const Register kLeftRegister = EAX;
     const Register kRightRegister = EDX;
     const Register kAllocatedRegister = ECX;
     const Register kTempRegister = EBX;
     CodeGenInfo left_info(node->left());  // Receiver.
     CodeGenInfo right_info(node->right());
+    left_info.set_allow_temp(true);
+    right_info.set_allow_temp(true);
     VisitLoadTwo(node->left(), node->right(), kLeftRegister, kRightRegister);
     // First allocate result object or specify an existing object as result.
     Register result_register = kNoRegister;
-    if (node->info() == NULL) {
+    const bool using_temp =
+        (node->info() != NULL) && node->info()->allow_temp();
+    if (!using_temp) {
       // Parent node cannot handle a temporary double object, allocate one
       // each time.
       result_register = kAllocatedRegister;
       const Code& stub =
           Code::Handle(StubCode::GetAllocationStubForClass(double_class_));
       const ExternalLabel label(double_class_.ToCString(), stub.EntryPoint());
       __ pushl(kLeftRegister);
       __ pushl(kRightRegister);
       GenerateCall(node->token_index(), &label);
       __ movl(result_register, EAX);
@@ skipping 85 matching lines @@
     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)) {
       if (node->info() != NULL) {
-        node->info()->set_is_temp(true);
+        node->info()->set_is_temp(using_temp);
         node->info()->set_is_class(&double_class_);
       }
       HandleResult(node, result_register);
     }
     return;
   }
 
   TraceNotOpt(node, kOptMessage);
   CodeGenerator::VisitBinaryOpNode(node);
 }
@@ skipping 1861 matching lines @@
     }
   }
   // TODO(srdjan): Implement unary kSUB (negate) Mint.
   CodeGenerator::VisitUnaryOpNode(node);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32