VM: Improve performance of method recognizer and unify the it with the intrinsifier.

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/json_stream.h"
 #include "vm/bitmap.h"
 #include "vm/dart.h"
 #include "vm/globals.h"
 #include "vm/handles.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
+#include "vm/method_recognizer.h"
 #include "vm/os.h"
 #include "vm/raw_object.h"
 #include "vm/report.h"
 #include "vm/scanner.h"
 #include "vm/tags.h"
 
 namespace dart {
 
 // Forward declarations.
 #define DEFINE_FORWARD_DECLARATION(clazz)                                      \
@@ skipping 1804 matching lines @@
   bool is_visible() const {
     return VisibleBit::decode(raw_ptr()->kind_tag_);
   }
   void set_is_visible(bool value) const;
 
   bool is_intrinsic() const {
     return IntrinsicBit::decode(raw_ptr()->kind_tag_);
   }
   void set_is_intrinsic(bool value) const;
 
-  bool is_recognized() const {
-    return RecognizedBit::decode(raw_ptr()->kind_tag_);
+  MethodRecognizer::Kind recognized_kind() const {
+    return RecognizedBits::decode(raw_ptr()->kind_tag_);
   }
-  void set_is_recognized(bool value) const;
+  void set_recognized_kind(MethodRecognizer::Kind value) const;
+
+  bool IsRecognized() const {
+    return recognized_kind() != MethodRecognizer::kUnknown;
+  }
 
   bool is_redirecting() const {
     return RedirectingBit::decode(raw_ptr()->kind_tag_);
   }
   void set_is_redirecting(bool value) const;
 
   bool allows_hoisting_check_class() const {
     return AllowsHoistingCheckClassBit::decode(raw_ptr()->kind_tag_);
   }
   void set_allows_hoisting_check_class(bool value) const;
 
+  bool is_always_inline() const {

[srdjan, 2014/08/20 17:13:46]

Optional: is_always_inline reads a little hard; how about should_always_inline?

[Cutch, 2014/08/20 17:17:25]

+1

[Florian Schneider, 2014/08/21 09:31:08]

Agree. I went for just always_inline instead.

+    return AlwaysInlineBit::decode(raw_ptr()->kind_tag_);
+  }
+  void set_is_always_inline(bool value) const {
+    set_kind_tag(AlwaysInlineBit::update(value, raw_ptr()->kind_tag_));
+  }
+
+  bool is_polymorphic_target() const {
+    return PolymorphicTargetBit::decode(raw_ptr()->kind_tag_);
+  }
+  void set_is_polymorphic_target(bool value) const {
+    set_kind_tag(PolymorphicTargetBit::update(value, raw_ptr()->kind_tag_));
+  }
+
+
   bool HasOptimizedCode() const;
 
   // Returns true if the argument counts are valid for calling this function.
   // Otherwise, it returns false and the reason (if error_message is not NULL).
   bool AreValidArgumentCounts(intptr_t num_arguments,
                               intptr_t num_named_arguments,
                               String* error_message) const;
 
   // Returns true if the total argument count and the names of optional
   // arguments are valid for calling this function.
@@ skipping 153 matching lines @@
   static const int kCtorPhaseAll = (kCtorPhaseInit | kCtorPhaseBody);
 
   void set_modifier(RawFunction::AsyncModifier value) const;
 
  private:
   void set_ic_data_array(const Array& value) const;
 
   enum KindTagBits {
     kKindTagPos = 0,
     kKindTagSize = 4,
-    kStaticBit = kKindTagPos + kKindTagSize,  // = 4
-    kConstBit = 5,
-    kAbstractBit = 6,
-    kVisibleBit = 7,
-    kOptimizableBit = 8,
-    kInlinableBit = 9,
-    kIntrinsicBit = 10,
-    kRecognizedBit = 11,
-    kNativeBit = 12,
-    kRedirectingBit = 13,
-    kExternalBit = 14,
-    kAllowsHoistingCheckClassBit = 15,
-    kModifierPos = 16,
-    kAsyncClosureBit = 17,
+    kRecognizedTagPos = kKindTagPos + kKindTagSize,
+    kRecognizedTagSize = 8,
+    // Single bit sized fields start here.
+    kStaticBit = kRecognizedTagPos + kRecognizedTagSize,
+    kConstBit,
+    kAbstractBit,
+    kVisibleBit,
+    kOptimizableBit,
+    kInlinableBit,
+    kIntrinsicBit,
+    kNativeBit,
+    kRedirectingBit,
+    kExternalBit,
+    kAllowsHoistingCheckClassBit,
+    kModifierPos,
+    kAsyncClosureBit,
+    kAlwaysInlineBit,
+    kPolymorphicTargetBit,
+    kNumTagBits
   };
+
+  COMPILE_ASSERT(
+      MethodRecognizer::kNumRecognizedMethods < (1 << kRecognizedTagSize));
+  COMPILE_ASSERT(
+      kNumTagBits <= (kBitsPerByte * sizeof(RawFunction::kind_tag_)));
+
   class KindBits :
     public BitField<RawFunction::Kind, kKindTagPos, kKindTagSize> {};  // NOLINT
+  class RecognizedBits : public BitField<MethodRecognizer::Kind,
+                                         kRecognizedTagPos,
+                                         kRecognizedTagSize> {};
   class StaticBit : public BitField<bool, kStaticBit, 1> {};
   class ConstBit : public BitField<bool, kConstBit, 1> {};
   class AbstractBit : public BitField<bool, kAbstractBit, 1> {};
   class VisibleBit : public BitField<bool, kVisibleBit, 1> {};
   class OptimizableBit : public BitField<bool, kOptimizableBit, 1> {};
   class InlinableBit : public BitField<bool, kInlinableBit, 1> {};
   class IntrinsicBit : public BitField<bool, kIntrinsicBit, 1> {};
-  class RecognizedBit : public BitField<bool, kRecognizedBit, 1> {};
   class NativeBit : public BitField<bool, kNativeBit, 1> {};
   class ExternalBit : public BitField<bool, kExternalBit, 1> {};
   class RedirectingBit : public BitField<bool, kRedirectingBit, 1> {};
   class AllowsHoistingCheckClassBit :
       public BitField<bool, kAllowsHoistingCheckClassBit, 1> {};  // NOLINT
   class ModifierBits :
       public BitField<RawFunction::AsyncModifier, kModifierPos, 1> {};  // NOLINT
   class AsyncClosureBit : public BitField<bool, kAsyncClosureBit, 1> {};
+  class AlwaysInlineBit : public BitField<bool, kAlwaysInlineBit, 1> {};
+  class PolymorphicTargetBit :
+      public BitField<bool, kPolymorphicTargetBit, 1> {};  // NOLINT
 
   void set_name(const String& value) const;
   void set_kind(RawFunction::Kind value) const;
   void set_is_static(bool value) const;
   void set_is_const(bool value) const;
   void set_is_external(bool value) const;
   void set_parent_function(const Function& value) const;
   void set_owner(const Object& value) const;
   RawFunction* implicit_closure_function() const;
   void set_implicit_closure_function(const Function& value) const;
@@ skipping 5236 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_