[Libreoffice-commits] core.git: bridges/CustomTarget_gcc3_ios.mk bridges/Library_cpp_uno.mk bridges/Module_bridges.mk bridges/source
jan Iversen
jani at libreoffice.org
Fri Sep 22 15:31:13 UTC 2017
bridges/CustomTarget_gcc3_ios.mk | 20
bridges/Library_cpp_uno.mk | 3
bridges/Module_bridges.mk | 2
bridges/source/cpp_uno/gcc3_ios/abi.cxx | 328 +
bridges/source/cpp_uno/gcc3_ios/abi.hxx | 61
bridges/source/cpp_uno/gcc3_ios/call.cxx | 78
bridges/source/cpp_uno/gcc3_ios/call.hxx | 37
bridges/source/cpp_uno/gcc3_ios/callvirtualmethod.cxx | 180
bridges/source/cpp_uno/gcc3_ios/callvirtualmethod.hxx | 40
bridges/source/cpp_uno/gcc3_ios/cpp2uno-simulator.cxx | 520 ++
bridges/source/cpp_uno/gcc3_ios/cpp2uno.cxx | 2
bridges/source/cpp_uno/gcc3_ios/generate-snippets.pl | 114
bridges/source/cpp_uno/gcc3_ios/helper.s | 448 --
bridges/source/cpp_uno/gcc3_ios/ios64_helper.s | 3254 ++++++++++++++++++
bridges/source/cpp_uno/gcc3_ios/uno2cpp-i386.cxx | 487 --
bridges/source/cpp_uno/gcc3_ios/uno2cpp-simulator.cxx | 444 ++
16 files changed, 4945 insertions(+), 1073 deletions(-)
New commits:
commit e69ed74e34712419c0c3737b6bb846be11d4e460
Author: jan Iversen <jani at libreoffice.org>
Date: Fri Sep 22 08:29:13 2017 +0200
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
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 at 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:
... etc. - the rest is truncated
More information about the Libreoffice-commits
mailing list