CWS-TOOLING: integrate CWS selinux01

2009-01-13 12:54:38 +0100 cmc  r266213 : #i97320# might as well be silent if we fallback
2009-01-07 11:17:16 +0100 cmc  r265957 : #i97320# use a double-mmap of an anonymous file under linux to keep onside of selinux

13 files changed, 171 insertions, 55 deletions

diff --git a/bridges/inc/bridges/cpp_uno/shared/vtablefactory.hxx b/bridges/inc/bridges/cpp_uno/shared/vtablefactory.hxx
index bed106b49db0..9d7fe10df838 100644
--- a/bridges/inc/bridges/cpp_uno/shared/vtablefactory.hxx
+++ b/bridges/inc/bridges/cpp_uno/shared/vtablefactory.hxx
@@ -39,6 +39,11 @@
 
 #include <hash_map>
 
+/*See: http://people.redhat.com/drepper/selinux-mem.html*/
+#ifdef LINUX
+#define USE_DOUBLE_MMAP
+#endif
+
 namespace bridges { namespace cpp_uno { namespace shared {
 
 /** Hand out vtable structures for interface type descriptions.
@@ -63,6 +68,18 @@ public:
          */
         void * start;
 
+#ifdef USE_DOUBLE_MMAP
+    /** When seperately mmapping the block for writing and executing
+            exec points to the same memory as start, except start is used
+            exclusively for writing and exec for executing
+         */
+        void * exec;
+
+    /** File handle for the underlying anonymous file
+         */
+        int fd;
+#endif
+
         /** The size of the raw vtable block, in bytes.
          */
         sal_Size size;
@@ -111,6 +128,8 @@ private:
     VtableFactory(VtableFactory &); // not implemented
     void operator =(VtableFactory); // not implemented
 
+    bool createBlock(Block &block, sal_Int32 slotCount) const;
+
     void freeBlock(Block const & block) const;
 
     void createVtables(
@@ -151,6 +170,9 @@ private:
         given type
         @param code  points to the start of the area where code snippets can be
         generated
+        @param writetoexecdiff when the same code area is mmaped twice, once for
+        writing for code-generation, and once for code-execution, then this
+        records the offset from a writable address to its executable address
         @param type  the interface type description for which to generate vtable
         slots
         @param functionOffset  the function offset of the first vtable slot
@@ -165,6 +187,9 @@ private:
      */
     static unsigned char * addLocalFunctions(
         Slot ** slots, unsigned char * code,
+#ifdef USE_DOUBLE_MMAP
+        sal_PtrDiff writetoexecdiff,
+#endif
         typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
         sal_Int32 functionCount, sal_Int32 vtableOffset);
 
diff --git a/bridges/source/cpp_uno/gcc3_linux_arm/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_arm/cpp2uno.cxx
index dec7ce91d45a..23e33acafaa4 100644
--- a/bridges/source/cpp_uno/gcc3_linux_arm/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_arm/cpp2uno.cxx
@@ -467,7 +467,7 @@ bridges::cpp_uno::shared::VtableFactory::initializeBlock(
 }
 
 unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
-    Slot ** slots, unsigned char * code,
+    Slot ** slots, unsigned char * code, sal_PtrDiff writetoexecdiff,
     typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
     sal_Int32 functionCount, sal_Int32 vtableOffset)
 {
@@ -482,7 +482,7 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
         {
             case typelib_TypeClass_INTERFACE_ATTRIBUTE:
                 // Getter:
-                (s++)->fn = code;
+                (s++)->fn = code + writetoexecdiff;
                 code = codeSnippet(
                     code, functionOffset++, vtableOffset,
                     bridges::cpp_uno::shared::isSimpleType(
@@ -494,14 +494,14 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
                     typelib_InterfaceAttributeTypeDescription * >(
                         member)->bReadOnly)
                 {
-                    (s++)->fn = code;
+                    (s++)->fn = code + writetoexecdiff;
                     code = codeSnippet(
                         code, functionOffset++, vtableOffset, true);
                 }
                 break;
             case typelib_TypeClass_INTERFACE_METHOD:
             {
-                (s++)->fn = code;
+                (s++)->fn = code + writetoexecdiff;
 
                 typelib_InterfaceMethodTypeDescription *pMethodTD =
                     reinterpret_cast<
diff --git a/bridges/source/cpp_uno/gcc3_linux_ia64/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_ia64/cpp2uno.cxx
index 95dfdc0db67b..900560794513 100644
--- a/bridges/source/cpp_uno/gcc3_linux_ia64/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_ia64/cpp2uno.cxx
@@ -575,7 +575,7 @@ namespace
 {
 const int codeSnippetSize = 40;
 
-bridges::cpp_uno::shared::VtableFactory::Slot codeSnippet( unsigned char * code, sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset,
+bridges::cpp_uno::shared::VtableFactory::Slot codeSnippet( unsigned char * code, sal_PtrDiff writetoexecdiff, sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset,
                               bool bHasHiddenParam )
 {
 #ifdef CMC_DEBUG
@@ -598,7 +598,7 @@ bridges::cpp_uno::shared::VtableFactory::Slot codeSnippet( unsigned char * code,
     raw[2] = nOffsetAndIndex;
     raw[3] = destination->gp_value;
 
-    return *(bridges::cpp_uno::shared::VtableFactory::Slot*)(code);
+    return *(bridges::cpp_uno::shared::VtableFactory::Slot*)(code+writetoexecdiff);
 }
 }
 
@@ -628,7 +628,7 @@ bridges::cpp_uno::shared::VtableFactory::Slot* bridges::cpp_uno::shared::VtableF
 }
 
 unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
-    Slot ** in_slots, unsigned char * code,
+    Slot ** in_slots, unsigned char * code, sal_PtrDiff writetoexecdiff,
     typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
     sal_Int32 functionCount, sal_Int32 vtableOffset)
 {
@@ -647,7 +647,7 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
         case typelib_TypeClass_INTERFACE_ATTRIBUTE:
             // Getter:
             *slots++ = codeSnippet(
-                code, functionOffset++, vtableOffset,
+                code, writetoexecdiff, functionOffset++, vtableOffset,
                 ia64::return_in_hidden_param(
                     reinterpret_cast<
                     typelib_InterfaceAttributeTypeDescription * >(
@@ -660,14 +660,14 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
                 typelib_InterfaceAttributeTypeDescription * >(
                     member)->bReadOnly)
             {
-                *slots++ = codeSnippet(code, functionOffset++, vtableOffset, false);
+                *slots++ = codeSnippet(code, writetoexecdiff, functionOffset++, vtableOffset, false);
                 code += codeSnippetSize;
             }
             break;
 
         case typelib_TypeClass_INTERFACE_METHOD:
             *slots++ = codeSnippet(
-                code, functionOffset++, vtableOffset,
+                code, writetoexecdiff, functionOffset++, vtableOffset,
                 ia64::return_in_hidden_param(
                     reinterpret_cast<
                     typelib_InterfaceMethodTypeDescription * >(
diff --git a/bridges/source/cpp_uno/gcc3_linux_intel/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_intel/cpp2uno.cxx
index 40420633f923..6e6c2009dde8 100644
--- a/bridges/source/cpp_uno/gcc3_linux_intel/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_intel/cpp2uno.cxx
@@ -362,7 +362,7 @@ extern "C" typedef void (*PrivateSnippetExecutor)();
 int const codeSnippetSize = 16;
 
 unsigned char * codeSnippet(
-    unsigned char * code, sal_Int32 functionIndex, sal_Int32 vtableOffset,
+    unsigned char * code, sal_PtrDiff writetoexecdiff, sal_Int32 functionIndex, sal_Int32 vtableOffset,
     typelib_TypeClass returnTypeClass)
 {
     if (!bridges::cpp_uno::shared::isSimpleType(returnTypeClass)) {
@@ -408,7 +408,7 @@ unsigned char * codeSnippet(
     // jmp privateSnippetExecutor:
     *p++ = 0xE9;
     *reinterpret_cast< sal_Int32 * >(p)
-        = ((unsigned char *) exec) - p - sizeof (sal_Int32);
+        = ((unsigned char *) exec) - p - sizeof (sal_Int32) - writetoexecdiff;
     p += sizeof (sal_Int32);
     OSL_ASSERT(p - code <= codeSnippetSize);
     return code + codeSnippetSize;
@@ -440,7 +440,7 @@ bridges::cpp_uno::shared::VtableFactory::initializeBlock(
 }
 
 unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
-    Slot ** slots, unsigned char * code,
+    Slot ** slots, unsigned char * code, sal_PtrDiff writetoexecdiff,
     typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
     sal_Int32 functionCount, sal_Int32 vtableOffset)
 {
@@ -453,9 +453,9 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
         switch (member->eTypeClass) {
         case typelib_TypeClass_INTERFACE_ATTRIBUTE:
             // Getter:
-            (s++)->fn = code;
+            (s++)->fn = code + writetoexecdiff;
             code = codeSnippet(
-                code, functionOffset++, vtableOffset,
+                code, writetoexecdiff, functionOffset++, vtableOffset,
                 reinterpret_cast< typelib_InterfaceAttributeTypeDescription * >(
                     member)->pAttributeTypeRef->eTypeClass);
             // Setter:
@@ -463,17 +463,17 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
                 typelib_InterfaceAttributeTypeDescription * >(
                     member)->bReadOnly)
             {
-                (s++)->fn = code;
+                (s++)->fn = code + writetoexecdiff;
                 code = codeSnippet(
-                    code, functionOffset++, vtableOffset,
+                    code, writetoexecdiff, functionOffset++, vtableOffset,
                     typelib_TypeClass_VOID);
             }
             break;
 
         case typelib_TypeClass_INTERFACE_METHOD:
-            (s++)->fn = code;
+            (s++)->fn = code + writetoexecdiff;
             code = codeSnippet(
-                code, functionOffset++, vtableOffset,
+                code, writetoexecdiff, functionOffset++, vtableOffset,
                 reinterpret_cast< typelib_InterfaceMethodTypeDescription * >(
                     member)->pReturnTypeRef->eTypeClass);
             break;
diff --git a/bridges/source/cpp_uno/gcc3_linux_m68k/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_m68k/cpp2uno.cxx
index ef5fc6b4e2f9..0581b52f0c8d 100644
--- a/bridges/source/cpp_uno/gcc3_linux_m68k/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_m68k/cpp2uno.cxx
@@ -482,7 +482,7 @@ bridges::cpp_uno::shared::VtableFactory::initializeBlock(
 }
 
 unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
-    Slot ** slots, unsigned char * code,
+    Slot ** slots, unsigned char * code, sal_PtrDiff writetoexecdiff,
     typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
     sal_Int32 functionCount, sal_Int32 vtableOffset)
 {
@@ -497,20 +497,20 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
         {
             case typelib_TypeClass_INTERFACE_ATTRIBUTE:
                 // Getter:
-                (s++)->fn = code;
+                (s++)->fn = code + writetoexecdiff;
                 code = codeSnippet(code, functionOffset++, vtableOffset);
                 // Setter:
                 if (!reinterpret_cast<
                     typelib_InterfaceAttributeTypeDescription * >(
                         member)->bReadOnly)
                 {
-                    (s++)->fn = code;
+                    (s++)->fn = code + writetoexecdiff;
                     code = codeSnippet(code, functionOffset++, vtableOffset);
                 }
                 break;
             case typelib_TypeClass_INTERFACE_METHOD:
             {
-                (s++)->fn = code;
+                (s++)->fn = code + writetoexecdiff;
 
                 typelib_InterfaceMethodTypeDescription *pMethodTD =
                     reinterpret_cast<
diff --git a/bridges/source/cpp_uno/gcc3_linux_mips/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_mips/cpp2uno.cxx
index 5f453a8dec2d..ec4055ca74c4 100644
--- a/bridges/source/cpp_uno/gcc3_linux_mips/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_mips/cpp2uno.cxx
@@ -747,7 +747,7 @@ bridges::cpp_uno::shared::VtableFactory::initializeBlock(
 }
 
 unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
-    Slot ** slots, unsigned char * code,
+    Slot ** slots, unsigned char * code, sal_PtrDiff writetoexecdiff,
     typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
     sal_Int32 functionCount, sal_Int32 vtableOffset)
 {
@@ -767,7 +767,7 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
     switch (member->eTypeClass) {
       case typelib_TypeClass_INTERFACE_ATTRIBUTE:
         // Getter:
-        (s++)->fn = code;
+        (s++)->fn = code + writetoexecdiff;
         code = codeSnippet(
             code, functionOffset++, vtableOffset,
             bridges::cpp_uno::shared::isSimpleType(
@@ -780,13 +780,13 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
             typelib_InterfaceAttributeTypeDescription * >(
               member)->bReadOnly)
         {
-          (s++)->fn = code;
+          (s++)->fn = code + writetoexecdiff;
           code = codeSnippet(code, functionOffset++, vtableOffset, true);
         }
         break;
 
       case typelib_TypeClass_INTERFACE_METHOD:
-        (s++)->fn = code;
+        (s++)->fn = code + writetoexecdiff;
         code = codeSnippet(
             code, functionOffset++, vtableOffset,
             bridges::cpp_uno::shared::isSimpleType(
diff --git a/bridges/source/cpp_uno/gcc3_linux_powerpc/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_powerpc/cpp2uno.cxx
index 92b6a2ce3ab2..1aca0f480b6a 100644
--- a/bridges/source/cpp_uno/gcc3_linux_powerpc/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_powerpc/cpp2uno.cxx
@@ -681,7 +681,7 @@ bridges::cpp_uno::shared::VtableFactory::initializeBlock(
 }
 
 unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
-    Slot ** slots, unsigned char * code,
+    Slot ** slots, unsigned char * code, sal_PtrDiff writetoexecdiff,
     typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
     sal_Int32 functionCount, sal_Int32 vtableOffset)
 {
@@ -698,7 +698,7 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
         switch (member->eTypeClass) {
         case typelib_TypeClass_INTERFACE_ATTRIBUTE:
             // Getter:
-            (s++)->fn = code;
+            (s++)->fn = code + writetoexecdiff;
             code = codeSnippet(
                 code, functionOffset++, vtableOffset,
                 bridges::cpp_uno::shared::isSimpleType(
@@ -711,13 +711,13 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
                 typelib_InterfaceAttributeTypeDescription * >(
                     member)->bReadOnly)
             {
-                (s++)->fn = code;
+                (s++)->fn = code + writetoexecdiff;
                 code = codeSnippet(code, functionOffset++, vtableOffset, true);
             }
             break;
 
         case typelib_TypeClass_INTERFACE_METHOD:
-            (s++)->fn = code;
+            (s++)->fn = code + writetoexecdiff;
             code = codeSnippet(
                 code, functionOffset++, vtableOffset,
                 bridges::cpp_uno::shared::isSimpleType(
diff --git a/bridges/source/cpp_uno/gcc3_linux_powerpc64/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_powerpc64/cpp2uno.cxx
index 600ca1a3ebb6..e514914db3b7 100644
--- a/bridges/source/cpp_uno/gcc3_linux_powerpc64/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_powerpc64/cpp2uno.cxx
@@ -667,7 +667,7 @@ bridges::cpp_uno::shared::VtableFactory::initializeBlock(
 }
 
 unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
-    Slot ** slots, unsigned char * code,
+    Slot ** slots, unsigned char * code, sal_PtrDiff writetoexecdiff,
     typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
     sal_Int32 functionCount, sal_Int32 vtableOffset)
 {
@@ -685,7 +685,7 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
         switch (member->eTypeClass) {
         case typelib_TypeClass_INTERFACE_ATTRIBUTE:
             // Getter:
-            (s++)->fn = code;
+            (s++)->fn = code + writetoexecdiff;
             code = codeSnippet(
                 code, functionOffset++, vtableOffset,
                 bridges::cpp_uno::shared::isSimpleType(
@@ -698,13 +698,13 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
                 typelib_InterfaceAttributeTypeDescription * >(
                     member)->bReadOnly)
             {
-                (s++)->fn = code;
+                (s++)->fn = code + writetoexecdiff;
                 code = codeSnippet(code, functionOffset++, vtableOffset, true);
             }
             break;
 
         case typelib_TypeClass_INTERFACE_METHOD:
-            (s++)->fn = code;
+            (s++)->fn = code + writetoexecdiff;
             code = codeSnippet(
                 code, functionOffset++, vtableOffset,
                 bridges::cpp_uno::shared::isSimpleType(
diff --git a/bridges/source/cpp_uno/gcc3_linux_s390/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_s390/cpp2uno.cxx
index b29acb8db749..3ebc8a589df0 100644
--- a/bridges/source/cpp_uno/gcc3_linux_s390/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_s390/cpp2uno.cxx
@@ -640,7 +640,7 @@ bridges::cpp_uno::shared::VtableFactory::initializeBlock(
 }
 
 unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
-    Slot ** slots, unsigned char * code,
+    Slot ** slots, unsigned char * code, sal_PtrDiff writetoexecdiff,
     typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
     sal_Int32 functionCount, sal_Int32 vtableOffset)
 {
@@ -658,7 +658,7 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
         switch (member->eTypeClass) {
         case typelib_TypeClass_INTERFACE_ATTRIBUTE:
             // Getter:
-            (s++)->fn = code;
+            (s++)->fn = code + writetoexecdiff;
             code = codeSnippet(
                 code, functionOffset++, vtableOffset,
                 bridges::cpp_uno::shared::isSimpleType(
@@ -671,13 +671,13 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
                 typelib_InterfaceAttributeTypeDescription * >(
                     member)->bReadOnly)
             {
-                (s++)->fn = code;
+                (s++)->fn = code + writetoexecdiff;
                 code = codeSnippet(code, functionOffset++, vtableOffset, true);
             }
             break;
 
         case typelib_TypeClass_INTERFACE_METHOD:
-            (s++)->fn = code;
+            (s++)->fn = code + writetoexecdiff;
             code = codeSnippet(
                 code, functionOffset++, vtableOffset,
                 bridges::cpp_uno::shared::isSimpleType(
diff --git a/bridges/source/cpp_uno/gcc3_linux_s390x/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_s390x/cpp2uno.cxx
index af1d8a84a903..e866e05f32c5 100644
--- a/bridges/source/cpp_uno/gcc3_linux_s390x/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_s390x/cpp2uno.cxx
@@ -597,7 +597,7 @@ bridges::cpp_uno::shared::VtableFactory::initializeBlock(
 }
 
 unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
-    Slot ** slots, unsigned char * code,
+    Slot ** slots, unsigned char * code, sal_PtrDiff writetoexecdiff,
     typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
     sal_Int32 functionCount, sal_Int32 vtableOffset)
 {
@@ -615,7 +615,7 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
         switch (member->eTypeClass) {
         case typelib_TypeClass_INTERFACE_ATTRIBUTE:
             // Getter:
-            (s++)->fn = code;
+            (s++)->fn = code + writetoexecdiff;
             code = codeSnippet(
                 code, functionOffset++, vtableOffset,
                 bridges::cpp_uno::shared::isSimpleType(
@@ -628,13 +628,13 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
                 typelib_InterfaceAttributeTypeDescription * >(
                     member)->bReadOnly)
             {
-                (s++)->fn = code;
+                (s++)->fn = code + writetoexecdiff;
                 code = codeSnippet(code, functionOffset++, vtableOffset, true);
             }
             break;
 
         case typelib_TypeClass_INTERFACE_METHOD:
-            (s++)->fn = code;
+            (s++)->fn = code + writetoexecdiff;
             code = codeSnippet(
                 code, functionOffset++, vtableOffset,
                 bridges::cpp_uno::shared::isSimpleType(
diff --git a/bridges/source/cpp_uno/gcc3_linux_sparc/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_sparc/cpp2uno.cxx
index 4c0cdf9071d6..4e07c2c879d7 100644
--- a/bridges/source/cpp_uno/gcc3_linux_sparc/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_sparc/cpp2uno.cxx
@@ -513,7 +513,7 @@ bridges::cpp_uno::shared::VtableFactory::initializeBlock(
 }
 
 unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
-    Slot ** slots, unsigned char * code,
+    Slot ** slots, unsigned char * code, sal_PtrDiff writetoexecdiff,
     typelib_InterfaceTypeDescription const * type, sal_Int32 functionOffset,
     sal_Int32 functionCount, sal_Int32 vTableOffset)
 {
@@ -526,7 +526,7 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
         switch (member->eTypeClass) {
         case typelib_TypeClass_INTERFACE_ATTRIBUTE:
             // Getter:
-            (s++)->fn = code;
+            (s++)->fn = code + writetoexecdiff;
             code = codeSnippet(
                 code, functionOffset++, vTableOffset,
                 bridges::cpp_uno::shared::isSimpleType(
@@ -538,13 +538,13 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
                 typelib_InterfaceAttributeTypeDescription * >(
                     member)->bReadOnly)
             {
-                (s++)->fn = code;
+                (s++)->fn = code + writetoexecdiff;
                 code = codeSnippet(code, functionOffset++, vTableOffset, true);
             }
             break;
 
         case typelib_TypeClass_INTERFACE_METHOD:
-            (s++)->fn = code;
+            (s++)->fn = code + writetoexecdiff;
             code = codeSnippet(
                 code, functionOffset++, vTableOffset,
                 bridges::cpp_uno::shared::isSimpleType(
diff --git a/bridges/source/cpp_uno/gcc3_linux_x86-64/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_linux_x86-64/cpp2uno.cxx
index cb6fb6e179db..5fb2bd7e12a3 100644
--- a/bridges/source/cpp_uno/gcc3_linux_x86-64/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_linux_x86-64/cpp2uno.cxx
@@ -489,7 +489,7 @@ bridges::cpp_uno::shared::VtableFactory::initializeBlock(
 //==================================================================================================
 
 unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
-    Slot ** slots, unsigned char * code,
+    Slot ** slots, unsigned char * code, sal_PtrDiff writetoexecdiff,
     typelib_InterfaceTypeDescription const * type, sal_Int32 nFunctionOffset,
     sal_Int32 functionCount, sal_Int32 nVtableOffset )
 {
@@ -508,14 +508,14 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
                 reinterpret_cast<typelib_InterfaceAttributeTypeDescription *>( pTD );
 
             // get method
-            (s++)->fn = code;
+            (s++)->fn = code + writetoexecdiff;
             code = codeSnippet( code, nFunctionOffset++, nVtableOffset,
                                 x86_64::return_in_hidden_param( pAttrTD->pAttributeTypeRef ) );
 
             if ( ! pAttrTD->bReadOnly )
             {
                 // set method
-                (s++)->fn = code;
+                (s++)->fn = code + writetoexecdiff;
                 code = codeSnippet( code, nFunctionOffset++, nVtableOffset, false );
             }
         }
@@ -524,7 +524,7 @@ unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
             typelib_InterfaceMethodTypeDescription *pMethodTD =
                 reinterpret_cast<typelib_InterfaceMethodTypeDescription *>( pTD );
 
-            (s++)->fn = code;
+            (s++)->fn = code + writetoexecdiff;
             code = codeSnippet( code, nFunctionOffset++, nVtableOffset,
                                 x86_64::return_in_hidden_param( pMethodTD->pReturnTypeRef ) );
         }
diff --git a/bridges/source/cpp_uno/shared/vtablefactory.cxx b/bridges/source/cpp_uno/shared/vtablefactory.cxx
index 6df4f53d9897..34e5f9635974 100644
--- a/bridges/source/cpp_uno/shared/vtablefactory.cxx
+++ b/bridges/source/cpp_uno/shared/vtablefactory.cxx
@@ -42,6 +42,9 @@
 
 #include "bridges/cpp_uno/shared/vtables.hxx"
 
+#include "osl/thread.h"
+#include "osl/security.hxx"
+#include "osl/file.hxx"
 #include "osl/diagnose.h"
 #include "osl/mutex.hxx"
 #include "rtl/alloc.h"
@@ -55,6 +58,7 @@
 
 #if defined SAL_UNX
 #include <unistd.h>
+#include <string.h>
 #include <sys/mman.h>
 #elif defined SAL_W32
 #define WIN32_LEAN_AND_MEAN
@@ -243,9 +247,89 @@ VtableFactory::Vtables VtableFactory::getVtables(
     return i->second;
 }
 
+#ifdef USE_DOUBLE_MMAP
+bool VtableFactory::createBlock(Block &block, sal_Int32 slotCount) const
+{
+    sal_Size size = getBlockSize(slotCount);
+    sal_Size pagesize = sysconf(_SC_PAGESIZE);
+    block.size = (size + (pagesize - 1)) & ~(pagesize - 1);
+    block.start = block.exec = NULL;
+    block.fd = -1;
+
+    osl::Security aSecurity;
+    rtl::OUString strDirectory;
+    rtl::OUString strURLDirectory;
+    if (aSecurity.getHomeDir(strURLDirectory))
+        osl::File::getSystemPathFromFileURL(strURLDirectory, strDirectory);
+
+    for (int i = strDirectory.getLength() == 0 ? 1 : 0; i < 2; ++i)
+    {
+        if (!strDirectory.getLength())
+            strDirectory = rtl::OUString::createFromAscii("/tmp");
+
+        strDirectory += rtl::OUString::createFromAscii("/.execoooXXXXXX");
+        rtl::OString aTmpName = rtl::OUStringToOString(strDirectory, osl_getThreadTextEncoding());
+        char *tmpfname = new char[aTmpName.getLength()+1];
+        strncpy(tmpfname, aTmpName.getStr(), aTmpName.getLength()+1);
+        if ((block.fd = mkstemp(tmpfname)) == -1)
+          perror("creation of executable memory area failed");
+        if (block.fd == -1)
+        {
+            delete[] tmpfname;
+            break;
+        }
+        unlink(tmpfname);
+        delete[] tmpfname;
+        ftruncate(block.fd, block.size);
+        block.start = mmap(NULL, block.size, PROT_READ | PROT_WRITE, MAP_SHARED, block.fd, 0);
+        if (block.start== MAP_FAILED) {
+            block.start = 0;
+        }
+        block.exec = mmap(NULL, block.size, PROT_READ | PROT_EXEC, MAP_SHARED, block.fd, 0);
+        if (block.exec == MAP_FAILED) {
+           block.exec = 0;
+        }
+
+        //All good
+        if (block.start && block.exec && block.fd != -1)
+            break;
+
+        freeBlock(block);
+
+        strDirectory = rtl::OUString();
+    }
+    if (!block.start || !block.exec || block.fd == -1)
+    {
+       //Fall back to non-doublemmaped allocation
+       block.fd = -1;
+       block.start = block.exec = rtl_arena_alloc(m_arena, &block.size);
+    }
+    return (block.start != 0 && block.exec != 0);
+}
+
+void VtableFactory::freeBlock(Block const & block) const {
+    //if the double-map failed we were allocated on the arena
+    if (block.fd == -1 && block.start == block.exec && block.start != NULL)
+        rtl_arena_free(m_arena, block.start, block.size);
+    else
+    {
+        if (block.start) munmap(block.start, block.size);
+        if (block.exec) munmap(block.exec, block.size);
+        if (block.fd != -1) close(block.fd);
+    }
+}
+#else
+bool VtableFactory::createBlock(Block &block, sal_Int32 slotCount) const
+{
+    block.size = getBlockSize(slotCount);
+    block.start = rtl_arena_alloc(m_arena, &block.size);
+    return block.start != 0;
+}
+
 void VtableFactory::freeBlock(Block const & block) const {
     rtl_arena_free(m_arena, block.start, block.size);
 }
+#endif
 
 void VtableFactory::createVtables(
     GuardedBlocks & blocks, BaseOffset const & baseOffset,
@@ -255,9 +339,7 @@ void VtableFactory::createVtables(
         sal_Int32 slotCount
             = bridges::cpp_uno::shared::getPrimaryFunctions(type);
         Block block;
-        block.size = getBlockSize(slotCount);
-        block.start = rtl_arena_alloc(m_arena, &block.size);
-        if (block.start == 0) {
+        if (!createBlock(block, slotCount)) {
             throw std::bad_alloc();
         }
         try {
@@ -270,12 +352,21 @@ void VtableFactory::createVtables(
                  type2 != 0; type2 = type2->pBaseTypeDescription)
             {
                 code = addLocalFunctions(
-                    &slots, code, type2,
+                    &slots, code,
+#ifdef USE_DOUBLE_MMAP
+                    sal_IntPtr(block.exec) - sal_IntPtr(block.start),
+#endif
+                    type2,
                     baseOffset.getFunctionOffset(type2->aBase.pTypeName),
                     bridges::cpp_uno::shared::getLocalFunctions(type2),
                     vtableOffset);
             }
             flushCode(codeBegin, code);
+#ifdef USE_DOUBLE_MMAP
+        //Finished generating block, swap writable pointer with executable
+        //pointer
+            ::std::swap(block.start, block.exec);
+#endif
             blocks.push_back(block);
         } catch (...) {
             freeBlock(block);