Fix for issue 6359 - Make snapshots platform independent.

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 436 matching lines @@
   void* operator new(size_t size);
   // Disallow copy constructor.
   DISALLOW_COPY_AND_ASSIGN(Object);
 };
 
 
 class Class : public Object {
  public:
   intptr_t instance_size() const {
     ASSERT(is_finalized() || is_prefinalized());
-    return raw_ptr()->instance_size_;
+    return (raw_ptr()->instance_size_in_words_ * kWordSize);
   }
-  void set_instance_size(intptr_t value) const {
-    ASSERT(Utils::IsAligned(value, kObjectAlignment));
-    raw_ptr()->instance_size_ = value;
+  void set_instance_size(intptr_t value_in_bytes) const {
+    ASSERT(kWordSize != 0);
+    set_instance_size_in_words(value_in_bytes / kWordSize);
   }
-  static intptr_t instance_size_offset() {
-    return OFFSET_OF(RawClass, instance_size_);
+  void set_instance_size_in_words(intptr_t value) const {
+    ASSERT(Utils::IsAligned((value * kWordSize), kObjectAlignment));
+    raw_ptr()->instance_size_in_words_ = value;
   }
 
   intptr_t next_field_offset() const {
-    return raw_ptr()->next_field_offset_;
+    return raw_ptr()->next_field_offset_in_words_ * kWordSize;
   }
-  void set_next_field_offset(intptr_t value) const {
-    ASSERT((Utils::IsAligned(value, kObjectAlignment) &&
-            (value == raw_ptr()->instance_size_)) ||
-           (!Utils::IsAligned(value, kObjectAlignment) &&
-            (value + kWordSize == raw_ptr()->instance_size_)));
-    raw_ptr()->next_field_offset_ = value;
+  void set_next_field_offset(intptr_t value_in_bytes) const {
+    ASSERT(kWordSize != 0);
+    set_next_field_offset_in_words(value_in_bytes / kWordSize);
+  }
+  void set_next_field_offset_in_words(intptr_t value) const {
+    ASSERT((Utils::IsAligned((value * kWordSize), kObjectAlignment) &&
+            (value == raw_ptr()->instance_size_in_words_)) ||
+           (!Utils::IsAligned((value * kWordSize), kObjectAlignment) &&
+            ((value + 1) == raw_ptr()->instance_size_in_words_)));
+    raw_ptr()->next_field_offset_in_words_ = value;
   }
 
   cpp_vtable handle_vtable() const { return raw_ptr()->handle_vtable_; }
   void set_handle_vtable(cpp_vtable value) const {
     raw_ptr()->handle_vtable_ = value;
   }
 
   intptr_t id() const { return raw_ptr()->id_; }
   void set_id(intptr_t value) const {
     raw_ptr()->id_ = value;
@@ skipping 49 matching lines @@
 
   // The type argument vector is flattened and includes the type arguments of
   // the super class.
   bool HasTypeArguments() const;
   intptr_t NumTypeArguments() const;
 
   // If this class is parameterized, each instance has a type_arguments field.
   static const intptr_t kNoTypeArguments = -1;
   intptr_t type_arguments_field_offset() const {
     ASSERT(is_finalized() || is_prefinalized());
-    return raw_ptr()->type_arguments_field_offset_;
+    if (raw_ptr()->type_arguments_field_offset_in_words_ == kNoTypeArguments) {
+      return kNoTypeArguments;
+    }
+    return raw_ptr()->type_arguments_field_offset_in_words_ * kWordSize;
   }
-  void set_type_arguments_field_offset(intptr_t value) const {
-    raw_ptr()->type_arguments_field_offset_ = value;
+  void set_type_arguments_field_offset(intptr_t value_in_bytes) const {
+    intptr_t value;
+    if (value_in_bytes == kNoTypeArguments) {
+      value = kNoTypeArguments;
+    } else {
+      ASSERT(kWordSize != 0);
+      value = value_in_bytes / kWordSize;
+    }
+    set_type_arguments_field_offset_in_words(value);
   }
-  static intptr_t type_arguments_field_offset_offset() {
-    return OFFSET_OF(RawClass, type_arguments_field_offset_);
+  void set_type_arguments_field_offset_in_words(intptr_t value) const {
+    raw_ptr()->type_arguments_field_offset_in_words_ = value;
+  }
+  static intptr_t type_arguments_field_offset_in_words_offset() {
+    return OFFSET_OF(RawClass, type_arguments_field_offset_in_words_);
   }
 
   // The super type of this class, Object type if not explicitly specified.
   RawType* super_type() const { return raw_ptr()->super_type_; }
   void set_super_type(const Type& value) const;
   static intptr_t super_type_offset() {
     return OFFSET_OF(RawClass, super_type_);
   }
 
   // Asserts that the class of the super type has been resolved.
@@ skipping 1009 matching lines @@
  public:
   RawString* name() const { return raw_ptr()->name_; }
   RawString* UserVisibleName() const;
   virtual RawString* DictionaryName() const { return name(); }
 
   bool is_static() const { return StaticBit::decode(raw_ptr()->kind_bits_); }
   bool is_final() const { return FinalBit::decode(raw_ptr()->kind_bits_); }
   bool is_const() const { return ConstBit::decode(raw_ptr()->kind_bits_); }
 
   inline intptr_t Offset() const;
-  inline void SetOffset(intptr_t value) const;
+  inline void SetOffset(intptr_t value_in_bytes) const;
 
   RawInstance* value() const;
   void set_value(const Instance& value) const;
 
   RawClass* owner() const { return raw_ptr()->owner_; }
 
   RawAbstractType* type() const  { return raw_ptr()->type_; }
   void set_type(const AbstractType& value) const;
 
   static intptr_t InstanceSize() {
@@ skipping 4317 matching lines @@
 }
 
 
 bool Function::HasCode() const {
   return raw_ptr()->code_ != Code::null();
 }
 
 
 intptr_t Field::Offset() const {
   ASSERT(!is_static());  // Offset is valid only for instance fields.
-  return Smi::Value(reinterpret_cast<RawSmi*>(raw_ptr()->value_));
+  intptr_t value = Smi::Value(reinterpret_cast<RawSmi*>(raw_ptr()->value_));
+  return (value * kWordSize);
 }
 
 
-void Field::SetOffset(intptr_t value) const {
+void Field::SetOffset(intptr_t value_in_bytes) const {
   ASSERT(!is_static());  // SetOffset is valid only for instance fields.
-  raw_ptr()->value_ = Smi::New(value);
+  ASSERT(kWordSize != 0);
+  raw_ptr()->value_ = Smi::New(value_in_bytes / kWordSize);
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 
 intptr_t Instance::GetNativeField(Isolate* isolate, int index) const {
   ASSERT(IsValidNativeIndex(index));
@@ skipping 32 matching lines @@
     if (this->CharAt(i) != str.CharAt(begin_index + i)) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_