Second set of changes for implementation of stack map support.

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/bitmap.h"
 #include "vm/dart.h"
 #include "vm/globals.h"
 #include "vm/handles.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/os.h"
 #include "vm/raw_object.h"
 #include "vm/scanner.h"
 
 namespace dart {
 
 // Forward declarations.
 #define DEFINE_FORWARD_DECLARATION(clazz)                                      \
   class clazz;
 CLASS_LIST(DEFINE_FORWARD_DECLARATION)
 #undef DEFINE_FORWARD_DECLARATION
 class Assembler;
+class Code;
 class LocalScope;
 
 #define OBJECT_IMPLEMENTATION(object, super)                                   \
  public:  /* NOLINT */                                                         \
   Raw##object* raw() const { return reinterpret_cast<Raw##object*>(raw_); }    \
   void operator=(Raw##object* value) {                                         \
     initializeHandle(this, value);                                             \
   }                                                                            \
   bool Is##object() const { return true; }                                     \
   void operator^=(RawObject* value) {                                          \
@@ skipping 1950 matching lines @@
 
 
 class Stackmap : public Object {
  public:
   static const intptr_t kNoMaximum = -1;
   static const intptr_t kNoMinimum = -1;
 
   bool IsObject(intptr_t offset) const {
     return InRange(offset) && GetBit(offset);
   }
-  uword pc() const { return raw_ptr()->pc_; }
+  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;
+
+  // Return the offset of the lowest stack slot that has an object.
+  intptr_t Minimum() const;
 
   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);
 
  private:
   inline intptr_t SizeInBits() const;
 
   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;
 
-  // Return the offset of the highest stack slot that has an object.
-  intptr_t Maximum() const;
-
-  // Return the offset of the lowest stack slot that has an object.
-  intptr_t Minimum() 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;
 };
 
 
@@ skipping 74 matching lines @@
     return instr.size();
   }
 
   RawPcDescriptors* pc_descriptors() const {
     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;
+
   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 1754 matching lines @@
 }
 
 
 intptr_t Stackmap::SizeInBits() const {
   return (Smi::Value(raw_ptr()->bitmap_size_in_bytes_) * kBitsPerByte);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_