Implement a garbage collection prologue and epilogue callback mechanism.

runtime/vm/gc_callbacks.h

Index: runtime/vm/gc_callbacks.h
diff --git a/runtime/vm/gc_callbacks.h b/runtime/vm/gc_callbacks.h
new file mode 100644
index 0000000000000000000000000000000000000000..1081fa853a4fd8861efba7ad3052e12f64464989
--- /dev/null
+++ b/runtime/vm/gc_callbacks.h
@@ -0,0 +1,111 @@
+// 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_GC_CALLBACKS_H_
+#define VM_GC_CALLBACKS_H_
+
+#include "include/dart_api.h"
+#include "platform/utils.h"
+
+namespace dart {
+
+// A container for garbage collection callback function pointers.
+// Pointers to the callback methods are stored within linked list
+// nodes managed by the container.
+template<typename T>
+class GcCallbacks {
+ public:
+  GcCallbacks() : head_(NULL) {
+  }
+
+  ~GcCallbacks() {
+    while (head_ != NULL) {
+      Link* prev = head_;
+      head_ = head_->next_;
+      delete prev;
+    }
+  }
+
+  // Adds a new callback to the list.  The new callback must not
+  // already be present in the list.
+  void Add(T callback) {
+    ASSERT(callback != NULL);
+    Link* link = new Link(callback, head_);
+    head_ = link;
+  }
+
+  // Removes a callback from the list.  The callback must be present
+  // in the list.
+  void Remove(T callback) {
+    ASSERT(callback != NULL);
+    if (head_ == NULL) return;
+    Link* prev = head_;
+    Link* curr = head_->next_;
+    if (prev->callback_ == callback) {
+      head_ = curr;
+      delete prev;
+      return;
+    }
+    while (curr != NULL) {
+      if (curr->callback_ == callback) {
+        prev->next_ = curr->next_;
+        delete curr;
+        return;
+      }
+      prev = curr;
+      curr = curr->next_;
+    }
+  }
+
+  // Iterates through all of the callbacks in the list and invokes
+  // their callback methods.
+  void Invoke() const {
+    for (Link* curr = head_; curr != NULL; curr = curr->next_) {
+      (*curr->callback_)();
+    }
+  }
+
+  // Returns the number of callbacks stored in the list.
+  intptr_t Count() const {
+    intptr_t sum = 0;
+    for (Link* curr = head_; curr != NULL; curr = curr->next_) {
+      ++sum;
+    }
+    return sum;
+  }
+
+  // Returns true if the specified callback is present in the
+  // container.
+  bool Contains(T callback) const {
+    for (Link* curr = head_; curr != NULL; curr = curr->next_) {
+      if (curr->callback_ == callback) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+ private:
+  // A linked-list element.
+  struct Link {
+    Link(T callback, Link* next) : callback_(callback), next_(next) {
+    }
+    T callback_;
+    Link* next_;
+  };
+
+  Link* head_;
+};
+
+
+// A container for storing garbage collection prologue methods.
+class GcPrologueCallbacks : public GcCallbacks<Dart_GcPrologueCallback> {};
+
+
+// A container for storing garbage collection epilogue methods.
+class GcEpilogueCallbacks : public GcCallbacks<Dart_GcEpilogueCallback> {};
+
+};  // namespace dart
+
+#endif  // VM_GC_CALLBACKS_H_