iOS, make simulator config copy of macosx.

When compiling for the simulator it is like compiling
for macosx (64bit) but with other libraries, therefore
the bridge should be like the macosx.

Change-Id: I59f1442a5c77d09ad0bc4bf31c2432fc32ef725e

16 files changed, 4945 insertions, 1073 deletions

diff --git a/bridges/CustomTarget_gcc3_ios.mk b/bridges/CustomTarget_gcc3_ios.mk
deleted file mode 100644
index a39c919c4a40..000000000000
--- a/bridges/CustomTarget_gcc3_ios.mk
+++ /dev/null
@@ -1,20 +0,0 @@
-# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
-#
-# This file is part of the LibreOffice project.
-#
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-#
-
-$(eval $(call gb_CustomTarget_CustomTarget,bridges/source/cpp_uno/gcc3_ios))
-
-$(call gb_CustomTarget_get_target,bridges/source/cpp_uno/gcc3_ios) : \
-	$(call gb_CustomTarget_get_workdir,bridges/source/cpp_uno/gcc3_ios)/codesnippets.S
-
-$(call gb_CustomTarget_get_workdir,bridges/source/cpp_uno/gcc3_ios)/codesnippets.S : \
-	$(SRCDIR)/bridges/source/cpp_uno/gcc3_ios/generate-snippets.pl \
-	| $(call gb_CustomTarget_get_workdir,bridges/source/cpp_uno/gcc3_ios)/.dir
-	$(PERL) $< > $@
-
-# vim: set noet sw=4 ts=4:
diff --git a/bridges/Library_cpp_uno.mk b/bridges/Library_cpp_uno.mk
index 7c85b051f27d..801667790fef 100644
--- a/bridges/Library_cpp_uno.mk
+++ b/bridges/Library_cpp_uno.mk
@@ -11,7 +11,8 @@ $(eval $(call gb_Library_Library,$(gb_CPPU_ENV)_uno))
 
 ifeq ($(OS),IOS)
 bridges_SELECTED_BRIDGE := gcc3_ios
-bridge_noopt_objects := cpp2uno except uno2cpp uno2cpp-i386
+bridge_noopt_objects := cpp2uno cpp2uno-simulator except uno2cpp uno2cpp-simulator callvirtualmethod abi call
+bridge_asm_objects := ios64_helper
 
 else ifeq ($(CPUNAME),ARM)
 
diff --git a/bridges/Module_bridges.mk b/bridges/Module_bridges.mk
index f19e485e7257..3016bf2c404f 100644
--- a/bridges/Module_bridges.mk
+++ b/bridges/Module_bridges.mk
@@ -17,8 +17,6 @@ $(eval $(call gb_Module_add_targets,bridges,\
 		$(if $(filter MACOSX,$(OS)),Package_jnilib_java_uno) \
 	) \
 	$(if $(filter ARM,$(CPUNAME)),\
-		$(if $(filter IOS,$(OS)),\
-			CustomTarget_gcc3_ios) \
 		$(if $(filter ANDROID LINUX,$(OS)),\
 			CustomTarget_gcc3_linux_arm) \
 	) \
diff --git a/bridges/source/cpp_uno/gcc3_ios/abi.cxx b/bridges/source/cpp_uno/gcc3_ios/abi.cxx
new file mode 100644
index 000000000000..042a857bae32
--- /dev/null
+++ b/bridges/source/cpp_uno/gcc3_ios/abi.cxx
@@ -0,0 +1,328 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifdef __x86_64
+
+// This is an implementation of the x86-64 ABI as described in 'System V
+// Application Binary Interface, AMD64 Architecture Processor Supplement'
+// (http://www.x86-64.org/documentation/abi-0.95.pdf)
+//
+// The code in this file is a modification of src/x86/ffi64.c from libffi
+// (http://sources.redhat.com/libffi/) which is under the following license:
+
+/* -----------------------------------------------------------------------
+   ffi.c - Copyright (c) 2002  Bo Thorsen <bo@suse.de>
+
+   x86-64 Foreign Function Interface
+
+   Permission is hereby granted, free of charge, to any person obtaining
+   a copy of this software and associated documentation files (the
+   ``Software''), to deal in the Software without restriction, including
+   without limitation the rights to use, copy, modify, merge, publish,
+   distribute, sublicense, and/or sell copies of the Software, and to
+   permit persons to whom the Software is furnished to do so, subject to
+   the following conditions:
+
+   The above copyright notice and this permission notice shall be included
+   in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
+   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+   IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+   OTHER DEALINGS IN THE SOFTWARE.
+   ----------------------------------------------------------------------- */
+
+#include "sal/config.h"
+
+#include "abi.hxx"
+
+#include <sal/log.hxx>
+
+using namespace x86_64;
+
+/* Register class used for passing given 64bit part of the argument.
+   These represent classes as documented by the PS ABI, with the exception
+   of SSESF, SSEDF classes, that are basically SSE class, just gcc will
+   use SF or DFmode move instead of DImode to avoid reformatting penalties.
+
+   Similarly we play games with INTEGERSI_CLASS to use cheaper SImode moves
+   whenever possible (upper half does contain padding).
+ */
+enum x86_64_reg_class
+{
+    X86_64_NO_CLASS,
+    X86_64_INTEGER_CLASS,
+    X86_64_INTEGERSI_CLASS,
+    X86_64_SSE_CLASS,
+    X86_64_SSESF_CLASS,
+    X86_64_SSEDF_CLASS,
+    X86_64_SSEUP_CLASS,
+    X86_64_X87_CLASS,
+    X86_64_X87UP_CLASS,
+    X86_64_MEMORY_CLASS
+};
+
+#define MAX_CLASSES 4
+
+/* x86-64 register passing implementation.  See x86-64 ABI for details.  Goal
+   of this code is to classify each 8bytes of incoming argument by the register
+   class and assign registers accordingly.  */
+
+/* Return the union class of CLASS1 and CLASS2.
+   See the x86-64 PS ABI for details.  */
+
+static enum x86_64_reg_class
+merge_classes (enum x86_64_reg_class class1, enum x86_64_reg_class class2)
+    throw ()
+{
+    /* Rule #1: If both classes are equal, this is the resulting class.  */
+    if (class1 == class2)
+        return class1;
+
+    /* Rule #2: If one of the classes is NO_CLASS, the resulting class is
+       the other class.  */
+    if (class1 == X86_64_NO_CLASS)
+        return class2;
+    if (class2 == X86_64_NO_CLASS)
+        return class1;
+
+    /* Rule #3: If one of the classes is MEMORY, the result is MEMORY.  */
+    if (class1 == X86_64_MEMORY_CLASS || class2 == X86_64_MEMORY_CLASS)
+        return X86_64_MEMORY_CLASS;
+
+    /* Rule #4: If one of the classes is INTEGER, the result is INTEGER.  */
+    if ((class1 == X86_64_INTEGERSI_CLASS && class2 == X86_64_SSESF_CLASS)
+            || (class2 == X86_64_INTEGERSI_CLASS && class1 == X86_64_SSESF_CLASS))
+        return X86_64_INTEGERSI_CLASS;
+    if (class1 == X86_64_INTEGER_CLASS || class1 == X86_64_INTEGERSI_CLASS
+            || class2 == X86_64_INTEGER_CLASS || class2 == X86_64_INTEGERSI_CLASS)
+        return X86_64_INTEGER_CLASS;
+
+    /* Rule #5: If one of the classes is X87 or X87UP class, MEMORY is used.  */
+    if (class1 == X86_64_X87_CLASS || class1 == X86_64_X87UP_CLASS
+            || class2 == X86_64_X87_CLASS || class2 == X86_64_X87UP_CLASS)
+        return X86_64_MEMORY_CLASS;
+
+    /* Rule #6: Otherwise class SSE is used.  */
+    return X86_64_SSE_CLASS;
+}
+
+/* Classify the argument of type TYPE and mode MODE.
+   CLASSES will be filled by the register class used to pass each word
+   of the operand.  The number of words is returned.  In case the parameter
+   should be passed in memory, 0 is returned. As a special case for zero
+   sized containers, classes[0] will be NO_CLASS and 1 is returned.
+
+   See the x86-64 PS ABI for details.
+*/
+static int
+classify_argument( typelib_TypeDescriptionReference *pTypeRef, enum x86_64_reg_class classes[], int byteOffset ) throw ()
+{
+    switch ( pTypeRef->eTypeClass )
+    {
+        case typelib_TypeClass_VOID:
+            classes[0] = X86_64_NO_CLASS;
+            return 1;
+        case typelib_TypeClass_CHAR:
+        case typelib_TypeClass_BOOLEAN:
+        case typelib_TypeClass_BYTE:
+        case typelib_TypeClass_SHORT:
+        case typelib_TypeClass_UNSIGNED_SHORT:
+        case typelib_TypeClass_LONG:
+        case typelib_TypeClass_UNSIGNED_LONG:
+        case typelib_TypeClass_HYPER:
+        case typelib_TypeClass_UNSIGNED_HYPER:
+        case typelib_TypeClass_ENUM:
+            if ( ( byteOffset % 8 + pTypeRef->pType->nSize ) <= 4 )
+                classes[0] = X86_64_INTEGERSI_CLASS;
+            else
+                classes[0] = X86_64_INTEGER_CLASS;
+            return 1;
+        case typelib_TypeClass_FLOAT:
+            if ( ( byteOffset % 8 ) == 0 )
+                classes[0] = X86_64_SSESF_CLASS;
+            else
+                classes[0] = X86_64_SSE_CLASS;
+            return 1;
+        case typelib_TypeClass_DOUBLE:
+            classes[0] = X86_64_SSEDF_CLASS;
+            return 1;
+        /*case LONGDOUBLE:
+            classes[0] = X86_64_X87_CLASS;
+            classes[1] = X86_64_X87UP_CLASS;
+            return 2;*/
+        case typelib_TypeClass_STRING:
+        case typelib_TypeClass_TYPE:
+        case typelib_TypeClass_ANY:
+        case typelib_TypeClass_TYPEDEF:
+        case typelib_TypeClass_SEQUENCE:
+        case typelib_TypeClass_INTERFACE:
+            return 0;
+        case typelib_TypeClass_STRUCT:
+        case typelib_TypeClass_EXCEPTION:
+            {
+                typelib_TypeDescription * pTypeDescr = nullptr;
+                TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef );
+
+                const int UNITS_PER_WORD = 8;
+                int words = ( pTypeDescr->nSize + UNITS_PER_WORD - 1 ) / UNITS_PER_WORD;
+                enum x86_64_reg_class subclasses[MAX_CLASSES];
+
+                /* If the struct is larger than 16 bytes, pass it on the stack.  */
+                if ( pTypeDescr->nSize > 16 )
+                {
+                    TYPELIB_DANGER_RELEASE( pTypeDescr );
+                    return 0;
+                }
+
+                for ( int i = 0; i < words; i++ )
+                    classes[i] = X86_64_NO_CLASS;
+
+                const typelib_CompoundTypeDescription *pStruct = reinterpret_cast<const typelib_CompoundTypeDescription*>( pTypeDescr );
+
+                /* Merge the fields of structure.  */
+                for ( sal_Int32 nMember = 0; nMember < pStruct->nMembers; ++nMember )
+                {
+                    typelib_TypeDescriptionReference *pTypeInStruct = pStruct->ppTypeRefs[ nMember ];
+                    int offset = byteOffset + pStruct->pMemberOffsets[ nMember ];
+
+                    int num = classify_argument( pTypeInStruct, subclasses, offset );
+
+                    if ( num == 0 )
+                    {
+                        TYPELIB_DANGER_RELEASE( pTypeDescr );
+                        return 0;
+                    }
+
+                    for ( int i = 0; i < num; i++ )
+                    {
+                        int pos = offset / 8;
+                        classes[i + pos] = merge_classes( subclasses[i], classes[i + pos] );
+                    }
+                }
+
+                TYPELIB_DANGER_RELEASE( pTypeDescr );
+
+                /* Final merger cleanup.  */
+                for ( int i = 0; i < words; i++ )
+                {
+                    /* If one class is MEMORY, everything should be passed in
+                       memory.  */
+                    if ( classes[i] == X86_64_MEMORY_CLASS )
+                        return 0;
+
+                    /* The X86_64_SSEUP_CLASS should be always preceded by
+                       X86_64_SSE_CLASS.  */
+                    if ( classes[i] == X86_64_SSEUP_CLASS
+                            && ( i == 0 || classes[i - 1] != X86_64_SSE_CLASS ) )
+                        classes[i] = X86_64_SSE_CLASS;
+
+                    /*  X86_64_X87UP_CLASS should be preceded by X86_64_X87_CLASS.  */
+                    if ( classes[i] == X86_64_X87UP_CLASS
+                            && ( i == 0 || classes[i - 1] != X86_64_X87_CLASS ) )
+                        classes[i] = X86_64_SSE_CLASS;
+                }
+                return words;
+            }
+
+        default:
+            SAL_WARN("bridges", "Unhandled case: pType->eTypeClass == "
+                    << pTypeRef->eTypeClass);
+            assert(false);
+    }
+    return 0; /* Never reached.  */
+}
+
+/* Examine the argument and return set number of register required in each
+   class.  Return 0 iff parameter should be passed in memory.  */
+bool x86_64::examine_argument( typelib_TypeDescriptionReference *pTypeRef, bool bInReturn, int &nUsedGPR, int &nUsedSSE ) throw ()
+{
+    enum x86_64_reg_class classes[MAX_CLASSES];
+    int n;
+
+    n = classify_argument( pTypeRef, classes, 0 );
+
+    if ( n == 0 )
+        return false;
+
+    nUsedGPR = 0;
+    nUsedSSE = 0;
+    for ( n--; n >= 0; n-- )
+        switch ( classes[n] )
+        {
+            case X86_64_INTEGER_CLASS:
+            case X86_64_INTEGERSI_CLASS:
+                nUsedGPR++;
+                break;
+            case X86_64_SSE_CLASS:
+            case X86_64_SSESF_CLASS:
+            case X86_64_SSEDF_CLASS:
+                nUsedSSE++;
+                break;
+            case X86_64_NO_CLASS:
+            case X86_64_SSEUP_CLASS:
+                break;
+            case X86_64_X87_CLASS:
+            case X86_64_X87UP_CLASS:
+                if ( !bInReturn )
+                    return false;
+                break;
+            default:
+            SAL_WARN("bridges", "Unhandled case: classes[n] == " << classes[n]);
+            assert(false);
+        }
+    return true;
+}
+
+bool x86_64::return_in_hidden_param( typelib_TypeDescriptionReference *pTypeRef ) throw ()
+{
+    int g, s;
+
+    return !examine_argument( pTypeRef, true, g, s );
+}
+
+void x86_64::fill_struct( typelib_TypeDescriptionReference *pTypeRef, const sal_uInt64 *pGPR, const double *pSSE, void *pStruct ) throw ()
+{
+    enum x86_64_reg_class classes[MAX_CLASSES];
+    int n;
+
+    n = classify_argument( pTypeRef, classes, 0 );
+
+    sal_uInt64 *pStructAlign = static_cast<sal_uInt64 *>( pStruct );
+    for ( n--; n >= 0; n-- )
+        switch ( classes[n] )
+        {
+            case X86_64_INTEGER_CLASS:
+            case X86_64_INTEGERSI_CLASS:
+                *pStructAlign++ = *pGPR++;
+                break;
+            case X86_64_SSE_CLASS:
+            case X86_64_SSESF_CLASS:
+            case X86_64_SSEDF_CLASS:
+                *pStructAlign++ = *reinterpret_cast<const sal_uInt64 *>( pSSE++ );
+                break;
+            default:
+                break;
+        }
+}
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/bridges/source/cpp_uno/gcc3_ios/abi.hxx b/bridges/source/cpp_uno/gcc3_ios/abi.hxx
new file mode 100644
index 000000000000..90aad264c89d
--- /dev/null
+++ b/bridges/source/cpp_uno/gcc3_ios/abi.hxx
@@ -0,0 +1,61 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_BRIDGES_SOURCE_CPP_UNO_GCC3_MACOSX_X86_64_ABI_HXX
+#define INCLUDED_BRIDGES_SOURCE_CPP_UNO_GCC3_MACOSX_X86_64_ABI_HXX
+
+// This is an implementation of the x86-64 ABI as described in 'System V
+// Application Binary Interface, AMD64 Architecture Processor Supplement'
+// (http://www.x86-64.org/documentation/abi-0.95.pdf)
+
+#include <typelib/typedescription.hxx>
+
+namespace x86_64
+{
+
+/* 6 general purpose registers are used for parameter passing */
+const sal_uInt32 MAX_GPR_REGS = 6;
+
+/* 8 SSE registers are used for parameter passing */
+const sal_uInt32 MAX_SSE_REGS = 8;
+
+/* Count number of required registers.
+
+ Examine the argument and return set number of register required in each
+ class.
+
+ Return false iff parameter should be passed in memory.
+*/
+bool examine_argument( typelib_TypeDescriptionReference *pTypeRef, bool bInReturn, int &nUsedGPR, int &nUsedSSE ) throw ();
+
+/** Does function that returns this type use a hidden parameter, or registers?
+
+ The value can be returned either in a hidden 1st parameter (which is a
+ pointer to a structure allocated by the caller), or in registers (rax, rdx
+ for the integers, xmm0, xmm1 for the floating point numbers).
+*/
+bool return_in_hidden_param( typelib_TypeDescriptionReference *pTypeRef ) throw ();
+
+void fill_struct( typelib_TypeDescriptionReference *pTypeRef, const sal_uInt64* pGPR, const double* pSSE, void *pStruct ) throw ();
+
+} // namespace x86_64
+
+#endif // INCLUDED_BRIDGES_SOURCE_CPP_UNO_GCC3_MACOSX_X86_64_ABI_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/bridges/source/cpp_uno/gcc3_ios/call.cxx b/bridges/source/cpp_uno/gcc3_ios/call.cxx
new file mode 100644
index 000000000000..7b50e37e510d
--- /dev/null
+++ b/bridges/source/cpp_uno/gcc3_ios/call.cxx
@@ -0,0 +1,78 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifdef __x86_64
+
+#include <sal/config.h>
+
+#include <call.hxx>
+
+void privateSnippetExecutor()
+{
+    asm volatile
+        (
+         "    subq  $160, %rsp\n"
+
+         "    movq  %r10, -152(%rbp)        # Save (nVtableOffset << 32) + nFunctionIndex\n"
+
+         "    movq  %rdi, -112(%rbp)        # Save GP registers\n"
+         "    movq  %rsi, -104(%rbp)\n"
+         "    movq  %rdx, -96(%rbp)\n"
+         "    movq  %rcx, -88(%rbp)\n"
+         "    movq  %r8 , -80(%rbp)\n"
+         "    movq  %r9 , -72(%rbp)\n"
+
+         "    movsd %xmm0, -64(%rbp)        # Save FP registers\n"
+         "    movsd %xmm1, -56(%rbp)\n"
+         "    movsd %xmm2, -48(%rbp)\n"
+         "    movsd %xmm3, -40(%rbp)\n"
+         "    movsd %xmm4, -32(%rbp)\n"
+         "    movsd %xmm5, -24(%rbp)\n"
+         "    movsd %xmm6, -16(%rbp)\n"
+         "    movsd %xmm7, -8(%rbp)\n"
+
+         "    leaq  -144(%rbp), %r9         # 6th param: sal_uInt64 * pRegisterReturn\n"
+         "    leaq  16(%rbp), %r8           # 5rd param: void ** ovrflw\n"
+         "    leaq  -64(%rbp), %rcx         # 4th param: void ** fpreg\n"
+         "    leaq  -112(%rbp), %rdx        # 3rd param: void ** gpreg\n"
+         "    movl  -148(%rbp), %esi        # 2nd param: sal_int32 nVtableOffset\n"
+         "    movl  -152(%rbp), %edi        # 1st param: sal_int32 nFunctionIndex\n"
+
+         "    call  _cpp_vtable_call\n"
+
+         "    cmp   $10, %rax               # typelib_TypeClass_FLOAT\n"
+         "    je    .Lfloat\n"
+         "    cmp   $11, %rax               # typelib_TypeClass_DOUBLE\n"
+         "    je    .Lfloat\n"
+
+         "    movq  -144(%rbp), %rax        # Return value (int case)\n"
+         "    movq  -136(%rbp), %rdx        # Return value (int case)\n"
+         "    movq  -144(%rbp), %xmm0       # Return value (int case)\n"
+         "    movq  -136(%rbp), %xmm1       # Return value (int case)\n"
+         "    jmp   .Lfinish\n"
+
+         ".Lfloat:\n"
+         "    movlpd    -144(%rbp), %xmm0   # Return value (float/double case)\n"
+
+         ".Lfinish:\n"
+         "    addq  $160, %rsp\n"
+         );
+}
+#endif
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/bridges/source/cpp_uno/gcc3_ios/call.hxx b/bridges/source/cpp_uno/gcc3_ios/call.hxx
new file mode 100644
index 000000000000..6738970d2fb7
--- /dev/null
+++ b/bridges/source/cpp_uno/gcc3_ios/call.hxx
@@ -0,0 +1,37 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_BRIDGES_SOURCE_CPP_UNO_GCC3_MACOSX_X86_64_CALL_HXX
+#define INCLUDED_BRIDGES_SOURCE_CPP_UNO_GCC3_MACOSX_X86_64_CALL_HXX
+
+#include <sal/config.h>
+
+#include <sal/types.h>
+#include <typelib/typeclass.h>
+
+extern "C" typelib_TypeClass cpp_vtable_call(
+    sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset,
+    void ** gpreg, void ** fpreg, void ** ovrflw,
+    sal_uInt64 * pRegisterReturn /* space for register return */ );
+
+extern "C" void privateSnippetExecutor();
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/bridges/source/cpp_uno/gcc3_ios/callvirtualmethod.cxx b/bridges/source/cpp_uno/gcc3_ios/callvirtualmethod.cxx
new file mode 100644
index 000000000000..21efdbab1a82
--- /dev/null
+++ b/bridges/source/cpp_uno/gcc3_ios/callvirtualmethod.cxx
@@ -0,0 +1,180 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifdef __x86_64
+#include "sal/config.h"
+
+#include <cstring>
+
+#include "cppu/macros.hxx"
+#include "sal/types.h"
+#include "typelib/typeclass.h"
+#include "typelib/typedescription.h"
+
+#include "abi.hxx"
+#include "callvirtualmethod.hxx"
+
+// The call instruction within the asm block of callVirtualMethod may throw
+// exceptions.  At least GCC 4.7.0 with -O0 would create (unnecessary)
+// .gcc_exception_table call-site table entries around all other calls in this
+// function that can throw, leading to std::terminate if the asm call throws an
+// exception and the unwinding C++ personality routine finds the unexpected hole
+// in the .gcc_exception_table.  Therefore, make sure this function explicitly
+// only calls nothrow-functions (so GCC 4.7.0 with -O0 happens to not create a
+// .gcc_exception_table section at all for this function).  For some reason,
+// this also needs to be in a source file of its own.
+//
+// Also, this file should be compiled with -fnon-call-exceptions, and ideally
+// there would be a way to tell the compiler that the asm block contains calls
+// to functions that can potentially throw; see the mail thread starting at
+// <http://gcc.gnu.org/ml/gcc/2012-03/msg00454.html> "C++: Letting compiler know
+// asm block can call function that can throw?"
+
+void CPPU_CURRENT_NAMESPACE::callVirtualMethod(
+    void * pThis, sal_uInt32 nVtableIndex, void * pRegisterReturn,
+    typelib_TypeDescriptionReference * pReturnTypeRef, bool bSimpleReturn,
+    sal_uInt64 *pStack, sal_uInt32 nStack, sal_uInt64 *pGPR, double * pFPR)
+{
+    // Work around -fsanitize=address "inline assembly requires more registers
+    // than available" error:
+    struct Data {
+        sal_uInt64 pMethod;
+        sal_uInt64 * pStack;
+        sal_uInt32 nStack;
+        sal_uInt64 * pGPR;
+        double * pFPR;
+        // Return values:
+        sal_uInt64 rax;
+        sal_uInt64 rdx;
+        double xmm0;
+        double xmm1;
+    } data;
+    data.pStack = pStack;
+    data.nStack = nStack;
+    data.pGPR = pGPR;
+    data.pFPR = pFPR;
+
+    // Get pointer to method
+    sal_uInt64 pMethod = *static_cast<sal_uInt64 *>(pThis);
+    pMethod += 8 * nVtableIndex;
+    data.pMethod = *reinterpret_cast<sal_uInt64 *>(pMethod);
+
+    asm volatile (
+        // Push arguments to stack
+        "movq %%rsp, %%r12\n\t"
+        "movl 16%0, %%ecx\n\t"
+        "jrcxz Lpushed\n\t"
+        "xor %%rax, %%rax\n\t"
+        "leaq (%%rax, %%rcx, 8), %%rax\n\t"
+        "subq %%rax, %%rsp\n\t"
+        "andq $-9, %%rsp\n\t" // 16-bytes aligned
+        "movq 8%0, %%rsi\n\t"
+        "\nLpush:\n\t"
+        "decq %%rcx\n\t"
+        "movq (%%rsi, %%rcx, 8), %%rax\n\t"
+        "movq %%rax, (%%rsp, %%rcx, 8)\n\t"
+        "jnz Lpush\n\t"
+        "\nLpushed:\n\t"
+
+        // Fill the xmm registers
+        "movq 32%0, %%rax\n\t"
+
+        "movsd   (%%rax), %%xmm0\n\t"
+        "movsd  8(%%rax), %%xmm1\n\t"
+        "movsd 16(%%rax), %%xmm2\n\t"
+        "movsd 24(%%rax), %%xmm3\n\t"
+        "movsd 32(%%rax), %%xmm4\n\t"
+        "movsd 40(%%rax), %%xmm5\n\t"
+        "movsd 48(%%rax), %%xmm6\n\t"
+        "movsd 56(%%rax), %%xmm7\n\t"
+
+        // Fill the general purpose registers
+        "movq 24%0, %%rax\n\t"
+
+        "movq    (%%rax), %%rdi\n\t"
+        "movq   8(%%rax), %%rsi\n\t"
+        "movq  16(%%rax), %%rdx\n\t"
+        "movq  24(%%rax), %%rcx\n\t"
+        "movq  32(%%rax), %%r8\n\t"
+        "movq  40(%%rax), %%r9\n\t"
+
+        // Perform the call
+        "movq 0%0, %%r11\n\t"
+        "call *%%r11\n\t"
+
+        // Fill the return values
+        "movq   %%rax, 40%0\n\t"
+        "movq   %%rdx, 48%0\n\t"
+        "movsd %%xmm0, 56%0\n\t"
+        "movsd %%xmm1, 64%0\n\t"
+
+        // Reset %rsp
+        "movq %%r12, %%rsp\n\t"
+        :: "o" (data)
+        : "rax", "rdi", "rsi", "rdx", "rcx", "r8", "r9", "r10", "r11", "r12",
+          "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
+          "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
+          "memory"
+    );
+
+    switch (pReturnTypeRef->eTypeClass)
+    {
+    case typelib_TypeClass_HYPER:
+    case typelib_TypeClass_UNSIGNED_HYPER:
+        *static_cast<sal_uInt64 *>( pRegisterReturn ) = data.rax;
+        break;
+    case typelib_TypeClass_LONG:
+    case typelib_TypeClass_UNSIGNED_LONG:
+    case typelib_TypeClass_ENUM:
+        *static_cast<sal_uInt32 *>( pRegisterReturn ) = *reinterpret_cast<sal_uInt32 *>( &data.rax );
+        break;
+    case typelib_TypeClass_CHAR:
+    case typelib_TypeClass_SHORT:
+    case typelib_TypeClass_UNSIGNED_SHORT:
+        *static_cast<sal_uInt16 *>( pRegisterReturn ) = *reinterpret_cast<sal_uInt16 *>( &data.rax );
+        break;
+    case typelib_TypeClass_BOOLEAN:
+    case typelib_TypeClass_BYTE:
+        *static_cast<sal_uInt8 *>( pRegisterReturn ) = *reinterpret_cast<sal_uInt8 *>( &data.rax );
+        break;
+    case typelib_TypeClass_FLOAT:
+    case typelib_TypeClass_DOUBLE:
+        *static_cast<double *>( pRegisterReturn ) = data.xmm0;
+        break;
+    default:
+        {
+            sal_Int32 const nRetSize = pReturnTypeRef->pType->nSize;
+            if (bSimpleReturn && nRetSize <= 16 && nRetSize > 0)
+            {
+                sal_uInt64 longs[2];
+                longs[0] = data.rax;
+                longs[1] = data.rdx;
+
+                double doubles[2];
+                doubles[0] = data.xmm0;
+                doubles[1] = data.xmm1;
+                x86_64::fill_struct( pReturnTypeRef, &longs[0], &doubles[0], pRegisterReturn);
+            }
+            break;
+        }
+    }
+}
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/bridges/source/cpp_uno/gcc3_ios/callvirtualmethod.hxx b/bridges/source/cpp_uno/gcc3_ios/callvirtualmethod.hxx
new file mode 100644
index 000000000000..53c5ac0986c6
--- /dev/null
+++ b/bridges/source/cpp_uno/gcc3_ios/callvirtualmethod.hxx
@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_BRIDGES_SOURCE_CPP_UNO_GCC3_MACOSX_X86_64_CALLVIRTUALMETHOD_HXX
+#define INCLUDED_BRIDGES_SOURCE_CPP_UNO_GCC3_MACOSX_X86_64_CALLVIRTUALMETHOD_HXX
+
+#include "sal/config.h"
+
+#include "cppu/macros.hxx"
+#include "sal/types.h"
+#include "typelib/typedescription.h"
+
+namespace CPPU_CURRENT_NAMESPACE {
+
+void callVirtualMethod(
+    void * pThis, sal_uInt32 nVtableIndex, void * pRegisterReturn,
+    typelib_TypeDescriptionReference * pReturnTypeRef, bool bSimpleReturn,
+    sal_uInt64 *pStack, sal_uInt32 nStack, sal_uInt64 *pGPR, double * pFPR);
+
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/bridges/source/cpp_uno/gcc3_ios/cpp2uno-simulator.cxx b/bridges/source/cpp_uno/gcc3_ios/cpp2uno-simulator.cxx
new file mode 100644
index 000000000000..d350d0c4c3e1
--- /dev/null
+++ b/bridges/source/cpp_uno/gcc3_ios/cpp2uno-simulator.cxx
@@ -0,0 +1,520 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef __arm64
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <rtl/alloc.h>
+#include <sal/log.hxx>
+
+#include <com/sun/star/uno/genfunc.hxx>
+#include "com/sun/star/uno/RuntimeException.hpp"
+#include <uno/data.h>
+#include <typelib/typedescription.hxx>
+
+#include "bridge.hxx"
+#include "cppinterfaceproxy.hxx"
+#include "types.hxx"
+#include "vtablefactory.hxx"
+
+#include "abi.hxx"
+#include "call.hxx"
+#include "share.hxx"
+
+using namespace ::osl;
+using namespace ::com::sun::star::uno;
+
+
+// Perform the UNO call
+//
+// We must convert the parameters stored in gpreg, fpreg and ovrflw to UNO
+// arguments and call pThis->getUnoI()->pDispatcher.
+//
+// gpreg:  [ret *], this, [gpr params]
+// fpreg:  [fpr params]
+// ovrflw: [gpr or fpr params (properly aligned)]
+//
+// [ret *] is present when we are returning a structure bigger than 16 bytes
+// Simple types are returned in rax, rdx (int), or xmm0, xmm1 (fp).
+// Similarly structures <= 16 bytes are in rax, rdx, xmm0, xmm1 as necessary.
+static typelib_TypeClass cpp2uno_call(
+    bridges::cpp_uno::shared::CppInterfaceProxy * pThis,
+    const typelib_TypeDescription * pMemberTypeDescr,
+    typelib_TypeDescriptionReference * pReturnTypeRef, // 0 indicates void return
+    sal_Int32 nParams, typelib_MethodParameter * pParams,
+    void ** gpreg, void ** fpreg, void ** ovrflw,
+    sal_uInt64 * pRegisterReturn /* space for register return */ )
+{
+    unsigned int nr_gpr = 0; //number of gpr registers used
+    unsigned int nr_fpr = 0; //number of fpr registers used
+
+    // return
+    typelib_TypeDescription * pReturnTypeDescr = nullptr;
+    if (pReturnTypeRef)
+        TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
+
+    void * pUnoReturn = nullptr;
+    void * pCppReturn = nullptr; // complex return ptr: if != 0 && != pUnoReturn, reconversion need
+
+    if ( pReturnTypeDescr )
+    {
+        if ( x86_64::return_in_hidden_param( pReturnTypeRef ) )
+        {
+            pCppReturn = *gpreg++;
+            nr_gpr++;
+
+            pUnoReturn = ( bridges::cpp_uno::shared::relatesToInterfaceType( pReturnTypeDescr )
+                           ? alloca( pReturnTypeDescr->nSize )
+                           : pCppReturn ); // direct way
+        }
+        else
+            pUnoReturn = pRegisterReturn; // direct way for simple types
+    }
+
+    // pop this
+    gpreg++;
+    nr_gpr++;
+
+    // stack space
+    // parameters
+    void ** pUnoArgs = static_cast<void **>(alloca( 4 * sizeof(void *) * nParams ));
+    void ** pCppArgs = pUnoArgs + nParams;
+    // indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = reinterpret_cast<sal_Int32 *>(pUnoArgs + (2 * nParams));
+    // type descriptions for reconversions
+    typelib_TypeDescription ** ppTempParamTypeDescr = reinterpret_cast<typelib_TypeDescription **>(pUnoArgs + (3 * nParams));
+
+    sal_Int32 nTempIndices = 0;
+
+    for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
+    {
+        const typelib_MethodParameter & rParam = pParams[nPos];
+
+        int nUsedGPR = 0;
+        int nUsedSSE = 0;
+#if OSL_DEBUG_LEVEL > 0
+        bool bFitsRegisters =
+#endif
+            x86_64::examine_argument( rParam.pTypeRef, false, nUsedGPR, nUsedSSE );
+        if ( !rParam.bOut && bridges::cpp_uno::shared::isSimpleType( rParam.pTypeRef ) ) // value
+        {
+            // Simple types must fit exactly one register on x86_64
+            assert(bFitsRegisters && ( ( nUsedSSE == 1 && nUsedGPR == 0 ) || ( nUsedSSE == 0 && nUsedGPR == 1 ) ));
+
+            if ( nUsedSSE == 1 )
+            {
+                if ( nr_fpr < x86_64::MAX_SSE_REGS )
+                {
+                    pCppArgs[nPos] = pUnoArgs[nPos] = fpreg++;
+                    nr_fpr++;
+                }
+                else
+                    pCppArgs[nPos] = pUnoArgs[nPos] = ovrflw++;
+            }
+            else if ( nUsedGPR == 1 )
+            {
+                if ( nr_gpr < x86_64::MAX_GPR_REGS )
+                {
+                    pCppArgs[nPos] = pUnoArgs[nPos] = gpreg++;
+                    nr_gpr++;
+                }
+                else
+                    pCppArgs[nPos] = pUnoArgs[nPos] = ovrflw++;
+            }
+        }
+        else // struct <= 16 bytes || ptr to complex value || ref
+        {
+            typelib_TypeDescription * pParamTypeDescr = nullptr;
+            TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
+
+            void *pCppStack;
+            if ( nr_gpr < x86_64::MAX_GPR_REGS )
+            {
+                pCppArgs[nPos] = pCppStack = *gpreg++;
+                nr_gpr++;
+            }
+            else
+                pCppArgs[nPos] = pCppStack = *ovrflw++;
+
+            if (! rParam.bIn) // is pure out
+            {
+                // uno out is unconstructed mem!
+                pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize );
+                pTempIndices[nTempIndices] = nPos;
+                // will be released at reconversion
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
+            }
+            else if ( bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ) ) // is in/inout
+            {
+                uno_copyAndConvertData( pUnoArgs[nPos] = alloca( pParamTypeDescr->nSize ),
+                                        pCppStack, pParamTypeDescr,
+                                        pThis->getBridge()->getCpp2Uno() );
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
+                // will be released at reconversion
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
+            }
+            else // direct way
+            {
+                pUnoArgs[nPos] = pCppStack;
+                // no longer needed
+                TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+            }
+        }
+    }
+
+    // ExceptionHolder
+    uno_Any aUnoExc; // Any will be constructed by callee
+    uno_Any * pUnoExc = &aUnoExc;
+
+    // invoke uno dispatch call
+    (*pThis->getUnoI()->pDispatcher)( pThis->getUnoI(), pMemberTypeDescr, pUnoReturn, pUnoArgs, &pUnoExc );
+
+    // in case an exception occurred...
+    if ( pUnoExc )
+    {
+        // destruct temporary in/inout params
+        for ( ; nTempIndices--; )
+        {
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+
+            if (pParams[nIndex].bIn) // is in/inout => was constructed
+                uno_destructData( pUnoArgs[nIndex], ppTempParamTypeDescr[nTempIndices], nullptr );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
+        }
+        if (pReturnTypeDescr)
+            TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
+
+        CPPU_CURRENT_NAMESPACE::raiseException( &aUnoExc, pThis->getBridge()->getUno2Cpp() ); // has to destruct the any
+        // is here for dummy
+        return typelib_TypeClass_VOID;
+    }
+    else // else no exception occurred...
+    {
+        // temporary params
+        for ( ; nTempIndices--; )
+        {
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
+
+            if ( pParams[nIndex].bOut ) // inout/out
+            {
+                // convert and assign
+                uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
+                uno_copyAndConvertData( pCppArgs[nIndex], pUnoArgs[nIndex], pParamTypeDescr,
+                                        pThis->getBridge()->getUno2Cpp() );
+            }
+            // destroy temp uno param
+            uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, nullptr );
+
+            TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+        }
+        // return
+        if ( pCppReturn ) // has complex return
+        {
+            if ( pUnoReturn != pCppReturn ) // needs reconversion
+            {
+                uno_copyAndConvertData( pCppReturn, pUnoReturn, pReturnTypeDescr,
+                                        pThis->getBridge()->getUno2Cpp() );
+                // destroy temp uno return
+                uno_destructData( pUnoReturn, pReturnTypeDescr, nullptr );
+            }
+            // complex return ptr is set to return reg
+            *reinterpret_cast<void **>(pRegisterReturn) = pCppReturn;
+        }
+        if ( pReturnTypeDescr )
+        {
+            typelib_TypeClass eRet = pReturnTypeDescr->eTypeClass;
+            TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
+            return eRet;
+        }
+        else
+            return typelib_TypeClass_VOID;
+    }
+}
+
+typelib_TypeClass cpp_vtable_call(
+    sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset,
+    void ** gpreg, void ** fpreg, void ** ovrflw,
+    sal_uInt64 * pRegisterReturn /* space for register return */ )
+{
+    // gpreg:  [ret *], this, [other gpr params]
+    // fpreg:  [fpr params]
+    // ovrflw: [gpr or fpr params (properly aligned)]
+    void * pThis;
+    if ( nFunctionIndex & 0x80000000 )
+    {
+        nFunctionIndex &= 0x7fffffff;
+        pThis = gpreg[1];
+    }
+    else
+    {
+        pThis = gpreg[0];
+    }
+    pThis = static_cast<char *>( pThis ) - nVtableOffset;
+
+    bridges::cpp_uno::shared::CppInterfaceProxy * pCppI =
+        bridges::cpp_uno::shared::CppInterfaceProxy::castInterfaceToProxy( pThis );
+
+    typelib_InterfaceTypeDescription * pTypeDescr = pCppI->getTypeDescr();
+
+    if ( nFunctionIndex >= pTypeDescr->nMapFunctionIndexToMemberIndex )
+    {
+        SAL_WARN(
+            "bridges",
+            "illegal " << OUString::unacquired(&pTypeDescr->aBase.pTypeName)
+                << " vtable index " << nFunctionIndex << "/"
+                << pTypeDescr->nMapFunctionIndexToMemberIndex);
+        throw RuntimeException(
+            ("illegal " + OUString::unacquired(&pTypeDescr->aBase.pTypeName)
+             + " vtable index " + OUString::number(nFunctionIndex) + "/"
+             + OUString::number(pTypeDescr->nMapFunctionIndexToMemberIndex)),
+            reinterpret_cast<XInterface *>( pCppI ) );
+    }
+
+    // determine called method
+    sal_Int32 nMemberPos = pTypeDescr->pMapFunctionIndexToMemberIndex[nFunctionIndex];
+    assert(nMemberPos < pTypeDescr->nAllMembers);
+
+    TypeDescription aMemberDescr( pTypeDescr->ppAllMembers[nMemberPos] );
+
+    typelib_TypeClass eRet;
+    switch ( aMemberDescr.get()->eTypeClass )
+    {
+        case typelib_TypeClass_INTERFACE_ATTRIBUTE:
+        {
+            typelib_TypeDescriptionReference *pAttrTypeRef =
+                reinterpret_cast<typelib_InterfaceAttributeTypeDescription *>( aMemberDescr.get() )->pAttributeTypeRef;
+
+            if ( pTypeDescr->pMapMemberIndexToFunctionIndex[nMemberPos] == nFunctionIndex )
+            {
+                // is GET method
+                eRet = cpp2uno_call( pCppI, aMemberDescr.get(), pAttrTypeRef,
+                        0, nullptr, // no params
+                        gpreg, fpreg, ovrflw, pRegisterReturn );
+            }
+            else
+            {
+                // is SET method
+                typelib_MethodParameter aParam;
+                aParam.pTypeRef = pAttrTypeRef;
+                aParam.bIn      = true;
+                aParam.bOut     = false;
+
+                eRet = cpp2uno_call( pCppI, aMemberDescr.get(),
+                        nullptr, // indicates void return
+                        1, &aParam,
+                        gpreg, fpreg, ovrflw, pRegisterReturn );
+            }
+            break;
+        }
+        case typelib_TypeClass_INTERFACE_METHOD:
+        {
+            // is METHOD
+            switch ( nFunctionIndex )
+            {
+                case 1: // acquire()
+                    pCppI->acquireProxy(); // non virtual call!
+                    eRet = typelib_TypeClass_VOID;
+                    break;
+                case 2: // release()
+                    pCppI->releaseProxy(); // non virtual call!
+                    eRet = typelib_TypeClass_VOID;
+                    break;
+                case 0: // queryInterface() opt
+                {
+                    typelib_TypeDescription * pTD = nullptr;
+                    TYPELIB_DANGER_GET( &pTD, static_cast<Type *>( gpreg[2] )->getTypeLibType() );
+                    if ( pTD )
+                    {
+                        XInterface * pInterface = nullptr;
+                        (*pCppI->getBridge()->getCppEnv()->getRegisteredInterface)
+                            ( pCppI->getBridge()->getCppEnv(),
+                              reinterpret_cast<void **>(&pInterface),
+                              pCppI->getOid().pData,
+                              reinterpret_cast<typelib_InterfaceTypeDescription *>( pTD ) );
+
+                        if ( pInterface )
+                        {
+                            ::uno_any_construct( static_cast<uno_Any *>( gpreg[0] ),
+                                                 &pInterface, pTD, cpp_acquire );
+
+                            pInterface->release();
+                            TYPELIB_DANGER_RELEASE( pTD );
+
+                            reinterpret_cast<void **>( pRegisterReturn )[0] = gpreg[0];
+                            eRet = typelib_TypeClass_ANY;
+                            break;
+                        }
+                        TYPELIB_DANGER_RELEASE( pTD );
+                    }
+                    SAL_FALLTHROUGH; // else perform queryInterface()
+                }
+                default:
+                {
+                    typelib_InterfaceMethodTypeDescription *pMethodTD =
+                        reinterpret_cast<typelib_InterfaceMethodTypeDescription *>( aMemberDescr.get() );
+
+                    eRet = cpp2uno_call( pCppI, aMemberDescr.get(),
+                                         pMethodTD->pReturnTypeRef,
+                                         pMethodTD->nParams,
+                                         pMethodTD->pParams,
+                                         gpreg, fpreg, ovrflw, pRegisterReturn );
+                }
+            }
+            break;
+        }
+        default:
+        {
+            throw RuntimeException("no member description found!",
+                                    reinterpret_cast<XInterface *>( pCppI ) );
+        }
+    }
+
+    return eRet;
+}
+
+const int codeSnippetSize = 24;
+
+// Generate a trampoline that redirects method calls to
+// privateSnippetExecutor().
+//
+// privateSnippetExecutor() saves all the registers that are used for
+// parameter passing on x86_64, and calls the cpp_vtable_call().
+// When it returns, privateSnippetExecutor() sets the return value.
+//
+// Note: The code snippet we build here must not create a stack frame,
+// otherwise the UNO exceptions stop working thanks to non-existing
+// unwinding info.
+unsigned char * codeSnippet( unsigned char * code,
+        sal_Int32 nFunctionIndex, sal_Int32 nVtableOffset,
+        bool bHasHiddenParam )
+{
+    sal_uInt64 nOffsetAndIndex = ( ( (sal_uInt64) nVtableOffset ) << 32 ) | ( (sal_uInt64) nFunctionIndex );
+
+    if ( bHasHiddenParam )
+        nOffsetAndIndex |= 0x80000000;
+
+    // movq $<nOffsetAndIndex>, %r10
+    *reinterpret_cast<sal_uInt16 *>( code ) = 0xba49;
+    *reinterpret_cast<sal_uInt16 *>( code + 2 ) = nOffsetAndIndex & 0xFFFF;
+    *reinterpret_cast<sal_uInt32 *>( code + 4 ) = nOffsetAndIndex >> 16;
+    *reinterpret_cast<sal_uInt16 *>( code + 8 ) = nOffsetAndIndex >> 48;
+
+    // movq $<address of the privateSnippetExecutor>, %r11
+    *reinterpret_cast<sal_uInt16 *>( code + 10 ) = 0xbb49;
+    *reinterpret_cast<sal_uInt32 *>( code + 12 )
+        = reinterpret_cast<sal_uInt64>(privateSnippetExecutor);
+    *reinterpret_cast<sal_uInt32 *>( code + 16 )
+        = reinterpret_cast<sal_uInt64>(privateSnippetExecutor) >> 32;
+
+    // jmpq *%r11
+    *reinterpret_cast<sal_uInt32 *>( code + 20 ) = 0x00e3ff49;
+
+#if OSL_DEBUG_LEVEL > 1
+    fprintf(stderr,
+            "==> codeSnippet, functionIndex=%d%s, vtableOffset=%d\n",
+            nFunctionIndex, (bHasHiddenParam ? "|0x80000000":""), nVtableOffset);
+#endif
+
+    return code + codeSnippetSize;
+}
+
+struct bridges::cpp_uno::shared::VtableFactory::Slot { void * fn; };
+
+bridges::cpp_uno::shared::VtableFactory::Slot *
+bridges::cpp_uno::shared::VtableFactory::mapBlockToVtable(void * block)
+{
+    return static_cast< Slot * >(block) + 2;
+}
+
+std::size_t bridges::cpp_uno::shared::VtableFactory::getBlockSize(
+    sal_Int32 slotCount)
+{
+    return (slotCount + 2) * sizeof (Slot) + slotCount * codeSnippetSize;
+}
+
+bridges::cpp_uno::shared::VtableFactory::Slot *
+bridges::cpp_uno::shared::VtableFactory::initializeBlock(
+    void * block, sal_Int32 slotCount, sal_Int32,
+    typelib_InterfaceTypeDescription *)
+{
+    Slot * slots = mapBlockToVtable(block);
+    slots[-2].fn = nullptr;
+    slots[-1].fn = nullptr;
+    return slots + slotCount;
+}
+
+
+unsigned char * bridges::cpp_uno::shared::VtableFactory::addLocalFunctions(
+    Slot ** slots, unsigned char * code,
+    typelib_InterfaceTypeDescription const * type, sal_Int32 nFunctionOffset,
+    sal_Int32 functionCount, sal_Int32 nVtableOffset )
+{
+    const sal_PtrDiff writetoexecdiff = 0;
+    (*slots) -= functionCount;
+    Slot * s = *slots;
+    for ( sal_Int32 nPos = 0; nPos < type->nMembers; ++nPos )
+    {
+        typelib_TypeDescription * pTD = nullptr;
+
+        TYPELIB_DANGER_GET( &pTD, type->ppMembers[ nPos ] );
+        assert(pTD);
+
+        if ( typelib_TypeClass_INTERFACE_ATTRIBUTE == pTD->eTypeClass )
+        {
+            typelib_InterfaceAttributeTypeDescription *pAttrTD =
+                reinterpret_cast<typelib_InterfaceAttributeTypeDescription *>( pTD );
+
+            // get method
+            (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 + writetoexecdiff;
+                code = codeSnippet( code, nFunctionOffset++, nVtableOffset, false );
+            }
+        }
+        else if ( typelib_TypeClass_INTERFACE_METHOD == pTD->eTypeClass )
+        {
+            typelib_InterfaceMethodTypeDescription *pMethodTD =
+                reinterpret_cast<typelib_InterfaceMethodTypeDescription *>( pTD );
+
+            (s++)->fn = code + writetoexecdiff;
+            code = codeSnippet( code, nFunctionOffset++, nVtableOffset,
+                                x86_64::return_in_hidden_param( pMethodTD->pReturnTypeRef ) );
+        }
+        else
+            assert(false);
+
+        TYPELIB_DANGER_RELEASE( pTD );
+    }
+    return code;
+}
+
+void bridges::cpp_uno::shared::VtableFactory::flushCode(
+    SAL_UNUSED_PARAMETER unsigned char const *,
+    SAL_UNUSED_PARAMETER unsigned char const * )
+{}
+
+#endif
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/bridges/source/cpp_uno/gcc3_ios/cpp2uno.cxx b/bridges/source/cpp_uno/gcc3_ios/cpp2uno.cxx
index 6773486e9c9c..762dbdc8db76 100644
--- a/bridges/source/cpp_uno/gcc3_ios/cpp2uno.cxx
+++ b/bridges/source/cpp_uno/gcc3_ios/cpp2uno.cxx
@@ -29,6 +29,7 @@
 
 #include "share.hxx"
 
+#ifdef __arm64
 extern "C" {
     extern int nFunIndexes, nVtableOffsets;
     extern int codeSnippets[];
@@ -447,7 +448,6 @@ extern "C" sal_Int64 cpp_vtable_call( sal_Int32 *pFunctionAndOffset,
     return nRegReturn;
 }
 
-#ifdef __arm64
 namespace
 {
     unsigned char *codeSnippet(const typelib_InterfaceTypeDescription *type,
diff --git a/bridges/source/cpp_uno/gcc3_ios/generate-snippets.pl b/bridges/source/cpp_uno/gcc3_ios/generate-snippets.pl
deleted file mode 100755
index a8548836fef3..000000000000
--- a/bridges/source/cpp_uno/gcc3_ios/generate-snippets.pl
+++ /dev/null
@@ -1,114 +0,0 @@
-#!/usr/bin/perl -w # -*- tab-width: 4; indent-tabs-mode: nil; cperl-indent-level: 4 -*-
-#
-# This file is part of the LibreOffice project.
-#
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-#
-
-my $nFunIndexes = 8;
-my $nVtableOffsets = 4;
-
-sub gen_arm ($$)
-{
-    my ($funIndex, $vtableOffset) = @_;
-    if ($funIndex & 0x80000000) {
-        printf ("#ifndef __arm64\n");
-    }
-    printf ("codeSnippet_%08x_%d:\n", $funIndex, $vtableOffset);
-    printf ("#ifdef __arm\n");
-    # Note: pc is the address of instruction being executed plus 8
-    printf ("    mov ip, pc\n");
-    printf ("#else\n");
-    printf ("    adr x15, .+8\n");
-    printf ("#endif\n");
-    printf ("    b _privateSnippetExecutor\n");
-    printf ("    .long %#08x\n", $funIndex);
-    printf ("    .long %d\n", $vtableOffset);
-    if ($funIndex & 0x80000000) {
-        printf ("#endif\n");
-    }
-}
-
-sub gen_x86 ($$$)
-{
-    my ($funIndex, $vtableOffset, $executor) = @_;
-    printf ("codeSnippet_%08x_%d_%s:\n", $funIndex, $vtableOffset, $executor);
-    printf ("    movl \$%#08x, %%eax\n", $funIndex);
-    printf ("    movl \$%d, %%edx\n", $vtableOffset);
-    printf ("    jmp _privateSnippetExecutor%s\n", $executor);
-}
-
-printf (".text\n");
-
-printf ("#if defined(__arm) || defined(__arm64)\n");
-
-printf ("\n");
-printf ("// Each codeSnippetX function stores into ip (arm64: x15) an address and branches to _privateSnippetExecutor\n");
-printf ("// The address is that following the branch instruction, containing two 32-bit ints:\n");
-printf ("// - the function index, which for 32-bit can have the 0x80000000 bit set\n");
-printf ("//   to indicate that a hidden parameter is used for returning large values\n");
-printf ("// - the vtable offset\n");
-printf ("\n");
-
-printf ("    .align 4\n");
-printf ("\n");
-
-foreach my $funIndex (0 .. $nFunIndexes-1)
-{
-   foreach my $vtableOffset (0 .. $nVtableOffsets-1)
-   {
-       gen_arm ($funIndex, $vtableOffset);
-       gen_arm ($funIndex|0x80000000, $vtableOffset);
-   }
-}
-
-printf ("#else\n");
-printf ("    .align 1, 0x90\n");
-
-foreach my $funIndex (0 .. $nFunIndexes-1)
-{
-    foreach my $vtableOffset (0 .. $nVtableOffsets-1)
-    {
-        foreach my $executor ('General', 'Void', 'Hyper', 'Float', 'Double', 'Class')
-        {
-            gen_x86 ($funIndex, $vtableOffset, $executor);
-            gen_x86 ($funIndex|0x80000000, $vtableOffset, $executor);
-        }
-    }
-  }
-
-printf ("#endif\n");
-
-printf ("    .globl _nFunIndexes\n");
-printf ("_nFunIndexes:\n");
-printf ("    .long %d\n", $nFunIndexes);
-
-printf ("    .globl _nVtableOffsets\n");
-printf ("_nVtableOffsets:\n");
-printf ("    .long %d\n", $nVtableOffsets);
-
-printf ("    .globl _codeSnippets\n");
-printf ("_codeSnippets:\n");
-
-foreach my $funIndex (0 .. $nFunIndexes-1)
-{
-    foreach my $vtableOffset (0 .. $nVtableOffsets-1)
-    {
-        printf ("#if defined(__arm) || defined(__arm64)\n");
-        printf ("    .long codeSnippet_%08x_%d - _codeSnippets\n", $funIndex, $vtableOffset);
-        printf ("#ifndef __arm64\n");
-        printf ("    .long codeSnippet_%08x_%d - _codeSnippets\n", $funIndex|0x80000000, $vtableOffset);
-        printf ("#endif\n");
-        printf ("#else\n");
-        foreach my $executor ('General', 'Void', 'Hyper', 'Float', 'Double', 'Class')
-        {
-            printf ("    .long codeSnippet_%08x_%d_%s - _codeSnippets\n", $funIndex, $vtableOffset, $executor);
-            printf ("    .long codeSnippet_%08x_%d_%s - _codeSnippets\n", $funIndex|0x80000000, $vtableOffset, $executor);
-        }
-        printf ("#endif\n");
-    }
-}
-
-# vim:set shiftwidth=4 softtabstop=4 expandtab:
diff --git a/bridges/source/cpp_uno/gcc3_ios/helper.s b/bridges/source/cpp_uno/gcc3_ios/helper.s
deleted file mode 100644
index 148b53ee2423..000000000000
--- a/bridges/source/cpp_uno/gcc3_ios/helper.s
+++ /dev/null
@@ -1,448 +0,0 @@
-// -*- Mode: Asm; tab-width: 4; tab-stop-list: (4 12 32); comment-column: 30; comment-start: "// "; indent-tabs-mode: nil -*-
-//
-// This file is part of the LibreOffice project.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-//
-// This file incorporates work covered by the following license notice:
-//
-//   Licensed to the Apache Software Foundation (ASF) under one or more
-//   contributor license agreements. See the NOTICE file distributed
-//   with this work for additional information regarding copyright
-//   ownership. The ASF licenses this file to you under the Apache
-//   License, Version 2.0 (the "License"); you may not use this file
-//   except in compliance with the License. You may obtain a copy of
-//   the License at http://www.apache.org/licenses/LICENSE-2.0 .
-//
-
-#include "codesnippets.S"
-
-#ifdef(__arm64)
-
-    .text
-    .align 4
-
-_privateSnippetExecutor:
-
-    .cfi_startproc
-    // _privateSnippetExecutor is jumped to from each of the
-    // codeSnippet_*  generated by generate-snippets.pl
-
-    // Store potential args in general purpose registers
-    stp     x6, x7, [sp, #-16]!
-    stp     x4, x5, [sp, #-16]!
-    stp     x2, x3, [sp, #-16]!
-    stp     x0, x1, [sp, #-16]!
-
-    // Store potential args in floating point/SIMD registers
-    stp     d6, d7, [sp, #-16]!
-    stp     d4, d5, [sp, #-16]!
-    stp     d2, d3, [sp, #-16]!
-    stp     d0, d1, [sp, #-16]!
-
-    // First argument to cpp_vtable_call: The x15 set up in the codeSnippet instance
-    mov     x0, x15
-    // Store x8 (potential pointer to return value storage) and lr
-    stp     x8, lr, [sp, #-16]!
-    // Second argument: The pointer to all the above
-    mov     x1, sp
-
-    bl      _cpp_vtable_call
-
-    ldp     x8, lr, [sp, #0]
-    add     sp, sp, #144
-    ret     lr
-    .cfi_endproc
-
-#elif defined(__i386)
-    // i386 code, for the simulator
-    .text
-
-.align 1, 0x90
-_privateSnippetExecutorGeneral:
-LFBg:
-    movl    %esp,%ecx
-    pushl   %ebp              // proper stack frame needed for exception handling
-LCFIg0:
-    movl    %esp,%ebp
-LCFIg1:
-    subl    $0x8,%esp         // padding + 32bit returnValue
-    pushl   %esp              // 32bit &returnValue
-    pushl   %ecx              // 32bit pCallStack
-    pushl   %edx              // 32bit nVtableOffset
-    pushl   %eax              // 32bit nFunctionIndex
-    call    L_cpp_vtable_call$stub
-    movl    16(%esp),%eax     // 32bit returnValue
-    leave
-    ret
-LFEg:
-    .long   .-_privateSnippetExecutorGeneral
-
-.align 1, 0x90
-_privateSnippetExecutorVoid:
-LFBv:
-    movl    %esp,%ecx
-    pushl   %ebp              // proper stack frame needed for exception handling
-LCFIv0:
-    movl    %esp,%ebp
-LCFIv1:
-    sub     $8,%esp           // padding
-    pushl   $0                // 32bit null pointer (returnValue not used)
-    pushl   %ecx              // 32bit pCallStack
-    pushl   %edx              // 32bit nVtableOffset
-    pushl   %eax              // 32bit nFunctionIndex
-    call    L_cpp_vtable_call$stub
-    leave
-    ret
-LFEv:
-    .long   .-_privateSnippetExecutorVoid
-
-.align 1, 0x90
-_privateSnippetExecutorHyper:
-LFBh:
-    movl    %esp,%ecx
-    pushl   %ebp              // proper stack frame needed for exception handling
-LCFIh0:
-    movl    %esp,%ebp
-LCFIh1:
-    subl    $0x8,%esp         // 64bit returnValue
-    pushl   %esp              // 32bit &returnValue
-    pushl   %ecx              // 32bit pCallStack
-    pushl   %edx              // 32bit nVtableOffset
-    pushl   %eax              // 32bit nFunctionIndex
-    call    L_cpp_vtable_call$stub
-    movl    16(%esp),%eax     // 64bit returnValue, lower half
-    movl    20(%esp),%edx     // 64bit returnValue, upper half
-    leave
-    ret
-LFEh:
-    .long   .-_privateSnippetExecutorHyper
-
-.align 1, 0x90
-_privateSnippetExecutorFloat:
-LFBf:
-    movl    %esp,%ecx
-    pushl   %ebp              // proper stack frame needed for exception handling
-LCFIf0:
-    movl    %esp,%ebp
-LCFIf1:
-    subl    $0x8,%esp         // padding + 32bit returnValue
-    pushl   %esp              // 32bit &returnValue
-    pushl   %ecx              // 32bit pCallStack
-    pushl   %edx              // 32bit nVtableOffset
-    pushl   %eax              // 32bit nFunctionIndex
-    call    L_cpp_vtable_call$stub
-    flds    16(%esp)          // 32bit returnValue
-    leave
-    ret
-LFEf:
-    .long   .-_privateSnippetExecutorFloat
-
-.align 1, 0x90
-_privateSnippetExecutorDouble:
-LFBd:
-    movl    %esp,%ecx
-    pushl   %ebp              // proper stack frame needed for exception handling
-LCFId0:
-    movl    %esp,%ebp
-LCFId1:
-    subl    $0x8,%esp         // 64bit returnValue
-    pushl   %esp              // 32bit &returnValue
-    pushl   %ecx              // 32bit pCallStack
-    pushl   %edx              // 32bit nVtableOffset
-    pushl   %eax              // 32bit nFunctionIndex
-    call    L_cpp_vtable_call$stub
-    fldl    16(%esp)          // 64bit returnValue
-    leave
-    ret
-LFEd:
-    .long   .-_privateSnippetExecutorDouble
-
-.align 1, 0x90
-_privateSnippetExecutorClass:
-LFBc:
-    movl    %esp,%ecx
-    pushl   %ebp              // proper stack frame needed for exception handling
-LCFIc0:
-    movl    %esp,%ebp
-LCFIc1:
-    subl    $0x8,%esp         // padding + 32bit returnValue
-    pushl   %esp              // 32bit &returnValue
-    pushl   %ecx              // 32bit pCallStack
-    pushl   %edx              // 32bit nVtableOffset
-    pushl   %eax              // 32bit nFunctionIndex
-    call    L_cpp_vtable_call$stub
-    movl    16(%esp),%eax     // 32bit returnValue
-    leave
-    ret     $4
-LFEc:
-    .long   .-_privateSnippetExecutorClass
-
-    .section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms+live_support
-EH_frame1:
-    .set L$set$frame1,LECIE1-LSCIE1
-    .long   L$set$frame1      // length
-LSCIE1:
-    .long   0                 // CIE_ID
-    .byte   1                 // version
-    .ascii  "zPR\0"           // augmentation
-    .byte   1                 // code_alignment_factor (.uleb128 1)
-    .byte   0x7c              // data_alignment_factor (.sleb128 -4)
-    .byte   8                 // return_address_register
-    .byte   0x6               // augmentation size 7:
-    .byte   0x9b              //  ???
-    .long   L___gxx_personality_v0$non_lazy_ptr-.
-    .byte   0x10
-                              // initial_instructions:
-    .byte   0x0C              //  DW_CFA_def_cfa %esp, 4
-    .byte   5
-    .byte   4
-    .byte   0x88              //  DW_CFA_offset ret, 1
-    .byte   1
-    .align 2
-LECIE1:
-_privateSnippetExecutorGeneral.eh:
-LSFDEg:
-    .set L$set$g1,LEFDEg-LASFDEg
-    .long   L$set$g1          // length
-LASFDEg:
-    .long   LASFDEg-EH_frame1 // CIE_pointer
-    .long   LFBg-.            // initial_location
-    .long   LFEg-LFBg         // address_range
-    .byte   0                 // augmentation size 0
-                              // instructions:
-    .byte   0x04              //  DW_CFA_advance_loc4
-    .long   LCFIg0-LFBg
-    .byte   0x0E              //  DW_CFA_def_cfa_offset 8
-    .byte   8
-    .byte   0x84              //  DW_CFA_offset %ebp, 2
-    .byte   2
-    .byte   0x04              //  DW_CFA_advance_loc4
-    .long   LCFIg1-LCFIg0
-    .byte   0x0D              //  DW_CFA_def_cfa_register %ebp
-    .byte   4
-    .align 2
-LEFDEg:
-_privateSnippetExecutorVoid.eh:
-LSFDEv:
-    .set L$set$v1,LEFDEv-LASFDEv
-    .long   L$set$v1          // length
-LASFDEv:
-    .long   LASFDEv-EH_frame1 // CIE_pointer
-    .long   LFBv-.            // initial_location
-    .long   LFEv-LFBv         // address_range
-    .byte   0                 // augmentation size 0
-                              // instructions:
-    .byte   0x04              //  DW_CFA_advance_loc4
-    .long   LCFIv0-LFBv
-    .byte   0x0E              //  DW_CFA_def_cfa_offset 8
-    .byte   8
-    .byte   0x84              //  DW_CFA_offset %ebp, 2
-    .byte   2
-    .byte   0x04              //  DW_CFA_advance_loc4
-    .long   LCFIv1-LCFIv0
-    .byte   0x0D              //  DW_CFA_def_cfa_register %ebp
-    .byte   4
-    .align 2
-LEFDEv:
-_privateSnippetExecutorHyper.eh:
-LSFDEh:
-    .set L$set$h1,LEFDEh-LASFDEh
-    .long   L$set$h1          // length
-LASFDEh:
-    .long   LASFDEh-EH_frame1 // CIE_pointer
-    .long   LFBh-.            // initial_location
-    .long   LFEh-LFBh         // address_range
-    .byte   0                 // augmentation size 0
-                              // instructions:
-    .byte   0x04              //  DW_CFA_advance_loc4
-    .long   LCFIh0-LFBh
-    .byte   0x0E              //  DW_CFA_def_cfa_offset 8
-    .byte   8
-    .byte   0x84              //  DW_CFA_offset %ebp, 2
-    .byte   2
-    .byte   0x04              //  DW_CFA_advance_loc4
-    .long   LCFIh1-LCFIh0
-    .byte   0x0D              //  DW_CFA_def_cfa_register %ebp
-    .byte   4
-    .align 2
-LEFDEh:
-_privateSnippetExecutorFloat.eh:
-LSFDEf:
-    .set L$set$f1,LEFDEf-LASFDEf
-    .long   L$set$f1          // length
-LASFDEf:
-    .long   LASFDEf-EH_frame1 // CIE_pointer
-    .long   LFBf-.            // initial_location
-    .long   LFEf-LFBf         // address_range
-    .byte   0                 // augmentation size 0
-                              // instructions:
-    .byte   0x04              //  DW_CFA_advance_loc4
-    .long   LCFIf0-LFBf
-    .byte   0x0E              //  DW_CFA_def_cfa_offset 8
-    .byte   8
-    .byte   0x84              //  DW_CFA_offset %ebp, 2
-    .byte   2
-    .byte   0x04              //  DW_CFA_advance_loc4
-    .long   LCFIf1-LCFIf0
-    .byte   0x0D              //  DW_CFA_def_cfa_register %ebp
-    .byte   4
-    .align 2
-LEFDEf:
-_privateSnippetExecutorDouble.eh:
-LSFDEd:
-    .set L$set$d1,LEFDEd-LASFDEd
-    .long   L$set$d1          // length
-LASFDEd:
-    .long   LASFDEd-EH_frame1 // CIE_pointer
-    .long   LFBd-.            // initial_location
-    .long   LFEd-LFBd         // address_range
-    .byte   0                 // augmentation size 0
-                              // instructions:
-    .byte   0x04              //  DW_CFA_advance_loc4
-    .long   LCFId0-LFBd
-    .byte   0x0E              //  DW_CFA_def_cfa_offset 8
-    .byte   8
-    .byte   0x84              //  DW_CFA_offset %ebp, 2
-    .byte   2
-    .byte   0x04              //  DW_CFA_advance_loc4
-    .long   LCFId1-LCFId0
-    .byte   0x0D              //  DW_CFA_def_cfa_register %ebp
-    .byte   4
-    .align 2
-LEFDEd:
-_privateSnippetExecutorClass.eh:
-LSFDEc:
-    .set L$set$c1,LEFDEc-LASFDEc
-    .long   L$set$c1          // length
-LASFDEc:
-    .long   LASFDEc-EH_frame1 // CIE_pointer
-    .long   LFBc-.            // initial_location
-    .long   LFEc-LFBc         // address_range
-    .byte   0                 // augmentation size 0
-                              // instructions:
-    .byte   0x04              //  DW_CFA_advance_loc4
-    .long   LCFIc0-LFBc
-    .byte   0x0E              //  DW_CFA_def_cfa_offset 8
-    .byte   8
-    .byte   0x84              //  DW_CFA_offset %ebp, 2
-    .byte   2
-    .byte   0x04              //  DW_CFA_advance_loc4
-    .long   LCFIc1-LCFIc0
-    .byte   0x0D              //  DW_CFA_def_cfa_register %ebp
-    .byte   4
-    .align 2
-LEFDEc:
-    .section __IMPORT,__jump_table,symbol_stubs,self_modifying_code+pure_instructions,5
-L_cpp_vtable_call$stub:
-    .indirect_symbol _cpp_vtable_call
-    hlt ; hlt ; hlt ; hlt ; hlt
-    .section __IMPORT,__pointers,non_lazy_symbol_pointers
-L___gxx_personality_v0$non_lazy_ptr:
-    .indirect_symbol ___gxx_personality_v0
-    .long 0
-    .constructor
-    .destructor
-    .align 1
-#else
-
-	.text
-	.align 2
-.globl privateSnippetExecutor
-_privateSnippetExecutor:
-.LFB3:
-	pushq	%rbp
-.LCFI0:
-	movq	%rsp, %rbp
-.LCFI1:
-	subq	$160, %rsp
-.LCFI2:
-	movq	%r10, -152(%rbp)		# Save (nVtableOffset << 32) + nFunctionIndex
-
-	movq	%rdi, -112(%rbp)		# Save GP registers
-	movq	%rsi, -104(%rbp)
-	movq	%rdx, -96(%rbp)
-	movq	%rcx, -88(%rbp)
-	movq	%r8 , -80(%rbp)
-	movq	%r9 , -72(%rbp)
-	
-	movsd	%xmm0, -64(%rbp)		# Save FP registers
-	movsd	%xmm1, -56(%rbp)
-	movsd	%xmm2, -48(%rbp)
-	movsd	%xmm3, -40(%rbp)
-	movsd	%xmm4, -32(%rbp)
-	movsd	%xmm5, -24(%rbp)
-	movsd	%xmm6, -16(%rbp)
-	movsd	%xmm7, -8(%rbp)
-
-	leaq	-144(%rbp), %r9			# 6th param: sal_uInt64 * pRegisterReturn
-	leaq	16(%rbp), %r8			# 5rd param: void ** ovrflw
-	leaq	-64(%rbp), %rcx			# 4th param: void ** fpreg
-	leaq	-112(%rbp), %rdx		# 3rd param: void ** gpreg
-	movl	-148(%rbp), %esi		# 2nd param: sal_int32 nVtableOffset
-	movl	-152(%rbp), %edi		# 1st param: sal_int32 nFunctionIndex
-	
-	call	cpp_vtable_call
-
-	cmp	$10, %rax					# typelib_TypeClass_FLOAT
-	je	.Lfloat
-	cmp	$11, %rax					# typelib_TypeClass_DOUBLE
-	je	.Lfloat
-
-	movq	-144(%rbp), %rax		# Return value (int case)
-	movq	-136(%rbp), %rdx		# Return value (int case)
-	movq	-144(%rbp), %xmm0		# Return value (int case)
-	movq	-136(%rbp), %xmm1		# Return value (int case)
-	jmp	.Lfinish
-.Lfloat:
-	movlpd	-144(%rbp), %xmm0		# Return value (float/double case)
-
-.Lfinish:
-	leave
-	ret
-.LFE3:
-	# see http://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html
-	# for details of the .eh_frame, the "Common Information Entry" and "Frame Description Entry" formats
-	# and http://mentorembedded.github.io/cxx-abi/exceptions.pdf for more info
-.Lframe1:
-	.long	.LECIE1-.LSCIE1
-.LSCIE1:
-	.long	0x0
-	.byte	0x1
-	.string	"zR"
-	.uleb128 0x1
-	.sleb128 -8
-	.byte	0x10
-	.uleb128 0x1
-	.byte	0x1b
-	.byte	0xc
-	.uleb128 0x7
-	.uleb128 0x8
-	.byte	0x90
-	.uleb128 0x1
-	.align 8
-.LECIE1:
-.LSFDE1:
-	.long	.LEFDE1-.LASFDE1
-.LASFDE1:
-	.long	.LASFDE1-.Lframe1
-	.long	.LFB3-.
-	.long	.LFE3-.LFB3
-	.uleb128 0x0
-	.byte	0x4
-	.long	.LCFI0-.LFB3
-	.byte	0xe
-	.uleb128 0x10
-	.byte	0x86
-	.uleb128 0x2
-	.byte	0x4
-	.long	.LCFI1-.LCFI0
-	.byte	0xd
-	.uleb128 0x6
-	.align 8
-.LEFDE1:
-#endif
-
-// vim:set shiftwidth=4 softtabstop=4 expandtab:
diff --git a/bridges/source/cpp_uno/gcc3_ios/ios64_helper.s b/bridges/source/cpp_uno/gcc3_ios/ios64_helper.s
new file mode 100644
index 000000000000..9c4af3e98318
--- /dev/null
+++ b/bridges/source/cpp_uno/gcc3_ios/ios64_helper.s
@@ -0,0 +1,3254 @@
+// -*- Mode: Asm; tab-width: 4; tab-stop-list: (4 12 32); comment-column: 30; comment-start: "// "; indent-tabs-mode: nil -*-
+//
+// This file is part of the LibreOffice project.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//
+// This file incorporates work covered by the following license notice:
+//
+//   Licensed to the Apache Software Foundation (ASF) under one or more
+//   contributor license agreements. See the NOTICE file distributed
+//   with this work for additional information regarding copyright
+//   ownership. The ASF licenses this file to you under the Apache
+//   License, Version 2.0 (the "License"); you may not use this file
+//   except in compliance with the License. You may obtain a copy of
+//   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+//
+
+#ifdef __arm64
+
+.text
+#if defined(__arm) || defined(__arm64)
+
+// Each codeSnippetX function stores into ip (arm64: x15) an address and branches to _privateSnippetExecutor
+// The address is that following the branch instruction, containing two 32-bit ints:
+// - the function index, which for 32-bit can have the 0x80000000 bit set
+//   to indicate that a hidden parameter is used for returning large values
+// - the vtable offset
+
+    .align 4
+
+codeSnippet_00000000_0:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 00000000
+    .long 0
+#ifndef __arm64
+codeSnippet_80000000_0:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000000
+    .long 0
+#endif
+codeSnippet_00000000_1:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 00000000
+    .long 1
+#ifndef __arm64
+codeSnippet_80000000_1:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000000
+    .long 1
+#endif
+codeSnippet_00000000_2:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 00000000
+    .long 2
+#ifndef __arm64
+codeSnippet_80000000_2:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000000
+    .long 2
+#endif
+codeSnippet_00000000_3:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 00000000
+    .long 3
+#ifndef __arm64
+codeSnippet_80000000_3:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000000
+    .long 3
+#endif
+codeSnippet_00000001_0:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000001
+    .long 0
+#ifndef __arm64
+codeSnippet_80000001_0:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000001
+    .long 0
+#endif
+codeSnippet_00000001_1:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000001
+    .long 1
+#ifndef __arm64
+codeSnippet_80000001_1:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000001
+    .long 1
+#endif
+codeSnippet_00000001_2:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000001
+    .long 2
+#ifndef __arm64
+codeSnippet_80000001_2:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000001
+    .long 2
+#endif
+codeSnippet_00000001_3:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000001
+    .long 3
+#ifndef __arm64
+codeSnippet_80000001_3:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000001
+    .long 3
+#endif
+codeSnippet_00000002_0:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000002
+    .long 0
+#ifndef __arm64
+codeSnippet_80000002_0:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000002
+    .long 0
+#endif
+codeSnippet_00000002_1:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000002
+    .long 1
+#ifndef __arm64
+codeSnippet_80000002_1:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000002
+    .long 1
+#endif
+codeSnippet_00000002_2:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000002
+    .long 2
+#ifndef __arm64
+codeSnippet_80000002_2:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000002
+    .long 2
+#endif
+codeSnippet_00000002_3:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000002
+    .long 3
+#ifndef __arm64
+codeSnippet_80000002_3:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000002
+    .long 3
+#endif
+codeSnippet_00000003_0:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000003
+    .long 0
+#ifndef __arm64
+codeSnippet_80000003_0:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000003
+    .long 0
+#endif
+codeSnippet_00000003_1:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000003
+    .long 1
+#ifndef __arm64
+codeSnippet_80000003_1:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000003
+    .long 1
+#endif
+codeSnippet_00000003_2:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000003
+    .long 2
+#ifndef __arm64
+codeSnippet_80000003_2:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000003
+    .long 2
+#endif
+codeSnippet_00000003_3:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000003
+    .long 3
+#ifndef __arm64
+codeSnippet_80000003_3:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000003
+    .long 3
+#endif
+codeSnippet_00000004_0:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000004
+    .long 0
+#ifndef __arm64
+codeSnippet_80000004_0:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000004
+    .long 0
+#endif
+codeSnippet_00000004_1:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000004
+    .long 1
+#ifndef __arm64
+codeSnippet_80000004_1:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000004
+    .long 1
+#endif
+codeSnippet_00000004_2:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000004
+    .long 2
+#ifndef __arm64
+codeSnippet_80000004_2:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000004
+    .long 2
+#endif
+codeSnippet_00000004_3:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000004
+    .long 3
+#ifndef __arm64
+codeSnippet_80000004_3:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000004
+    .long 3
+#endif
+codeSnippet_00000005_0:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000005
+    .long 0
+#ifndef __arm64
+codeSnippet_80000005_0:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000005
+    .long 0
+#endif
+codeSnippet_00000005_1:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000005
+    .long 1
+#ifndef __arm64
+codeSnippet_80000005_1:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000005
+    .long 1
+#endif
+codeSnippet_00000005_2:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000005
+    .long 2
+#ifndef __arm64
+codeSnippet_80000005_2:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000005
+    .long 2
+#endif
+codeSnippet_00000005_3:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000005
+    .long 3
+#ifndef __arm64
+codeSnippet_80000005_3:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000005
+    .long 3
+#endif
+codeSnippet_00000006_0:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000006
+    .long 0
+#ifndef __arm64
+codeSnippet_80000006_0:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000006
+    .long 0
+#endif
+codeSnippet_00000006_1:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000006
+    .long 1
+#ifndef __arm64
+codeSnippet_80000006_1:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000006
+    .long 1
+#endif
+codeSnippet_00000006_2:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000006
+    .long 2
+#ifndef __arm64
+codeSnippet_80000006_2:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000006
+    .long 2
+#endif
+codeSnippet_00000006_3:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000006
+    .long 3
+#ifndef __arm64
+codeSnippet_80000006_3:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000006
+    .long 3
+#endif
+codeSnippet_00000007_0:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000007
+    .long 0
+#ifndef __arm64
+codeSnippet_80000007_0:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000007
+    .long 0
+#endif
+codeSnippet_00000007_1:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000007
+    .long 1
+#ifndef __arm64
+codeSnippet_80000007_1:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000007
+    .long 1
+#endif
+codeSnippet_00000007_2:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000007
+    .long 2
+#ifndef __arm64
+codeSnippet_80000007_2:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000007
+    .long 2
+#endif
+codeSnippet_00000007_3:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x000007
+    .long 3
+#ifndef __arm64
+codeSnippet_80000007_3:
+#ifdef __arm
+    mov ip, pc
+#else
+    adr x15, .+8
+#endif
+    b _privateSnippetExecutor
+    .long 0x80000007
+    .long 3
+#endif
+#else
+    .align 1, 0x90
+codeSnippet_00000000_0_General:
+    movl $00000000, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000000_0_General:
+    movl $0x80000000, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000000_0_Void:
+    movl $00000000, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000000_0_Void:
+    movl $0x80000000, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000000_0_Hyper:
+    movl $00000000, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000000_0_Hyper:
+    movl $0x80000000, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000000_0_Float:
+    movl $00000000, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000000_0_Float:
+    movl $0x80000000, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000000_0_Double:
+    movl $00000000, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000000_0_Double:
+    movl $0x80000000, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000000_0_Class:
+    movl $00000000, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000000_0_Class:
+    movl $0x80000000, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000000_1_General:
+    movl $00000000, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000000_1_General:
+    movl $0x80000000, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000000_1_Void:
+    movl $00000000, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000000_1_Void:
+    movl $0x80000000, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000000_1_Hyper:
+    movl $00000000, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000000_1_Hyper:
+    movl $0x80000000, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000000_1_Float:
+    movl $00000000, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000000_1_Float:
+    movl $0x80000000, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000000_1_Double:
+    movl $00000000, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000000_1_Double:
+    movl $0x80000000, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000000_1_Class:
+    movl $00000000, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000000_1_Class:
+    movl $0x80000000, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000000_2_General:
+    movl $00000000, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000000_2_General:
+    movl $0x80000000, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000000_2_Void:
+    movl $00000000, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000000_2_Void:
+    movl $0x80000000, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000000_2_Hyper:
+    movl $00000000, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000000_2_Hyper:
+    movl $0x80000000, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000000_2_Float:
+    movl $00000000, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000000_2_Float:
+    movl $0x80000000, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000000_2_Double:
+    movl $00000000, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000000_2_Double:
+    movl $0x80000000, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000000_2_Class:
+    movl $00000000, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000000_2_Class:
+    movl $0x80000000, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000000_3_General:
+    movl $00000000, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000000_3_General:
+    movl $0x80000000, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000000_3_Void:
+    movl $00000000, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000000_3_Void:
+    movl $0x80000000, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000000_3_Hyper:
+    movl $00000000, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000000_3_Hyper:
+    movl $0x80000000, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000000_3_Float:
+    movl $00000000, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000000_3_Float:
+    movl $0x80000000, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000000_3_Double:
+    movl $00000000, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000000_3_Double:
+    movl $0x80000000, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000000_3_Class:
+    movl $00000000, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000000_3_Class:
+    movl $0x80000000, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000001_0_General:
+    movl $0x000001, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000001_0_General:
+    movl $0x80000001, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000001_0_Void:
+    movl $0x000001, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000001_0_Void:
+    movl $0x80000001, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000001_0_Hyper:
+    movl $0x000001, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000001_0_Hyper:
+    movl $0x80000001, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000001_0_Float:
+    movl $0x000001, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000001_0_Float:
+    movl $0x80000001, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000001_0_Double:
+    movl $0x000001, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000001_0_Double:
+    movl $0x80000001, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000001_0_Class:
+    movl $0x000001, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000001_0_Class:
+    movl $0x80000001, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000001_1_General:
+    movl $0x000001, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000001_1_General:
+    movl $0x80000001, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000001_1_Void:
+    movl $0x000001, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000001_1_Void:
+    movl $0x80000001, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000001_1_Hyper:
+    movl $0x000001, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000001_1_Hyper:
+    movl $0x80000001, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000001_1_Float:
+    movl $0x000001, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000001_1_Float:
+    movl $0x80000001, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000001_1_Double:
+    movl $0x000001, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000001_1_Double:
+    movl $0x80000001, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000001_1_Class:
+    movl $0x000001, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000001_1_Class:
+    movl $0x80000001, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000001_2_General:
+    movl $0x000001, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000001_2_General:
+    movl $0x80000001, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000001_2_Void:
+    movl $0x000001, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000001_2_Void:
+    movl $0x80000001, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000001_2_Hyper:
+    movl $0x000001, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000001_2_Hyper:
+    movl $0x80000001, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000001_2_Float:
+    movl $0x000001, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000001_2_Float:
+    movl $0x80000001, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000001_2_Double:
+    movl $0x000001, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000001_2_Double:
+    movl $0x80000001, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000001_2_Class:
+    movl $0x000001, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000001_2_Class:
+    movl $0x80000001, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000001_3_General:
+    movl $0x000001, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000001_3_General:
+    movl $0x80000001, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000001_3_Void:
+    movl $0x000001, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000001_3_Void:
+    movl $0x80000001, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000001_3_Hyper:
+    movl $0x000001, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000001_3_Hyper:
+    movl $0x80000001, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000001_3_Float:
+    movl $0x000001, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000001_3_Float:
+    movl $0x80000001, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000001_3_Double:
+    movl $0x000001, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000001_3_Double:
+    movl $0x80000001, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000001_3_Class:
+    movl $0x000001, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000001_3_Class:
+    movl $0x80000001, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000002_0_General:
+    movl $0x000002, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000002_0_General:
+    movl $0x80000002, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000002_0_Void:
+    movl $0x000002, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000002_0_Void:
+    movl $0x80000002, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000002_0_Hyper:
+    movl $0x000002, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000002_0_Hyper:
+    movl $0x80000002, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000002_0_Float:
+    movl $0x000002, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000002_0_Float:
+    movl $0x80000002, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000002_0_Double:
+    movl $0x000002, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000002_0_Double:
+    movl $0x80000002, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000002_0_Class:
+    movl $0x000002, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000002_0_Class:
+    movl $0x80000002, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000002_1_General:
+    movl $0x000002, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000002_1_General:
+    movl $0x80000002, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000002_1_Void:
+    movl $0x000002, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000002_1_Void:
+    movl $0x80000002, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000002_1_Hyper:
+    movl $0x000002, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000002_1_Hyper:
+    movl $0x80000002, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000002_1_Float:
+    movl $0x000002, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000002_1_Float:
+    movl $0x80000002, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000002_1_Double:
+    movl $0x000002, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000002_1_Double:
+    movl $0x80000002, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000002_1_Class:
+    movl $0x000002, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000002_1_Class:
+    movl $0x80000002, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000002_2_General:
+    movl $0x000002, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000002_2_General:
+    movl $0x80000002, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000002_2_Void:
+    movl $0x000002, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000002_2_Void:
+    movl $0x80000002, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000002_2_Hyper:
+    movl $0x000002, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000002_2_Hyper:
+    movl $0x80000002, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000002_2_Float:
+    movl $0x000002, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000002_2_Float:
+    movl $0x80000002, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000002_2_Double:
+    movl $0x000002, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000002_2_Double:
+    movl $0x80000002, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000002_2_Class:
+    movl $0x000002, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000002_2_Class:
+    movl $0x80000002, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000002_3_General:
+    movl $0x000002, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000002_3_General:
+    movl $0x80000002, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000002_3_Void:
+    movl $0x000002, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000002_3_Void:
+    movl $0x80000002, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000002_3_Hyper:
+    movl $0x000002, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000002_3_Hyper:
+    movl $0x80000002, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000002_3_Float:
+    movl $0x000002, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000002_3_Float:
+    movl $0x80000002, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000002_3_Double:
+    movl $0x000002, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000002_3_Double:
+    movl $0x80000002, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000002_3_Class:
+    movl $0x000002, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000002_3_Class:
+    movl $0x80000002, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000003_0_General:
+    movl $0x000003, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000003_0_General:
+    movl $0x80000003, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000003_0_Void:
+    movl $0x000003, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000003_0_Void:
+    movl $0x80000003, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000003_0_Hyper:
+    movl $0x000003, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000003_0_Hyper:
+    movl $0x80000003, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000003_0_Float:
+    movl $0x000003, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000003_0_Float:
+    movl $0x80000003, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000003_0_Double:
+    movl $0x000003, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000003_0_Double:
+    movl $0x80000003, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000003_0_Class:
+    movl $0x000003, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000003_0_Class:
+    movl $0x80000003, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000003_1_General:
+    movl $0x000003, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000003_1_General:
+    movl $0x80000003, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000003_1_Void:
+    movl $0x000003, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000003_1_Void:
+    movl $0x80000003, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000003_1_Hyper:
+    movl $0x000003, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000003_1_Hyper:
+    movl $0x80000003, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000003_1_Float:
+    movl $0x000003, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000003_1_Float:
+    movl $0x80000003, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000003_1_Double:
+    movl $0x000003, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000003_1_Double:
+    movl $0x80000003, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000003_1_Class:
+    movl $0x000003, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000003_1_Class:
+    movl $0x80000003, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000003_2_General:
+    movl $0x000003, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000003_2_General:
+    movl $0x80000003, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000003_2_Void:
+    movl $0x000003, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000003_2_Void:
+    movl $0x80000003, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000003_2_Hyper:
+    movl $0x000003, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000003_2_Hyper:
+    movl $0x80000003, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000003_2_Float:
+    movl $0x000003, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000003_2_Float:
+    movl $0x80000003, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000003_2_Double:
+    movl $0x000003, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000003_2_Double:
+    movl $0x80000003, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000003_2_Class:
+    movl $0x000003, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000003_2_Class:
+    movl $0x80000003, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000003_3_General:
+    movl $0x000003, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000003_3_General:
+    movl $0x80000003, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000003_3_Void:
+    movl $0x000003, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000003_3_Void:
+    movl $0x80000003, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000003_3_Hyper:
+    movl $0x000003, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000003_3_Hyper:
+    movl $0x80000003, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000003_3_Float:
+    movl $0x000003, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000003_3_Float:
+    movl $0x80000003, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000003_3_Double:
+    movl $0x000003, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000003_3_Double:
+    movl $0x80000003, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000003_3_Class:
+    movl $0x000003, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000003_3_Class:
+    movl $0x80000003, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000004_0_General:
+    movl $0x000004, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000004_0_General:
+    movl $0x80000004, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000004_0_Void:
+    movl $0x000004, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000004_0_Void:
+    movl $0x80000004, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000004_0_Hyper:
+    movl $0x000004, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000004_0_Hyper:
+    movl $0x80000004, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000004_0_Float:
+    movl $0x000004, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000004_0_Float:
+    movl $0x80000004, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000004_0_Double:
+    movl $0x000004, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000004_0_Double:
+    movl $0x80000004, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000004_0_Class:
+    movl $0x000004, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000004_0_Class:
+    movl $0x80000004, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000004_1_General:
+    movl $0x000004, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000004_1_General:
+    movl $0x80000004, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000004_1_Void:
+    movl $0x000004, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000004_1_Void:
+    movl $0x80000004, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000004_1_Hyper:
+    movl $0x000004, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000004_1_Hyper:
+    movl $0x80000004, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000004_1_Float:
+    movl $0x000004, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000004_1_Float:
+    movl $0x80000004, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000004_1_Double:
+    movl $0x000004, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000004_1_Double:
+    movl $0x80000004, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000004_1_Class:
+    movl $0x000004, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000004_1_Class:
+    movl $0x80000004, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000004_2_General:
+    movl $0x000004, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000004_2_General:
+    movl $0x80000004, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000004_2_Void:
+    movl $0x000004, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000004_2_Void:
+    movl $0x80000004, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000004_2_Hyper:
+    movl $0x000004, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000004_2_Hyper:
+    movl $0x80000004, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000004_2_Float:
+    movl $0x000004, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000004_2_Float:
+    movl $0x80000004, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000004_2_Double:
+    movl $0x000004, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000004_2_Double:
+    movl $0x80000004, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000004_2_Class:
+    movl $0x000004, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000004_2_Class:
+    movl $0x80000004, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000004_3_General:
+    movl $0x000004, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000004_3_General:
+    movl $0x80000004, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000004_3_Void:
+    movl $0x000004, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000004_3_Void:
+    movl $0x80000004, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000004_3_Hyper:
+    movl $0x000004, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000004_3_Hyper:
+    movl $0x80000004, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000004_3_Float:
+    movl $0x000004, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000004_3_Float:
+    movl $0x80000004, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000004_3_Double:
+    movl $0x000004, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000004_3_Double:
+    movl $0x80000004, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000004_3_Class:
+    movl $0x000004, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000004_3_Class:
+    movl $0x80000004, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000005_0_General:
+    movl $0x000005, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000005_0_General:
+    movl $0x80000005, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000005_0_Void:
+    movl $0x000005, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000005_0_Void:
+    movl $0x80000005, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000005_0_Hyper:
+    movl $0x000005, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000005_0_Hyper:
+    movl $0x80000005, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000005_0_Float:
+    movl $0x000005, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000005_0_Float:
+    movl $0x80000005, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000005_0_Double:
+    movl $0x000005, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000005_0_Double:
+    movl $0x80000005, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000005_0_Class:
+    movl $0x000005, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000005_0_Class:
+    movl $0x80000005, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000005_1_General:
+    movl $0x000005, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000005_1_General:
+    movl $0x80000005, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000005_1_Void:
+    movl $0x000005, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000005_1_Void:
+    movl $0x80000005, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000005_1_Hyper:
+    movl $0x000005, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000005_1_Hyper:
+    movl $0x80000005, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000005_1_Float:
+    movl $0x000005, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000005_1_Float:
+    movl $0x80000005, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000005_1_Double:
+    movl $0x000005, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000005_1_Double:
+    movl $0x80000005, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000005_1_Class:
+    movl $0x000005, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000005_1_Class:
+    movl $0x80000005, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000005_2_General:
+    movl $0x000005, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000005_2_General:
+    movl $0x80000005, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000005_2_Void:
+    movl $0x000005, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000005_2_Void:
+    movl $0x80000005, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000005_2_Hyper:
+    movl $0x000005, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000005_2_Hyper:
+    movl $0x80000005, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000005_2_Float:
+    movl $0x000005, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000005_2_Float:
+    movl $0x80000005, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000005_2_Double:
+    movl $0x000005, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000005_2_Double:
+    movl $0x80000005, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000005_2_Class:
+    movl $0x000005, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000005_2_Class:
+    movl $0x80000005, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000005_3_General:
+    movl $0x000005, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000005_3_General:
+    movl $0x80000005, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000005_3_Void:
+    movl $0x000005, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000005_3_Void:
+    movl $0x80000005, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000005_3_Hyper:
+    movl $0x000005, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000005_3_Hyper:
+    movl $0x80000005, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000005_3_Float:
+    movl $0x000005, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000005_3_Float:
+    movl $0x80000005, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000005_3_Double:
+    movl $0x000005, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000005_3_Double:
+    movl $0x80000005, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000005_3_Class:
+    movl $0x000005, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000005_3_Class:
+    movl $0x80000005, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000006_0_General:
+    movl $0x000006, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000006_0_General:
+    movl $0x80000006, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000006_0_Void:
+    movl $0x000006, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000006_0_Void:
+    movl $0x80000006, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000006_0_Hyper:
+    movl $0x000006, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000006_0_Hyper:
+    movl $0x80000006, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000006_0_Float:
+    movl $0x000006, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000006_0_Float:
+    movl $0x80000006, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000006_0_Double:
+    movl $0x000006, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000006_0_Double:
+    movl $0x80000006, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000006_0_Class:
+    movl $0x000006, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000006_0_Class:
+    movl $0x80000006, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000006_1_General:
+    movl $0x000006, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000006_1_General:
+    movl $0x80000006, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000006_1_Void:
+    movl $0x000006, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000006_1_Void:
+    movl $0x80000006, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000006_1_Hyper:
+    movl $0x000006, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000006_1_Hyper:
+    movl $0x80000006, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000006_1_Float:
+    movl $0x000006, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000006_1_Float:
+    movl $0x80000006, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000006_1_Double:
+    movl $0x000006, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000006_1_Double:
+    movl $0x80000006, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000006_1_Class:
+    movl $0x000006, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000006_1_Class:
+    movl $0x80000006, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000006_2_General:
+    movl $0x000006, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000006_2_General:
+    movl $0x80000006, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000006_2_Void:
+    movl $0x000006, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000006_2_Void:
+    movl $0x80000006, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000006_2_Hyper:
+    movl $0x000006, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000006_2_Hyper:
+    movl $0x80000006, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000006_2_Float:
+    movl $0x000006, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000006_2_Float:
+    movl $0x80000006, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000006_2_Double:
+    movl $0x000006, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000006_2_Double:
+    movl $0x80000006, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000006_2_Class:
+    movl $0x000006, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000006_2_Class:
+    movl $0x80000006, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000006_3_General:
+    movl $0x000006, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000006_3_General:
+    movl $0x80000006, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000006_3_Void:
+    movl $0x000006, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000006_3_Void:
+    movl $0x80000006, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000006_3_Hyper:
+    movl $0x000006, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000006_3_Hyper:
+    movl $0x80000006, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000006_3_Float:
+    movl $0x000006, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000006_3_Float:
+    movl $0x80000006, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000006_3_Double:
+    movl $0x000006, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000006_3_Double:
+    movl $0x80000006, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000006_3_Class:
+    movl $0x000006, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000006_3_Class:
+    movl $0x80000006, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000007_0_General:
+    movl $0x000007, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000007_0_General:
+    movl $0x80000007, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000007_0_Void:
+    movl $0x000007, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000007_0_Void:
+    movl $0x80000007, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000007_0_Hyper:
+    movl $0x000007, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000007_0_Hyper:
+    movl $0x80000007, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000007_0_Float:
+    movl $0x000007, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000007_0_Float:
+    movl $0x80000007, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000007_0_Double:
+    movl $0x000007, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000007_0_Double:
+    movl $0x80000007, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000007_0_Class:
+    movl $0x000007, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000007_0_Class:
+    movl $0x80000007, %eax
+    movl $0, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000007_1_General:
+    movl $0x000007, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000007_1_General:
+    movl $0x80000007, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000007_1_Void:
+    movl $0x000007, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000007_1_Void:
+    movl $0x80000007, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000007_1_Hyper:
+    movl $0x000007, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000007_1_Hyper:
+    movl $0x80000007, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000007_1_Float:
+    movl $0x000007, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000007_1_Float:
+    movl $0x80000007, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000007_1_Double:
+    movl $0x000007, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000007_1_Double:
+    movl $0x80000007, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000007_1_Class:
+    movl $0x000007, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000007_1_Class:
+    movl $0x80000007, %eax
+    movl $1, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000007_2_General:
+    movl $0x000007, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000007_2_General:
+    movl $0x80000007, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000007_2_Void:
+    movl $0x000007, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000007_2_Void:
+    movl $0x80000007, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000007_2_Hyper:
+    movl $0x000007, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000007_2_Hyper:
+    movl $0x80000007, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000007_2_Float:
+    movl $0x000007, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000007_2_Float:
+    movl $0x80000007, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000007_2_Double:
+    movl $0x000007, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000007_2_Double:
+    movl $0x80000007, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000007_2_Class:
+    movl $0x000007, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000007_2_Class:
+    movl $0x80000007, %eax
+    movl $2, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_00000007_3_General:
+    movl $0x000007, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_80000007_3_General:
+    movl $0x80000007, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorGeneral
+codeSnippet_00000007_3_Void:
+    movl $0x000007, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_80000007_3_Void:
+    movl $0x80000007, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorVoid
+codeSnippet_00000007_3_Hyper:
+    movl $0x000007, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_80000007_3_Hyper:
+    movl $0x80000007, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorHyper
+codeSnippet_00000007_3_Float:
+    movl $0x000007, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_80000007_3_Float:
+    movl $0x80000007, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorFloat
+codeSnippet_00000007_3_Double:
+    movl $0x000007, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_80000007_3_Double:
+    movl $0x80000007, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorDouble
+codeSnippet_00000007_3_Class:
+    movl $0x000007, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorClass
+codeSnippet_80000007_3_Class:
+    movl $0x80000007, %eax
+    movl $3, %edx
+    jmp _privateSnippetExecutorClass
+#endif
+    .globl _nFunIndexes
+_nFunIndexes:
+    .long 8
+    .globl _nVtableOffsets
+_nVtableOffsets:
+    .long 4
+    .globl _codeSnippets
+_codeSnippets:
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000000_0 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000000_0 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000000_0_General - _codeSnippets
+    .long codeSnippet_80000000_0_General - _codeSnippets
+    .long codeSnippet_00000000_0_Void - _codeSnippets
+    .long codeSnippet_80000000_0_Void - _codeSnippets
+    .long codeSnippet_00000000_0_Hyper - _codeSnippets
+    .long codeSnippet_80000000_0_Hyper - _codeSnippets
+    .long codeSnippet_00000000_0_Float - _codeSnippets
+    .long codeSnippet_80000000_0_Float - _codeSnippets
+    .long codeSnippet_00000000_0_Double - _codeSnippets
+    .long codeSnippet_80000000_0_Double - _codeSnippets
+    .long codeSnippet_00000000_0_Class - _codeSnippets
+    .long codeSnippet_80000000_0_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000000_1 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000000_1 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000000_1_General - _codeSnippets
+    .long codeSnippet_80000000_1_General - _codeSnippets
+    .long codeSnippet_00000000_1_Void - _codeSnippets
+    .long codeSnippet_80000000_1_Void - _codeSnippets
+    .long codeSnippet_00000000_1_Hyper - _codeSnippets
+    .long codeSnippet_80000000_1_Hyper - _codeSnippets
+    .long codeSnippet_00000000_1_Float - _codeSnippets
+    .long codeSnippet_80000000_1_Float - _codeSnippets
+    .long codeSnippet_00000000_1_Double - _codeSnippets
+    .long codeSnippet_80000000_1_Double - _codeSnippets
+    .long codeSnippet_00000000_1_Class - _codeSnippets
+    .long codeSnippet_80000000_1_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000000_2 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000000_2 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000000_2_General - _codeSnippets
+    .long codeSnippet_80000000_2_General - _codeSnippets
+    .long codeSnippet_00000000_2_Void - _codeSnippets
+    .long codeSnippet_80000000_2_Void - _codeSnippets
+    .long codeSnippet_00000000_2_Hyper - _codeSnippets
+    .long codeSnippet_80000000_2_Hyper - _codeSnippets
+    .long codeSnippet_00000000_2_Float - _codeSnippets
+    .long codeSnippet_80000000_2_Float - _codeSnippets
+    .long codeSnippet_00000000_2_Double - _codeSnippets
+    .long codeSnippet_80000000_2_Double - _codeSnippets
+    .long codeSnippet_00000000_2_Class - _codeSnippets
+    .long codeSnippet_80000000_2_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000000_3 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000000_3 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000000_3_General - _codeSnippets
+    .long codeSnippet_80000000_3_General - _codeSnippets
+    .long codeSnippet_00000000_3_Void - _codeSnippets
+    .long codeSnippet_80000000_3_Void - _codeSnippets
+    .long codeSnippet_00000000_3_Hyper - _codeSnippets
+    .long codeSnippet_80000000_3_Hyper - _codeSnippets
+    .long codeSnippet_00000000_3_Float - _codeSnippets
+    .long codeSnippet_80000000_3_Float - _codeSnippets
+    .long codeSnippet_00000000_3_Double - _codeSnippets
+    .long codeSnippet_80000000_3_Double - _codeSnippets
+    .long codeSnippet_00000000_3_Class - _codeSnippets
+    .long codeSnippet_80000000_3_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000001_0 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000001_0 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000001_0_General - _codeSnippets
+    .long codeSnippet_80000001_0_General - _codeSnippets
+    .long codeSnippet_00000001_0_Void - _codeSnippets
+    .long codeSnippet_80000001_0_Void - _codeSnippets
+    .long codeSnippet_00000001_0_Hyper - _codeSnippets
+    .long codeSnippet_80000001_0_Hyper - _codeSnippets
+    .long codeSnippet_00000001_0_Float - _codeSnippets
+    .long codeSnippet_80000001_0_Float - _codeSnippets
+    .long codeSnippet_00000001_0_Double - _codeSnippets
+    .long codeSnippet_80000001_0_Double - _codeSnippets
+    .long codeSnippet_00000001_0_Class - _codeSnippets
+    .long codeSnippet_80000001_0_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000001_1 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000001_1 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000001_1_General - _codeSnippets
+    .long codeSnippet_80000001_1_General - _codeSnippets
+    .long codeSnippet_00000001_1_Void - _codeSnippets
+    .long codeSnippet_80000001_1_Void - _codeSnippets
+    .long codeSnippet_00000001_1_Hyper - _codeSnippets
+    .long codeSnippet_80000001_1_Hyper - _codeSnippets
+    .long codeSnippet_00000001_1_Float - _codeSnippets
+    .long codeSnippet_80000001_1_Float - _codeSnippets
+    .long codeSnippet_00000001_1_Double - _codeSnippets
+    .long codeSnippet_80000001_1_Double - _codeSnippets
+    .long codeSnippet_00000001_1_Class - _codeSnippets
+    .long codeSnippet_80000001_1_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000001_2 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000001_2 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000001_2_General - _codeSnippets
+    .long codeSnippet_80000001_2_General - _codeSnippets
+    .long codeSnippet_00000001_2_Void - _codeSnippets
+    .long codeSnippet_80000001_2_Void - _codeSnippets
+    .long codeSnippet_00000001_2_Hyper - _codeSnippets
+    .long codeSnippet_80000001_2_Hyper - _codeSnippets
+    .long codeSnippet_00000001_2_Float - _codeSnippets
+    .long codeSnippet_80000001_2_Float - _codeSnippets
+    .long codeSnippet_00000001_2_Double - _codeSnippets
+    .long codeSnippet_80000001_2_Double - _codeSnippets
+    .long codeSnippet_00000001_2_Class - _codeSnippets
+    .long codeSnippet_80000001_2_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000001_3 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000001_3 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000001_3_General - _codeSnippets
+    .long codeSnippet_80000001_3_General - _codeSnippets
+    .long codeSnippet_00000001_3_Void - _codeSnippets
+    .long codeSnippet_80000001_3_Void - _codeSnippets
+    .long codeSnippet_00000001_3_Hyper - _codeSnippets
+    .long codeSnippet_80000001_3_Hyper - _codeSnippets
+    .long codeSnippet_00000001_3_Float - _codeSnippets
+    .long codeSnippet_80000001_3_Float - _codeSnippets
+    .long codeSnippet_00000001_3_Double - _codeSnippets
+    .long codeSnippet_80000001_3_Double - _codeSnippets
+    .long codeSnippet_00000001_3_Class - _codeSnippets
+    .long codeSnippet_80000001_3_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000002_0 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000002_0 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000002_0_General - _codeSnippets
+    .long codeSnippet_80000002_0_General - _codeSnippets
+    .long codeSnippet_00000002_0_Void - _codeSnippets
+    .long codeSnippet_80000002_0_Void - _codeSnippets
+    .long codeSnippet_00000002_0_Hyper - _codeSnippets
+    .long codeSnippet_80000002_0_Hyper - _codeSnippets
+    .long codeSnippet_00000002_0_Float - _codeSnippets
+    .long codeSnippet_80000002_0_Float - _codeSnippets
+    .long codeSnippet_00000002_0_Double - _codeSnippets
+    .long codeSnippet_80000002_0_Double - _codeSnippets
+    .long codeSnippet_00000002_0_Class - _codeSnippets
+    .long codeSnippet_80000002_0_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000002_1 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000002_1 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000002_1_General - _codeSnippets
+    .long codeSnippet_80000002_1_General - _codeSnippets
+    .long codeSnippet_00000002_1_Void - _codeSnippets
+    .long codeSnippet_80000002_1_Void - _codeSnippets
+    .long codeSnippet_00000002_1_Hyper - _codeSnippets
+    .long codeSnippet_80000002_1_Hyper - _codeSnippets
+    .long codeSnippet_00000002_1_Float - _codeSnippets
+    .long codeSnippet_80000002_1_Float - _codeSnippets
+    .long codeSnippet_00000002_1_Double - _codeSnippets
+    .long codeSnippet_80000002_1_Double - _codeSnippets
+    .long codeSnippet_00000002_1_Class - _codeSnippets
+    .long codeSnippet_80000002_1_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000002_2 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000002_2 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000002_2_General - _codeSnippets
+    .long codeSnippet_80000002_2_General - _codeSnippets
+    .long codeSnippet_00000002_2_Void - _codeSnippets
+    .long codeSnippet_80000002_2_Void - _codeSnippets
+    .long codeSnippet_00000002_2_Hyper - _codeSnippets
+    .long codeSnippet_80000002_2_Hyper - _codeSnippets
+    .long codeSnippet_00000002_2_Float - _codeSnippets
+    .long codeSnippet_80000002_2_Float - _codeSnippets
+    .long codeSnippet_00000002_2_Double - _codeSnippets
+    .long codeSnippet_80000002_2_Double - _codeSnippets
+    .long codeSnippet_00000002_2_Class - _codeSnippets
+    .long codeSnippet_80000002_2_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000002_3 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000002_3 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000002_3_General - _codeSnippets
+    .long codeSnippet_80000002_3_General - _codeSnippets
+    .long codeSnippet_00000002_3_Void - _codeSnippets
+    .long codeSnippet_80000002_3_Void - _codeSnippets
+    .long codeSnippet_00000002_3_Hyper - _codeSnippets
+    .long codeSnippet_80000002_3_Hyper - _codeSnippets
+    .long codeSnippet_00000002_3_Float - _codeSnippets
+    .long codeSnippet_80000002_3_Float - _codeSnippets
+    .long codeSnippet_00000002_3_Double - _codeSnippets
+    .long codeSnippet_80000002_3_Double - _codeSnippets
+    .long codeSnippet_00000002_3_Class - _codeSnippets
+    .long codeSnippet_80000002_3_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000003_0 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000003_0 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000003_0_General - _codeSnippets
+    .long codeSnippet_80000003_0_General - _codeSnippets
+    .long codeSnippet_00000003_0_Void - _codeSnippets
+    .long codeSnippet_80000003_0_Void - _codeSnippets
+    .long codeSnippet_00000003_0_Hyper - _codeSnippets
+    .long codeSnippet_80000003_0_Hyper - _codeSnippets
+    .long codeSnippet_00000003_0_Float - _codeSnippets
+    .long codeSnippet_80000003_0_Float - _codeSnippets
+    .long codeSnippet_00000003_0_Double - _codeSnippets
+    .long codeSnippet_80000003_0_Double - _codeSnippets
+    .long codeSnippet_00000003_0_Class - _codeSnippets
+    .long codeSnippet_80000003_0_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000003_1 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000003_1 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000003_1_General - _codeSnippets
+    .long codeSnippet_80000003_1_General - _codeSnippets
+    .long codeSnippet_00000003_1_Void - _codeSnippets
+    .long codeSnippet_80000003_1_Void - _codeSnippets
+    .long codeSnippet_00000003_1_Hyper - _codeSnippets
+    .long codeSnippet_80000003_1_Hyper - _codeSnippets
+    .long codeSnippet_00000003_1_Float - _codeSnippets
+    .long codeSnippet_80000003_1_Float - _codeSnippets
+    .long codeSnippet_00000003_1_Double - _codeSnippets
+    .long codeSnippet_80000003_1_Double - _codeSnippets
+    .long codeSnippet_00000003_1_Class - _codeSnippets
+    .long codeSnippet_80000003_1_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000003_2 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000003_2 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000003_2_General - _codeSnippets
+    .long codeSnippet_80000003_2_General - _codeSnippets
+    .long codeSnippet_00000003_2_Void - _codeSnippets
+    .long codeSnippet_80000003_2_Void - _codeSnippets
+    .long codeSnippet_00000003_2_Hyper - _codeSnippets
+    .long codeSnippet_80000003_2_Hyper - _codeSnippets
+    .long codeSnippet_00000003_2_Float - _codeSnippets
+    .long codeSnippet_80000003_2_Float - _codeSnippets
+    .long codeSnippet_00000003_2_Double - _codeSnippets
+    .long codeSnippet_80000003_2_Double - _codeSnippets
+    .long codeSnippet_00000003_2_Class - _codeSnippets
+    .long codeSnippet_80000003_2_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000003_3 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000003_3 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000003_3_General - _codeSnippets
+    .long codeSnippet_80000003_3_General - _codeSnippets
+    .long codeSnippet_00000003_3_Void - _codeSnippets
+    .long codeSnippet_80000003_3_Void - _codeSnippets
+    .long codeSnippet_00000003_3_Hyper - _codeSnippets
+    .long codeSnippet_80000003_3_Hyper - _codeSnippets
+    .long codeSnippet_00000003_3_Float - _codeSnippets
+    .long codeSnippet_80000003_3_Float - _codeSnippets
+    .long codeSnippet_00000003_3_Double - _codeSnippets
+    .long codeSnippet_80000003_3_Double - _codeSnippets
+    .long codeSnippet_00000003_3_Class - _codeSnippets
+    .long codeSnippet_80000003_3_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000004_0 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000004_0 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000004_0_General - _codeSnippets
+    .long codeSnippet_80000004_0_General - _codeSnippets
+    .long codeSnippet_00000004_0_Void - _codeSnippets
+    .long codeSnippet_80000004_0_Void - _codeSnippets
+    .long codeSnippet_00000004_0_Hyper - _codeSnippets
+    .long codeSnippet_80000004_0_Hyper - _codeSnippets
+    .long codeSnippet_00000004_0_Float - _codeSnippets
+    .long codeSnippet_80000004_0_Float - _codeSnippets
+    .long codeSnippet_00000004_0_Double - _codeSnippets
+    .long codeSnippet_80000004_0_Double - _codeSnippets
+    .long codeSnippet_00000004_0_Class - _codeSnippets
+    .long codeSnippet_80000004_0_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000004_1 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000004_1 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000004_1_General - _codeSnippets
+    .long codeSnippet_80000004_1_General - _codeSnippets
+    .long codeSnippet_00000004_1_Void - _codeSnippets
+    .long codeSnippet_80000004_1_Void - _codeSnippets
+    .long codeSnippet_00000004_1_Hyper - _codeSnippets
+    .long codeSnippet_80000004_1_Hyper - _codeSnippets
+    .long codeSnippet_00000004_1_Float - _codeSnippets
+    .long codeSnippet_80000004_1_Float - _codeSnippets
+    .long codeSnippet_00000004_1_Double - _codeSnippets
+    .long codeSnippet_80000004_1_Double - _codeSnippets
+    .long codeSnippet_00000004_1_Class - _codeSnippets
+    .long codeSnippet_80000004_1_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000004_2 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000004_2 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000004_2_General - _codeSnippets
+    .long codeSnippet_80000004_2_General - _codeSnippets
+    .long codeSnippet_00000004_2_Void - _codeSnippets
+    .long codeSnippet_80000004_2_Void - _codeSnippets
+    .long codeSnippet_00000004_2_Hyper - _codeSnippets
+    .long codeSnippet_80000004_2_Hyper - _codeSnippets
+    .long codeSnippet_00000004_2_Float - _codeSnippets
+    .long codeSnippet_80000004_2_Float - _codeSnippets
+    .long codeSnippet_00000004_2_Double - _codeSnippets
+    .long codeSnippet_80000004_2_Double - _codeSnippets
+    .long codeSnippet_00000004_2_Class - _codeSnippets
+    .long codeSnippet_80000004_2_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000004_3 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000004_3 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000004_3_General - _codeSnippets
+    .long codeSnippet_80000004_3_General - _codeSnippets
+    .long codeSnippet_00000004_3_Void - _codeSnippets
+    .long codeSnippet_80000004_3_Void - _codeSnippets
+    .long codeSnippet_00000004_3_Hyper - _codeSnippets
+    .long codeSnippet_80000004_3_Hyper - _codeSnippets
+    .long codeSnippet_00000004_3_Float - _codeSnippets
+    .long codeSnippet_80000004_3_Float - _codeSnippets
+    .long codeSnippet_00000004_3_Double - _codeSnippets
+    .long codeSnippet_80000004_3_Double - _codeSnippets
+    .long codeSnippet_00000004_3_Class - _codeSnippets
+    .long codeSnippet_80000004_3_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000005_0 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000005_0 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000005_0_General - _codeSnippets
+    .long codeSnippet_80000005_0_General - _codeSnippets
+    .long codeSnippet_00000005_0_Void - _codeSnippets
+    .long codeSnippet_80000005_0_Void - _codeSnippets
+    .long codeSnippet_00000005_0_Hyper - _codeSnippets
+    .long codeSnippet_80000005_0_Hyper - _codeSnippets
+    .long codeSnippet_00000005_0_Float - _codeSnippets
+    .long codeSnippet_80000005_0_Float - _codeSnippets
+    .long codeSnippet_00000005_0_Double - _codeSnippets
+    .long codeSnippet_80000005_0_Double - _codeSnippets
+    .long codeSnippet_00000005_0_Class - _codeSnippets
+    .long codeSnippet_80000005_0_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000005_1 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000005_1 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000005_1_General - _codeSnippets
+    .long codeSnippet_80000005_1_General - _codeSnippets
+    .long codeSnippet_00000005_1_Void - _codeSnippets
+    .long codeSnippet_80000005_1_Void - _codeSnippets
+    .long codeSnippet_00000005_1_Hyper - _codeSnippets
+    .long codeSnippet_80000005_1_Hyper - _codeSnippets
+    .long codeSnippet_00000005_1_Float - _codeSnippets
+    .long codeSnippet_80000005_1_Float - _codeSnippets
+    .long codeSnippet_00000005_1_Double - _codeSnippets
+    .long codeSnippet_80000005_1_Double - _codeSnippets
+    .long codeSnippet_00000005_1_Class - _codeSnippets
+    .long codeSnippet_80000005_1_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000005_2 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000005_2 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000005_2_General - _codeSnippets
+    .long codeSnippet_80000005_2_General - _codeSnippets
+    .long codeSnippet_00000005_2_Void - _codeSnippets
+    .long codeSnippet_80000005_2_Void - _codeSnippets
+    .long codeSnippet_00000005_2_Hyper - _codeSnippets
+    .long codeSnippet_80000005_2_Hyper - _codeSnippets
+    .long codeSnippet_00000005_2_Float - _codeSnippets
+    .long codeSnippet_80000005_2_Float - _codeSnippets
+    .long codeSnippet_00000005_2_Double - _codeSnippets
+    .long codeSnippet_80000005_2_Double - _codeSnippets
+    .long codeSnippet_00000005_2_Class - _codeSnippets
+    .long codeSnippet_80000005_2_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000005_3 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000005_3 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000005_3_General - _codeSnippets
+    .long codeSnippet_80000005_3_General - _codeSnippets
+    .long codeSnippet_00000005_3_Void - _codeSnippets
+    .long codeSnippet_80000005_3_Void - _codeSnippets
+    .long codeSnippet_00000005_3_Hyper - _codeSnippets
+    .long codeSnippet_80000005_3_Hyper - _codeSnippets
+    .long codeSnippet_00000005_3_Float - _codeSnippets
+    .long codeSnippet_80000005_3_Float - _codeSnippets
+    .long codeSnippet_00000005_3_Double - _codeSnippets
+    .long codeSnippet_80000005_3_Double - _codeSnippets
+    .long codeSnippet_00000005_3_Class - _codeSnippets
+    .long codeSnippet_80000005_3_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000006_0 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000006_0 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000006_0_General - _codeSnippets
+    .long codeSnippet_80000006_0_General - _codeSnippets
+    .long codeSnippet_00000006_0_Void - _codeSnippets
+    .long codeSnippet_80000006_0_Void - _codeSnippets
+    .long codeSnippet_00000006_0_Hyper - _codeSnippets
+    .long codeSnippet_80000006_0_Hyper - _codeSnippets
+    .long codeSnippet_00000006_0_Float - _codeSnippets
+    .long codeSnippet_80000006_0_Float - _codeSnippets
+    .long codeSnippet_00000006_0_Double - _codeSnippets
+    .long codeSnippet_80000006_0_Double - _codeSnippets
+    .long codeSnippet_00000006_0_Class - _codeSnippets
+    .long codeSnippet_80000006_0_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000006_1 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000006_1 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000006_1_General - _codeSnippets
+    .long codeSnippet_80000006_1_General - _codeSnippets
+    .long codeSnippet_00000006_1_Void - _codeSnippets
+    .long codeSnippet_80000006_1_Void - _codeSnippets
+    .long codeSnippet_00000006_1_Hyper - _codeSnippets
+    .long codeSnippet_80000006_1_Hyper - _codeSnippets
+    .long codeSnippet_00000006_1_Float - _codeSnippets
+    .long codeSnippet_80000006_1_Float - _codeSnippets
+    .long codeSnippet_00000006_1_Double - _codeSnippets
+    .long codeSnippet_80000006_1_Double - _codeSnippets
+    .long codeSnippet_00000006_1_Class - _codeSnippets
+    .long codeSnippet_80000006_1_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000006_2 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000006_2 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000006_2_General - _codeSnippets
+    .long codeSnippet_80000006_2_General - _codeSnippets
+    .long codeSnippet_00000006_2_Void - _codeSnippets
+    .long codeSnippet_80000006_2_Void - _codeSnippets
+    .long codeSnippet_00000006_2_Hyper - _codeSnippets
+    .long codeSnippet_80000006_2_Hyper - _codeSnippets
+    .long codeSnippet_00000006_2_Float - _codeSnippets
+    .long codeSnippet_80000006_2_Float - _codeSnippets
+    .long codeSnippet_00000006_2_Double - _codeSnippets
+    .long codeSnippet_80000006_2_Double - _codeSnippets
+    .long codeSnippet_00000006_2_Class - _codeSnippets
+    .long codeSnippet_80000006_2_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000006_3 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000006_3 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000006_3_General - _codeSnippets
+    .long codeSnippet_80000006_3_General - _codeSnippets
+    .long codeSnippet_00000006_3_Void - _codeSnippets
+    .long codeSnippet_80000006_3_Void - _codeSnippets
+    .long codeSnippet_00000006_3_Hyper - _codeSnippets
+    .long codeSnippet_80000006_3_Hyper - _codeSnippets
+    .long codeSnippet_00000006_3_Float - _codeSnippets
+    .long codeSnippet_80000006_3_Float - _codeSnippets
+    .long codeSnippet_00000006_3_Double - _codeSnippets
+    .long codeSnippet_80000006_3_Double - _codeSnippets
+    .long codeSnippet_00000006_3_Class - _codeSnippets
+    .long codeSnippet_80000006_3_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000007_0 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000007_0 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000007_0_General - _codeSnippets
+    .long codeSnippet_80000007_0_General - _codeSnippets
+    .long codeSnippet_00000007_0_Void - _codeSnippets
+    .long codeSnippet_80000007_0_Void - _codeSnippets
+    .long codeSnippet_00000007_0_Hyper - _codeSnippets
+    .long codeSnippet_80000007_0_Hyper - _codeSnippets
+    .long codeSnippet_00000007_0_Float - _codeSnippets
+    .long codeSnippet_80000007_0_Float - _codeSnippets
+    .long codeSnippet_00000007_0_Double - _codeSnippets
+    .long codeSnippet_80000007_0_Double - _codeSnippets
+    .long codeSnippet_00000007_0_Class - _codeSnippets
+    .long codeSnippet_80000007_0_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000007_1 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000007_1 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000007_1_General - _codeSnippets
+    .long codeSnippet_80000007_1_General - _codeSnippets
+    .long codeSnippet_00000007_1_Void - _codeSnippets
+    .long codeSnippet_80000007_1_Void - _codeSnippets
+    .long codeSnippet_00000007_1_Hyper - _codeSnippets
+    .long codeSnippet_80000007_1_Hyper - _codeSnippets
+    .long codeSnippet_00000007_1_Float - _codeSnippets
+    .long codeSnippet_80000007_1_Float - _codeSnippets
+    .long codeSnippet_00000007_1_Double - _codeSnippets
+    .long codeSnippet_80000007_1_Double - _codeSnippets
+    .long codeSnippet_00000007_1_Class - _codeSnippets
+    .long codeSnippet_80000007_1_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000007_2 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000007_2 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000007_2_General - _codeSnippets
+    .long codeSnippet_80000007_2_General - _codeSnippets
+    .long codeSnippet_00000007_2_Void - _codeSnippets
+    .long codeSnippet_80000007_2_Void - _codeSnippets
+    .long codeSnippet_00000007_2_Hyper - _codeSnippets
+    .long codeSnippet_80000007_2_Hyper - _codeSnippets
+    .long codeSnippet_00000007_2_Float - _codeSnippets
+    .long codeSnippet_80000007_2_Float - _codeSnippets
+    .long codeSnippet_00000007_2_Double - _codeSnippets
+    .long codeSnippet_80000007_2_Double - _codeSnippets
+    .long codeSnippet_00000007_2_Class - _codeSnippets
+    .long codeSnippet_80000007_2_Class - _codeSnippets
+#endif
+#if defined(__arm) || defined(__arm64)
+    .long codeSnippet_00000007_3 - _codeSnippets
+#ifndef __arm64
+    .long codeSnippet_80000007_3 - _codeSnippets
+#endif
+#else
+    .long codeSnippet_00000007_3_General - _codeSnippets
+    .long codeSnippet_80000007_3_General - _codeSnippets
+    .long codeSnippet_00000007_3_Void - _codeSnippets
+    .long codeSnippet_80000007_3_Void - _codeSnippets
+    .long codeSnippet_00000007_3_Hyper - _codeSnippets
+    .long codeSnippet_80000007_3_Hyper - _codeSnippets
+    .long codeSnippet_00000007_3_Float - _codeSnippets
+    .long codeSnippet_80000007_3_Float - _codeSnippets
+    .long codeSnippet_00000007_3_Double - _codeSnippets
+    .long codeSnippet_80000007_3_Double - _codeSnippets
+    .long codeSnippet_00000007_3_Class - _codeSnippets
+    .long codeSnippet_80000007_3_Class - _codeSnippets
+#endif
+
+
+    .text
+    .align 4
+
+_privateSnippetExecutor:
+
+    .cfi_startproc
+    // _privateSnippetExecutor is jumped to from each of the
+    // codeSnippet_*  generated by generate-snippets.pl
+
+    // Store potential args in general purpose registers
+    stp     x6, x7, [sp, #-16]!
+    stp     x4, x5, [sp, #-16]!
+    stp     x2, x3, [sp, #-16]!
+    stp     x0, x1, [sp, #-16]!
+
+    // Store potential args in floating point/SIMD registers
+    stp     d6, d7, [sp, #-16]!
+    stp     d4, d5, [sp, #-16]!
+    stp     d2, d3, [sp, #-16]!
+    stp     d0, d1, [sp, #-16]!
+
+    // First argument to cpp_vtable_call: The x15 set up in the codeSnippet instance
+    mov     x0, x15
+    // Store x8 (potential pointer to return value storage) and lr
+    stp     x8, lr, [sp, #-16]!
+    // Second argument: The pointer to all the above
+    mov     x1, sp
+
+    bl      _cpp_vtable_call
+
+    ldp     x8, lr, [sp, #0]
+    add     sp, sp, #144
+    ret     lr
+    .cfi_endproc
+
+#elif defined(__i386)
+    // i386 code, for the simulator
+    .text
+
+.align 1, 0x90
+_privateSnippetExecutorGeneral:
+LFBg:
+    movl    %esp,%ecx
+    pushl   %ebp              // proper stack frame needed for exception handling
+LCFIg0:
+    movl    %esp,%ebp
+LCFIg1:
+    subl    $0x8,%esp         // padding + 32bit returnValue
+    pushl   %esp              // 32bit &returnValue
+    pushl   %ecx              // 32bit pCallStack
+    pushl   %edx              // 32bit nVtableOffset
+    pushl   %eax              // 32bit nFunctionIndex
+    call    L_cpp_vtable_call$stub
+    movl    16(%esp),%eax     // 32bit returnValue
+    leave
+    ret
+LFEg:
+    .long   .-_privateSnippetExecutorGeneral
+
+.align 1, 0x90
+_privateSnippetExecutorVoid:
+LFBv:
+    movl    %esp,%ecx
+    pushl   %ebp              // proper stack frame needed for exception handling
+LCFIv0:
+    movl    %esp,%ebp
+LCFIv1:
+    sub     $8,%esp           // padding
+    pushl   $0                // 32bit null pointer (returnValue not used)
+    pushl   %ecx              // 32bit pCallStack
+    pushl   %edx              // 32bit nVtableOffset
+    pushl   %eax              // 32bit nFunctionIndex
+    call    L_cpp_vtable_call$stub
+    leave
+    ret
+LFEv:
+    .long   .-_privateSnippetExecutorVoid
+
+.align 1, 0x90
+_privateSnippetExecutorHyper:
+LFBh:
+    movl    %esp,%ecx
+    pushl   %ebp              // proper stack frame needed for exception handling
+LCFIh0:
+    movl    %esp,%ebp
+LCFIh1:
+    subl    $0x8,%esp         // 64bit returnValue
+    pushl   %esp              // 32bit &returnValue
+    pushl   %ecx              // 32bit pCallStack
+    pushl   %edx              // 32bit nVtableOffset
+    pushl   %eax              // 32bit nFunctionIndex
+    call    L_cpp_vtable_call$stub
+    movl    16(%esp),%eax     // 64bit returnValue, lower half
+    movl    20(%esp),%edx     // 64bit returnValue, upper half
+    leave
+    ret
+LFEh:
+    .long   .-_privateSnippetExecutorHyper
+
+.align 1, 0x90
+_privateSnippetExecutorFloat:
+LFBf:
+    movl    %esp,%ecx
+    pushl   %ebp              // proper stack frame needed for exception handling
+LCFIf0:
+    movl    %esp,%ebp
+LCFIf1:
+    subl    $0x8,%esp         // padding + 32bit returnValue
+    pushl   %esp              // 32bit &returnValue
+    pushl   %ecx              // 32bit pCallStack
+    pushl   %edx              // 32bit nVtableOffset
+    pushl   %eax              // 32bit nFunctionIndex
+    call    L_cpp_vtable_call$stub
+    flds    16(%esp)          // 32bit returnValue
+    leave
+    ret
+LFEf:
+    .long   .-_privateSnippetExecutorFloat
+
+.align 1, 0x90
+_privateSnippetExecutorDouble:
+LFBd:
+    movl    %esp,%ecx
+    pushl   %ebp              // proper stack frame needed for exception handling
+LCFId0:
+    movl    %esp,%ebp
+LCFId1:
+    subl    $0x8,%esp         // 64bit returnValue
+    pushl   %esp              // 32bit &returnValue
+    pushl   %ecx              // 32bit pCallStack
+    pushl   %edx              // 32bit nVtableOffset
+    pushl   %eax              // 32bit nFunctionIndex
+    call    L_cpp_vtable_call$stub
+    fldl    16(%esp)          // 64bit returnValue
+    leave
+    ret
+LFEd:
+    .long   .-_privateSnippetExecutorDouble
+
+.align 1, 0x90
+_privateSnippetExecutorClass:
+LFBc:
+    movl    %esp,%ecx
+    pushl   %ebp              // proper stack frame needed for exception handling
+LCFIc0:
+    movl    %esp,%ebp
+LCFIc1:
+    subl    $0x8,%esp         // padding + 32bit returnValue
+    pushl   %esp              // 32bit &returnValue
+    pushl   %ecx              // 32bit pCallStack
+    pushl   %edx              // 32bit nVtableOffset
+    pushl   %eax              // 32bit nFunctionIndex
+    call    L_cpp_vtable_call$stub
+    movl    16(%esp),%eax     // 32bit returnValue
+    leave
+    ret     $4
+LFEc:
+    .long   .-_privateSnippetExecutorClass
+
+    .section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms+live_support
+EH_frame1:
+    .set L$set$frame1,LECIE1-LSCIE1
+    .long   L$set$frame1      // length
+LSCIE1:
+    .long   0                 // CIE_ID
+    .byte   1                 // version
+    .ascii  "zPR\0"           // augmentation
+    .byte   1                 // code_alignment_factor (.uleb128 1)
+    .byte   0x7c              // data_alignment_factor (.sleb128 -4)
+    .byte   8                 // return_address_register
+    .byte   0x6               // augmentation size 7:
+    .byte   0x9b              //  ???
+    .long   L___gxx_personality_v0$non_lazy_ptr-.
+    .byte   0x10
+                              // initial_instructions:
+    .byte   0x0C              //  DW_CFA_def_cfa %esp, 4
+    .byte   5
+    .byte   4
+    .byte   0x88              //  DW_CFA_offset ret, 1
+    .byte   1
+    .align 2
+LECIE1:
+_privateSnippetExecutorGeneral.eh:
+LSFDEg:
+    .set L$set$g1,LEFDEg-LASFDEg
+    .long   L$set$g1          // length
+LASFDEg:
+    .long   LASFDEg-EH_frame1 // CIE_pointer
+    .long   LFBg-.            // initial_location
+    .long   LFEg-LFBg         // address_range
+    .byte   0                 // augmentation size 0
+                              // instructions:
+    .byte   0x04              //  DW_CFA_advance_loc4
+    .long   LCFIg0-LFBg
+    .byte   0x0E              //  DW_CFA_def_cfa_offset 8
+    .byte   8
+    .byte   0x84              //  DW_CFA_offset %ebp, 2
+    .byte   2
+    .byte   0x04              //  DW_CFA_advance_loc4
+    .long   LCFIg1-LCFIg0
+    .byte   0x0D              //  DW_CFA_def_cfa_register %ebp
+    .byte   4
+    .align 2
+LEFDEg:
+_privateSnippetExecutorVoid.eh:
+LSFDEv:
+    .set L$set$v1,LEFDEv-LASFDEv
+    .long   L$set$v1          // length
+LASFDEv:
+    .long   LASFDEv-EH_frame1 // CIE_pointer
+    .long   LFBv-.            // initial_location
+    .long   LFEv-LFBv         // address_range
+    .byte   0                 // augmentation size 0
+                              // instructions:
+    .byte   0x04              //  DW_CFA_advance_loc4
+    .long   LCFIv0-LFBv
+    .byte   0x0E              //  DW_CFA_def_cfa_offset 8
+    .byte   8
+    .byte   0x84              //  DW_CFA_offset %ebp, 2
+    .byte   2
+    .byte   0x04              //  DW_CFA_advance_loc4
+    .long   LCFIv1-LCFIv0
+    .byte   0x0D              //  DW_CFA_def_cfa_register %ebp
+    .byte   4
+    .align 2
+LEFDEv:
+_privateSnippetExecutorHyper.eh:
+LSFDEh:
+    .set L$set$h1,LEFDEh-LASFDEh
+    .long   L$set$h1          // length
+LASFDEh:
+    .long   LASFDEh-EH_frame1 // CIE_pointer
+    .long   LFBh-.            // initial_location
+    .long   LFEh-LFBh         // address_range
+    .byte   0                 // augmentation size 0
+                              // instructions:
+    .byte   0x04              //  DW_CFA_advance_loc4
+    .long   LCFIh0-LFBh
+    .byte   0x0E              //  DW_CFA_def_cfa_offset 8
+    .byte   8
+    .byte   0x84              //  DW_CFA_offset %ebp, 2
+    .byte   2
+    .byte   0x04              //  DW_CFA_advance_loc4
+    .long   LCFIh1-LCFIh0
+    .byte   0x0D              //  DW_CFA_def_cfa_register %ebp
+    .byte   4
+    .align 2
+LEFDEh:
+_privateSnippetExecutorFloat.eh:
+LSFDEf:
+    .set L$set$f1,LEFDEf-LASFDEf
+    .long   L$set$f1          // length
+LASFDEf:
+    .long   LASFDEf-EH_frame1 // CIE_pointer
+    .long   LFBf-.            // initial_location
+    .long   LFEf-LFBf         // address_range
+    .byte   0                 // augmentation size 0
+                              // instructions:
+    .byte   0x04              //  DW_CFA_advance_loc4
+    .long   LCFIf0-LFBf
+    .byte   0x0E              //  DW_CFA_def_cfa_offset 8
+    .byte   8
+    .byte   0x84              //  DW_CFA_offset %ebp, 2
+    .byte   2
+    .byte   0x04              //  DW_CFA_advance_loc4
+    .long   LCFIf1-LCFIf0
+    .byte   0x0D              //  DW_CFA_def_cfa_register %ebp
+    .byte   4
+    .align 2
+LEFDEf:
+_privateSnippetExecutorDouble.eh:
+LSFDEd:
+    .set L$set$d1,LEFDEd-LASFDEd
+    .long   L$set$d1          // length
+LASFDEd:
+    .long   LASFDEd-EH_frame1 // CIE_pointer
+    .long   LFBd-.            // initial_location
+    .long   LFEd-LFBd         // address_range
+    .byte   0                 // augmentation size 0
+                              // instructions:
+    .byte   0x04              //  DW_CFA_advance_loc4
+    .long   LCFId0-LFBd
+    .byte   0x0E              //  DW_CFA_def_cfa_offset 8
+    .byte   8
+    .byte   0x84              //  DW_CFA_offset %ebp, 2
+    .byte   2
+    .byte   0x04              //  DW_CFA_advance_loc4
+    .long   LCFId1-LCFId0
+    .byte   0x0D              //  DW_CFA_def_cfa_register %ebp
+    .byte   4
+    .align 2
+LEFDEd:
+_privateSnippetExecutorClass.eh:
+LSFDEc:
+    .set L$set$c1,LEFDEc-LASFDEc
+    .long   L$set$c1          // length
+LASFDEc:
+    .long   LASFDEc-EH_frame1 // CIE_pointer
+    .long   LFBc-.            // initial_location
+    .long   LFEc-LFBc         // address_range
+    .byte   0                 // augmentation size 0
+                              // instructions:
+    .byte   0x04              //  DW_CFA_advance_loc4
+    .long   LCFIc0-LFBc
+    .byte   0x0E              //  DW_CFA_def_cfa_offset 8
+    .byte   8
+    .byte   0x84              //  DW_CFA_offset %ebp, 2
+    .byte   2
+    .byte   0x04              //  DW_CFA_advance_loc4
+    .long   LCFIc1-LCFIc0
+    .byte   0x0D              //  DW_CFA_def_cfa_register %ebp
+    .byte   4
+    .align 2
+LEFDEc:
+    .section __IMPORT,__jump_table,symbol_stubs,self_modifying_code+pure_instructions,5
+L_cpp_vtable_call$stub:
+    .indirect_symbol _cpp_vtable_call
+    hlt ; hlt ; hlt ; hlt ; hlt
+    .section __IMPORT,__pointers,non_lazy_symbol_pointers
+L___gxx_personality_v0$non_lazy_ptr:
+    .indirect_symbol ___gxx_personality_v0
+    .long 0
+    .constructor
+    .destructor
+    .align 1
+#else
+
+	.text
+	.align 2
+.globl privateSnippetExecutor
+_privateSnippetExecutor:
+.LFB3:
+	pushq	%rbp
+.LCFI0:
+	movq	%rsp, %rbp
+.LCFI1:
+	subq	$160, %rsp
+.LCFI2:
+	movq	%r10, -152(%rbp)		# Save (nVtableOffset << 32) + nFunctionIndex
+
+	movq	%rdi, -112(%rbp)		# Save GP registers
+	movq	%rsi, -104(%rbp)
+	movq	%rdx, -96(%rbp)
+	movq	%rcx, -88(%rbp)
+	movq	%r8 , -80(%rbp)
+	movq	%r9 , -72(%rbp)
+	
+	movsd	%xmm0, -64(%rbp)		# Save FP registers
+	movsd	%xmm1, -56(%rbp)
+	movsd	%xmm2, -48(%rbp)
+	movsd	%xmm3, -40(%rbp)
+	movsd	%xmm4, -32(%rbp)
+	movsd	%xmm5, -24(%rbp)
+	movsd	%xmm6, -16(%rbp)
+	movsd	%xmm7, -8(%rbp)
+
+	leaq	-144(%rbp), %r9			# 6th param: sal_uInt64 * pRegisterReturn
+	leaq	16(%rbp), %r8			# 5rd param: void ** ovrflw
+	leaq	-64(%rbp), %rcx			# 4th param: void ** fpreg
+	leaq	-112(%rbp), %rdx		# 3rd param: void ** gpreg
+	movl	-148(%rbp), %esi		# 2nd param: sal_int32 nVtableOffset
+	movl	-152(%rbp), %edi		# 1st param: sal_int32 nFunctionIndex
+	
+	call	cpp_vtable_call
+
+	cmp	$10, %rax					# typelib_TypeClass_FLOAT
+	je	.Lfloat
+	cmp	$11, %rax					# typelib_TypeClass_DOUBLE
+	je	.Lfloat
+
+	movq	-144(%rbp), %rax		# Return value (int case)
+	movq	-136(%rbp), %rdx		# Return value (int case)
+	movq	-144(%rbp), %xmm0		# Return value (int case)
+	movq	-136(%rbp), %xmm1		# Return value (int case)
+	jmp	.Lfinish
+.Lfloat:
+	movlpd	-144(%rbp), %xmm0		# Return value (float/double case)
+
+.Lfinish:
+	leave
+	ret
+.LFE3:
+	# see http://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html
+	# for details of the .eh_frame, the "Common Information Entry" and "Frame Description Entry" formats
+	# and http://mentorembedded.github.io/cxx-abi/exceptions.pdf for more info
+.Lframe1:
+	.long	.LECIE1-.LSCIE1
+.LSCIE1:
+	.long	0x0
+	.byte	0x1
+	.string	"zR"
+	.uleb128 0x1
+	.sleb128 -8
+	.byte	0x10
+	.uleb128 0x1
+	.byte	0x1b
+	.byte	0xc
+	.uleb128 0x7
+	.uleb128 0x8
+	.byte	0x90
+	.uleb128 0x1
+	.align 8
+.LECIE1:
+.LSFDE1:
+	.long	.LEFDE1-.LASFDE1
+.LASFDE1:
+	.long	.LASFDE1-.Lframe1
+	.long	.LFB3-.
+	.long	.LFE3-.LFB3
+	.uleb128 0x0
+	.byte	0x4
+	.long	.LCFI0-.LFB3
+	.byte	0xe
+	.uleb128 0x10
+	.byte	0x86
+	.uleb128 0x2
+	.byte	0x4
+	.long	.LCFI1-.LCFI0
+	.byte	0xd
+	.uleb128 0x6
+	.align 8
+.LEFDE1:
+#endif
+
+// vim:set shiftwidth=4 softtabstop=4 expandtab:
diff --git a/bridges/source/cpp_uno/gcc3_ios/uno2cpp-i386.cxx b/bridges/source/cpp_uno/gcc3_ios/uno2cpp-i386.cxx
deleted file mode 100644
index 6b53831fd565..000000000000
--- a/bridges/source/cpp_uno/gcc3_ios/uno2cpp-i386.cxx
+++ /dev/null
@@ -1,487 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * This file is part of the LibreOffice project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * This file incorporates work covered by the following license notice:
- *
- *   Licensed to the Apache Software Foundation (ASF) under one or more
- *   contributor license agreements. See the NOTICE file distributed
- *   with this work for additional information regarding copyright
- *   ownership. The ASF licenses this file to you under the Apache
- *   License, Version 2.0 (the "License"); you may not use this file
- *   except in compliance with the License. You may obtain a copy of
- *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
- */
-
-#ifdef __i386
-
-// For the iOS emulator (i386). Basically a copy of
-// ../gcc3_macosx_intel/uno2cpp.cxx with some cleanups and necessary
-// changes.
-
-#include <com/sun/star/uno/RuntimeException.hpp>
-#include <sal/log.hxx>
-
-#include "bridge.hxx"
-#include "types.hxx"
-#include "unointerfaceproxy.hxx"
-#include "vtables.hxx"
-
-#include "share.hxx"
-
-using namespace ::com::sun::star::uno;
-
-namespace
-{
-
-// The call instruction within the asm section of callVirtualMethod may throw
-// exceptions.  So that the compiler handles this correctly, it is important
-// that (a) callVirtualMethod might call dummy_can_throw_anything (although this
-// never happens at runtime), which in turn can throw exceptions, and (b)
-// callVirtualMethod is not inlined at its call site (so that any exceptions are
-// caught which are thrown from the instruction calling callVirtualMethod):
-void callVirtualMethod(
-    void * pAdjustedThisPtr,
-    sal_Int32 nVtableIndex,
-    void * pRegisterReturn,
-    typelib_TypeDescription * pReturnTypeDescr, bool bSimpleReturn,
-    sal_Int32 * pStackLongs,
-    sal_Int32 nStackLongs ) __attribute__((noinline));
-
-void callVirtualMethod(
-    void * pAdjustedThisPtr,
-    sal_Int32 nVtableIndex,
-    void * pRegisterReturn,
-    typelib_TypeDescription * pReturnTypeDescr, bool bSimpleReturn,
-    sal_Int32 * pStackLongs,
-    sal_Int32 nStackLongs )
-{
-    // parameter list is mixed list of * and values
-    // reference parameters are pointers
-
-    assert(pStackLongs && pAdjustedThisPtr);
-    static_assert( (sizeof(void *) == 4) && (sizeof(sal_Int32) == 4), "### unexpected size of int!" );
-    assert(nStackLongs && pStackLongs && "### no stack in callVirtualMethod !");
-
-    // never called
-    if (! pAdjustedThisPtr) CPPU_CURRENT_NAMESPACE::dummy_can_throw_anything("xxx"); // address something
-
-    long edx, eax; // for register returns
-    void * stackptr;
-    asm volatile (
-        "mov   %%esp, %2\n\t"
-        "mov   %3, %%eax\n\t"
-        "mov   %%eax, %%edx\n\t"
-                // stack padding to keep stack aligned:
-        "shl   $2, %%eax\n\t"
-        "neg   %%eax\n\t"
-        "add   %%esp, %%eax\n\t"
-        "and   $0xf, %%eax\n\t"
-        "sub   %%eax, %%esp\n\t"
-                // copy:
-        "mov   %%edx, %%eax\n\t"
-        "dec   %%edx\n\t"
-        "shl   $2, %%edx\n\t"
-        "add   %4, %%edx\n"
-        "Lcopy:\n\t"
-        "pushl 0(%%edx)\n\t"
-        "sub   $4, %%edx\n\t"
-        "dec   %%eax\n\t"
-        "jne   Lcopy\n\t"
-        // do the actual call
-        "mov   %5, %%edx\n\t"
-        "mov   0(%%edx), %%edx\n\t"
-        "mov   %6, %%eax\n\t"
-        "shl   $2, %%eax\n\t"
-        "add   %%eax, %%edx\n\t"
-        "mov   0(%%edx), %%edx\n\t"
-        "call  *%%edx\n\t"
-        // save return registers
-         "mov   %%eax, %0\n\t"
-         "mov   %%edx, %1\n\t"
-        // cleanup stack
-        "mov   %2, %%esp\n\t"
-        : "=m"(eax), "=m"(edx), "=m"(stackptr)
-        : "m"(nStackLongs), "m"(pStackLongs), "m"(pAdjustedThisPtr), "m"(nVtableIndex)
-        : "eax", "edx" );
-    switch( pReturnTypeDescr->eTypeClass )
-    {
-    case typelib_TypeClass_VOID:
-        break;
-    case typelib_TypeClass_HYPER:
-    case typelib_TypeClass_UNSIGNED_HYPER:
-        ((long*)pRegisterReturn)[1] = edx;
-        SAL_FALLTHROUGH;
-    case typelib_TypeClass_LONG:
-    case typelib_TypeClass_UNSIGNED_LONG:
-    case typelib_TypeClass_CHAR:
-    case typelib_TypeClass_ENUM:
-        ((long*)pRegisterReturn)[0] = eax;
-        break;
-    case typelib_TypeClass_SHORT:
-    case typelib_TypeClass_UNSIGNED_SHORT:
-        *(unsigned short*)pRegisterReturn = eax;
-        break;
-    case typelib_TypeClass_BOOLEAN:
-    case typelib_TypeClass_BYTE:
-        *(unsigned char*)pRegisterReturn = eax;
-        break;
-    case typelib_TypeClass_FLOAT:
-        asm ( "fstps %0" : : "m"(*(char *)pRegisterReturn) );
-        break;
-    case typelib_TypeClass_DOUBLE:
-        asm ( "fstpl %0\n\t" : : "m"(*(char *)pRegisterReturn) );
-        break;
-    default: {
-        sal_Int32 const nRetSize = pReturnTypeDescr->nSize;
-        if (bSimpleReturn && nRetSize <= 8 && nRetSize > 0) {
-            if (nRetSize > 4)
-                static_cast<long *>(pRegisterReturn)[1] = edx;
-            static_cast<long *>(pRegisterReturn)[0] = eax;
-        }
-        break;
-    }
-    }
-}
-
-static void cpp_call(
-    bridges::cpp_uno::shared::UnoInterfaceProxy * pThis,
-    bridges::cpp_uno::shared::VtableSlot aVtableSlot,
-    typelib_TypeDescriptionReference * pReturnTypeRef,
-    sal_Int32 nParams, typelib_MethodParameter * pParams,
-    void * pUnoReturn, void * pUnoArgs[], uno_Any ** ppUnoExc )
-{
-      // max space for: [complex ret ptr], values|ptr ...
-      char * pCppStack      =
-          (char *)alloca( sizeof(sal_Int32) + ((nParams+2) * sizeof(sal_Int64)) );
-      char * pCppStackStart = pCppStack;
-
-    // return
-    typelib_TypeDescription * pReturnTypeDescr = 0;
-    TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
-    assert(pReturnTypeDescr);
-
-    void * pCppReturn = 0; // if != 0 && != pUnoReturn, needs reconversion
-    bool bSimpleReturn = true;
-
-    if (pReturnTypeDescr)
-    {
-        bSimpleReturn = CPPU_CURRENT_NAMESPACE::isSimpleReturnType(
-            pReturnTypeDescr);
-        if (bSimpleReturn)
-        {
-            pCppReturn = pUnoReturn; // direct way for simple types
-        }
-        else
-        {
-            pCppReturn = (bridges::cpp_uno::shared::relatesToInterfaceType(
-                              pReturnTypeDescr )
-                          ? alloca( pReturnTypeDescr->nSize )
-                          : pUnoReturn); // direct way
-            // complex return via ptr
-            *(void **)pCppStack = pCppReturn;
-            pCppStack += sizeof(void *);
-        }
-    }
-    // push this
-    void * pAdjustedThisPtr = reinterpret_cast< void ** >(pThis->getCppI())
-        + aVtableSlot.offset;
-    *(void**)pCppStack = pAdjustedThisPtr;
-    pCppStack += sizeof( void* );
-
-    // stack space
-    static_assert(sizeof(void *) == sizeof(sal_Int32), "### unexpected size!");
-    // args
-    void ** pCppArgs  = (void **)alloca( 3 * sizeof(void *) * nParams );
-    // indices of values this have to be converted (interface conversion cpp<=>uno)
-    sal_Int32 * pTempIndices = (sal_Int32 *)(pCppArgs + nParams);
-    // type descriptions for reconversions
-    typelib_TypeDescription ** ppTempParamTypeDescr = (typelib_TypeDescription **)(pCppArgs + (2 * nParams));
-
-    sal_Int32 nTempIndices   = 0;
-
-    for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
-    {
-        const typelib_MethodParameter & rParam = pParams[nPos];
-        typelib_TypeDescription * pParamTypeDescr = 0;
-        TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
-
-        if (!rParam.bOut
-            && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
-        {
-            uno_copyAndConvertData( pCppArgs[nPos] = pCppStack, pUnoArgs[nPos], pParamTypeDescr,
-                                    pThis->getBridge()->getUno2Cpp() );
-
-            switch (pParamTypeDescr->eTypeClass)
-            {
-            case typelib_TypeClass_HYPER:
-            case typelib_TypeClass_UNSIGNED_HYPER:
-            case typelib_TypeClass_DOUBLE:
-                pCppStack += sizeof(sal_Int32); // extra long
-                SAL_FALLTHROUGH;
-            default:
-                break;
-            }
-            // no longer needed
-            TYPELIB_DANGER_RELEASE( pParamTypeDescr );
-        }
-        else // ptr to complex value | ref
-        {
-            if (! rParam.bIn) // is pure out
-            {
-                // cpp out is constructed mem, uno out is not!
-                uno_constructData(
-                    *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
-                    pParamTypeDescr );
-                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
-                // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
-            }
-            // is in/inout
-            else if (bridges::cpp_uno::shared::relatesToInterfaceType(
-                         pParamTypeDescr ))
-            {
-                uno_copyAndConvertData(
-                    *(void **)pCppStack = pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
-                    pUnoArgs[nPos], pParamTypeDescr,
-                    pThis->getBridge()->getUno2Cpp() );
-
-                pTempIndices[nTempIndices] = nPos; // has to be reconverted
-                // will be released at reconversion
-                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
-            }
-            else // direct way
-            {
-                *(void **)pCppStack = pCppArgs[nPos] = pUnoArgs[nPos];
-                // no longer needed
-                TYPELIB_DANGER_RELEASE( pParamTypeDescr );
-            }
-        }
-        pCppStack += sizeof(sal_Int32); // standard parameter length
-    }
-
-    try
-    {
-        assert( !( (pCppStack - pCppStackStart ) & 3) && "UNALIGNED STACK !!! (Please DO panic)" );
-        callVirtualMethod(
-            pAdjustedThisPtr, aVtableSlot.index,
-            pCppReturn, pReturnTypeDescr, bSimpleReturn,
-            (sal_Int32 *)pCppStackStart, (pCppStack - pCppStackStart) / sizeof(sal_Int32) );
-        // NO exception occurred...
-        *ppUnoExc = 0;
-
-        // reconvert temporary params
-        for ( ; nTempIndices--; )
-        {
-            sal_Int32 nIndex = pTempIndices[nTempIndices];
-            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
-
-            if (pParams[nIndex].bIn)
-            {
-                if (pParams[nIndex].bOut) // inout
-                {
-                    uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, 0 ); // destroy uno value
-                    uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
-                                            pThis->getBridge()->getCpp2Uno() );
-                }
-            }
-            else // pure out
-            {
-                uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
-                                        pThis->getBridge()->getCpp2Uno() );
-            }
-            // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
-
-            TYPELIB_DANGER_RELEASE( pParamTypeDescr );
-        }
-        // return value
-        if (pCppReturn && pUnoReturn != pCppReturn)
-        {
-            uno_copyAndConvertData( pUnoReturn, pCppReturn, pReturnTypeDescr,
-                                    pThis->getBridge()->getCpp2Uno() );
-            uno_destructData( pCppReturn, pReturnTypeDescr, cpp_release );
-        }
-    }
-    catch (...)
-    {
-
-        SAL_INFO( "bridges.ios", "caught C++ exception" );
-
-          // fill uno exception
-        CPPU_CURRENT_NAMESPACE::fillUnoException( abi::__cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
-
-        // temporary params
-        for ( ; nTempIndices--; )
-        {
-            sal_Int32 nIndex = pTempIndices[nTempIndices];
-            // destroy temp cpp param => cpp: every param was constructed
-            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
-            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
-        }
-        // return type
-        if (pReturnTypeDescr)
-            TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
-    }
-}
-
-}
-
-namespace CPPU_CURRENT_NAMESPACE {
-bool isSimpleReturnType(typelib_TypeDescription * pTD, bool recursive)
-{
-    if (bridges::cpp_uno::shared::isSimpleType( pTD ))
-        return true;
-    // Only structs of exactly 1, 2, 4, or 8 bytes are returned through
-    // registers, see <http://developer.apple.com/documentation/DeveloperTools/
-    // Conceptual/LowLevelABI/Articles/IA32.html>:
-    if (pTD->eTypeClass == typelib_TypeClass_STRUCT &&
-        (recursive || pTD->nSize <= 2 || pTD->nSize == 4 || pTD->nSize == 8))
-    {
-        typelib_CompoundTypeDescription *const pCompTD =
-            (typelib_CompoundTypeDescription *) pTD;
-        for ( sal_Int32 pos = pCompTD->nMembers; pos--; ) {
-            typelib_TypeDescription * pMemberTD = 0;
-            TYPELIB_DANGER_GET( &pMemberTD, pCompTD->ppTypeRefs[pos] );
-            bool const b = isSimpleReturnType(pMemberTD, true);
-            TYPELIB_DANGER_RELEASE( pMemberTD );
-            if (! b)
-                return false;
-        }
-        return true;
-    }
-    return false;
-}
-}
-
-
-namespace bridges { namespace cpp_uno { namespace shared {
-void unoInterfaceProxyDispatch(
-    uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,
-    void * pReturn, void * pArgs[], uno_Any ** ppException )
-{
-    // is my surrogate
-    bridges::cpp_uno::shared::UnoInterfaceProxy * pThis
-        = static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy * >(pUnoI);
-
-    switch (pMemberDescr->eTypeClass)
-    {
-    case typelib_TypeClass_INTERFACE_ATTRIBUTE:
-    {
-        VtableSlot aVtableSlot(
-            getVtableSlot(
-                reinterpret_cast<
-                    typelib_InterfaceAttributeTypeDescription const * >(
-                        pMemberDescr)));
-        if (pReturn)
-        {
-            // dependent dispatch
-            cpp_call(
-                pThis, aVtableSlot,
-                ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef,
-                0, 0, // no params
-                pReturn, pArgs, ppException );
-        }
-        else
-        {
-            // is SET
-            typelib_MethodParameter aParam;
-            aParam.pTypeRef =
-                ((typelib_InterfaceAttributeTypeDescription *)pMemberDescr)->pAttributeTypeRef;
-            aParam.bIn      = sal_True;
-            aParam.bOut     = sal_False;
-
-            typelib_TypeDescriptionReference * pReturnTypeRef = 0;
-            OUString aVoidName("void");
-            typelib_typedescriptionreference_new(
-                &pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData );
-
-            // dependent dispatch
-            aVtableSlot.index += 1; // get, then set method
-            cpp_call(
-                pThis, aVtableSlot,
-                pReturnTypeRef,
-                1, &aParam,
-                pReturn, pArgs, ppException );
-
-            typelib_typedescriptionreference_release( pReturnTypeRef );
-        }
-
-        break;
-    }
-    case typelib_TypeClass_INTERFACE_METHOD:
-    {
-        VtableSlot aVtableSlot(
-            getVtableSlot(
-                reinterpret_cast<
-                    typelib_InterfaceMethodTypeDescription const * >(
-                        pMemberDescr)));
-        switch (aVtableSlot.index)
-        {
-            // standard calls
-        case 1: // acquire uno interface
-            (*pUnoI->acquire)( pUnoI );
-            *ppException = 0;
-            break;
-        case 2: // release uno interface
-            (*pUnoI->release)( pUnoI );
-            *ppException = 0;
-            break;
-        case 0: // queryInterface() opt
-        {
-            typelib_TypeDescription * pTD = 0;
-            TYPELIB_DANGER_GET( &pTD, reinterpret_cast< Type * >( pArgs[0] )->getTypeLibType() );
-            if (pTD)
-            {
-                uno_Interface * pInterface = 0;
-                (*pThis->pBridge->getUnoEnv()->getRegisteredInterface)(
-                    pThis->pBridge->getUnoEnv(),
-                    (void **)&pInterface, pThis->oid.pData, (typelib_InterfaceTypeDescription *)pTD );
-
-                if (pInterface)
-                {
-                    ::uno_any_construct(
-                        reinterpret_cast< uno_Any * >( pReturn ),
-                        &pInterface, pTD, 0 );
-                    (*pInterface->release)( pInterface );
-                    TYPELIB_DANGER_RELEASE( pTD );
-                    *ppException = 0;
-                    break;
-                }
-                TYPELIB_DANGER_RELEASE( pTD );
-            }
-        } // else perform queryInterface()
-        SAL_FALLTHROUGH;
-        default:
-            // dependent dispatch
-            cpp_call(
-                pThis, aVtableSlot,
-                ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pReturnTypeRef,
-                ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->nParams,
-                ((typelib_InterfaceMethodTypeDescription *)pMemberDescr)->pParams,
-                pReturn, pArgs, ppException );
-        }
-        break;
-    }
-    default:
-    {
-        ::com::sun::star::uno::RuntimeException aExc(
-            "illegal member type description!",
-            ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >() );
-
-        Type const & rExcType = cppu::UnoType<decltype(aExc)>::get();
-        // binary identical null reference
-        ::uno_type_any_construct( *ppException, &aExc, rExcType.getTypeLibType(), 0 );
-    }
-    }
-}
-
-} } }
-
-#endif
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/bridges/source/cpp_uno/gcc3_ios/uno2cpp-simulator.cxx b/bridges/source/cpp_uno/gcc3_ios/uno2cpp-simulator.cxx
new file mode 100644
index 000000000000..de032c3cca1d
--- /dev/null
+++ b/bridges/source/cpp_uno/gcc3_ios/uno2cpp-simulator.cxx
@@ -0,0 +1,444 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifdef __x86_64
+
+#include <sal/alloca.h>
+
+#include <exception>
+#include <typeinfo>
+
+#include "rtl/alloc.h"
+
+#include <com/sun/star/uno/genfunc.hxx>
+#include "com/sun/star/uno/RuntimeException.hpp"
+#include <o3tl/runtimetooustring.hxx>
+#include <uno/data.h>
+
+#include <bridge.hxx>
+#include <types.hxx>
+#include "unointerfaceproxy.hxx"
+#include "vtables.hxx"
+
+#include "abi.hxx"
+#include "callvirtualmethod.hxx"
+#include "share.hxx"
+
+using namespace ::com::sun::star::uno;
+
+namespace {
+
+// Functions for easier insertion of values to registers or stack
+// pSV - pointer to the source
+// nr - order of the value [will be increased if stored to register]
+// pFPR, pGPR - pointer to the registers
+// pDS - pointer to the stack [will be increased if stored here]
+
+// The value in %xmm register is already prepared to be retrieved as a float,
+// thus we treat float and double the same
+void INSERT_FLOAT_DOUBLE(
+    void const * pSV, sal_uInt32 & nr, double * pFPR, sal_uInt64 *& pDS)
+{
+    if ( nr < x86_64::MAX_SSE_REGS )
+        pFPR[nr++] = *static_cast<double const *>( pSV );
+    else
+        *pDS++ = *static_cast<sal_uInt64 const *>( pSV ); // verbatim!
+}
+
+void INSERT_INT64(
+    void const * pSV, sal_uInt32 & nr, sal_uInt64 * pGPR, sal_uInt64 *& pDS)
+{
+    if ( nr < x86_64::MAX_GPR_REGS )
+        pGPR[nr++] = *static_cast<sal_uInt64 const *>( pSV );
+    else
+        *pDS++ = *static_cast<sal_uInt64 const *>( pSV );
+}
+
+void INSERT_INT32(
+    void const * pSV, sal_uInt32 & nr, sal_uInt64 * pGPR, sal_uInt64 *& pDS)
+{
+    if ( nr < x86_64::MAX_GPR_REGS )
+        pGPR[nr++] = *static_cast<sal_uInt32 const *>( pSV );
+    else
+        *pDS++ = *static_cast<sal_uInt32 const *>( pSV );
+}
+
+void INSERT_INT16(
+    void const * pSV, sal_uInt32 & nr, sal_uInt64 * pGPR, sal_uInt64 *& pDS)
+{
+    if ( nr < x86_64::MAX_GPR_REGS )
+        pGPR[nr++] = *static_cast<sal_uInt16 const *>( pSV );
+    else
+        *pDS++ = *static_cast<sal_uInt16 const *>( pSV );
+}
+
+void INSERT_INT8(
+    void const * pSV, sal_uInt32 & nr, sal_uInt64 * pGPR, sal_uInt64 *& pDS)
+{
+    if ( nr < x86_64::MAX_GPR_REGS )
+        pGPR[nr++] = *static_cast<sal_uInt8 const *>( pSV );
+    else
+        *pDS++ = *static_cast<sal_uInt8 const *>( pSV );
+}
+
+}
+
+static void cpp_call(
+    bridges::cpp_uno::shared::UnoInterfaceProxy * pThis,
+    bridges::cpp_uno::shared::VtableSlot aVtableSlot,
+    typelib_TypeDescriptionReference * pReturnTypeRef,
+    sal_Int32 nParams, typelib_MethodParameter * pParams,
+    void * pUnoReturn, void * pUnoArgs[], uno_Any ** ppUnoExc )
+{
+    // Maximum space for [complex ret ptr], values | ptr ...
+    // (but will be used less - some of the values will be in pGPR and pFPR)
+      sal_uInt64 *pStack = static_cast<sal_uInt64 *>(__builtin_alloca( (nParams + 3) * sizeof(sal_uInt64) ));
+      sal_uInt64 *pStackStart = pStack;
+
+    sal_uInt64 pGPR[x86_64::MAX_GPR_REGS];
+    sal_uInt32 nGPR = 0;
+
+    double pFPR[x86_64::MAX_SSE_REGS];
+    sal_uInt32 nFPR = 0;
+
+    // Return
+    typelib_TypeDescription * pReturnTypeDescr = nullptr;
+    TYPELIB_DANGER_GET( &pReturnTypeDescr, pReturnTypeRef );
+    assert(pReturnTypeDescr);
+
+    void * pCppReturn = nullptr; // if != 0 && != pUnoReturn, needs reconversion (see below)
+
+    bool bSimpleReturn = true;
+    if ( pReturnTypeDescr )
+    {
+        if ( x86_64::return_in_hidden_param( pReturnTypeRef ) )
+            bSimpleReturn = false;
+
+        if ( bSimpleReturn )
+            pCppReturn = pUnoReturn; // direct way for simple types
+        else
+        {
+            // complex return via ptr
+            pCppReturn = bridges::cpp_uno::shared::relatesToInterfaceType( pReturnTypeDescr )?
+                         __builtin_alloca( pReturnTypeDescr->nSize ) : pUnoReturn;
+            INSERT_INT64( &pCppReturn, nGPR, pGPR, pStack );
+        }
+    }
+
+    // Push "this" pointer
+    void * pAdjustedThisPtr = reinterpret_cast< void ** >( pThis->getCppI() ) + aVtableSlot.offset;
+    INSERT_INT64( &pAdjustedThisPtr, nGPR, pGPR, pStack );
+
+    // Args
+    void ** pCppArgs = static_cast<void **>(alloca( 3 * sizeof(void *) * nParams ));
+    // Indices of values this have to be converted (interface conversion cpp<=>uno)
+    sal_Int32 * pTempIndices = reinterpret_cast<sal_Int32 *>(pCppArgs + nParams);
+    // Type descriptions for reconversions
+    typelib_TypeDescription ** ppTempParamTypeDescr = reinterpret_cast<typelib_TypeDescription **>(pCppArgs + (2 * nParams));
+
+    sal_Int32 nTempIndices = 0;
+
+    for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
+    {
+        const typelib_MethodParameter & rParam = pParams[nPos];
+        typelib_TypeDescription * pParamTypeDescr = nullptr;
+        TYPELIB_DANGER_GET( &pParamTypeDescr, rParam.pTypeRef );
+
+        if (!rParam.bOut && bridges::cpp_uno::shared::isSimpleType( pParamTypeDescr ))
+        {
+            uno_copyAndConvertData( pCppArgs[nPos] = alloca( 8 ), pUnoArgs[nPos], pParamTypeDescr,
+                                    pThis->getBridge()->getUno2Cpp() );
+
+            switch (pParamTypeDescr->eTypeClass)
+            {
+            case typelib_TypeClass_HYPER:
+            case typelib_TypeClass_UNSIGNED_HYPER:
+                INSERT_INT64( pCppArgs[nPos], nGPR, pGPR, pStack );
+                break;
+            case typelib_TypeClass_LONG:
+            case typelib_TypeClass_UNSIGNED_LONG:
+            case typelib_TypeClass_ENUM:
+                INSERT_INT32( pCppArgs[nPos], nGPR, pGPR, pStack );
+                break;
+            case typelib_TypeClass_SHORT:
+            case typelib_TypeClass_CHAR:
+            case typelib_TypeClass_UNSIGNED_SHORT:
+                INSERT_INT16( pCppArgs[nPos], nGPR, pGPR, pStack );
+                break;
+            case typelib_TypeClass_BOOLEAN:
+            case typelib_TypeClass_BYTE:
+                INSERT_INT8( pCppArgs[nPos], nGPR, pGPR, pStack );
+                break;
+            case typelib_TypeClass_FLOAT:
+            case typelib_TypeClass_DOUBLE:
+                INSERT_FLOAT_DOUBLE( pCppArgs[nPos], nFPR, pFPR, pStack );
+                break;
+            default:
+                break;
+            }
+
+            // no longer needed
+            TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+        }
+        else // ptr to complex value | ref
+        {
+            if (! rParam.bIn) // is pure out
+            {
+                // cpp out is constructed mem, uno out is not!
+                uno_constructData(
+                    pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
+                    pParamTypeDescr );
+                pTempIndices[nTempIndices] = nPos; // default constructed for cpp call
+                // will be released at reconversion
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
+            }
+            // is in/inout
+            else if (bridges::cpp_uno::shared::relatesToInterfaceType( pParamTypeDescr ))
+            {
+                uno_copyAndConvertData(
+                    pCppArgs[nPos] = alloca( pParamTypeDescr->nSize ),
+                    pUnoArgs[nPos], pParamTypeDescr, pThis->getBridge()->getUno2Cpp() );
+
+                pTempIndices[nTempIndices] = nPos; // has to be reconverted
+                // will be released at reconversion
+                ppTempParamTypeDescr[nTempIndices++] = pParamTypeDescr;
+            }
+            else // direct way
+            {
+                pCppArgs[nPos] = pUnoArgs[nPos];
+                // no longer needed
+                TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+            }
+            INSERT_INT64( &(pCppArgs[nPos]), nGPR, pGPR, pStack );
+        }
+    }
+
+    try
+    {
+        try {
+            CPPU_CURRENT_NAMESPACE::callVirtualMethod(
+                pAdjustedThisPtr, aVtableSlot.index,
+                pCppReturn, pReturnTypeRef, bSimpleReturn,
+                pStackStart, ( pStack - pStackStart ),
+                pGPR, pFPR );
+        } catch (const Exception &) {
+            throw;
+        } catch (const std::exception & e) {
+            throw RuntimeException(
+                "C++ code threw " + o3tl::runtimeToOUString(typeid(e).name())
+                + ": " + o3tl::runtimeToOUString(e.what()));
+        } catch (...) {
+            throw RuntimeException("C++ code threw unknown exception");
+        }
+
+        *ppUnoExc = nullptr;
+
+        // reconvert temporary params
+        for ( ; nTempIndices--; )
+        {
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            typelib_TypeDescription * pParamTypeDescr = ppTempParamTypeDescr[nTempIndices];
+
+            if (pParams[nIndex].bIn)
+            {
+                if (pParams[nIndex].bOut) // inout
+                {
+                    uno_destructData( pUnoArgs[nIndex], pParamTypeDescr, nullptr ); // destroy uno value
+                    uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
+                                            pThis->getBridge()->getCpp2Uno() );
+                }
+            }
+            else // pure out
+            {
+                uno_copyAndConvertData( pUnoArgs[nIndex], pCppArgs[nIndex], pParamTypeDescr,
+                                        pThis->getBridge()->getCpp2Uno() );
+            }
+            // destroy temp cpp param => cpp: every param was constructed
+            uno_destructData( pCppArgs[nIndex], pParamTypeDescr, cpp_release );
+
+            TYPELIB_DANGER_RELEASE( pParamTypeDescr );
+        }
+        // return value
+        if (pCppReturn && pUnoReturn != pCppReturn)
+        {
+            uno_copyAndConvertData( pUnoReturn, pCppReturn, pReturnTypeDescr,
+                                    pThis->getBridge()->getCpp2Uno() );
+            uno_destructData( pCppReturn, pReturnTypeDescr, cpp_release );
+        }
+    }
+     catch (...)
+     {
+          // fill uno exception
+        CPPU_CURRENT_NAMESPACE::fillUnoException( __cxa_get_globals()->caughtExceptions, *ppUnoExc, pThis->getBridge()->getCpp2Uno() );
+
+        // temporary params
+        for ( ; nTempIndices--; )
+        {
+            sal_Int32 nIndex = pTempIndices[nTempIndices];
+            // destroy temp cpp param => cpp: every param was constructed
+            uno_destructData( pCppArgs[nIndex], ppTempParamTypeDescr[nTempIndices], cpp_release );
+            TYPELIB_DANGER_RELEASE( ppTempParamTypeDescr[nTempIndices] );
+        }
+        // return type
+        if (pReturnTypeDescr)
+            TYPELIB_DANGER_RELEASE( pReturnTypeDescr );
+    }
+}
+
+
+namespace bridges { namespace cpp_uno { namespace shared {
+
+void unoInterfaceProxyDispatch(
+    uno_Interface * pUnoI, const typelib_TypeDescription * pMemberDescr,
+    void * pReturn, void * pArgs[], uno_Any ** ppException )
+{
+    // is my surrogate
+    bridges::cpp_uno::shared::UnoInterfaceProxy * pThis
+        = static_cast< bridges::cpp_uno::shared::UnoInterfaceProxy * >(pUnoI);
+#if OSL_DEBUG_LEVEL > 0
+    typelib_InterfaceTypeDescription * pTypeDescr = pThis->pTypeDescr;
+#endif
+
+    switch (pMemberDescr->eTypeClass)
+    {
+    case typelib_TypeClass_INTERFACE_ATTRIBUTE:
+    {
+#if OSL_DEBUG_LEVEL > 0
+        // determine vtable call index
+        sal_Int32 nMemberPos = reinterpret_cast<typelib_InterfaceMemberTypeDescription const *>(pMemberDescr)->nPosition;
+        assert(nMemberPos < pTypeDescr->nAllMembers);
+#endif
+        VtableSlot aVtableSlot(
+                getVtableSlot(
+                    reinterpret_cast<
+                    typelib_InterfaceAttributeTypeDescription const * >(
+                        pMemberDescr)));
+
+        if (pReturn)
+        {
+            // dependent dispatch
+            cpp_call(
+                pThis, aVtableSlot,
+                reinterpret_cast<typelib_InterfaceAttributeTypeDescription const *>(pMemberDescr)->pAttributeTypeRef,
+                0, nullptr, // no params
+                pReturn, pArgs, ppException );
+        }
+        else
+        {
+            // is SET
+            typelib_MethodParameter aParam;
+            aParam.pTypeRef =
+                reinterpret_cast<typelib_InterfaceAttributeTypeDescription const *>(pMemberDescr)->pAttributeTypeRef;
+            aParam.bIn      = true;
+            aParam.bOut     = false;
+
+            typelib_TypeDescriptionReference * pReturnTypeRef = nullptr;
+            OUString aVoidName("void");
+            typelib_typedescriptionreference_new(
+                &pReturnTypeRef, typelib_TypeClass_VOID, aVoidName.pData );
+
+            // dependent dispatch
+            aVtableSlot.index += 1; // get, then set method
+            cpp_call(
+                pThis, aVtableSlot, // get, then set method
+                pReturnTypeRef,
+                1, &aParam,
+                pReturn, pArgs, ppException );
+
+            typelib_typedescriptionreference_release( pReturnTypeRef );
+        }
+
+        break;
+    }
+    case typelib_TypeClass_INTERFACE_METHOD:
+    {
+#if OSL_DEBUG_LEVEL > 0
+        // determine vtable call index
+        sal_Int32 nMemberPos = reinterpret_cast<typelib_InterfaceMemberTypeDescription const *>(pMemberDescr)->nPosition;
+        assert(nMemberPos < pTypeDescr->nAllMembers);
+#endif
+        VtableSlot aVtableSlot(
+                getVtableSlot(
+                    reinterpret_cast<
+                    typelib_InterfaceMethodTypeDescription const * >(
+                        pMemberDescr)));
+
+        switch (aVtableSlot.index)
+        {
+            // standard calls
+        case 1: // acquire uno interface
+            (*pUnoI->acquire)( pUnoI );
+            *ppException = nullptr;
+            break;
+        case 2: // release uno interface
+            (*pUnoI->release)( pUnoI );
+            *ppException = nullptr;
+            break;
+        case 0: // queryInterface() opt
+        {
+            typelib_TypeDescription * pTD = nullptr;
+            TYPELIB_DANGER_GET( &pTD, static_cast< Type * >( pArgs[0] )->getTypeLibType() );
+            if (pTD)
+            {
+                uno_Interface * pInterface = nullptr;
+                (*pThis->getBridge()->getUnoEnv()->getRegisteredInterface)(
+                    pThis->getBridge()->getUnoEnv(),
+                    reinterpret_cast<void **>(&pInterface), pThis->oid.pData, reinterpret_cast<typelib_InterfaceTypeDescription *>(pTD) );
+
+                if (pInterface)
+                {
+                    ::uno_any_construct(
+                        static_cast< uno_Any * >( pReturn ),
+                        &pInterface, pTD, nullptr );
+                    (*pInterface->release)( pInterface );
+                    TYPELIB_DANGER_RELEASE( pTD );
+                    *ppException = nullptr;
+                    break;
+                }
+                TYPELIB_DANGER_RELEASE( pTD );
+            }
+            SAL_FALLTHROUGH; // else perform queryInterface()
+        }
+        default:
+            // dependent dispatch
+            cpp_call(
+                pThis, aVtableSlot,
+                reinterpret_cast<typelib_InterfaceMethodTypeDescription const *>(pMemberDescr)->pReturnTypeRef,
+                reinterpret_cast<typelib_InterfaceMethodTypeDescription const *>(pMemberDescr)->nParams,
+                reinterpret_cast<typelib_InterfaceMethodTypeDescription const *>(pMemberDescr)->pParams,
+                pReturn, pArgs, ppException );
+        }
+        break;
+    }
+    default:
+    {
+        ::com::sun::star::uno::RuntimeException aExc(
+            "illegal member type description!",
+            ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >() );
+
+        Type const & rExcType = cppu::UnoType<decltype(aExc)>::get();
+        // binary identical null reference
+        ::uno_type_any_construct( *ppException, &aExc, rExcType.getTypeLibType(), nullptr );
+    }
+    }
+}
+
+} } }
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */