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

vm/raw_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_RAW_OBJECT_H_
 #define VM_RAW_OBJECT_H_
 
 #include "platform/assert.h"
 #include "vm/globals.h"
 #include "vm/token.h"
@@ skipping 233 matching lines @@
       ASSERT(result == SizeFromClass());
       return result;
     }
     result = SizeFromClass();
     ASSERT((result > SizeTag::kMaxSizeTag) || FreeBit::decode(tags));
     return result;
   }
 
   void Validate() const;
   intptr_t VisitPointers(ObjectPointerVisitor* visitor);
+  bool FindObject(FindObjectVisitor* visitor);
 
   static RawObject* FromAddr(uword addr) {
     // We expect the untagged address here.
     ASSERT((addr & kSmiTagMask) != kHeapObjectTag);
     return reinterpret_cast<RawObject*>(addr + kHeapObjectTag);
   }
 
   static uword ToAddr(RawObject* raw_obj) {
     return reinterpret_cast<uword>(raw_obj->ptr());
   }
 
   static bool IsCreatedFromSnapshot(intptr_t value) {
     return CreatedFromSnapshotTag::decode(value);
   }
 
   static bool IsCanonical(intptr_t value) {
     return CanonicalObjectTag::decode(value);
   }
 
+  static bool IsRawInstruction(RawObject* raw_obj);
+
  protected:
   RawClass* class_;
   uword tags_;  // Various object tags (bits).
 
  private:
   class FreeBit : public BitField<bool, kFreeBit, 1> {};
 
   class MarkBit : public BitField<bool, kMarkBit, 1> {};
 
   class CanonicalObjectTag : public BitField<bool, kCanonicalBit, 1> {};
@@ skipping 375 matching lines @@
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->var_descriptors_);
   }
 
   intptr_t pointer_offsets_length_;
   // This cannot be boolean because of alignment issues on x64 architectures.
   intptr_t is_optimized_;
 
   // Variable length data follows here.
   int32_t data_[0];
+
+  // Private helper function used while visiting stack frames during
+  // GC. The code which iterates over dart frames during GC is not
+  // allowed to create handles.
+  RawStackmap* GetStackmap(uword pc) const;
+
+  friend class DartFrame;
+  friend class StubFrame;
 };
 
 
 class RawInstructions : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Instructions);
 
   RawCode* code_;
   intptr_t size_;
 
   // Variable length data follows here.
   uint8_t data_[0];
 
+  // Private helper function used while visiting stack frames. The
+  // code which iterates over dart frames is also called during GC and
+  // is not allowed to create handles.
+  static bool ContainsPC(RawObject* raw_obj, uword pc);
+
   friend class RawCode;
+  friend class StackFrame;
 };
 
 
 class RawPcDescriptors : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(PcDescriptors);
 
   RawSmi* length_;  // Number of descriptors.
 
   // Variable length data follows here.
   intptr_t data_[0];
@@ skipping 16 matching lines @@
   }
   RawCode* code_;  // Code object corresponding to the frame described.
   RawSmi* bitmap_size_in_bytes_;  // Size of the bit map in bytes.
   RawObject** to() {
     return reinterpret_cast<RawObject**>(&ptr()->bitmap_size_in_bytes_);
   }
   uword pc_;  // PC corresponding to this stack map representation.
 
   // Variable length data follows here (bitmap of the stack layout).
   uint8_t data_[0];
+
+  // Private helper functions used while visiting stack frames during
+  // GC. The code which iterates over dart frames during GC is not
+  // allowed to create handles.
+  bool IsObject(intptr_t bit_offset) const;
+  intptr_t SizeInBits() const;
+  uword PC() const { return ptr()->pc_; }
+
+  friend class RawCode;
+  friend class DartFrame;
 };
 
 
 class RawLocalVarDescriptors : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(LocalVarDescriptors);
 
   struct VarInfo {
     intptr_t index;      // Slot index on stack or in context.
     intptr_t scope_id;   // Scope to which the variable belongs.
     intptr_t begin_pos;  // Token position of scope start.
@@ skipping 297 matching lines @@
   RawSmi* length_;
   // Variable length data follows here.
   RawObject** data() {
     uword address_of_length = reinterpret_cast<uword>(&length_);
     return reinterpret_cast<RawObject**>(address_of_length + kWordSize);
   }
   RawObject** to(intptr_t length) {
     return reinterpret_cast<RawObject**>(&ptr()->data()[length - 1]);
   }
 
+  // Private helper functions used while visiting stack frames during
+  // GC. The code which iterates over dart frames during GC is not
+  // allowed to create handles.
+  intptr_t Length() const;
+  RawObject* DataAt(intptr_t index) const { return ptr()->data()[index]; }
+
+  friend class RawCode;
   friend class RawImmutableArray;
   friend class SnapshotReader;
   friend class GrowableObjectArray;
 };
 
 
 class RawImmutableArray : public RawArray {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ImmutableArray);
 
   friend class SnapshotReader;
@@ skipping 120 matching lines @@
   intptr_t type_;  // Uninitialized, simple or complex.
   intptr_t flags_;  // Represents global/local, case insensitive, multiline.
 
   // Variable length data follows here.
   uint8_t data_[0];
 };
 
 }  // namespace dart
 
 #endif  // VM_RAW_OBJECT_H_