Generalize bounds checks.

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 5410 matching lines @@
 void Function::set_kind(RawFunction::Kind value) const {
   set_kind_tag(KindBits::update(value, raw_ptr()->kind_tag_));
 }
 
 
 void Function::set_modifier(RawFunction::AsyncModifier value) const {
   set_kind_tag(ModifierBits::update(value, raw_ptr()->kind_tag_));
 }
 
 
-void Function::set_is_intrinsic(bool value) const {
-  set_kind_tag(IntrinsicBit::update(value, raw_ptr()->kind_tag_));
-}
-
-
 void Function::set_recognized_kind(MethodRecognizer::Kind value) const {
   // Prevent multiple settings of kind.
   ASSERT((value == MethodRecognizer::kUnknown) || !IsRecognized());
   set_kind_tag(RecognizedBits::update(value, raw_ptr()->kind_tag_));
 }
 
 
-void Function::set_is_redirecting(bool value) const {
-  set_kind_tag(RedirectingBit::update(value, raw_ptr()->kind_tag_));
-}
-
-
-void Function::set_is_static(bool value) const {
-  set_kind_tag(StaticBit::update(value, raw_ptr()->kind_tag_));
-}
-
-
-void Function::set_is_const(bool value) const {
-  set_kind_tag(ConstBit::update(value, raw_ptr()->kind_tag_));
-}
-
-
-void Function::set_is_external(bool value) const {
-  set_kind_tag(ExternalBit::update(value, raw_ptr()->kind_tag_));
-}
-
-
-void Function::set_is_async_closure(bool value) const {
-  set_kind_tag(AsyncClosureBit::update(value, raw_ptr()->kind_tag_));
-  // Prohibit inlining as the closure is used for implementing a continuation.
-  set_is_inlinable(false);
-}
-
-
 void Function::set_token_pos(intptr_t value) const {
   ASSERT(value >= 0);
   StoreNonPointer(&raw_ptr()->token_pos_, value);
 }
 
 
 void Function::set_kind_tag(intptr_t value) const {
   StoreNonPointer(&raw_ptr()->kind_tag_, static_cast<uint32_t>(value));
 }
 
@@ skipping 60 matching lines @@
   }
 }
 
 
 void Function::SetIsNativeAutoSetupScope(bool value) const {
   ASSERT(is_native());
   set_is_optimizable(value);
 }
 
 
-void Function::set_is_optimizable(bool value) const {
-  set_kind_tag(OptimizableBit::update(value, raw_ptr()->kind_tag_));
+bool Function::CanBeInlined() const {
+  return is_inlinable() &&
+         !is_async_closure() &&
+         HasCode() &&
+         !Isolate::Current()->debugger()->HasBreakpoint(*this);
 }
 
 
-void Function::set_allows_hoisting_check_class(bool value) const {
-  set_kind_tag(
-      AllowsHoistingCheckClassBit::update(value, raw_ptr()->kind_tag_));
-}
-
-
-void Function::set_is_native(bool value) const {
-  set_kind_tag(NativeBit::update(value, raw_ptr()->kind_tag_));
-}
-
-
-void Function::set_is_abstract(bool value) const {
-  set_kind_tag(AbstractBit::update(value, raw_ptr()->kind_tag_));
-}
-
-
-void Function::set_is_inlinable(bool value) const {
-  set_kind_tag(InlinableBit::update(value, raw_ptr()->kind_tag_));
-}
-
-
-bool Function::IsInlineable() const {
-  return (InlinableBit::decode(raw_ptr()->kind_tag_) &&
-          HasCode() &&
-          !Isolate::Current()->debugger()->HasBreakpoint(*this));
-}
-
-
-void Function::set_is_visible(bool value) const {
-  set_kind_tag(VisibleBit::update(value, raw_ptr()->kind_tag_));
-}
-
-
 intptr_t Function::NumParameters() const {
   return num_fixed_parameters() + NumOptionalParameters();
 }
 
 
 intptr_t Function::NumImplicitParameters() const {
   if (kind() == RawFunction::kConstructor) {
     if (is_static()) {
       ASSERT(IsFactory());
       return 1;  // Type arguments.
@@ skipping 515 matching lines @@
   result.set_end_token_pos(token_pos);
   result.set_num_fixed_parameters(0);
   result.set_num_optional_parameters(0);
   result.set_usage_counter(0);
   result.set_deoptimization_counter(0);
   result.set_optimized_instruction_count(0);
   result.set_optimized_call_site_count(0);
   result.set_is_optimizable(is_native ? false : true);
   result.set_is_inlinable(true);
   result.set_allows_hoisting_check_class(true);
+  result.set_allows_bounds_check_generalization(true);
   result.SetInstructions(Code::Handle(StubCode::LazyCompile_entry()->code()));
   if (kind == RawFunction::kClosureFunction) {
     const ClosureData& data = ClosureData::Handle(ClosureData::New());
     result.set_data(data);
   }
 
   return result.raw();
 }
 
 
@@ skipping 633 matching lines @@
     jsobj.AddProperty("parent", parent);
   }
   const char* kind_string = Function::KindToCString(kind());
   jsobj.AddProperty("kind", kind_string);
   if (ref) {
     return;
   }
   jsobj.AddProperty("static", is_static());
   jsobj.AddProperty("const", is_const());
   jsobj.AddProperty("optimizable", is_optimizable());
-  jsobj.AddProperty("inlinable", IsInlineable());
+  jsobj.AddProperty("inlinable", CanBeInlined());
   jsobj.AddProperty("unoptimizedCode", Object::Handle(unoptimized_code()));
   jsobj.AddProperty("usageCounter", usage_counter());
   jsobj.AddProperty("optimizedCallSiteCount", optimized_call_site_count());
   jsobj.AddProperty("code", Object::Handle(CurrentCode()));
   jsobj.AddProperty("deoptimizations",
                     static_cast<intptr_t>(deoptimization_counter()));
 
   const Script& script = Script::Handle(this->script());
   if (!script.IsNull()) {
     jsobj.AddProperty("script", script);
@@ skipping 4343 matching lines @@
   }
   return pos;
 }
 
 
 void DeoptInfo::ToInstructions(const Array& table,
                                GrowableArray<DeoptInstr*>* instructions) const {
   ASSERT(instructions->is_empty());
   Smi& offset = Smi::Handle();
   DeoptInfo& info = DeoptInfo::Handle(raw());
-  Smi& reason = Smi::Handle();
+  Smi& reason_and_flags = Smi::Handle();
   intptr_t index = 0;
   intptr_t length = TranslationLength();
   while (index < length) {
     intptr_t instruction = info.Instruction(index);
     intptr_t from_index = info.FromIndex(index);
     if (instruction == DeoptInstr::kSuffix) {
       // Suffix instructions cause us to 'jump' to another translation,
       // changing info, length and index.
       intptr_t info_number = 0;
       intptr_t suffix_length =
           DeoptInstr::DecodeSuffix(from_index, &info_number);
-      DeoptTable::GetEntry(table, info_number, &offset, &info, &reason);
+      DeoptTable::GetEntry(
+          table, info_number, &offset, &info, &reason_and_flags);
       length = info.TranslationLength();
       index = length - suffix_length;
     } else {
       instructions->Add(DeoptInstr::Create(instruction, from_index));
       ++index;
     }
   }
 }
 
 
@@ skipping 755 matching lines @@
   }
 #endif  // DEBUG
 }
 
 
 bool Code::HasBreakpoint() const {
   return Isolate::Current()->debugger()->HasBreakpoint(*this);
 }
 
 
-RawDeoptInfo* Code::GetDeoptInfoAtPc(
-    uword pc, ICData::DeoptReasonId* deopt_reason) const {
+RawDeoptInfo* Code::GetDeoptInfoAtPc(uword pc,
+                                     ICData::DeoptReasonId* deopt_reason,
+                                     uint32_t* deopt_flags) const {
   ASSERT(is_optimized());
   const Instructions& instrs = Instructions::Handle(instructions());
   uword code_entry = instrs.EntryPoint();
   const Array& table = Array::Handle(deopt_info_array());
   ASSERT(!table.IsNull());
   // Linear search for the PC offset matching the target PC.
   intptr_t length = DeoptTable::GetLength(table);
   Smi& offset = Smi::Handle();
-  Smi& reason = Smi::Handle();
+  Smi& reason_and_flags = Smi::Handle();
   DeoptInfo& info = DeoptInfo::Handle();
   for (intptr_t i = 0; i < length; ++i) {
-    DeoptTable::GetEntry(table, i, &offset, &info, &reason);
+    DeoptTable::GetEntry(table, i, &offset, &info, &reason_and_flags);
     if (pc == (code_entry + offset.Value())) {
       ASSERT(!info.IsNull());
-      ASSERT((0 <= reason.Value()) &&
-             (reason.Value() < ICData::kDeoptNumReasons));
-      *deopt_reason = static_cast<ICData::DeoptReasonId>(reason.Value());
+      *deopt_reason = DeoptTable::ReasonField::decode(reason_and_flags.Value());
+      *deopt_flags = DeoptTable::FlagsField::decode(reason_and_flags.Value());
       return info.raw();
     }
   }
   *deopt_reason = ICData::kDeoptUnknown;
   return DeoptInfo::null();
 }
 
 
 intptr_t Code::BinarySearchInSCallTable(uword pc) const {
   NoGCScope no_gc;
@@ skipping 8350 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart