minor orb stuff

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

diff --git a/include/c++/orb.h b/include/c++/orb.h
index cba58491b4bc24ba02c52c58adbfee6ec22491b5..23f0b72571ad07e544855e6d7c26748c2ccb456e 100644 (file)
--- a/include/c++/orb.h
+++ b/include/c++/orb.h
@@ -25,15 +25,10 @@ namespace System {
                        
                        ORBMM();
                        
-                       void *alloc(size_t size, AllocGroup *group = NULL);
-                       
-                       void retain(Region region);
-                       void release(Region region);
-                       void super_retain(Region region);
-                       void super_release(Region region);
-                       AllocGroup *create_group();
-                       void destroy_group(AllocGroup *group);
-                       void *add_region(Region region);
+                       void *alloc(size_t size, int refs = 1);
+                       void retain(void *ptr, int refs = 1);
+                       void release(void *ptr, int refs = 1);
+                       void add_region(Region region, bool unmap_orig, int refs = 1);
                };
                
                extern ORBMM *orbmm;
@@ -264,6 +259,9 @@ namespace System {
                uintptr_t downcast(::System::_i_Object *obj,
                                   const unsigned long *new_guid);
 
+               typedef uint64_t GUID[2];
+
+               // FIXME: use above typedef
                static inline bool guids_equal(const unsigned long *guid1,
                                               const unsigned long *guid2)
                {
@@ -274,40 +272,99 @@ namespace System {
                                  guid1[3] == guid2[3])));
                }
                
-               // 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
-               // than a function call.  OPT: put this in lowlevel-lib, so that
-               // architectures can provide a faster version.
-               
-               unsigned long get_pc();
-               
+               typedef uint32_t ID;
                struct ParamInfoBlock {
-                       uintptr_t buffer_size;
-                       void **objlist_ptr;
-                       uintptr_t objlist_len;
-                       void **ptrlist_ptr;
-                       uintptr_t ptrlist_len;
-                       uintptr_t num_segments;
+                       uint32_t buffer_size;
+                       uint32_t copy_size;
+                       ID *objlist;
+                       uint32_t objlist_len;
+                       uint32_t num_segments;
 
                        struct Segment {
-                               void *ptr;
+                               uint8_t *ptr;
                                uintptr_t len;
                                uintptr_t flags;
+                               uintptr_t reserved;
+                               
+                               enum {
+                                       In = 1,
+                                       Out = 2,
+                                       Inline = 4,
+                                       Copy = 8
+                               };
                        } segments[0];
                };
-       }
+               
+               struct Segment0 {
+                       enum {
+                               InvokeMethod = 0,
+                               GetIFaces = 1,
+                               ReturnIFaces = 2,
+                       };
+               
+                       union {
+                               struct {
+                                       uint8_t opcode;
+                               };
+                               
+                               unsigned long pad;
+                       };
+               };
+                       
+               struct InvokeMethod {
+                       Segment0 seg0;
+                       uint32_t iface;
+                       uint32_t method;
+                       uint8_t args[0];
+               };
+               
+               union Message {
+                       Segment0 seg0;
+                       InvokeMethod invoke;
+               };
+       
+               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
+                       // than a function call.  OPT: put this in lowlevel-lib, so that
+                       // architectures can provide a faster version.
+                       
+                       unsigned long get_pc();
+
+                       static inline bool in_kernel()
+                       {
+#ifdef _KERNEL
+                               return true;
+#else
+                               return false;
+#endif
+                       }
+               }
+       };
 }
 
 inline void *operator new(size_t len, ::System::RunTime::ORBMM *orbmm,
-                          ::System::RunTime::ORBMM::AllocGroup *group = NULL)
+                          int refs = 1)
 {
-       return orbmm->alloc(len, group);
+       return orbmm->alloc(len, refs);
 }
 
 inline void *operator new[](size_t len, ::System::RunTime::ORBMM *orbmm,
-                            ::System::RunTime::ORBMM::AllocGroup *group = NULL)
+                            int refs = 1)
+{
+       return orbmm->alloc(len, refs);
+}
+
+inline void operator delete(void *ptr, ::System::RunTime::ORBMM *orbmm,
+                            int refs = 1)
+{
+       orbmm->release(ptr, refs);
+}
+
+inline void operator delete[](void *ptr, ::System::RunTime::ORBMM *orbmm,
+                              int refs = 1)
 {
-       return orbmm->alloc(len, group);
+       orbmm->release(ptr, refs);
 }
 
 // This is a macro rather than an inline template function so that the
@@ -323,16 +380,16 @@ inline void *operator new[](size_t len, ::System::RunTime::ORBMM *orbmm,
        throw T(NULL, NULL, \
                new(::System::RunTime::orbmm) \
                   ::System::Exceptions::NativeCodeExceptionOriginInfo \
-                  (::System::RunTime::get_pc()), \
-               _KERNEL ? 1 : 0, ##args); \
+                  (::System::RunTime::Priv::get_pc()), \
+               ::System::RunTime::Priv::in_kernel(), ##args); \
 } while (0)
 
 #define rethrow_idl(oldex, T, args...) do { \
        throw T(new(::System::RunTime::orbmm) typeof(oldex)(oldex), NULL, \
                new(::System::RunTime::orbmm) \
                   ::System::Exceptions::NativeCodeExceptionOriginInfo \
-                  (::System::RunTime::get_pc()), \
-               _KERNEL ? 1 : 0, ##args); \
+                  (::System::RunTime::Priv::get_pc()), \
+               ::System::RunTime::Priv::in_kernel(), ##args); \
 } while (0)
 #endif