Remove support for non-ssa optimizing code generation.

runtime/vm/intermediate_language_x64.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_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 15 matching lines @@
 // on the stack and return the result in a fixed register RAX.
 LocationSummary* Computation::MakeCallSummary() {
   LocationSummary* result = new LocationSummary(0, 0, LocationSummary::kCall);
   result->set_out(Location::RegisterLocation(RAX));
   return result;
 }
 
 
 void BindInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   computation()->EmitNativeCode(compiler);
-  if (is_used() && locs()->out().IsRegister()) {
-    // TODO(vegorov): this should really happen only for comparisons fused
-    // with branches.  Currrently IR does not provide an easy way to remove
-    // instructions from the graph so we just leave fused comparison in it
-    // but change its result location to be NoLocation.
-    compiler->frame_register_allocator()->Push(locs()->out().reg(), this);
+  if (is_used() && !compiler->is_optimizing()) {
+    __ pushq(locs()->out().reg());
   }
 }
 
 
 LocationSummary* ReturnInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, Location::RegisterLocation(RAX));
@@ skipping 405 matching lines @@
                                    BranchInstr* branch,
                                    intptr_t deopt_id,
                                    intptr_t token_pos,
                                    intptr_t try_index) {
   ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
   Register left = locs.in(0).reg();
   Register right = locs.in(1).reg();
   Register temp = locs.temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id,
                                         try_index,
-                                        kDeoptEquality,
-                                        left,
-                                        right);
+                                        kDeoptEquality);
   __ testq(left, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);
   // 'left' is not Smi.
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label identity_compare;
   __ cmpq(right, raw_null);
   __ j(EQUAL, &identity_compare);
   __ cmpq(left, raw_null);
   __ j(EQUAL, &identity_compare);
@@ skipping 86 matching lines @@
   Register left = locs.in(0).reg();
   Register right = locs.in(1).reg();
   const bool left_is_smi = (branch == NULL) ?
       false : (branch->left()->ResultCid() == kSmiCid);
   const bool right_is_smi = (branch == NULL) ?
       false : (branch->right()->ResultCid() == kSmiCid);
   if (!left_is_smi || !right_is_smi) {
     Register temp = locs.temp(0).reg();
     Label* deopt = compiler->AddDeoptStub(deopt_id,
                                           try_index,
-                                          kDeoptSmiCompareSmi,
-                                          left,
-                                          right);
+                                          kDeoptSmiCompareSmi);
     __ movq(temp, left);
     __ orq(temp, right);
     __ testq(temp, Immediate(kSmiTagMask));
     __ j(NOT_ZERO, deopt);
   }
 
   Condition true_condition = TokenKindToSmiCondition(kind);
   __ cmpq(left, right);
 
   if (branch != NULL) {
@@ skipping 32 matching lines @@
                                    BranchInstr* branch,
                                    intptr_t deopt_id,
                                    intptr_t token_pos,
                                    intptr_t try_index) {
   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,
                                         try_index,
-                                        kDeoptDoubleComparison,
-                                        left,
-                                        right);
+                                        kDeoptDoubleComparison);
   compiler->LoadDoubleOrSmiToXmm(XMM0, left, temp, deopt);
   compiler->LoadDoubleOrSmiToXmm(XMM1, right, temp, deopt);
 
   Condition true_condition = TokenKindToDoubleCondition(kind);
   if (branch != NULL) {
     compiler->EmitDoubleCompareBranch(
         true_condition, XMM0, XMM1, branch);
   } else {
     compiler->EmitDoubleCompareBool(
         true_condition, XMM0, XMM1, locs.out().reg());
@@ skipping 200 matching lines @@
   Register receiver = locs()->in(0).reg();
   Register index = locs()->in(1).reg();
   Register result = locs()->out().reg();
 
   const DeoptReasonId deopt_reason =
       (receiver_type() == kGrowableObjectArrayCid) ?
       kDeoptLoadIndexedGrowableArray : kDeoptLoadIndexedFixedArray;
 
   Label* deopt = compiler->AddDeoptStub(original()->deopt_id(),
                                         original()->try_index(),
-                                        deopt_reason,
-                                        receiver,
-                                        index);
+                                        deopt_reason);
 
   __ testq(receiver, Immediate(kSmiTagMask));  // Deoptimize if Smi.
   __ j(ZERO, deopt);
   __ CompareClassId(receiver, receiver_type());
   __ j(NOT_EQUAL, deopt);
 
   __ testq(index, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
 
   switch (receiver_type()) {
@@ skipping 47 matching lines @@
 }
 
 
 void StoreIndexedComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register receiver = locs()->in(0).reg();
   Register index = locs()->in(1).reg();
   Register value = locs()->in(2).reg();
 
   Label* deopt = compiler->AddDeoptStub(original()->deopt_id(),
                                         original()->try_index(),
-                                        kDeoptStoreIndexed,
-                                        receiver,
-                                        index,
-                                        value);
+                                        kDeoptStoreIndexed);
 
   __ testq(receiver, Immediate(kSmiTagMask));  // Deoptimize if Smi.
   __ j(ZERO, deopt);
   __ CompareClassId(receiver, receiver_type());
   __ j(NOT_EQUAL, deopt);
 
   __ testq(index, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
 
   switch (receiver_type()) {
@@ skipping 41 matching lines @@
 
 
 void LoadInstanceFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register instance_reg = locs()->in(0).reg();
   Register result_reg = locs()->out().reg();
 
   if (HasICData()) {
     ASSERT(original() != NULL);
     Label* deopt = compiler->AddDeoptStub(original()->deopt_id(),
                                           original()->try_index(),
-                                          kDeoptInstanceGetterSameTarget,
-                                          instance_reg);
+                                          kDeoptInstanceGetterSameTarget);
     // Smis do not have instance fields (Smi class is always first).
     // Use 'result' as temporary register.
     ASSERT(result_reg != instance_reg);
     ASSERT(ic_data() != NULL);
     compiler->EmitClassChecksNoSmi(*ic_data(), instance_reg, result_reg, deopt);
   }
   __ movq(result_reg, FieldAddress(instance_reg, field().Offset()));
 }
 
 
@@ skipping 113 matching lines @@
 }
 
 
 void LoadVMFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register instance_reg = locs()->in(0).reg();
   Register result_reg = locs()->out().reg();
   if (HasICData()) {
     ASSERT(original() != NULL);
     Label* deopt = compiler->AddDeoptStub(original()->deopt_id(),
                                           original()->try_index(),
-                                          kDeoptInstanceGetterSameTarget,
-                                          instance_reg);
+                                          kDeoptInstanceGetterSameTarget);
     // Smis do not have instance fields (Smi class is always first).
     // Use 'result' as temporary register.
     ASSERT(result_reg != instance_reg);
     ASSERT(ic_data() != NULL);
     compiler->EmitClassChecksNoSmi(*ic_data(), instance_reg, result_reg, deopt);
   }
 
   __ movq(result_reg, FieldAddress(instance_reg, offset_in_bytes()));
 }
 
@@ skipping 387 matching lines @@
     case Token::kBIT_XOR:
       can_deopt = !(right_is_smi && left_is_smi);
       break;
     default:
       can_deopt = true;
   }
   Label* deopt = NULL;
   if (can_deopt) {
     deopt = compiler->AddDeoptStub(comp->instance_call()->deopt_id(),
                                    comp->instance_call()->try_index(),
-                                   kDeoptSmiBinaryOp,
-                                   temp,
-                                   right);
+                                   kDeoptSmiBinaryOp);
   }
   if (left_is_smi && right_is_smi) {
     if (can_deopt) {
       // Preserve left for deopt.
       __ movq(temp, left);
     }
   } else {
     // TODO(vegorov): for many binary operations this pattern can be rearranged
     // to save one move.
     __ movq(temp, left);
@@ skipping 143 matching lines @@
   // receiver and a Mint or Smi argument. We fall back to the run time call if
   // both receiver and argument are Mint or if one of them is Mint and the other
   // is a negative Smi.
   Register left = comp->locs()->in(0).reg();
   Register right = comp->locs()->in(1).reg();
   Register result = comp->locs()->out().reg();
   ASSERT(left == result);
   ASSERT(comp->op_kind() == Token::kBIT_AND);
   Label* deopt = compiler->AddDeoptStub(comp->instance_call()->deopt_id(),
                                         comp->instance_call()->try_index(),
-                                        kDeoptMintBinaryOp,
-                                        left,
-                                        right);
+                                        kDeoptMintBinaryOp);
   Label mint_static_call, smi_static_call, non_smi, smi_smi, done;
   __ testq(left, Immediate(kSmiTagMask));  // Is receiver Smi?
   __ j(NOT_ZERO, &non_smi);
   __ testq(right, Immediate(kSmiTagMask));  // Is argument Smi?
   __ j(ZERO, &smi_smi);
   __ CompareClassId(right, kMintCid);  // Is argument Mint?
   __ j(NOT_EQUAL, deopt);  // Argument neither Smi nor Mint.
   __ cmpq(left, Immediate(0));
   __ j(LESS, &smi_static_call);  // Negative Smi receiver, Mint argument.
 
@@ skipping 153 matching lines @@
   ASSERT(ic_data.NumberOfChecks() == 1);
   intptr_t test_class_id;
   Function& target = Function::Handle();
   ic_data.GetOneClassCheckAt(0, &test_class_id, &target);
 
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
   ASSERT(value == result);
   Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
                                         instance_call()->try_index(),
-                                        kDeoptUnaryOp,
-                                        value);
+                                        kDeoptUnaryOp);
   if (test_class_id == kSmiCid) {
     __ testq(value, Immediate(kSmiTagMask));
     __ j(NOT_ZERO, deopt);
     switch (op_kind()) {
       case Token::kNEGATE:
         __ negq(value);
         __ j(OVERFLOW, deopt);
         break;
       case Token::kBIT_NOT:
         __ notq(value);
@@ skipping 29 matching lines @@
   ASSERT(ic_data.NumberOfChecks() == 1);
   intptr_t test_class_id;
   Function& target = Function::Handle();
   ic_data.GetOneClassCheckAt(0, &test_class_id, &target);
 
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
   ASSERT(value == result);
   Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
                                         instance_call()->try_index(),
-                                        kDeoptUnaryOp,
-                                        value);
+                                        kDeoptUnaryOp);
   if (test_class_id == kDoubleCid) {
     Register temp = locs()->temp(0).reg();
     __ testq(value, Immediate(kSmiTagMask));
     __ j(ZERO, deopt);  // Smi.
     __ CompareClassId(value, kDoubleCid);
     __ j(NOT_EQUAL, deopt);
     // Allocate result object.
     const Class& double_class = compiler->double_class();
     const Code& stub =
         Code::Handle(StubCode::GetAllocationStubForClass(double_class));
@@ skipping 28 matching lines @@
   return locs;
 }
 
 
 void DoubleToDoubleComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
                                         instance_call()->try_index(),
-                                        kDeoptDoubleToDouble,
-                                        value);
+                                        kDeoptDoubleToDouble);
 
   __ testq(value, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);  // Deoptimize if Smi.
   __ CompareClassId(value, kDoubleCid);
   __ j(NOT_EQUAL, deopt);  // Deoptimize if not Double.
   ASSERT(value == result);
 }
 
 
 LocationSummary* SmiToDoubleComp::MakeLocationSummary() const {
@@ skipping 231 matching lines @@
   summary->set_temp(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void CheckClassComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                         try_index(),
-                                        kDeoptCheckClass,
-                                        value);
+                                        kDeoptCheckClass);
   ASSERT(ic_data()->GetReceiverClassIdAt(0) != kSmiCid);
   __ testq(value, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);
   __ LoadClassId(temp, value);
   Label is_ok;
   const intptr_t num_checks = ic_data()->NumberOfChecks();
   const bool use_near_jump = num_checks < 5;
   for (intptr_t i = 0; i < num_checks; i++) {
     __ cmpl(temp, Immediate(ic_data()->GetReceiverClassIdAt(i)));
     if (i == (num_checks - 1)) {
       __ j(NOT_EQUAL, deopt);
     } else {
       if (use_near_jump) {
         __ j(EQUAL, &is_ok, Assembler::kNearJump);
       } else {
         __ j(EQUAL, &is_ok);
       }
     }
   }
   __ Bind(&is_ok);
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64