diff options
Diffstat (limited to 'bridges')
| -rw-r--r-- | bridges/CustomTarget_gcc3_ios.mk | 20 | ||||
| -rw-r--r-- | bridges/Library_cpp_uno.mk | 3 | ||||
| -rw-r--r-- | bridges/Module_bridges.mk | 2 | ||||
| -rw-r--r-- | bridges/source/cpp_uno/gcc3_ios/abi.cxx | 328 | ||||
| -rw-r--r-- | bridges/source/cpp_uno/gcc3_ios/abi.hxx | 61 | ||||
| -rw-r--r-- | bridges/source/cpp_uno/gcc3_ios/call.cxx | 78 | ||||
| -rw-r--r-- | bridges/source/cpp_uno/gcc3_ios/call.hxx | 37 | ||||
| -rw-r--r-- | bridges/source/cpp_uno/gcc3_ios/callvirtualmethod.cxx | 180 | ||||
| -rw-r--r-- | bridges/source/cpp_uno/gcc3_ios/callvirtualmethod.hxx | 40 | ||||
| -rw-r--r-- | bridges/source/cpp_uno/gcc3_ios/cpp2uno-simulator.cxx | 520 | ||||
| -rw-r--r-- | bridges/source/cpp_uno/gcc3_ios/cpp2uno.cxx | 2 | ||||
| -rwxr-xr-x | bridges/source/cpp_uno/gcc3_ios/generate-snippets.pl | 114 | ||||
| -rw-r--r-- | bridges/source/cpp_uno/gcc3_ios/helper.s | 448 | ||||
| -rw-r--r-- | bridges/source/cpp_uno/gcc3_ios/ios64_helper.s | 3254 | ||||
| -rw-r--r-- | bridges/source/cpp_uno/gcc3_ios/uno2cpp-i386.cxx | 487 | ||||
| -rw-r--r-- | bridges/source/cpp_uno/gcc3_ios/uno2cpp-simulator.cxx | 444 |
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: */ |