- Wire the stack frame iterator to use stack maps for traversing objects if there are stack maps in…

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 112 matching lines @@
                                Snapshot::Kind);                                \
   friend class SnapshotReader;                                                 \
 
 #define HEAP_OBJECT_IMPLEMENTATION(object, super)                              \
   OBJECT_IMPLEMENTATION(object, super);                                        \
   Raw##object* raw_ptr() const {                                               \
     ASSERT(raw() != null());                                                   \
     return raw()->ptr();                                                       \
   }                                                                            \
   SNAPSHOT_READER_SUPPORT(object)                                              \
+  friend class DartFrame;                                                      \
 
 class Object {
  public:
   // Index for Singleton internal VM classes,
   // this index is used in snapshots to refer to these classes directly.
   enum {
     kNullObject = 0,
     kSentinelObject,
     kClassClass,
     kNullClass,
@@ skipping 1926 matching lines @@
   bool IsObject(intptr_t offset) const {
     return InRange(offset) && GetBit(offset);
   }
   uword PC() const { return raw_ptr()->pc_; }
   void SetPC(uword value) const { raw_ptr()->pc_ = value; }
 
   RawCode* GetCode() const { return raw_ptr()->code_; }
   void SetCode(const Code& code) const;
 
   // Return the offset of the highest stack slot that has an object.
-  intptr_t Maximum() const;
+  intptr_t MaximumBitOffset() const { return raw_ptr()->max_set_bit_offset_; }
 
   // Return the offset of the lowest stack slot that has an object.
-  intptr_t Minimum() const;
+  intptr_t MinimumBitOffset() const { return raw_ptr()->min_set_bit_offset_; }
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawStackmap) == OFFSET_OF(RawStackmap, data_));
     return 0;
   }
   static intptr_t InstanceSize(intptr_t size) {
     return RoundedAllocationSize(sizeof(RawStackmap) + (size * kWordSize));
   }
-  static RawStackmap* New(uword pc, const Code& code, BitmapBuilder* bmap);
+  static RawStackmap* New(uword pc, BitmapBuilder* bmap);
 
  private:
   inline intptr_t SizeInBits() const;
 
+  void SetMinBitOffset(intptr_t value) const {
+    raw_ptr()->min_set_bit_offset_ = value;
+  }
+  void SetMaxBitOffset(intptr_t value) const {
+    raw_ptr()->max_set_bit_offset_ = value;
+  }
+
   bool InRange(intptr_t offset) const { return offset < SizeInBits(); }
 
   bool GetBit(intptr_t bit_offset) const;
   void SetBit(intptr_t bit_offset, bool value) const;
 
   void set_bitmap_size_in_bytes(intptr_t value) const;
-  void set_pc(uword value) const;
-  void set_code(const Code& code) const;
 
   HEAP_OBJECT_IMPLEMENTATION(Stackmap, Object);
   friend class Class;
   friend class BitmapBuilder;
 };
 
 
 class ExceptionHandlers : public Object {
  public:
   intptr_t Length() const;
@@ skipping 75 matching lines @@
     return raw_ptr()->pc_descriptors_;
   }
   void set_pc_descriptors(const PcDescriptors& descriptors) const {
     StorePointer(&raw_ptr()->pc_descriptors_, descriptors.raw());
   }
 
   RawArray* stackmaps() const {
     return raw_ptr()->stackmaps_;
   }
   void set_stackmaps(const Array& maps) const;
+  RawStackmap* GetStackmap(uword pc, Array* stackmaps, Stackmap* map) const;
 
   RawLocalVarDescriptors* var_descriptors() const {
     return raw_ptr()->var_descriptors_;
   }
   void set_var_descriptors(const LocalVarDescriptors& value) const {
     StorePointer(&raw_ptr()->var_descriptors_, value.raw());
   }
 
   RawExceptionHandlers* exception_handlers() const {
     return raw_ptr()->exception_handlers_;
@@ skipping 1757 matching lines @@
 }
 
 
 intptr_t Stackmap::SizeInBits() const {
   return (Smi::Value(raw_ptr()->bitmap_size_in_bytes_) * kBitsPerByte);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_