- Add AtomicOperations::CompareAndSwapWord

runtime/vm/snapshot.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_SNAPSHOT_H_
 #define VM_SNAPSHOT_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
@@ skipping 410 matching lines @@
   friend class TypeParameter;
   friend class TypeRef;
   friend class UnresolvedClass;
   friend class UnhandledException;
   friend class WeakProperty;
   friend class MirrorReference;
   DISALLOW_COPY_AND_ASSIGN(SnapshotReader);
 };
 
 
-class BaseWriter {
+class BaseWriter : public StackResource {
  public:
   // Size of the snapshot.
   intptr_t BytesWritten() const { return stream_.bytes_written(); }
 
   // Writes raw data to the stream (basic type).
   // sizeof(T) must be in {1,2,4,8}.
   template <typename T>
   void Write(T value) {
     WriteStream::Raw<sizeof(T), T>::Write(&stream_, value);
   }
@@ skipping 47 matching lines @@
     stream_.WriteBytes(addr, len);
   }
 
   void WriteDouble(double value) {
     stream_.WriteBytes(reinterpret_cast<const uint8_t*>(&value), sizeof(value));
   }
 
  protected:
   BaseWriter(uint8_t** buffer,
              ReAlloc alloc,
-             intptr_t initial_size) : stream_(buffer, alloc, initial_size) {
+             intptr_t initial_size)
+      : StackResource(Isolate::Current()),
+        stream_(buffer, alloc, initial_size) {
     ASSERT(buffer != NULL);
     ASSERT(alloc != NULL);
   }
   ~BaseWriter() { }
 
   void ReserveHeader() {
     // Make room for recording snapshot buffer size.
     stream_.set_current(stream_.buffer() + Snapshot::kHeaderSize);
   }
 
   void FillHeader(Snapshot::Kind kind) {
     int64_t* data = reinterpret_cast<int64_t*>(stream_.buffer());
     data[Snapshot::kLengthIndex] = stream_.bytes_written();
     data[Snapshot::kSnapshotFlagIndex] = kind;
   }
 
  private:
   WriteStream stream_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(BaseWriter);
 };
 
 
 class ForwardList {
  public:
-  explicit ForwardList(intptr_t first_object_id)
-      : first_object_id_(first_object_id),
-        nodes_(),
-        first_unprocessed_object_id_(first_object_id) {}
+  explicit ForwardList(intptr_t first_object_id);
+  ~ForwardList();
 
   class Node : public ZoneAllocated {
    public:
     Node(RawObject* raw, uword tags, SerializeState state)
         : raw_(raw), tags_(tags), state_(state) {}
     RawObject* raw() const { return raw_; }
     uword tags() const { return tags_; }
     bool is_serialized() const { return state_ == kIsSerialized; }
 
    private:
@@ skipping 85 matching lines @@
                     RawTypeArguments* type_arguments,
                     RawObject* data[]);
   void CheckIfSerializable(RawClass* cls);
   void SetWriteException(Exceptions::ExceptionType type, const char* msg);
   void WriteInstance(intptr_t object_id,
                      RawObject* raw,
                      RawClass* cls,
                      intptr_t tags);
   void WriteInstanceRef(RawObject* raw, RawClass* cls);
 
+  Isolate* isolate() const { return isolate_; }
   ObjectStore* object_store() const { return object_store_; }
 
  private:
   Snapshot::Kind kind_;
+  Isolate* isolate_;
   ObjectStore* object_store_;  // Object store for common classes.
   ClassTable* class_table_;  // Class table for the class index to class lookup.
   ForwardList forward_list_;
   Exceptions::ExceptionType exception_type_;  // Exception type.
   const char* exception_msg_;  // Message associated with exception.
 
   friend class RawArray;
   friend class RawClass;
   friend class RawClosureData;
   friend class RawGrowableObjectArray;
@@ skipping 87 matching lines @@
  private:
   SnapshotWriter* writer_;
   bool as_references_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriterVisitor);
 };
 
 }  // namespace dart
 
 #endif  // VM_SNAPSHOT_H_