Unbox phis that were proven to be of type Double.

runtime/vm/intermediate_language_ia32.cc

 // Copyright (c) 2012, 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/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 222 matching lines @@
       UNREACHABLE();
       return OVERFLOW;
   }
 }
 
 
 LocationSummary* EqualityCompareComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const bool is_checked_strict_equal =
       HasICData() && ic_data()->AllTargetsHaveSameOwner(kInstanceCid);
-  if ((receiver_class_id() == kSmiCid) ||
-      (receiver_class_id() == kDoubleCid) ||
-      is_checked_strict_equal) {
+  if (receiver_class_id() == kDoubleCid) {
+    const intptr_t kNumTemps = 0;
+    LocationSummary* locs =
+        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
+    locs->set_in(0, Location::RequiresXmmRegister());
+    locs->set_in(1, Location::RequiresXmmRegister());
+    locs->set_out(Location::RequiresRegister());
+    return locs;
+  }
+  if ((receiver_class_id() == kSmiCid) || is_checked_strict_equal) {
     const intptr_t kNumTemps = 1;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresRegister());
     locs->set_in(1, Location::RequiresRegister());
     locs->set_temp(0, Location::RequiresRegister());
     locs->set_out(Location::RequiresRegister());
     return locs;
   }
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
@@ skipping 317 matching lines @@
     default:
       UNREACHABLE();
       return OVERFLOW;
   }
 }
 
 
 static void EmitDoubleComparisonOp(FlowGraphCompiler* compiler,
                                    const LocationSummary& locs,
                                    Token::Kind kind,
-                                   BranchInstr* branch,
-                                   intptr_t deopt_id) {
-  Register left = locs.in(0).reg();
-  Register right = locs.in(1).reg();
-  // TODO(srdjan): temp is only needed if a conversion Smi->Double occurs.
-  Register temp = locs.temp(0).reg();
-  Label* deopt = compiler->AddDeoptStub(deopt_id, kDeoptDoubleComparison);
-  compiler->LoadDoubleOrSmiToXmm(XMM0, left, temp, deopt);
-  compiler->LoadDoubleOrSmiToXmm(XMM1, right, temp, deopt);
+                                   BranchInstr* branch) {
+  XmmRegister left = locs.in(0).xmm_reg();
+  XmmRegister right = locs.in(1).xmm_reg();
 
   Condition true_condition = TokenKindToDoubleCondition(kind);
   if (branch != NULL) {
     compiler->EmitDoubleCompareBranch(
-        true_condition, XMM0, XMM1, branch);
+        true_condition, left, right, branch);
   } else {
     compiler->EmitDoubleCompareBool(
-        true_condition, XMM0, XMM1, locs.out().reg());
+        true_condition, left, right, locs.out().reg());
   }
 }
 
 
 void EqualityCompareComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT((kind() == Token::kNE) || (kind() == Token::kEQ));
   BranchInstr* kNoBranch = NULL;
   if (receiver_class_id() == kSmiCid) {
     // Deoptimizes if both arguments not Smi.
     EmitSmiComparisonOp(compiler, *locs(), kind(), kNoBranch, deopt_id());
     return;
   }
   if (receiver_class_id() == kDoubleCid) {
-    // Deoptimizes if both arguments are Smi, or if none is Double or Smi.
-    EmitDoubleComparisonOp(compiler, *locs(), kind(), kNoBranch, deopt_id());
+    EmitDoubleComparisonOp(compiler, *locs(), kind(), kNoBranch);
     return;
   }
   const bool is_checked_strict_equal =
       HasICData() && ic_data()->AllTargetsHaveSameOwner(kInstanceCid);
   if (is_checked_strict_equal) {
     EmitCheckedStrictEqual(compiler, *ic_data(), *locs(), kind(), kNoBranch,
                            deopt_id());
     return;
   }
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
@@ skipping 12 matching lines @@
 
 void EqualityCompareComp::EmitBranchCode(FlowGraphCompiler* compiler,
                                          BranchInstr* branch) {
   ASSERT((kind() == Token::kNE) || (kind() == Token::kEQ));
   if (receiver_class_id() == kSmiCid) {
     // Deoptimizes if both arguments not Smi.
     EmitSmiComparisonOp(compiler, *locs(), kind(), branch, deopt_id());
     return;
   }
   if (receiver_class_id() == kDoubleCid) {
-    // Deoptimizes if both arguments are Smi, or if none is Double or Smi.
-    EmitDoubleComparisonOp(compiler, *locs(), kind(), branch, deopt_id());
+    EmitDoubleComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
   const bool is_checked_strict_equal =
       HasICData() && ic_data()->AllTargetsHaveSameOwner(kInstanceCid);
   if (is_checked_strict_equal) {
     EmitCheckedStrictEqual(compiler, *ic_data(), *locs(), kind(), branch,
                            deopt_id());
     return;
   }
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
@@ skipping 11 matching lines @@
                              Token::kEQ,  // kNE reverse occurs at branch.
                              locs());
   Condition branch_condition = (kind() == Token::kNE) ? NOT_EQUAL : EQUAL;
   __ CompareObject(EAX, compiler->bool_true());
   branch->EmitBranchOnCondition(compiler, branch_condition);
 }
 
 
 LocationSummary* RelationalOpComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
-  if ((operands_class_id() == kSmiCid) || (operands_class_id() == kDoubleCid)) {
+  if (operands_class_id() == kDoubleCid) {
+    const intptr_t kNumTemps = 0;
+    LocationSummary* summary =
+        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
+    summary->set_in(0, Location::RequiresXmmRegister());
+    summary->set_in(1, Location::RequiresXmmRegister());
+    summary->set_out(Location::RequiresRegister());
+    return summary;
+  } else if (operands_class_id() == kSmiCid) {
     const intptr_t kNumTemps = 1;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::RequiresRegister());
     summary->set_out(Location::RequiresRegister());
     summary->set_temp(0, Location::RequiresRegister());
     return summary;
   }
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   // Pick arbitrary fixed input registers because this is a call.
   locs->set_in(0, Location::RegisterLocation(EAX));
   locs->set_in(1, Location::RegisterLocation(ECX));
   locs->set_out(Location::RegisterLocation(EAX));
   return locs;
 }
 
 
 void RelationalOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (operands_class_id() == kSmiCid) {
     EmitSmiComparisonOp(compiler, *locs(), kind(), NULL, deopt_id());
     return;
   }
   if (operands_class_id() == kDoubleCid) {
-    EmitDoubleComparisonOp(compiler, *locs(), kind(), NULL, deopt_id());
+    EmitDoubleComparisonOp(compiler, *locs(), kind(), NULL);
     return;
   }
 
   // Push arguments for the call.
   // TODO(fschneider): Split this instruction into different types to avoid
   // explicitly pushing arguments to the call here.
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
   __ pushl(left);
   __ pushl(right);
@@ skipping 36 matching lines @@
 }
 
 
 void RelationalOpComp::EmitBranchCode(FlowGraphCompiler* compiler,
                                       BranchInstr* branch) {
   if (operands_class_id() == kSmiCid) {
     EmitSmiComparisonOp(compiler, *locs(), kind(), branch, deopt_id());
     return;
   }
   if (operands_class_id() == kDoubleCid) {
-    EmitDoubleComparisonOp(compiler, *locs(), kind(), branch, deopt_id());
+    EmitDoubleComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
   EmitNativeCode(compiler);
   __ CompareObject(EAX, compiler->bool_true());
   branch->EmitBranchOnCondition(compiler, EQUAL);
 }
 
 
 LocationSummary* NativeCallComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
@@ skipping 1039 matching lines @@
   explicit BoxDoubleSlowPath(BoxDoubleComp* computation)
       : computation_(computation) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     __ Bind(entry_label());
     const Class& double_class = compiler->double_class();
     const Code& stub =
         Code::Handle(StubCode::GetAllocationStubForClass(double_class));
     const ExternalLabel label(double_class.ToCString(), stub.EntryPoint());
 
-    // TODO(vegorov): here stack map needs to be set up correctly to skip
-    // double registers.
     LocationSummary* locs = computation_->locs();
     locs->live_registers()->Remove(locs->out());
 
     compiler->SaveLiveRegisters(locs);
-    compiler->GenerateCall(computation_->instance_call()->token_pos(),
+    compiler->GenerateCall(computation_->token_pos(),
                            &label,
                            PcDescriptors::kOther,
                            locs);
     if (EAX != locs->out().reg()) __ movl(locs->out().reg(), EAX);
     compiler->RestoreLiveRegisters(locs);
 
     __ jmp(exit_label());
   }
 
  private:
@@ skipping 31 matching lines @@
   return summary;
 }
 
 
 void UnboxDoubleComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   const intptr_t v_cid = value()->ResultCid();
 
   const Register value = locs()->in(0).reg();
   const XmmRegister result = locs()->out().xmm_reg();
   if (v_cid != kDoubleCid) {
-    Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
-                                          kDeoptBinaryDoubleOp);
+    Label* deopt = compiler->AddDeoptStub(deopt_id_, kDeoptBinaryDoubleOp);
     compiler->LoadDoubleOrSmiToXmm(result,
                                    value,
                                    locs()->temp(0).reg(),
                                    deopt);
   } else {
     __ movsd(result, FieldAddress(value, Double::value_offset()));
   }
 }
 
 
@@ skipping 315 matching lines @@
   }
   __ j(ABOVE_EQUAL, deopt);
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64