Cleanup of branch code generation (no change in functionality).

runtime/vm/intermediate_language_mips.cc

 // Copyright (c) 2013, 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_MIPS.
 #if defined(TARGET_ARCH_MIPS)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 109 matching lines @@
     case GT: return LE;
     case GE: return LT;
     default:
       OS::Print("Error: Condition not recognized: %d\n", condition);
       UNIMPLEMENTED();
       return EQ;
   }
 }
 
 
-static bool BindsToSmiConstant(Value* val, intptr_t* smi_value) {
-  if (!val->BindsToConstant()) {
-    return false;
-  }
-
-  const Object& bound_constant = val->BoundConstant();
-  if (!bound_constant.IsSmi()) {
-    return false;
-  }
-
-  *smi_value = Smi::Cast(bound_constant).Value();
-  return true;
-}
-
-
 // Detect pattern when one value is zero and another is a power of 2.
 static bool IsPowerOfTwoKind(intptr_t v1, intptr_t v2) {
   return (Utils::IsPowerOfTwo(v1) && (v2 == 0)) ||
          (Utils::IsPowerOfTwo(v2) && (v1 == 0));
 }
 
 
-bool IfThenElseInstr::Supports(ComparisonInstr* comparison,
-                               Value* v1,
-                               Value* v2) {
-  if (!(comparison->IsStrictCompare() &&
-        !comparison->AsStrictCompare()->needs_number_check()) &&
-      !(comparison->IsEqualityCompare() &&
-        (comparison->AsEqualityCompare()->operation_cid() == kSmiCid))) {
-    return false;
-  }
-
-  intptr_t v1_value, v2_value;
-
-  if (!BindsToSmiConstant(v1, &v1_value) ||
-      !BindsToSmiConstant(v2, &v2_value)) {
-    return false;
-  }
-
-  return true;
-}
-
-
 LocationSummary* IfThenElseInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, Location::RegisterOrConstant(left()));
   locs->set_in(1, Location::RegisterOrConstant(right()));
   locs->set_out(Location::RequiresRegister());
   return locs;
 }
@@ skipping 315 matching lines @@
     case LE: return GE;
     case GT: return LT;
     case GE: return LE;
     default:
       UNREACHABLE();
       return EQ;
   }
 }
 
 
+static void EmitBranchOnValue(FlowGraphCompiler* compiler,
+                              TargetEntryInstr* true_successor,
+                              TargetEntryInstr* false_successor,
+                              bool value) {
+  __ TraceSimMsg("ControlInstruction::EmitBranchOnValue");
+  if (value && !compiler->CanFallThroughTo(true_successor)) {
+    __ b(compiler->GetJumpLabel(true_successor));
+  } else if (!value && !compiler->CanFallThroughTo(false_successor)) {
+    __ b(compiler->GetJumpLabel(false_successor));
+  }
+}
+
+
+// The comparison result is in CMPRES1.
+static void EmitBranchOnCondition(FlowGraphCompiler* compiler,
+                                  TargetEntryInstr* true_successor,
+                                  TargetEntryInstr* false_successor,
+                                  Condition true_condition) {
+  __ TraceSimMsg("ControlInstruction::EmitBranchOnCondition");
+  if (compiler->CanFallThroughTo(false_successor)) {
+    // If the next block is the false successor, fall through to it.
+    Label* label = compiler->GetJumpLabel(true_successor);
+    EmitBranchAfterCompare(compiler, true_condition, label);
+  } else {
+    // If the next block is not the false successor, branch to it.
+    Condition false_condition = NegateCondition(true_condition);
+    Label* label = compiler->GetJumpLabel(false_successor);
+    EmitBranchAfterCompare(compiler, false_condition, label);
+    // Fall through or jump to the true successor.
+    if (!compiler->CanFallThroughTo(true_successor)) {
+      __ b(compiler->GetJumpLabel(true_successor));
+    }
+  }
+}
+
+
 static void EmitSmiComparisonOp(FlowGraphCompiler* compiler,
                                 const LocationSummary& locs,
                                 Token::Kind kind,
                                 BranchInstr* branch) {
   __ TraceSimMsg("EmitSmiComparisonOp");
   __ Comment("EmitSmiComparisonOp");
   Location left = locs.in(0);
   Location right = locs.in(1);
   ASSERT(!left.IsConstant() || !right.IsConstant());
 
   Condition true_condition = TokenKindToSmiCondition(kind);
 
   if (left.IsConstant()) {
     __ CompareObject(CMPRES1, CMPRES2, right.reg(), left.constant());
     true_condition = FlipCondition(true_condition);
   } else if (right.IsConstant()) {
     __ CompareObject(CMPRES1, CMPRES2, left.reg(), right.constant());
   } else {
     __ slt(CMPRES1, left.reg(), right.reg());
     __ slt(CMPRES2, right.reg(), left.reg());
   }
 
   if (branch != NULL) {
-    branch->EmitBranchOnCondition(compiler, true_condition);
+    EmitBranchOnCondition(compiler,
+                          branch->true_successor(),
+                          branch->false_successor(),
+                          true_condition);
   } else {
     Register result = locs.out().reg();
     Label done, is_true;
     EmitBranchAfterCompare(compiler, true_condition, &is_true);
     __ LoadObject(result, Bool::False());
     __ b(&done);
     __ Bind(&is_true);
     __ LoadObject(result, Bool::True());
     __ Bind(&done);
   }
@@ skipping 24 matching lines @@
     case Token::kGT: return GT;
     case Token::kLTE: return LE;
     case Token::kGTE: return GE;
     default:
       UNREACHABLE();
       return VS;
   }
 }
 
 
+static void EmitDoubleCompareBranch(FlowGraphCompiler* compiler,
+                                    Condition true_condition,
+                                    FpuRegister left,
+                                    FpuRegister right,
+                                    BranchInstr* branch) {
+  ASSERT(branch != NULL);
+  __ Comment("DoubleCompareBranch");
+  __ cund(left, right);
+  BlockEntryInstr* nan_result = (true_condition == NE) ?
+      branch->true_successor() : branch->false_successor();
+  __ bc1t(compiler->GetJumpLabel(nan_result));
+
+  switch (true_condition) {
+    case EQ: __ ceqd(left, right); break;
+    case NE: __ ceqd(left, right); break;
+    case LT: __ coltd(left, right); break;
+    case LE: __ coled(left, right); break;
+    case GT: __ coltd(right, left); break;
+    case GE: __ coled(right, left); break;
+    default: {
+      // Should only passing the above conditions to this function.
+      UNREACHABLE();
+      break;
+    }
+  }
+
+  __ LoadImmediate(TMP, 1);
+  if (true_condition == NE) {
+    __ movf(CMPRES1, ZR);
+    __ movt(CMPRES1, TMP);
+  } else {
+    __ movf(CMPRES1, TMP);
+    __ movt(CMPRES1, ZR);
+  }
+  __ mov(CMPRES2, ZR);
+
+  // EmitBranchOnCondition expects ordering to be described by CMPRES1, CMPRES2.
+  EmitBranchOnCondition(compiler,
+                        branch->true_successor(),
+                        branch->false_successor(),
+                        EQ);
+}
+
+
+static void EmitDoubleCompareBool(FlowGraphCompiler* compiler,
+                                  Condition true_condition,
+                                  FpuRegister left,
+                                  FpuRegister right,
+                                  Register result) {
+  Label done, is_true;
+  Label* nan_label = (true_condition == NE) ? &is_true : &done;
+  __ Comment("DoubleCompareBool");
+  __ LoadObject(result, Bool::False());
+  __ cund(left, right);
+  __ bc1t(nan_label);
+
+  switch (true_condition) {
+    case EQ: __ ceqd(left, right); break;
+    case NE: __ ceqd(left, right); break;
+    case LT: __ coltd(left, right); break;
+    case LE: __ coled(left, right); break;
+    case GT: __ coltd(right, left); break;
+    case GE: __ coled(right, left); break;
+    default: {
+      // Should only passing the above conditions to this function.
+      UNREACHABLE();
+      break;
+    }
+  }
+
+  if (true_condition == NE) {
+    __ bc1t(&done);  // False is already in result.
+  } else {
+    __ bc1f(&done);
+  }
+  __ Bind(&is_true);
+  __ LoadObject(result, Bool::True());
+  __ Bind(&done);
+}
+
+
 static void EmitDoubleComparisonOp(FlowGraphCompiler* compiler,
                                    const LocationSummary& locs,
                                    Token::Kind kind,
                                    BranchInstr* branch) {
   DRegister left = locs.in(0).fpu_reg();
   DRegister right = locs.in(1).fpu_reg();
 
   __ Comment("DoubleComparisonOp(left=%d, right=%d)", left, right);
 
   Condition true_condition = TokenKindToDoubleCondition(kind);
   if (branch != NULL) {
-    compiler->EmitDoubleCompareBranch(
-        true_condition, left, right, branch);
+    EmitDoubleCompareBranch(compiler, true_condition, left, right, branch);
   } else {
-    compiler->EmitDoubleCompareBool(
-        true_condition, left, right, locs.out().reg());
+    EmitDoubleCompareBool(compiler, true_condition,
+                          left, right, locs.out().reg());
   }
 }
 
 
 void EqualityCompareInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT((kind() == Token::kNE) || (kind() == Token::kEQ));
   BranchInstr* kNoBranch = NULL;
   __ Comment("EqualityCompareInstr");
   if (operation_cid() == kSmiCid) {
     EmitSmiComparisonOp(compiler, *locs(), kind(), kNoBranch);
@@ skipping 59 matching lines @@
   Location right = locs()->in(1);
   if (right.IsConstant()) {
     ASSERT(right.constant().IsSmi());
     const int32_t imm =
         reinterpret_cast<int32_t>(right.constant().raw());
     __ AndImmediate(CMPRES1, left, imm);
   } else {
     __ and_(CMPRES1, left, right.reg());
   }
   __ mov(CMPRES2, ZR);
-  branch->EmitBranchOnCondition(compiler, branch_condition);
+  EmitBranchOnCondition(compiler,
+                        branch->true_successor(),
+                        branch->false_successor(),
+                        branch_condition);
 }
 
 
 LocationSummary* RelationalOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   if (operation_cid() == kMintCid) {
     const intptr_t kNumTemps = 2;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
@@ skipping 3021 matching lines @@
   }
 
   // We can fall through if the successor is the next block in the list.
   // Otherwise, we need a jump.
   if (!compiler->CanFallThroughTo(successor())) {
     __ b(compiler->GetJumpLabel(successor()));
   }
 }
 
 
-void ControlInstruction::EmitBranchOnValue(FlowGraphCompiler* compiler,
-                                           bool value) {
-  __ TraceSimMsg("ControlInstruction::EmitBranchOnValue");
-  if (value && !compiler->CanFallThroughTo(true_successor())) {
-    __ b(compiler->GetJumpLabel(true_successor()));
-  } else if (!value && !compiler->CanFallThroughTo(false_successor())) {
-    __ b(compiler->GetJumpLabel(false_successor()));
-  }
-}
-
-
-// The comparison result is in CMPRES1.
-void ControlInstruction::EmitBranchOnCondition(FlowGraphCompiler* compiler,
-                                               Condition true_condition) {
-  __ TraceSimMsg("ControlInstruction::EmitBranchOnCondition");
-  if (compiler->CanFallThroughTo(false_successor())) {
-    // If the next block is the false successor, fall through to it.
-    Label* label = compiler->GetJumpLabel(true_successor());
-    EmitBranchAfterCompare(compiler, true_condition, label);
-  } else {
-    // If the next block is not the false successor, branch to it.
-    Condition false_condition = NegateCondition(true_condition);
-    Label* label = compiler->GetJumpLabel(false_successor());
-    EmitBranchAfterCompare(compiler, false_condition, label);
-    // Fall through or jump to the true successor.
-    if (!compiler->CanFallThroughTo(true_successor())) {
-      __ b(compiler->GetJumpLabel(true_successor()));
-    }
-  }
-}
-
-
 LocationSummary* CurrentContextInstr::MakeLocationSummary() const {
   return LocationSummary::Make(0,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void CurrentContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ mov(locs()->out().reg(), CTX);
 }
@@ skipping 63 matching lines @@
                                         BranchInstr* branch) {
   __ TraceSimMsg("StrictCompareInstr::EmitBranchCode");
   ASSERT(kind() == Token::kEQ_STRICT || kind() == Token::kNE_STRICT);
   Location left = locs()->in(0);
   Location right = locs()->in(1);
   if (left.IsConstant() && right.IsConstant()) {
     // TODO(vegorov): should be eliminated earlier by constant propagation.
     const bool result = (kind() == Token::kEQ_STRICT) ?
         left.constant().raw() == right.constant().raw() :
         left.constant().raw() != right.constant().raw();
-    branch->EmitBranchOnValue(compiler, result);
+    EmitBranchOnValue(compiler,
+                      branch->true_successor(),
+                      branch->false_successor(),
+                      result);
     return;
   }
   if (left.IsConstant()) {
     compiler->EmitEqualityRegConstCompare(right.reg(),
                                           left.constant(),
                                           needs_number_check(),
                                           token_pos());
   } else if (right.IsConstant()) {
     compiler->EmitEqualityRegConstCompare(left.reg(),
                                           right.constant(),
                                           needs_number_check(),
                                           token_pos());
   } else {
     compiler->EmitEqualityRegRegCompare(left.reg(),
                                         right.reg(),
                                         needs_number_check(),
                                         token_pos());
   }
 
   Condition true_condition = (kind() == Token::kEQ_STRICT) ? EQ : NE;
-  branch->EmitBranchOnCondition(compiler, true_condition);
+  EmitBranchOnCondition(compiler,
+                        branch->true_successor(),
+                        branch->false_successor(),
+                        true_condition);
 }
 
 
 LocationSummary* BooleanNegateInstr::MakeLocationSummary() const {
   return LocationSummary::Make(1,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
@@ skipping 67 matching lines @@
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS