---

yaml
---
r: 3706
b: refs/heads/master
c: 5d9a5b7
h: refs/heads/master
v: v3

Author: Eric Holk

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 8acadb17c2d679291aa94e94af8cc96513cab830
+refs/heads/master: 5d9a5b7d556f6573508c83242a0e7b7795d2c2dd

trunk/src/rt/memory.h

@@ -2,33 +2,42 @@
 #ifndef MEMORY_H
 #define MEMORY_H
 
-inline void *operator new(size_t size, void *mem) {
-    return mem;
+#if 0
+inline void operator delete(void *mem, rust_task *task) {
+    task->free(mem);
+    return;
 }
+#endif
 
-inline void *operator new(size_t size, rust_kernel *kernel) {
-    return kernel->malloc(size);
+// FIXME: It would be really nice to be able to get rid of this.
+inline void *operator new[](size_t size, rust_task *task) {
+    return task->malloc(size);
 }
 
-inline void *operator new(size_t size, rust_task *task) {
+template <typename T>
+inline void *task_owned<T>::operator new(size_t size, rust_task *task) {
     return task->malloc(size);
 }
 
-inline void *operator new[](size_t size, rust_task *task) {
+template <typename T>
+inline void *task_owned<T>::operator new[](size_t size, rust_task *task) {
     return task->malloc(size);
 }
 
-inline void *operator new(size_t size, rust_task &task) {
+template <typename T>
+inline void *task_owned<T>::operator new(size_t size, rust_task &task) {
     return task.malloc(size);
 }
 
-inline void *operator new[](size_t size, rust_task &task) {
+template <typename T>
+inline void *task_owned<T>::operator new[](size_t size, rust_task &task) {
     return task.malloc(size);
 }
 
-inline void operator delete(void *mem, rust_task *task) {
-    task->free(mem);
-    return;
+template <typename T>
+inline void *kernel_owned<T>::operator new(size_t size, rust_kernel *kernel) {
+    return kernel->malloc(size);
 }
 
+
 #endif /* MEMORY_H */

trunk/src/rt/rust_internal.h

@@ -115,12 +115,22 @@ template <typename T> struct rc_base {
 };
 
 template <typename T> struct task_owned {
+    inline void *operator new(size_t size, rust_task *task);
+
+    inline void *operator new[](size_t size, rust_task *task);
+
+    inline void *operator new(size_t size, rust_task &task);
+
+    inline void *operator new[](size_t size, rust_task &task);
+
     void operator delete(void *ptr) {
         ((T *)ptr)->task->free(ptr);
     }
 };
 
 template <typename T> struct kernel_owned {
+    inline void *operator new(size_t size, rust_kernel *kernel);
+
     void operator delete(void *ptr) {
         ((T *)ptr)->kernel->free(ptr);
     }

trunk/src/rt/rust_util.h

@@ -184,6 +184,10 @@ rust_vec : public rc_base<rust_vec>
             memcpy(&data[0], d, fill);
     }
     ~rust_vec() {}
+
+    inline void *operator new(size_t size, void *mem) {
+        return mem;
+    }
 };
 
 // Rust types vec and str look identical from our perspective.