xfer to odin

[polintos/scott/priv.git] / include / c++ / orb.h

diff --git a/include/c++/orb.h b/include/c++/orb.h
index 23f0b72571ad07e544855e6d7c26748c2ccb456e..30c4157728e083e885d37188f1fa56ed88f5425e 100644 (file)
--- a/include/c++/orb.h
+++ b/include/c++/orb.h
@@ -4,6 +4,10 @@
 #include <stdint.h>
 #include <stddef.h>
 #include <string.h>
+#include <limits.h>
+
+#include <lowlevel/barriers.h>
+#include <lowlevel/bitops.h>
 
 namespace System {
        struct _i_Object;
@@ -125,6 +129,71 @@ namespace System {
                                return new_arr;
                        }
                };
+               
+               template<typename T>
+               struct GrowableArray : public MutableArray<T> {
+                       using MutableArray<T>::ptr;
+                       using MutableArray<T>::count;
+                       size_t bufsize;
+                       
+                       GrowableArray()
+                       {
+                               bufsize = 0;
+                       }
+                       
+                       GrowableArray(NullArray na) : MutableArray<T>(na)
+                       {
+                               bufsize = 0;
+                       }
+                       
+                       GrowableArray(T *PTR, size_t COUNT) : MutableArray<T>(PTR, COUNT)
+                       {
+                               bufsize = COUNT;
+                       }
+                       
+                       GrowableArray(T *PTR, size_t COUNT, size_t BUFSIZE) :
+                       MutableArray<T>(PTR, COUNT)
+                       {
+                               bufsize = BUFSIZE;
+                       }
+                       
+                       GrowableArray(MutableArray<T> &ma) : MutableArray<T>(ma)
+                       {
+                               bufsize = count;
+                       }
+                       
+                       void grow(size_t newsize)
+                       {
+                               if (newsize <= bufsize)
+                                       return;
+                               
+                               T *oldptr = ptr;
+                               T *newptr = new(orbmm) T[newsize];
+                               memcpy(newptr, ptr, count * sizeof(T));
+                               ptr = newptr;
+                               ll_smp_membar_store_after_store();
+                               bufsize = newsize;
+                               // FIXME: Should release imply membar?
+                               ll_smp_membar_any_after_store();
+                               orbmm->release(oldptr);
+                       }
+                       
+                       // Caller must sync against all writers.
+                       void append(T *newptr, size_t len, size_t max = ULONG_MAX)
+                       {
+                               if (count + len < count)
+                                       throw ArrayException();
+                               
+                               if (count + len > max)
+                                       throw ArrayException();
+                               
+                               if (count + len > bufsize)
+                                       grow(ll_get_order_round_up(count + len));
+                               
+                               memcpy(ptr + count, newptr, len * sizeof(T));
+                               count += len;
+                       }
+               };
 
                template<typename T> struct Array {
                        const T *ptr;
@@ -239,8 +308,10 @@ namespace System {
                        return ret;
                }
                
+               struct IFaceInfo;
+
                struct IFaceTable {
-                       const unsigned long *const guid;
+                       const IFaceInfo *info;
                        const ptrdiff_t offset;
                };
                
@@ -322,7 +393,19 @@ namespace System {
                        Segment0 seg0;
                        InvokeMethod invoke;
                };
-       
+
+               struct IFaceInfo {
+                       static const uint8_t *guid;
+                       int (*marshall)(GrowableArray<uint8_t> &buf,
+                                       GrowableArray<ID> &objlist,
+                                       ParamInfoBlock::Segment *segs,
+                                       int nsegs);
+                       void (*unmarshall)(Array<uint8_t> buf,
+                                          Array<ID> objlist,
+                                          ParamInfoBlock::Segment *segs,
+                                          int nsegs);
+               };
+               
                namespace Priv {
                        // Return the caller's PC.  It'd be nice if GCC had a builtin for
                        // the current PC, so that a simple relocation could be used rather
@@ -355,6 +438,7 @@ inline void *operator new[](size_t len, ::System::RunTime::ORBMM *orbmm,
        return orbmm->alloc(len, refs);
 }
 
+// FIXME: This isn't safe on anything with a descructor.
 inline void operator delete(void *ptr, ::System::RunTime::ORBMM *orbmm,
                             int refs = 1)
 {