Version 1.1.0-dev.5.2

dart/runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
@@ skipping 1437 matching lines @@
         value()->Type()->IsAssignableTo(dst_type())) {
       return value()->definition();
     }
     ConstantInstr* null_constant = flow_graph->constant_null();
     instantiator_type_arguments()->BindTo(null_constant);
   }
   return this;
 }
 
 
+LocationSummary* DebugStepCheckInstr::MakeLocationSummary(bool opt) const {
+  const intptr_t kNumInputs = 0;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
+  return locs;
+}
+
+
+void DebugStepCheckInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  ASSERT(!compiler->is_optimizing());
+  const ExternalLabel label("debug_step_check",
+                            StubCode::DebugStepCheckEntryPoint());
+  compiler->GenerateCall(token_pos(),
+                         &label,
+                         PcDescriptors::kReturn,
+                         locs());
+}
+
+
+Instruction* DebugStepCheckInstr::Canonicalize(FlowGraph* flow_graph) {
+  return NULL;
+}
+
+
 Definition* BoxDoubleInstr::Canonicalize(FlowGraph* flow_graph) {
   if (input_use_list() == NULL) {
     // Environments can accomodate any representation. No need to box.
     return value()->definition();
   }
 
   // Fold away BoxDouble(UnboxDouble(v)) if value is known to be double.
   UnboxDoubleInstr* defn = value()->definition()->AsUnboxDouble();
   if ((defn != NULL) && (defn->value()->Type()->ToCid() == kDoubleCid)) {
     return defn->value()->definition();
@@ skipping 1143 matching lines @@
   return false;
 }
 
 
 static bool IsArrayLength(Definition* defn) {
   LoadFieldInstr* load = defn->AsLoadField();
   return (load != NULL) && load->IsImmutableLengthLoad();
 }
 
 
+static int64_t ConstantAbsMax(const Range* range) {
+  if (range == NULL) return Smi::kMaxValue;
+  const int64_t abs_min = Utils::Abs(Range::ConstantMin(range).value());
+  const int64_t abs_max = Utils::Abs(Range::ConstantMax(range).value());
+  return abs_min > abs_max ? abs_min : abs_max;
+}
+
+
+static bool OnlyPositiveOrZero(const Range* a, const Range* b) {
+  if ((a == NULL) || (b == NULL)) return false;
+  if (Range::ConstantMin(a).value() < 0) return false;
+  if (Range::ConstantMin(b).value() < 0) return false;
+  return true;
+}
+
+
+static bool OnlyNegativeOrZero(const Range* a, const Range* b) {
+  if ((a == NULL) || (b == NULL)) return false;
+  if (Range::ConstantMax(a).value() > 0) return false;
+  if (Range::ConstantMax(b).value() > 0) return false;
+  return true;
+}
+
+
 void BinarySmiOpInstr::InferRange() {
   // TODO(vegorov): canonicalize BinarySmiOp to always have constant on the
   // right and a non-constant on the left.
   Definition* left_defn = left()->definition();
 
   Range* left_range = left_defn->range();
   Range* right_range = right()->definition()->range();
 
   if ((left_range == NULL) || (right_range == NULL)) {
     range_ = new Range(RangeBoundary::MinSmi(), RangeBoundary::MaxSmi());
@@ skipping 36 matching lines @@
       }
 
       if (!SymbolicSub(left_max, right_range->min(), &max)) {
         max =
           RangeBoundary::Sub(Range::ConstantMax(left_range),
                              Range::ConstantMin(right_range),
                              RangeBoundary::OverflowedMaxSmi());
       }
       break;
 
+    case Token::kMUL: {
+      const int64_t left_max = ConstantAbsMax(left_range);
+      const int64_t right_max = ConstantAbsMax(right_range);
+      if ((left_max < 0x7FFFFFFF) && (right_max < 0x7FFFFFFF)) {
+        // Product of left and right max values stays in 64 bit range.
+        const int64_t result_max = left_max * right_max;
+        if (Smi::IsValid64(result_max) && Smi::IsValid64(-result_max)) {
+          const intptr_t r_min =
+              OnlyPositiveOrZero(left_range, right_range) ? 0 : -result_max;
+          min = RangeBoundary::FromConstant(r_min);
+          const intptr_t r_max =
+              OnlyNegativeOrZero(left_range, right_range) ? 0 : result_max;
+          max = RangeBoundary::FromConstant(r_max);
+          break;
+        }
+      }
+      if (range_ == NULL) {
+        range_ = Range::Unknown();
+      }
+      return;
+    }
     case Token::kBIT_AND:
       if (Range::ConstantMin(right_range).value() >= 0) {
         min = RangeBoundary::FromConstant(0);
         max = Range::ConstantMax(right_range);
         break;
       }
       if (Range::ConstantMin(left_range).value() >= 0) {
         min = RangeBoundary::FromConstant(0);
         max = Range::ConstantMax(left_range);
         break;
@@ skipping 341 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart