Remember inside an ICData if it is for a static call or an instance call

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"
@@ skipping 1824 matching lines @@
   }
 
   intptr_t NumArgsTested() const;
 
   intptr_t deopt_id() const {
     return raw_ptr()->deopt_id_;
   }
 
   bool IsImmutable() const;
 
-  void Reset(bool is_static_call) const;
+  void Reset() const;
   void ResetData() const;
 
   // Note: only deopts with reasons before Unknown in this list are recorded in
   // the ICData. All other reasons are used purely for informational messages
   // printed during deoptimization itself.
   #define DEOPT_REASONS(V)                                                     \
     V(BinarySmiOp)                                                             \
     V(BinaryMintOp)                                                            \
     V(DoubleToSmi)                                                             \
     V(CheckSmi)                                                                \
@@ skipping 165 matching lines @@
   // Consider only used entries.
   bool AllTargetsHaveSameOwner(intptr_t owner_cid) const;
   bool AllReceiversAreNumbers() const;
   bool HasOneTarget() const;
   bool HasReceiverClassId(intptr_t class_id) const;
 
   static RawICData* New(const Function& owner,
                         const String& target_name,
                         const Array& arguments_descriptor,
                         intptr_t deopt_id,
-                        intptr_t num_args_tested);
+                        intptr_t num_args_tested,
+                        bool is_static_call);
   static RawICData* NewFrom(const ICData& from, intptr_t num_args_tested);
 
   // Generates a new ICData with descriptor and data array copied (deep clone).
   static RawICData* Clone(const ICData& from);
 
   static intptr_t TestEntryLengthFor(intptr_t num_args);
 
   static intptr_t TargetIndexFor(intptr_t num_args) {
     return num_args;
   }
@@ skipping 97 matching lines @@
 
   enum {
     kCachedICDataArrayCount = 4
   };
 
 #if defined(TAG_IC_DATA)
   void set_tag(intptr_t value) const;
   intptr_t tag() const { return raw_ptr()->tag_; }
 #endif
 
+  void SetIsStaticCall(bool static_call) const;
+  bool is_static_call() const;
+
  private:
   static RawICData* New();
 
   RawArray* ic_data() const {
     return raw_ptr()->ic_data_;
   }
 
   void set_owner(const Function& value) const;
   void set_target_name(const String& value) const;
   void set_arguments_descriptor(const Array& value) const;
   void set_deopt_id(intptr_t value) const;
   void SetNumArgsTested(intptr_t value) const;
   void set_ic_data_array(const Array& value) const;
   void set_state_bits(uint32_t bits) const;
 
   enum {
     kNumArgsTestedPos = 0,
     kNumArgsTestedSize = 2,
     kDeoptReasonPos = kNumArgsTestedPos + kNumArgsTestedSize,
     kDeoptReasonSize = kLastRecordedDeoptReason + 1,
     kRangeFeedbackPos = kDeoptReasonPos + kDeoptReasonSize,
-    kRangeFeedbackSize = kBitsPerRangeFeedback * kRangeFeedbackSlots
+    kRangeFeedbackSize = kBitsPerRangeFeedback * kRangeFeedbackSlots,
+    kStaticCallPos = kRangeFeedbackPos + kRangeFeedbackSize,
+    kStaticCallSize = 1,
   };
 
   class NumArgsTestedBits : public BitField<uint32_t,
                                             uint32_t,
                                             kNumArgsTestedPos,
                                             kNumArgsTestedSize> {};
   class DeoptReasonBits : public BitField<uint32_t,
                                           uint32_t,
                                           ICData::kDeoptReasonPos,
                                           ICData::kDeoptReasonSize> {};
   class RangeFeedbackBits : public BitField<uint32_t,
                                             uint32_t,
                                             ICData::kRangeFeedbackPos,
                                             ICData::kRangeFeedbackSize> {};
 
+  class StaticCallBit : public BitField<uint32_t,
+                                        bool,
+                                        ICData::kStaticCallPos,
+                                        ICData::kStaticCallSize> {};
 #if defined(DEBUG)
   // Used in asserts to verify that a check is not added twice.
   bool HasCheck(const GrowableArray<intptr_t>& cids) const;
 #endif  // DEBUG
 
   intptr_t TestEntryLength() const;
   static RawArray* NewNonCachedEmptyICDataArray(intptr_t num_args_tested);
   static RawArray* NewEmptyICDataArray(intptr_t num_args_tested);
   static RawICData* NewDescriptor(Zone* zone,
                                   const Function& owner,
                                   const String& target_name,
                                   const Array& arguments_descriptor,
                                   intptr_t deopt_id,
-                                  intptr_t num_args_tested);
+                                  intptr_t num_args_tested,
+                                  bool is_static_call);
 
   static void WriteSentinel(const Array& data, intptr_t test_entry_length);
 
   // A cache of VM heap allocated preinitialized empty ic data entry arrays.
   static RawArray* cached_icdata_arrays_[kCachedICDataArrayCount];
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ICData, Object);
   friend class Class;
   friend class SnapshotWriter;
 };
@@ skipping 58 matching lines @@
   // does not involve generic parameter types or generic result type.
   bool HasInstantiatedSignature() const;
 
   // Build a string of the form 'T, {B b, C c}' representing the user
   // visible formal parameters of the function.
   RawString* UserVisibleFormalParameters() const;
 
   // Reloading support:
   void Reparent(const Class& new_cls) const;
   void ZeroEdgeCounters() const;
-  void FillICDataWithSentinels(const Code& code) const;
 
   RawClass* Owner() const;
   RawClass* origin() const;
   RawScript* script() const;
   RawObject* RawOwner() const { return raw_ptr()->owner_; }
 
   RawRegExp* regexp() const;
   intptr_t string_specialization_cid() const;
   void SetRegExpData(const RegExp& regexp,
                      intptr_t string_specialization_cid) const;
@@ skipping 2243 matching lines @@
 
   RawCodeSourceMap* code_source_map() const {
     return raw_ptr()->code_source_map_;
   }
 
   void set_code_source_map(const CodeSourceMap& code_source_map) const {
     ASSERT(code_source_map.IsOld());
     StorePointer(&raw_ptr()->code_source_map_, code_source_map.raw());
   }
 
+  // Used during reloading (see object_reload.cc). Calls Reset on all ICDatas
+  // that are embedded inside the Code object.
+  void ResetICDatas() const;
+
   TokenPosition GetTokenPositionAt(intptr_t offset) const;
 
   // Array of DeoptInfo objects.
   RawArray* deopt_info_array() const {
     return raw_ptr()->deopt_info_array_;
   }
   void set_deopt_info_array(const Array& array) const;
 
   RawArray* stackmaps() const {
     return raw_ptr()->stackmaps_;
@@ skipping 4160 matching lines @@
 
 inline void TypeArguments::SetHash(intptr_t value) const {
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   StoreSmi(&raw_ptr()->hash_, Smi::New(value));
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_