VM: Array bounds checks that don't deoptimize for precompiled code.

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/compiler.h"
@@ skipping 4841 matching lines @@
 }
 
 
 void CheckClassIdInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptCheckClass);
   __ BranchNotEqual(value, Immediate(Smi::RawValue(cid_)), deopt);
 }
 
 
+LocationSummary* GenericCheckBoundInstr::MakeLocationSummary(Zone* zone,
+                                                             bool opt) const {
+  const intptr_t kNumInputs = 2;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* locs = new(zone) LocationSummary(
+      zone, kNumInputs, kNumTemps, LocationSummary::kCallOnSlowPath);
+  locs->set_in(kLengthPos, Location::RequiresRegister());
+  locs->set_in(kIndexPos, Location::RequiresRegister());
+  return locs;
+}
+
+
+class RangeErrorSlowPath : public SlowPathCode {
+ public:
+  RangeErrorSlowPath(GenericCheckBoundInstr* instruction, intptr_t try_index)
+      : instruction_(instruction), try_index_(try_index) { }
+
+  virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
+    if (Assembler::EmittingComments()) {
+      __ Comment("slow path check bound operation");
+    }
+    __ Bind(entry_label());
+    LocationSummary* locs = instruction_->locs();
+    __ Push(locs->in(0).reg());
+    __ Push(locs->in(1).reg());
+    compiler->GenerateRuntimeCall(instruction_->token_pos(),
+                                  instruction_->deopt_id(),
+                                  kRangeErrorRuntimeEntry,
+                                  2,
+                                  instruction_->locs());
+    compiler->RecordSafepoint(locs, /* slow_path_argument_count = */ 2);
+    compiler->pc_descriptors_list()->AddDescriptor(
+        RawPcDescriptors::kOther,
+        compiler->assembler()->CodeSize(),
+        instruction_->deopt_id(),
+        instruction_->token_pos(),
+        try_index_);
+    __ break_(0);
+  }
+
+ private:
+  GenericCheckBoundInstr* instruction_;
+  intptr_t try_index_;
+};
+
+
+void GenericCheckBoundInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  RangeErrorSlowPath* slow_path =
+      new RangeErrorSlowPath(this, compiler->CurrentTryIndex());
+  compiler->AddSlowPathCode(slow_path);
+
+  Location length_loc = locs()->in(kLengthPos);
+  Location index_loc = locs()->in(kIndexPos);
+  Register length = length_loc.reg();
+  Register index = index_loc.reg();
+  const intptr_t index_cid = this->index()->Type()->ToCid();
+  if (index_cid != kSmiCid) {
+    __ andi(CMPRES1, index, Immediate(kSmiTagMask));

[Vyacheslav Egorov (Google), 2016/07/14 09:35:59]

I wonder if assembler could benefit from BranchIfSmi or something like that.

[Florian Schneider, 2016/07/14 17:05:21]

Ya, I wished that too.

I'll add BranchIfNotSmi and BranchIfSmi.

+    __ bne(CMPRES1, ZR, slow_path->entry_label());
+  }
+  __ BranchUnsignedGreaterEqual(index, length, slow_path->entry_label());
+}
+
+
 LocationSummary* CheckArrayBoundInstr::MakeLocationSummary(Zone* zone,
                                                            bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(kLengthPos, Location::RegisterOrSmiConstant(length()));
   locs->set_in(kIndexPos, Location::RegisterOrSmiConstant(index()));
   return locs;
 }
@@ skipping 13 matching lines @@
   if (length_loc.IsConstant() && index_loc.IsConstant()) {
     ASSERT((Smi::Cast(length_loc.constant()).Value() <=
             Smi::Cast(index_loc.constant()).Value()) ||
            (Smi::Cast(index_loc.constant()).Value() < 0));
     // Unconditionally deoptimize for constant bounds checks because they
     // only occur only when index is out-of-bounds.
     __ b(deopt);
     return;
   }
 
+  const intptr_t index_cid = index()->Type()->ToCid();
   if (index_loc.IsConstant()) {
     Register length = length_loc.reg();
     const Smi& index = Smi::Cast(index_loc.constant());
     __ BranchUnsignedLessEqual(
         length, Immediate(reinterpret_cast<int32_t>(index.raw())), deopt);
   } else if (length_loc.IsConstant()) {
     const Smi& length = Smi::Cast(length_loc.constant());
     Register index = index_loc.reg();
+    if (index_cid != kSmiCid) {
+      __ andi(CMPRES1, index, Immediate(kSmiTagMask));
+      __ bne(CMPRES1, ZR, deopt);
+    }
     if (length.Value() == Smi::kMaxValue) {
       __ BranchSignedLess(index, Immediate(0), deopt);
     } else {
       __ BranchUnsignedGreaterEqual(
           index, Immediate(reinterpret_cast<int32_t>(length.raw())), deopt);
     }
   } else {
     Register length = length_loc.reg();
     Register index = index_loc.reg();
+    if (index_cid != kSmiCid) {
+      __ andi(CMPRES1, index, Immediate(kSmiTagMask));
+      __ bne(CMPRES1, ZR, deopt);
+    }
     __ BranchUnsignedGreaterEqual(index, length, deopt);
   }
 }
 
 LocationSummary* BinaryMintOpInstr::MakeLocationSummary(Zone* zone,
                                                         bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
@@ skipping 805 matching lines @@
                                 1,
                                 locs());
   __ lw(result, Address(SP, 1 * kWordSize));
   __ addiu(SP, SP, Immediate(2 * kWordSize));
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS