Optimize code for bound checks if array is constant. Skip unnecessary Smi checks if they still surv…

runtime/vm/intermediate_language_ia32.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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 2186 matching lines @@
       } else {
         __ j(EQUAL, &is_ok);
       }
     }
   }
   __ Bind(&is_ok);
 }
 
 
 LocationSummary* CheckSmiInstr::MakeLocationSummary() const {
+  if (value()->ResultCid() == kSmiCid) {

[Vyacheslav Egorov (Google), 2012/09/13 09:27:51]

Maybe we should better reorder LICM and CSE?

[srdjan, 2012/09/13 09:46:45]

I will try this in a separate CL (added a TODO here), since I would need to do a
thorough performance analysis.

+    return new LocationSummary(0, 0, LocationSummary::kNoCall);
+  }
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void CheckSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  if (value()->ResultCid() == kSmiCid) return;
   Register value = locs()->in(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                         kDeoptCheckSmi);
   __ testl(value, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
 }
 
 
 LocationSummary* CheckArrayBoundInstr::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::RequiresRegister());
+  locs->set_in(0, Location::RegisterOrConstant(array()));
   locs->set_in(1, Location::RegisterOrConstant(index()));
   return locs;
 }
 
 
 void CheckArrayBoundInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  Register receiver = locs()->in(0).reg();
-
   const DeoptReasonId deopt_reason =
       (array_type() == kGrowableObjectArrayCid) ?
       kDeoptLoadIndexedGrowableArray : kDeoptLoadIndexedFixedArray;
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                         deopt_reason);
   ASSERT(array_type() == kArrayCid ||
          array_type() == kImmutableArrayCid ||
          array_type() == kGrowableObjectArrayCid);
   intptr_t length_offset = (array_type() == kGrowableObjectArrayCid)
       ? GrowableObjectArray::length_offset()
       : Array::length_offset();
+  // This case should not have created a bound check instruction.
+  ASSERT(!(locs()->in(0).IsConstant() && locs()->in(1).IsConstant()));
 
   if (locs()->in(1).IsConstant()) {
+    Register receiver = locs()->in(0).reg();
     const Object& constant = locs()->in(1).constant();
     ASSERT(constant.IsSmi());
     const int32_t imm =
         reinterpret_cast<int32_t>(constant.raw());
     __ cmpl(FieldAddress(receiver, length_offset), Immediate(imm));
     __ j(BELOW_EQUAL, deopt);
+  } else if (locs()->in(0).IsConstant()) {
+    const Object& constant = locs()->in(0).constant();
+    ASSERT(constant.IsArray());
+    const Array& array =  Array::Cast(constant);
+    Register index = locs()->in(1).reg();
+    __ cmpl(index, Immediate(array.Length()));
+    __ j(ABOVE_EQUAL, deopt);
   } else {
+    Register receiver = locs()->in(0).reg();
     Register index = locs()->in(1).reg();
     __ cmpl(index, FieldAddress(receiver, length_offset));
     __ j(ABOVE_EQUAL, deopt);
   }
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64