Resubmit change 6302 after fixing the compiler warning on older GCC compiler versions:

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 109 matching lines @@
 
 #define VISITOR_SUPPORT(object)                                                \
   static intptr_t Visit##object##Pointers(Raw##object* raw_obj,                \
                                           ObjectPointerVisitor* visitor);
 
 #define RAW_OBJECT_IMPLEMENTATION(object)                                      \
  private:  /* NOLINT */                                                        \
   VISITOR_SUPPORT(object)                                                      \
   friend class object;                                                         \
   friend class RawObject;                                                      \
+  friend class Heap;                                                           \
   DISALLOW_ALLOCATION();                                                       \
   DISALLOW_IMPLICIT_CONSTRUCTORS(Raw##object)
 
 #define RAW_HEAP_OBJECT_IMPLEMENTATION(object)                                 \
   private:                                                                     \
     RAW_OBJECT_IMPLEMENTATION(object);                                         \
     Raw##object* ptr() const {                                                 \
       ASSERT(IsHeapObject());                                                  \
       return reinterpret_cast<Raw##object*>(                                   \
           reinterpret_cast<uword>(this) - kHeapObjectTag);                     \
@@ skipping 104 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());
   }
@@ skipping 20 matching lines @@
   class CreatedFromSnapshotTag : public BitField<bool, kFromSnapshotBit, 1> {};
 
   RawObject* ptr() const {
     ASSERT(IsHeapObject());
     return reinterpret_cast<RawObject*>(
         reinterpret_cast<uword>(this) - kHeapObjectTag);
   }
 
   intptr_t SizeFromClass() const;
 
+  friend class Heap;
   friend class Object;
   friend class Array;
+  friend class RawInstructions;
   friend class SnapshotWriter;
   friend class SnapshotReader;
   friend class MarkingVisitor;
 
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(RawObject);
 };
 
 
 class RawClass : public RawObject {
@@ skipping 34 matching lines @@
   intptr_t type_arguments_instance_field_offset_;  // May be kNoTypeArguments.
   intptr_t next_field_offset_;  // Offset of then next instance field.
   intptr_t num_native_fields_;  // Number of native fields in class.
   intptr_t token_index_;
   int8_t class_state_;  // Of type ClassState.
   bool is_const_;
   bool is_interface_;
 
   friend class Object;
   friend class RawInstance;
+  friend class RawInstructions;
   friend RawClass* AllocateFakeClass();
   friend class SnapshotReader;
 };
 
 
 class RawUnresolvedClass : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(UnresolvedClass);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->library_prefix_);
@@ skipping 301 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];
+
+  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 13 matching lines @@
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->code_);
   }
   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.
+  intptr_t min_set_bit_offset_;  // Minimum bit offset which is set.
+  intptr_t max_set_bit_offset_;  // Maximum bit offset which is set.
 
   // Variable length data follows here (bitmap of the stack layout).
   uint8_t data_[0];
 };
 
 
 class RawLocalVarDescriptors : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(LocalVarDescriptors);
 
   struct VarInfo {
@@ skipping 300 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]);
   }
 
+  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_