Revert "Reduce copying, redundancy & repetition for codegen of comparison instructions"

runtime/vm/intermediate_language_dbc.cc

 // Copyright (c) 2016, 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_DBC.
 #if defined(TARGET_ARCH_DBC)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/cpu.h"
@@ skipping 465 matching lines @@
     if (labels.fall_through != labels.true_label) {
       // The preceeding Jump instruction will be skipped if the test succeeds.
       // If we aren't falling through to the true case, then we have to do
       // a Jump to it here.
       __ Jump(labels.true_label);
     }
   }
 }
 
 
-Condition StrictCompareInstr::GetNextInstructionCondition(
-    FlowGraphCompiler* compiler,
-    BranchLabels labels) {
-  return (labels.fall_through == labels.false_label) ? NEXT_IS_TRUE
-                                                     : NEXT_IS_FALSE;
-}
-
-
 Condition StrictCompareInstr::EmitComparisonCode(FlowGraphCompiler* compiler,
                                                  BranchLabels labels) {
   ASSERT((kind() == Token::kNE_STRICT) || (kind() == Token::kEQ_STRICT));
 
   Token::Kind comparison;
   Condition condition;
   if (labels.fall_through == labels.false_label) {
     condition = NEXT_IS_TRUE;
     comparison = kind();
   } else {
@@ skipping 23 matching lines @@
   if (needs_number_check() && token_pos().IsReal()) {
     compiler->RecordSafepoint(locs());
     compiler->AddCurrentDescriptor(RawPcDescriptors::kRuntimeCall, deopt_id_,
                                    token_pos());
   }
 
   return condition;
 }
 
 
-DEFINE_MAKE_LOCATION_SUMMARY(StrictCompare,
-                             2,
-                             Location::RequiresRegister(),
-                             needs_number_check() ? LocationSummary::kCall
-                                                  : LocationSummary::kNoCall)
+void StrictCompareInstr::EmitBranchCode(FlowGraphCompiler* compiler,
+                                        BranchInstr* branch) {
+  ASSERT((kind() == Token::kEQ_STRICT) || (kind() == Token::kNE_STRICT));
 
-
-void ComparisonInstr::EmitBranchCode(FlowGraphCompiler* compiler,
-                                     BranchInstr* branch) {
   BranchLabels labels = compiler->CreateBranchLabels(branch);
   Condition true_condition = EmitComparisonCode(compiler, labels);
-  if (true_condition != INVALID_CONDITION) {
-    EmitBranchOnCondition(compiler, true_condition, labels);
-  }
+  EmitBranchOnCondition(compiler, true_condition, labels);
 }
 
 
-void ComparisonInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+EMIT_NATIVE_CODE(StrictCompare,
+                 2,
+                 Location::RequiresRegister(),
+                 needs_number_check() ? LocationSummary::kCall
+                                      : LocationSummary::kNoCall) {
+  ASSERT((kind() == Token::kEQ_STRICT) || (kind() == Token::kNE_STRICT));
+
   Label is_true, is_false;
   BranchLabels labels = {&is_true, &is_false, &is_false};
-  Condition true_condition =
-      this->GetNextInstructionCondition(compiler, labels);
-  if (true_condition == INVALID_CONDITION || !compiler->is_optimizing() ||
-      is_true.IsLinked() || is_false.IsLinked()) {
-    Condition actual_condition = EmitComparisonCode(compiler, labels);
-    ASSERT(actual_condition == true_condition);
-    if (true_condition != INVALID_CONDITION) {
-      EmitBranchOnCondition(compiler, true_condition, labels);
-    }
-    Label done;
+  Condition true_condition = EmitComparisonCode(compiler, labels);
+  EmitBranchOnCondition(compiler, true_condition, labels);
+  Label done;
+  if (compiler->is_optimizing()) {
+    const Register result = locs()->out(0).reg();
+    __ Bind(&is_false);
+    __ LoadConstant(result, Bool::False());
+    __ Jump(&done);
+    __ Bind(&is_true);
+    __ LoadConstant(result, Bool::True());
+    __ Bind(&done);
+  } else {
     __ Bind(&is_false);
     __ PushConstant(Bool::False());
     __ Jump(&done);
     __ Bind(&is_true);
     __ PushConstant(Bool::True());
     __ Bind(&done);
-  } else {
-    const Register result = this->locs()->out(0).reg();
-    __ LoadConstant(
-        result, true_condition == NEXT_IS_TRUE ? Bool::False() : Bool::True());
-    Condition actual_condition = EmitComparisonCode(compiler, labels);
-    ASSERT(actual_condition == true_condition);
-    __ LoadConstant(
-        result, true_condition == NEXT_IS_TRUE ? Bool::True() : Bool::False());
   }
 }
 
 
 LocationSummary* BranchInstr::MakeLocationSummary(Zone* zone, bool opt) const {
   comparison()->InitializeLocationSummary(zone, opt);
   if (!comparison()->HasLocs()) {
     return NULL;
   }
   // Branches don't produce a result.
@@ skipping 18 matching lines @@
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
   // We can fall through if the successor is the next block in the list.
   // Otherwise, we need a jump.
   if (!compiler->CanFallThroughTo(successor())) {
     __ Jump(compiler->GetJumpLabel(successor()));
   }
 }
 
 
-Condition TestSmiInstr::GetNextInstructionCondition(FlowGraphCompiler* compiler,
-                                                    BranchLabels labels) {
-  ASSERT((kind() == Token::kEQ) || (kind() == Token::kNE));
-  return (kind() == Token::kEQ) ? NEXT_IS_TRUE : NEXT_IS_FALSE;
-}
-
-
 Condition TestSmiInstr::EmitComparisonCode(FlowGraphCompiler* compiler,
                                            BranchLabels labels) {
   ASSERT((kind() == Token::kEQ) || (kind() == Token::kNE));
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
   __ TestSmi(left, right);
   return (kind() == Token::kEQ) ? NEXT_IS_TRUE : NEXT_IS_FALSE;
 }
 
 
-DEFINE_MAKE_LOCATION_SUMMARY(TestSmi,
-                             2,
-                             Location::RequiresRegister(),
-                             LocationSummary::kNoCall)
+void TestSmiInstr::EmitBranchCode(FlowGraphCompiler* compiler,
+                                  BranchInstr* branch) {
+  BranchLabels labels = compiler->CreateBranchLabels(branch);
+  Condition true_condition = EmitComparisonCode(compiler, labels);
+  EmitBranchOnCondition(compiler, true_condition, labels);
+}
+
+
+EMIT_NATIVE_CODE(TestSmi,
+                 2,
+                 Location::RequiresRegister(),
+                 LocationSummary::kNoCall) {
+  // Never emitted outside of the BranchInstr.
+  UNREACHABLE();
+}
 
 
 Condition TestCidsInstr::EmitComparisonCode(FlowGraphCompiler* compiler,
                                             BranchLabels labels) {
   ASSERT((kind() == Token::kIS) || (kind() == Token::kISNOT));
   const Register value = locs()->in(0).reg();
   const intptr_t true_result = (kind() == Token::kIS) ? 1 : 0;
 
   const ZoneGrowableArray<intptr_t>& data = cid_results();
   const intptr_t num_cases = data.length() / 2;
@@ skipping 16 matching lines @@
     // that are in the list.  These must be all the same (see asserts in the
     // constructor).
     Label* target = result ? labels.false_label : labels.true_label;
     __ Jump(target);
   }
 
   return NEXT_IS_TRUE;
 }
 
 
-Condition TestCidsInstr::GetNextInstructionCondition(
-    FlowGraphCompiler* compiler,
-    BranchLabels labels) {
-  return NEXT_IS_TRUE;
+void TestCidsInstr::EmitBranchCode(FlowGraphCompiler* compiler,
+                                   BranchInstr* branch) {
+  BranchLabels labels = compiler->CreateBranchLabels(branch);
+  Condition true_condition = EmitComparisonCode(compiler, labels);
+  EmitBranchOnCondition(compiler, true_condition, labels);
 }
 
 
-DEFINE_MAKE_LOCATION_SUMMARY(TestCids,
-                             1,
-                             Location::RequiresRegister(),
-                             LocationSummary::kNoCall)
+EMIT_NATIVE_CODE(TestCids,
+                 1,
+                 Location::RequiresRegister(),
+                 LocationSummary::kNoCall) {
+  Register result_reg = locs()->out(0).reg();
+  Label is_true, is_false, done;
+  BranchLabels labels = {&is_true, &is_false, &is_false};
+  EmitComparisonCode(compiler, labels);
+  __ Jump(&is_true);
+  __ Bind(&is_false);
+  __ LoadConstant(result_reg, Bool::False());
+  __ Jump(&done);
+  __ Bind(&is_true);
+  __ LoadConstant(result_reg, Bool::True());
+  __ Bind(&done);
+}
 
 
 EMIT_NATIVE_CODE(CreateArray,
                  2,
                  Location::RequiresRegister(),
                  LocationSummary::kCall) {
   if (compiler->is_optimizing()) {
     const Register length = locs()->in(kLengthPos).reg();
     const Register type_arguments = locs()->in(kElementTypePos).reg();
     const Register out = locs()->out(0).reg();
@@ skipping 1047 matching lines @@
       __ DDiv(result, left, right);
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
 Condition DoubleTestOpInstr::EmitComparisonCode(FlowGraphCompiler* compiler,
                                                 BranchLabels labels) {
+  UNREACHABLE();
+  return Condition();
+}
+
+
+void DoubleTestOpInstr::EmitBranchCode(FlowGraphCompiler* compiler,
+                                       BranchInstr* branch) {
   ASSERT(compiler->is_optimizing());
+  BranchLabels labels = compiler->CreateBranchLabels(branch);
   const Register value = locs()->in(0).reg();
   switch (op_kind()) {
     case MethodRecognizer::kDouble_getIsNaN:
       __ DoubleIsNaN(value);
       break;
     case MethodRecognizer::kDouble_getIsInfinite:
       __ DoubleIsInfinite(value);
       break;
     default:
       UNREACHABLE();
   }
   const bool is_negated = kind() != Token::kEQ;
-  return is_negated ? NEXT_IS_FALSE : NEXT_IS_TRUE;
+  EmitBranchOnCondition(compiler, is_negated ? NEXT_IS_FALSE : NEXT_IS_TRUE,
+                        labels);
 }
 
 
-Condition DoubleTestOpInstr::GetNextInstructionCondition(
-    FlowGraphCompiler* compiler,
-    BranchLabels labels) {
+EMIT_NATIVE_CODE(DoubleTestOp, 1, Location::RequiresRegister()) {
+  ASSERT(compiler->is_optimizing());
+  const Register value = locs()->in(0).reg();
+  const Register result = locs()->out(0).reg();
   const bool is_negated = kind() != Token::kEQ;
-  return is_negated ? NEXT_IS_FALSE : NEXT_IS_TRUE;
+  __ LoadConstant(result, is_negated ? Bool::True() : Bool::False());
+  switch (op_kind()) {
+    case MethodRecognizer::kDouble_getIsNaN:
+      __ DoubleIsNaN(value);
+      break;
+    case MethodRecognizer::kDouble_getIsInfinite:
+      __ DoubleIsInfinite(value);
+      break;
+    default:
+      UNREACHABLE();
+  }
+  __ LoadConstant(result, is_negated ? Bool::False() : Bool::True());
 }
 
 
-DEFINE_MAKE_LOCATION_SUMMARY(DoubleTestOp, 1, Location::RequiresRegister())
-
-
 EMIT_NATIVE_CODE(UnaryDoubleOp, 1, Location::RequiresRegister()) {
   const Register value = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
   __ DNeg(result, value);
 }
 
 
 EMIT_NATIVE_CODE(MathUnary, 1, Location::RequiresRegister()) {
   const Register value = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
@@ skipping 154 matching lines @@
                                      Token::Kind kind,
                                      BranchLabels labels) {
   const Register left = locs->in(0).reg();
   const Register right = locs->in(1).reg();
   Token::Kind comparison = kind;
   Condition condition = NEXT_IS_TRUE;
   if (labels.fall_through != labels.false_label) {
     // If we aren't falling through to the false label, we can save a Jump
     // instruction in the case that the true case is the fall through by
     // flipping the sense of the test such that the instruction following the
-    // test is the Jump to the false label.  In the case where both labels are
-    // null we don't flip the sense of the test.
+    // test is the Jump to the false label.
     condition = NEXT_IS_FALSE;
     comparison = FlipCondition(kind);
   }
   __ Emit(Bytecode::Encode(OpcodeForSmiCondition(comparison), left, right));
   return condition;
 }
 
 
 static Condition EmitDoubleComparisonOp(FlowGraphCompiler* compiler,
                                         LocationSummary* locs,
@@ skipping 16 matching lines @@
                                                    BranchLabels labels) {
   if (operation_cid() == kSmiCid) {
     return EmitSmiComparisonOp(compiler, locs(), kind(), labels);
   } else {
     ASSERT(operation_cid() == kDoubleCid);
     return EmitDoubleComparisonOp(compiler, locs(), kind());
   }
 }
 
 
-Condition EqualityCompareInstr::GetNextInstructionCondition(
-    FlowGraphCompiler* compiler,
-    BranchLabels labels) {
-  if (operation_cid() == kSmiCid) {
-    return (labels.fall_through != labels.false_label) ? NEXT_IS_FALSE
-                                                       : NEXT_IS_TRUE;
-  } else {
-    ASSERT(operation_cid() == kDoubleCid);
-    return NEXT_IS_TRUE;
-  }
+EMIT_NATIVE_CODE(EqualityCompare, 2, Location::RequiresRegister()) {
+  ASSERT(compiler->is_optimizing());
+  ASSERT((kind() == Token::kEQ) || (kind() == Token::kNE));
+  Label is_true, is_false;
+  // These labels are not used. They are arranged so that EmitComparisonCode
+  // emits a test that executes the following instruction when the test
+  // succeeds.
+  BranchLabels labels = {&is_true, &is_false, &is_false};
+  const Register result = locs()->out(0).reg();
+  __ LoadConstant(result, Bool::False());
+  Condition true_condition = EmitComparisonCode(compiler, labels);
+  ASSERT(true_condition == NEXT_IS_TRUE);
+  __ LoadConstant(result, Bool::True());
 }
 
 
-DEFINE_MAKE_LOCATION_SUMMARY(EqualityCompare, 2, Location::RequiresRegister());
+void EqualityCompareInstr::EmitBranchCode(FlowGraphCompiler* compiler,
+                                          BranchInstr* branch) {
+  ASSERT((kind() == Token::kNE) || (kind() == Token::kEQ));
+  BranchLabels labels = compiler->CreateBranchLabels(branch);
+  Condition true_condition = EmitComparisonCode(compiler, labels);
+  EmitBranchOnCondition(compiler, true_condition, labels);
+}
 
 
 Condition RelationalOpInstr::EmitComparisonCode(FlowGraphCompiler* compiler,
                                                 BranchLabels labels) {
   if (operation_cid() == kSmiCid) {
     return EmitSmiComparisonOp(compiler, locs(), kind(), labels);
   } else {
     ASSERT(operation_cid() == kDoubleCid);
     return EmitDoubleComparisonOp(compiler, locs(), kind());
   }
 }
 
 
-Condition RelationalOpInstr::GetNextInstructionCondition(
-    FlowGraphCompiler* compiler,
-    BranchLabels labels) {
-  if (operation_cid() == kSmiCid) {
-    return (labels.fall_through != labels.false_label) ? NEXT_IS_FALSE
-                                                       : NEXT_IS_TRUE;
-  } else {
-    ASSERT(operation_cid() == kDoubleCid);
-    return NEXT_IS_TRUE;
-  }
+EMIT_NATIVE_CODE(RelationalOp, 2, Location::RequiresRegister()) {
+  ASSERT(compiler->is_optimizing());
+  Label is_true, is_false;
+  BranchLabels labels = {&is_true, &is_false, &is_false};
+  const Register result = locs()->out(0).reg();
+  __ LoadConstant(result, Bool::False());
+  Condition true_condition = EmitComparisonCode(compiler, labels);
+  ASSERT(true_condition == NEXT_IS_TRUE);
+  __ LoadConstant(result, Bool::True());
 }
 
 
-DEFINE_MAKE_LOCATION_SUMMARY(RelationalOp, 2, Location::RequiresRegister())
+void RelationalOpInstr::EmitBranchCode(FlowGraphCompiler* compiler,
+                                       BranchInstr* branch) {
+  BranchLabels labels = compiler->CreateBranchLabels(branch);
+  Condition true_condition = EmitComparisonCode(compiler, labels);
+  EmitBranchOnCondition(compiler, true_condition, labels);
+}
 
 
 EMIT_NATIVE_CODE(CheckArrayBound, 2) {
   const Register length = locs()->in(kLengthPos).reg();
   const Register index = locs()->in(kIndexPos).reg();
   const intptr_t index_cid = this->index()->Type()->ToCid();
   if (index_cid != kSmiCid) {
     __ CheckSmi(index);
     compiler->EmitDeopt(deopt_id(), ICData::kDeoptCheckArrayBound,
                         (generalized_ ? ICData::kGeneralized : 0) |
                             (licm_hoisted_ ? ICData::kHoisted : 0));
   }
   __ IfULe(length, index);
   compiler->EmitDeopt(deopt_id(), ICData::kDeoptCheckArrayBound,
                       (generalized_ ? ICData::kGeneralized : 0) |
                           (licm_hoisted_ ? ICData::kHoisted : 0));
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC