Add support for XMM registers in SSA code generation pipeline.

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 1766 matching lines @@
     case Token::kDIV: __ divsd(XMM0, XMM1); break;
     default: UNREACHABLE();
   }
 
   __ movsd(FieldAddress(result, Double::value_offset()), XMM0);
 
   __ Drop(2);
 }
 
 
+LocationSummary* CheckEitherNonSmiComp::MakeLocationSummary() const {
+  if (left()->ResultCid() == kDoubleCid || right()->ResultCid() == kDoubleCid) {
+    const intptr_t kNumInputs = 2;
+    const intptr_t kNumTemps = 0;
+    LocationSummary* summary =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
+    summary->set_in(0, Location::Any());
+    summary->set_in(1, Location::Any());
+    return summary;
+  } else {
+    const intptr_t kNumInputs = 2;
+    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_temp(0, Location::RequiresRegister());
+    return summary;
+  }
+}
+
+
+void CheckEitherNonSmiComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+  if (left()->ResultCid() == kDoubleCid || right()->ResultCid() == kDoubleCid) {

[Florian Schneider, 2012/08/24 11:09:28]

I'd rather eliminate the check by overriding Computation::TryReplace.

[Vyacheslav Egorov (Google), 2012/08/24 13:23:01]

Done.

+    return;
+  }
+
+  Label* deopt = compiler->AddDeoptStub(deopt_id(),
+                                        try_index(),
+                                        kDeoptBinaryDoubleOp);
+
+  Register temp = locs()->temp(0).reg();
+  __ movl(temp, locs()->in(0).reg());
+  __ orl(temp, locs()->in(1).reg());
+  __ testl(temp, Immediate(kSmiTagMask));
+  __ j(ZERO, deopt);
+}
+
+
+LocationSummary* BoxDoubleComp::MakeLocationSummary() const {
+  const intptr_t kNumInputs = 1;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* summary =
+      new LocationSummary(kNumInputs,
+                          kNumTemps,
+                          LocationSummary::kCallOnSlowPath);
+  summary->set_in(0, Location::RequiresXmmRegister());
+  summary->set_out(Location::RequiresRegister());
+  return summary;
+}
+
+
+class BoxDoubleSlowPath : public SlowPathCode {
+ public:
+  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(),
+                           computation_->instance_call()->try_index(),
+                           &label,
+                           PcDescriptors::kOther,
+                           computation_->locs()->stack_bitmap());
+    if (EAX != locs->out().reg()) {
+      __ movl(locs->out().reg(), EAX);
+    }
+    compiler->RestoreLiveRegisters(locs);

[Florian Schneider, 2012/08/24 11:09:28]

This only works if the output register is not live here.

Maybe ASSERT(!locs->live_registers->Contain(locs->out().reg()));

Or change the order of restore and assert that EAX is not in the live registers.

[Vyacheslav Egorov (Google), 2012/08/24 13:23:01]

locs->live_registers()->Remove(locs->out()); <- this line takes care of correct
restoration, see above

+
+    // TODO(vegorov): wrong order of save restore if EAX is live across this

[Florian Schneider, 2012/08/24 11:09:28]

How can that happen?

[Vyacheslav Egorov (Google), 2012/08/24 13:23:01]

This comment is left over from before it was fixed.

+    // code.
+    __ jmp(exit_label());
+  }
+
+ private:
+  BoxDoubleComp* computation_;
+};
+
+
+void BoxDoubleComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+  BoxDoubleSlowPath* slow_path = new BoxDoubleSlowPath(this);
+  compiler->AddSlowPathCode(slow_path);
+
+  Register out_reg = locs()->out().reg();
+  XmmRegister value = locs()->in(0).xmm_reg();
+
+  AssemblerMacros::TryAllocate(compiler->assembler(),
+                               compiler->double_class(),
+                               slow_path->entry_label(),
+                               Assembler::kFarJump,
+                               out_reg);
+  __ Bind(slow_path->exit_label());
+  __ movsd(FieldAddress(out_reg, Double::value_offset()), value);
+}
+
+
+LocationSummary* UnboxDoubleComp::MakeLocationSummary() const {
+  const intptr_t v_cid = value()->ResultCid();
+
+  const intptr_t kNumInputs = 1;
+  const intptr_t kNumTemps = (v_cid != kDoubleCid) ? 1 : 0;
+  LocationSummary* summary =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  summary->set_in(0, Location::RequiresRegister());
+  if (v_cid != kDoubleCid) summary->set_temp(0, Location::RequiresRegister());
+  summary->set_out(Location::RequiresXmmRegister());
+  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(),
+                                          instance_call()->try_index(),
+                                          kDeoptBinaryDoubleOp);
+    compiler->LoadDoubleOrSmiToXmm(result,
+                                   value,
+                                   locs()->temp(0).reg(),
+                                   deopt);
+  } else {
+    __ movsd(result, FieldAddress(value, Double::value_offset()));
+  }
+}
+
+
+LocationSummary* UnboxedDoubleBinaryOpComp::MakeLocationSummary() const {
+  const intptr_t kNumInputs = 2;
+  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::SameAsFirstInput());
+  return summary;
+}
+
+
+void UnboxedDoubleBinaryOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+  XmmRegister left = locs()->in(0).xmm_reg();
+  XmmRegister right = locs()->in(1).xmm_reg();
+
+  ASSERT(locs()->out().xmm_reg() == left);
+
+  switch (op_kind()) {
+    case Token::kADD: __ addsd(left, right); break;
+    case Token::kSUB: __ subsd(left, right); break;
+    case Token::kMUL: __ mulsd(left, right); break;
+    case Token::kDIV: __ divsd(left, right); break;
+    default: UNREACHABLE();
+  }
+}
+
+
 LocationSummary* UnarySmiOpComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   summary->set_out(Location::SameAsFirstInput());
   return summary;
 }
 
@@ skipping 393 matching lines @@
     }
   }
   __ Bind(&is_ok);
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64