Make core snapshot word-size portable again.

runtime/vm/clustered_snapshot.h

 // Copyright (c) 2016, 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_CLUSTERED_SNAPSHOT_H_
 #define VM_CLUSTERED_SNAPSHOT_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
 #include "vm/datastream.h"
 #include "vm/exceptions.h"
 #include "vm/globals.h"
 #include "vm/growable_array.h"
+#include "vm/hash_map.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/snapshot.h"
 #include "vm/version.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 // Forward declarations.
@@ skipping 51 matching lines @@
   // as rehashing.
   virtual void PostLoad(const Array& refs, Snapshot::Kind kind, Zone* zone) { }
 
  protected:
   // The range of the ref array that belongs to this cluster.
   intptr_t start_index_;
   intptr_t stop_index_;
 };
 
 
-enum {
-  kRefTagSize = 1,
-  kRefTagShift = 1,
-  kRefTagMask = 1,
-  kSmiRefTag = 0x0,
-  kHeapRefTag = 0x1,
+class SmiObjectIdPair {
+ public:
+  SmiObjectIdPair() : smi_(NULL), id_(0) { }
+  RawSmi* smi_;
+  intptr_t id_;
+
+  bool operator==(const SmiObjectIdPair& other) const {
+    return (smi_ == other.smi_) && (id_ == other.id_);
+  }
 };
 
 
+class SmiObjectIdPairTrait {
+ public:
+  typedef RawSmi* Key;
+  typedef intptr_t Value;
+  typedef SmiObjectIdPair Pair;
+
+  static Key KeyOf(Pair kv) { return kv.smi_; }
+  static Value ValueOf(Pair kv) { return kv.id_; }
+  static inline intptr_t Hashcode(Key key) { return Smi::Value(key); }
+  static inline bool IsKeyEqual(Pair kv, Key key) { return kv.smi_ == key; }
+};
+
+
+typedef DirectChainedHashMap<SmiObjectIdPairTrait> SmiObjectIdMap;
+
+
 class Serializer : public StackResource {
  public:
   Serializer(Thread* thread,
              Snapshot::Kind kind,
              uint8_t** buffer,
              ReAlloc alloc,
              intptr_t initial_size,
              InstructionsWriter* instructions_writer_);
   ~Serializer();
 
   intptr_t WriteVMSnapshot(const Array& symbols, const Array& scripts);
   void WriteFullSnapshot(intptr_t num_base_objects, ObjectStore* object_store);
 
   void AddVMIsolateBaseObjects();
 
   void AddBaseObject(RawObject* base_object) {
     AssignRef(base_object);
     num_base_objects_++;
   }
 
   void AssignRef(RawObject* object) {
     ASSERT(next_ref_index_ != 0);
-    heap_->SetObjectId(object, next_ref_index_);
-    ASSERT(heap_->GetObjectId(object) == next_ref_index_);
+    if (object->IsHeapObject()) {
+      heap_->SetObjectId(object, next_ref_index_);
+      ASSERT(heap_->GetObjectId(object) == next_ref_index_);
+    } else {
+      RawSmi* smi = Smi::RawCast(object);
+      SmiObjectIdPair* existing_pair = smi_ids_.Lookup(smi);
+      if (existing_pair != NULL) {
+        ASSERT(existing_pair->id_ == 1);
+        existing_pair->id_ = next_ref_index_;
+      } else {
+        SmiObjectIdPair new_pair;
+        new_pair.smi_ = smi;
+        new_pair.id_ = next_ref_index_;
+        smi_ids_.Insert(new_pair);
+      }
+    }
     next_ref_index_++;
   }
 
   void Push(RawObject* object) {
     if (!object->IsHeapObject()) {
+      RawSmi* smi = Smi::RawCast(object);
+      if (smi_ids_.Lookup(smi) == NULL) {
+        SmiObjectIdPair pair;
+        pair.smi_ = smi;
+        pair.id_ = 1;
+        smi_ids_.Insert(pair);
+        stack_.Add(object);
+        num_written_objects_++;
+      }
       return;
     }
 
     if (object->IsCode() && !Snapshot::IncludesCode(kind_)) {
       return;  // Do not trace, will write null.
     }
 
     if (object->IsSendPort()) {
       // TODO(rmacnak): Do a better job of resetting fields in precompilation
       // and assert this is unreachable.
@@ skipping 39 matching lines @@
   void Write(T value) {
     WriteStream::Raw<sizeof(T), T>::Write(&stream_, value);
   }
 
   void WriteBytes(const uint8_t* addr, intptr_t len) {
     stream_.WriteBytes(addr, len);
   }
 
   void WriteRef(RawObject* object) {
     if (!object->IsHeapObject()) {
-      ASSERT(static_cast<intptr_t>(kSmiRefTag) ==
-             static_cast<intptr_t>(kSmiTag));
-      Write<intptr_t>(reinterpret_cast<intptr_t>(object));
+      RawSmi* smi = Smi::RawCast(object);
+      intptr_t id = smi_ids_.Lookup(smi)->id_;
+      if (id == 0) {
+        FATAL("Missing ref");
+      }
+      Write<int32_t>(id);
       return;
     }
 
     intptr_t id = heap_->GetObjectId(object);
     if (id == 0) {
       if (object->IsCode() && !Snapshot::IncludesCode(kind_)) {
         WriteRef(Object::null());
         return;
       }
       if (object->IsSendPort()) {
         // TODO(rmacnak): Do a better job of resetting fields in precompilation
         // and assert this is unreachable.
         WriteRef(Object::null());
         return;
       }
       FATAL("Missing ref");
     }
-    Write<intptr_t>((id << kRefTagShift) | kHeapRefTag);
+    Write<int32_t>(id);
   }
 
   void WriteTokenPosition(TokenPosition pos) {
     Write<int32_t>(pos.SnapshotEncode());
   }
 
   void WriteCid(intptr_t cid) {
     COMPILE_ASSERT(RawObject::kClassIdTagSize <= 32);
     Write<int32_t>(cid);
   }
@@ skipping 13 matching lines @@
   Zone* zone_;
   Snapshot::Kind kind_;
   WriteStream stream_;
   InstructionsWriter* instructions_writer_;
   SerializationCluster** clusters_by_cid_;
   GrowableArray<RawObject*> stack_;
   intptr_t num_cids_;
   intptr_t num_base_objects_;
   intptr_t num_written_objects_;
   intptr_t next_ref_index_;
+  SmiObjectIdMap smi_ids_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(Serializer);
 };
 
 
 class Deserializer : public StackResource {
  public:
   Deserializer(Thread* thread,
                Snapshot::Kind kind,
                const uint8_t* buffer,
@@ skipping 46 matching lines @@
     next_ref_index_++;
   }
 
   RawObject* Ref(intptr_t index) const {
     ASSERT(index > 0);
     ASSERT(index <= num_objects_);
     return refs_->ptr()->data()[index];
   }
 
   RawObject* ReadRef() {
-    intptr_t index = Read<intptr_t>();
-    if ((index & kRefTagMask) == kSmiRefTag) {
-      ASSERT(static_cast<intptr_t>(kSmiRefTag) ==
-             static_cast<intptr_t>(kSmiTag));
-      return reinterpret_cast<RawSmi*>(index);
-    }
-    return Ref(index >> kRefTagShift);
+    int32_t index = Read<int32_t>();
+    return Ref(index);
   }
 
   TokenPosition ReadTokenPosition() {
     return TokenPosition::SnapshotDecode(Read<int32_t>());
   }
 
   intptr_t ReadCid() {
     COMPILE_ASSERT(RawObject::kClassIdTagSize <= 32);
     return Read<int32_t>();
   }
@@ skipping 149 matching lines @@
   intptr_t size_;
   const uint8_t* instructions_buffer_;
   const uint8_t* data_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(IsolateSnapshotReader);
 };
 
 }  // namespace dart
 
 #endif  // VM_CLUSTERED_SNAPSHOT_H_