161dff127SAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
361dff127SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
461dff127SAndrew Rist * or more contributor license agreements. See the NOTICE file
561dff127SAndrew Rist * distributed with this work for additional information
661dff127SAndrew Rist * regarding copyright ownership. The ASF licenses this file
761dff127SAndrew Rist * to you under the Apache License, Version 2.0 (the
861dff127SAndrew Rist * "License"); you may not use this file except in compliance
961dff127SAndrew Rist * with the License. You may obtain a copy of the License at
1061dff127SAndrew Rist *
1161dff127SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
1261dff127SAndrew Rist *
1361dff127SAndrew Rist * Unless required by applicable law or agreed to in writing,
1461dff127SAndrew Rist * software distributed under the License is distributed on an
1561dff127SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
1661dff127SAndrew Rist * KIND, either express or implied. See the License for the
1761dff127SAndrew Rist * specific language governing permissions and limitations
1861dff127SAndrew Rist * under the License.
1961dff127SAndrew Rist *
2061dff127SAndrew Rist *************************************************************/
2161dff127SAndrew Rist
2261dff127SAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_bridges.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir // This is an implementation of the x86-64 ABI as described in 'System V
28cdf0e10cSrcweir // Application Binary Interface, AMD64 Architecture Processor Supplement'
29cdf0e10cSrcweir // (http://www.x86-64.org/documentation/abi-0.95.pdf)
30cdf0e10cSrcweir //
31cdf0e10cSrcweir // The code in this file is a modification of src/x86/ffi64.c from libffi
32cdf0e10cSrcweir // (http://sources.redhat.com/libffi/) which is under the following license:
33cdf0e10cSrcweir
34cdf0e10cSrcweir /* -----------------------------------------------------------------------
35cdf0e10cSrcweir ffi.c - Copyright (c) 2002 Bo Thorsen <bo@suse.de>
36cdf0e10cSrcweir
37cdf0e10cSrcweir x86-64 Foreign Function Interface
38cdf0e10cSrcweir
39cdf0e10cSrcweir Permission is hereby granted, free of charge, to any person obtaining
40cdf0e10cSrcweir a copy of this software and associated documentation files (the
41cdf0e10cSrcweir ``Software''), to deal in the Software without restriction, including
42cdf0e10cSrcweir without limitation the rights to use, copy, modify, merge, publish,
43cdf0e10cSrcweir distribute, sublicense, and/or sell copies of the Software, and to
44cdf0e10cSrcweir permit persons to whom the Software is furnished to do so, subject to
45cdf0e10cSrcweir the following conditions:
46cdf0e10cSrcweir
47cdf0e10cSrcweir The above copyright notice and this permission notice shall be included
48cdf0e10cSrcweir in all copies or substantial portions of the Software.
49cdf0e10cSrcweir
50cdf0e10cSrcweir THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
51cdf0e10cSrcweir OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
52cdf0e10cSrcweir MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
53cdf0e10cSrcweir IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
54cdf0e10cSrcweir OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
55cdf0e10cSrcweir ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
56cdf0e10cSrcweir OTHER DEALINGS IN THE SOFTWARE.
57cdf0e10cSrcweir ----------------------------------------------------------------------- */
58cdf0e10cSrcweir
59*bfa8fc87SHerbert Dürr #include "abi.hxx"
60cdf0e10cSrcweir
61cdf0e10cSrcweir #include <rtl/ustring.hxx>
62cdf0e10cSrcweir
63cdf0e10cSrcweir using namespace x86_64;
64cdf0e10cSrcweir
65cdf0e10cSrcweir typedef struct
66cdf0e10cSrcweir {
67cdf0e10cSrcweir /* Registers for argument passing. */
68cdf0e10cSrcweir long gpr[MAX_GPR_REGS];
69cdf0e10cSrcweir __int128_t sse[MAX_SSE_REGS];
70cdf0e10cSrcweir
71cdf0e10cSrcweir /* Stack space for arguments. */
72cdf0e10cSrcweir char argspace[0];
73cdf0e10cSrcweir } stackLayout;
74cdf0e10cSrcweir
75cdf0e10cSrcweir /* Register class used for passing given 64bit part of the argument.
76cdf0e10cSrcweir These represent classes as documented by the PS ABI, with the exception
77cdf0e10cSrcweir of SSESF, SSEDF classes, that are basically SSE class, just gcc will
78cdf0e10cSrcweir use SF or DFmode move instead of DImode to avoid reformating penalties.
79cdf0e10cSrcweir
80cdf0e10cSrcweir Similary we play games with INTEGERSI_CLASS to use cheaper SImode moves
81cdf0e10cSrcweir whenever possible (upper half does contain padding).
82cdf0e10cSrcweir */
83cdf0e10cSrcweir enum x86_64_reg_class
84cdf0e10cSrcweir {
85cdf0e10cSrcweir X86_64_NO_CLASS,
86cdf0e10cSrcweir X86_64_INTEGER_CLASS,
87cdf0e10cSrcweir X86_64_INTEGERSI_CLASS,
88cdf0e10cSrcweir X86_64_SSE_CLASS,
89cdf0e10cSrcweir X86_64_SSESF_CLASS,
90cdf0e10cSrcweir X86_64_SSEDF_CLASS,
91cdf0e10cSrcweir X86_64_SSEUP_CLASS,
92cdf0e10cSrcweir X86_64_X87_CLASS,
93cdf0e10cSrcweir X86_64_X87UP_CLASS,
94cdf0e10cSrcweir X86_64_MEMORY_CLASS
95cdf0e10cSrcweir };
96cdf0e10cSrcweir
97cdf0e10cSrcweir #define MAX_CLASSES 4
98cdf0e10cSrcweir
99cdf0e10cSrcweir /* x86-64 register passing implementation. See x86-64 ABI for details. Goal
100cdf0e10cSrcweir of this code is to classify each 8bytes of incoming argument by the register
101cdf0e10cSrcweir class and assign registers accordingly. */
102cdf0e10cSrcweir
103cdf0e10cSrcweir /* Return the union class of CLASS1 and CLASS2.
104cdf0e10cSrcweir See the x86-64 PS ABI for details. */
105cdf0e10cSrcweir
106cdf0e10cSrcweir static enum x86_64_reg_class
merge_classes(enum x86_64_reg_class class1,enum x86_64_reg_class class2)107cdf0e10cSrcweir merge_classes (enum x86_64_reg_class class1, enum x86_64_reg_class class2)
108cdf0e10cSrcweir {
109cdf0e10cSrcweir /* Rule #1: If both classes are equal, this is the resulting class. */
110cdf0e10cSrcweir if (class1 == class2)
111cdf0e10cSrcweir return class1;
112cdf0e10cSrcweir
113cdf0e10cSrcweir /* Rule #2: If one of the classes is NO_CLASS, the resulting class is
114cdf0e10cSrcweir the other class. */
115cdf0e10cSrcweir if (class1 == X86_64_NO_CLASS)
116cdf0e10cSrcweir return class2;
117cdf0e10cSrcweir if (class2 == X86_64_NO_CLASS)
118cdf0e10cSrcweir return class1;
119cdf0e10cSrcweir
120cdf0e10cSrcweir /* Rule #3: If one of the classes is MEMORY, the result is MEMORY. */
121cdf0e10cSrcweir if (class1 == X86_64_MEMORY_CLASS || class2 == X86_64_MEMORY_CLASS)
122cdf0e10cSrcweir return X86_64_MEMORY_CLASS;
123cdf0e10cSrcweir
124cdf0e10cSrcweir /* Rule #4: If one of the classes is INTEGER, the result is INTEGER. */
125cdf0e10cSrcweir if ((class1 == X86_64_INTEGERSI_CLASS && class2 == X86_64_SSESF_CLASS)
126cdf0e10cSrcweir || (class2 == X86_64_INTEGERSI_CLASS && class1 == X86_64_SSESF_CLASS))
127cdf0e10cSrcweir return X86_64_INTEGERSI_CLASS;
128cdf0e10cSrcweir if (class1 == X86_64_INTEGER_CLASS || class1 == X86_64_INTEGERSI_CLASS
129cdf0e10cSrcweir || class2 == X86_64_INTEGER_CLASS || class2 == X86_64_INTEGERSI_CLASS)
130cdf0e10cSrcweir return X86_64_INTEGER_CLASS;
131cdf0e10cSrcweir
132cdf0e10cSrcweir /* Rule #5: If one of the classes is X87 or X87UP class, MEMORY is used. */
133cdf0e10cSrcweir if (class1 == X86_64_X87_CLASS || class1 == X86_64_X87UP_CLASS
134cdf0e10cSrcweir || class2 == X86_64_X87_CLASS || class2 == X86_64_X87UP_CLASS)
135cdf0e10cSrcweir return X86_64_MEMORY_CLASS;
136cdf0e10cSrcweir
137cdf0e10cSrcweir /* Rule #6: Otherwise class SSE is used. */
138cdf0e10cSrcweir return X86_64_SSE_CLASS;
139cdf0e10cSrcweir }
140cdf0e10cSrcweir
141cdf0e10cSrcweir /* Classify the argument of type TYPE and mode MODE.
142cdf0e10cSrcweir CLASSES will be filled by the register class used to pass each word
143cdf0e10cSrcweir of the operand. The number of words is returned. In case the parameter
144cdf0e10cSrcweir should be passed in memory, 0 is returned. As a special case for zero
145cdf0e10cSrcweir sized containers, classes[0] will be NO_CLASS and 1 is returned.
146cdf0e10cSrcweir
147cdf0e10cSrcweir See the x86-64 PS ABI for details.
148cdf0e10cSrcweir */
149cdf0e10cSrcweir static int
classify_argument(typelib_TypeDescriptionReference * pTypeRef,enum x86_64_reg_class classes[],int byteOffset)150942d46e3SPedro Giffuni classify_argument( typelib_TypeDescriptionReference *pTypeRef, enum x86_64_reg_class classes[], int byteOffset )
151cdf0e10cSrcweir {
152cdf0e10cSrcweir switch ( pTypeRef->eTypeClass )
153cdf0e10cSrcweir {
154cdf0e10cSrcweir case typelib_TypeClass_VOID:
155cdf0e10cSrcweir classes[0] = X86_64_NO_CLASS;
156cdf0e10cSrcweir return 1;
157cdf0e10cSrcweir case typelib_TypeClass_CHAR:
158cdf0e10cSrcweir case typelib_TypeClass_BOOLEAN:
159cdf0e10cSrcweir case typelib_TypeClass_BYTE:
160cdf0e10cSrcweir case typelib_TypeClass_SHORT:
161cdf0e10cSrcweir case typelib_TypeClass_UNSIGNED_SHORT:
162cdf0e10cSrcweir case typelib_TypeClass_LONG:
163cdf0e10cSrcweir case typelib_TypeClass_UNSIGNED_LONG:
164cdf0e10cSrcweir case typelib_TypeClass_HYPER:
165cdf0e10cSrcweir case typelib_TypeClass_UNSIGNED_HYPER:
166cdf0e10cSrcweir case typelib_TypeClass_ENUM:
167942d46e3SPedro Giffuni if ( ( byteOffset % 8 + pTypeRef->pType->nSize ) <= 4 )
168cdf0e10cSrcweir classes[0] = X86_64_INTEGERSI_CLASS;
169cdf0e10cSrcweir else
170cdf0e10cSrcweir classes[0] = X86_64_INTEGER_CLASS;
171cdf0e10cSrcweir return 1;
172cdf0e10cSrcweir case typelib_TypeClass_FLOAT:
173942d46e3SPedro Giffuni if ( ( byteOffset % 8 ) == 0 )
174cdf0e10cSrcweir classes[0] = X86_64_SSESF_CLASS;
175cdf0e10cSrcweir else
176cdf0e10cSrcweir classes[0] = X86_64_SSE_CLASS;
177cdf0e10cSrcweir return 1;
178cdf0e10cSrcweir case typelib_TypeClass_DOUBLE:
179cdf0e10cSrcweir classes[0] = X86_64_SSEDF_CLASS;
180cdf0e10cSrcweir return 1;
181cdf0e10cSrcweir /*case LONGDOUBLE:
182cdf0e10cSrcweir classes[0] = X86_64_X87_CLASS;
183cdf0e10cSrcweir classes[1] = X86_64_X87UP_CLASS;
184cdf0e10cSrcweir return 2;*/
185cdf0e10cSrcweir case typelib_TypeClass_STRING:
186cdf0e10cSrcweir case typelib_TypeClass_TYPE:
187cdf0e10cSrcweir case typelib_TypeClass_ANY:
188cdf0e10cSrcweir case typelib_TypeClass_TYPEDEF:
189cdf0e10cSrcweir case typelib_TypeClass_UNION:
190cdf0e10cSrcweir case typelib_TypeClass_SEQUENCE:
191cdf0e10cSrcweir case typelib_TypeClass_ARRAY:
192cdf0e10cSrcweir case typelib_TypeClass_INTERFACE:
193cdf0e10cSrcweir return 0;
194cdf0e10cSrcweir case typelib_TypeClass_STRUCT:
195cdf0e10cSrcweir case typelib_TypeClass_EXCEPTION:
196cdf0e10cSrcweir {
197cdf0e10cSrcweir typelib_TypeDescription * pTypeDescr = 0;
198cdf0e10cSrcweir TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef );
199cdf0e10cSrcweir
200cdf0e10cSrcweir const int UNITS_PER_WORD = 8;
201cdf0e10cSrcweir int words = ( pTypeDescr->nSize + UNITS_PER_WORD - 1 ) / UNITS_PER_WORD;
202cdf0e10cSrcweir enum x86_64_reg_class subclasses[MAX_CLASSES];
203cdf0e10cSrcweir
204cdf0e10cSrcweir /* If the struct is larger than 16 bytes, pass it on the stack. */
205cdf0e10cSrcweir if ( pTypeDescr->nSize > 16 )
206cdf0e10cSrcweir {
207cdf0e10cSrcweir TYPELIB_DANGER_RELEASE( pTypeDescr );
208cdf0e10cSrcweir return 0;
209cdf0e10cSrcweir }
210cdf0e10cSrcweir
211cdf0e10cSrcweir for ( int i = 0; i < words; i++ )
212cdf0e10cSrcweir classes[i] = X86_64_NO_CLASS;
213cdf0e10cSrcweir
214cdf0e10cSrcweir const typelib_CompoundTypeDescription *pStruct = reinterpret_cast<const typelib_CompoundTypeDescription*>( pTypeDescr );
215cdf0e10cSrcweir
216cdf0e10cSrcweir /* Merge the fields of structure. */
217cdf0e10cSrcweir for ( sal_Int32 nMember = 0; nMember < pStruct->nMembers; ++nMember )
218cdf0e10cSrcweir {
219cdf0e10cSrcweir typelib_TypeDescriptionReference *pTypeInStruct = pStruct->ppTypeRefs[ nMember ];
220942d46e3SPedro Giffuni int offset = byteOffset + pStruct->pMemberOffsets[ nMember ];
221cdf0e10cSrcweir
222942d46e3SPedro Giffuni int num = classify_argument( pTypeInStruct, subclasses, offset );
223cdf0e10cSrcweir
224cdf0e10cSrcweir if ( num == 0 )
225cdf0e10cSrcweir {
226cdf0e10cSrcweir TYPELIB_DANGER_RELEASE( pTypeDescr );
227cdf0e10cSrcweir return 0;
228cdf0e10cSrcweir }
229cdf0e10cSrcweir
230cdf0e10cSrcweir for ( int i = 0; i < num; i++ )
231cdf0e10cSrcweir {
232942d46e3SPedro Giffuni int pos = offset / 8;
233cdf0e10cSrcweir classes[i + pos] = merge_classes( subclasses[i], classes[i + pos] );
234cdf0e10cSrcweir }
235cdf0e10cSrcweir }
236cdf0e10cSrcweir
237cdf0e10cSrcweir TYPELIB_DANGER_RELEASE( pTypeDescr );
238cdf0e10cSrcweir
239cdf0e10cSrcweir /* Final merger cleanup. */
240cdf0e10cSrcweir for ( int i = 0; i < words; i++ )
241cdf0e10cSrcweir {
242cdf0e10cSrcweir /* If one class is MEMORY, everything should be passed in
243cdf0e10cSrcweir memory. */
244cdf0e10cSrcweir if ( classes[i] == X86_64_MEMORY_CLASS )
245cdf0e10cSrcweir return 0;
246cdf0e10cSrcweir
247cdf0e10cSrcweir /* The X86_64_SSEUP_CLASS should be always preceded by
248cdf0e10cSrcweir X86_64_SSE_CLASS. */
249cdf0e10cSrcweir if ( classes[i] == X86_64_SSEUP_CLASS
250cdf0e10cSrcweir && ( i == 0 || classes[i - 1] != X86_64_SSE_CLASS ) )
251cdf0e10cSrcweir classes[i] = X86_64_SSE_CLASS;
252cdf0e10cSrcweir
253cdf0e10cSrcweir /* X86_64_X87UP_CLASS should be preceded by X86_64_X87_CLASS. */
254cdf0e10cSrcweir if ( classes[i] == X86_64_X87UP_CLASS
255cdf0e10cSrcweir && ( i == 0 || classes[i - 1] != X86_64_X87_CLASS ) )
256cdf0e10cSrcweir classes[i] = X86_64_SSE_CLASS;
257cdf0e10cSrcweir }
258cdf0e10cSrcweir return words;
259cdf0e10cSrcweir }
260cdf0e10cSrcweir
261cdf0e10cSrcweir default:
262cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 1
263cdf0e10cSrcweir OSL_TRACE( "Unhandled case: pType->eTypeClass == %d\n", pTypeRef->eTypeClass );
264cdf0e10cSrcweir #endif
265cdf0e10cSrcweir OSL_ASSERT(0);
266cdf0e10cSrcweir }
267cdf0e10cSrcweir return 0; /* Never reached. */
268cdf0e10cSrcweir }
269cdf0e10cSrcweir
270cdf0e10cSrcweir /* Examine the argument and return set number of register required in each
271cdf0e10cSrcweir class. Return 0 iff parameter should be passed in memory. */
examine_argument(typelib_TypeDescriptionReference * pTypeRef,bool bInReturn,int & nUsedGPR,int & nUsedSSE)272cdf0e10cSrcweir bool x86_64::examine_argument( typelib_TypeDescriptionReference *pTypeRef, bool bInReturn, int &nUsedGPR, int &nUsedSSE )
273cdf0e10cSrcweir {
274cdf0e10cSrcweir enum x86_64_reg_class classes[MAX_CLASSES];
275cdf0e10cSrcweir int n;
276cdf0e10cSrcweir
277942d46e3SPedro Giffuni n = classify_argument( pTypeRef, classes, 0 );
278cdf0e10cSrcweir
279cdf0e10cSrcweir if ( n == 0 )
280cdf0e10cSrcweir return false;
281cdf0e10cSrcweir
282cdf0e10cSrcweir nUsedGPR = 0;
283cdf0e10cSrcweir nUsedSSE = 0;
284cdf0e10cSrcweir for ( n--; n >= 0; n-- )
285cdf0e10cSrcweir switch ( classes[n] )
286cdf0e10cSrcweir {
287cdf0e10cSrcweir case X86_64_INTEGER_CLASS:
288cdf0e10cSrcweir case X86_64_INTEGERSI_CLASS:
289cdf0e10cSrcweir nUsedGPR++;
290cdf0e10cSrcweir break;
291cdf0e10cSrcweir case X86_64_SSE_CLASS:
292cdf0e10cSrcweir case X86_64_SSESF_CLASS:
293cdf0e10cSrcweir case X86_64_SSEDF_CLASS:
294cdf0e10cSrcweir nUsedSSE++;
295cdf0e10cSrcweir break;
296cdf0e10cSrcweir case X86_64_NO_CLASS:
297cdf0e10cSrcweir case X86_64_SSEUP_CLASS:
298cdf0e10cSrcweir break;
299cdf0e10cSrcweir case X86_64_X87_CLASS:
300cdf0e10cSrcweir case X86_64_X87UP_CLASS:
301cdf0e10cSrcweir if ( !bInReturn )
302cdf0e10cSrcweir return false;
303cdf0e10cSrcweir break;
304cdf0e10cSrcweir default:
305cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 1
306cdf0e10cSrcweir OSL_TRACE( "Unhandled case: classes[n] == %d\n", classes[n] );
307cdf0e10cSrcweir #endif
308cdf0e10cSrcweir OSL_ASSERT(0);
309cdf0e10cSrcweir }
310cdf0e10cSrcweir return true;
311cdf0e10cSrcweir }
312cdf0e10cSrcweir
return_in_hidden_param(typelib_TypeDescriptionReference * pTypeRef)313cdf0e10cSrcweir bool x86_64::return_in_hidden_param( typelib_TypeDescriptionReference *pTypeRef )
314cdf0e10cSrcweir {
315cdf0e10cSrcweir int g, s;
316cdf0e10cSrcweir
317cdf0e10cSrcweir return examine_argument( pTypeRef, true, g, s ) == 0;
318cdf0e10cSrcweir }
319cdf0e10cSrcweir
fill_struct(typelib_TypeDescriptionReference * pTypeRef,const sal_uInt64 * pGPR,const double * pSSE,void * pStruct)32081293574SPedro Giffuni void x86_64::fill_struct( typelib_TypeDescriptionReference *pTypeRef, const sal_uInt64 *pGPR, const double *pSSE, void *pStruct )
321cdf0e10cSrcweir {
322cdf0e10cSrcweir enum x86_64_reg_class classes[MAX_CLASSES];
323cdf0e10cSrcweir int n;
324cdf0e10cSrcweir
325942d46e3SPedro Giffuni n = classify_argument( pTypeRef, classes, 0 );
326cdf0e10cSrcweir
327cdf0e10cSrcweir sal_uInt64 *pStructAlign = reinterpret_cast<sal_uInt64 *>( pStruct );
328cdf0e10cSrcweir for ( n--; n >= 0; n-- )
329cdf0e10cSrcweir switch ( classes[n] )
330cdf0e10cSrcweir {
331cdf0e10cSrcweir case X86_64_INTEGER_CLASS:
332cdf0e10cSrcweir case X86_64_INTEGERSI_CLASS:
33381293574SPedro Giffuni *pStructAlign++ = *pGPR++;
334cdf0e10cSrcweir break;
335cdf0e10cSrcweir case X86_64_SSE_CLASS:
336cdf0e10cSrcweir case X86_64_SSESF_CLASS:
337cdf0e10cSrcweir case X86_64_SSEDF_CLASS:
33881293574SPedro Giffuni *pStructAlign++ = *reinterpret_cast<const sal_uInt64 *>( pSSE++ );
33981293574SPedro Giffuni break;
34081293574SPedro Giffuni default:
341cdf0e10cSrcweir break;
342cdf0e10cSrcweir }
343cdf0e10cSrcweir }
344cdf0e10cSrcweir
345cdf0e10cSrcweir #if 0
346cdf0e10cSrcweir
347cdf0e10cSrcweir /* Functions to load floats and double to an SSE register placeholder. */
348cdf0e10cSrcweir extern void float2sse (float, __int128_t *);
349cdf0e10cSrcweir extern void double2sse (double, __int128_t *);
350cdf0e10cSrcweir extern void floatfloat2sse (void *, __int128_t *);
351cdf0e10cSrcweir
352cdf0e10cSrcweir /* Functions to put the floats and doubles back. */
353cdf0e10cSrcweir extern float sse2float (__int128_t *);
354cdf0e10cSrcweir extern double sse2double (__int128_t *);
355cdf0e10cSrcweir extern void sse2floatfloat(__int128_t *, void *);
356cdf0e10cSrcweir
357cdf0e10cSrcweir /*@-exportheader@*/
358cdf0e10cSrcweir void
359cdf0e10cSrcweir ffi_prep_args (stackLayout *stack, extended_cif *ecif)
360cdf0e10cSrcweir /*@=exportheader@*/
361cdf0e10cSrcweir {
362cdf0e10cSrcweir int gprcount, ssecount, i, g, s;
363cdf0e10cSrcweir void **p_argv;
364cdf0e10cSrcweir void *argp = &stack->argspace;
365cdf0e10cSrcweir ffi_type **p_arg;
366cdf0e10cSrcweir
367cdf0e10cSrcweir /* First check if the return value should be passed in memory. If so,
368cdf0e10cSrcweir pass the pointer as the first argument. */
369cdf0e10cSrcweir gprcount = ssecount = 0;
370cdf0e10cSrcweir if (ecif->cif->rtype->type != FFI_TYPE_VOID
371cdf0e10cSrcweir && examine_argument (ecif->cif->rtype, 1, &g, &s) == 0)
372cdf0e10cSrcweir (void *)stack->gpr[gprcount++] = ecif->rvalue;
373cdf0e10cSrcweir
374cdf0e10cSrcweir for (i=ecif->cif->nargs, p_arg=ecif->cif->arg_types, p_argv = ecif->avalue;
375cdf0e10cSrcweir i!=0; i--, p_arg++, p_argv++)
376cdf0e10cSrcweir {
377cdf0e10cSrcweir int in_register = 0;
378cdf0e10cSrcweir
379cdf0e10cSrcweir switch ((*p_arg)->type)
380cdf0e10cSrcweir {
381cdf0e10cSrcweir case FFI_TYPE_SINT8:
382cdf0e10cSrcweir case FFI_TYPE_SINT16:
383cdf0e10cSrcweir case FFI_TYPE_SINT32:
384cdf0e10cSrcweir case FFI_TYPE_SINT64:
385cdf0e10cSrcweir case FFI_TYPE_UINT8:
386cdf0e10cSrcweir case FFI_TYPE_UINT16:
387cdf0e10cSrcweir case FFI_TYPE_UINT32:
388cdf0e10cSrcweir case FFI_TYPE_UINT64:
389cdf0e10cSrcweir case FFI_TYPE_POINTER:
390cdf0e10cSrcweir if (gprcount < MAX_GPR_REGS)
391cdf0e10cSrcweir {
392cdf0e10cSrcweir stack->gpr[gprcount] = 0;
393cdf0e10cSrcweir stack->gpr[gprcount++] = *(long long *)(*p_argv);
394cdf0e10cSrcweir in_register = 1;
395cdf0e10cSrcweir }
396cdf0e10cSrcweir break;
397cdf0e10cSrcweir
398cdf0e10cSrcweir case FFI_TYPE_FLOAT:
399cdf0e10cSrcweir if (ssecount < MAX_SSE_REGS)
400cdf0e10cSrcweir {
401cdf0e10cSrcweir float2sse (*(float *)(*p_argv), &stack->sse[ssecount++]);
402cdf0e10cSrcweir in_register = 1;
403cdf0e10cSrcweir }
404cdf0e10cSrcweir break;
405cdf0e10cSrcweir
406cdf0e10cSrcweir case FFI_TYPE_DOUBLE:
407cdf0e10cSrcweir if (ssecount < MAX_SSE_REGS)
408cdf0e10cSrcweir {
409cdf0e10cSrcweir double2sse (*(double *)(*p_argv), &stack->sse[ssecount++]);
410cdf0e10cSrcweir in_register = 1;
411cdf0e10cSrcweir }
412cdf0e10cSrcweir break;
413cdf0e10cSrcweir }
414cdf0e10cSrcweir
415cdf0e10cSrcweir if (in_register)
416cdf0e10cSrcweir continue;
417cdf0e10cSrcweir
418cdf0e10cSrcweir /* Either all places in registers where filled, or this is a
419cdf0e10cSrcweir type that potentially goes into a memory slot. */
420cdf0e10cSrcweir if (examine_argument (*p_arg, 0, &g, &s) == 0
421cdf0e10cSrcweir || gprcount + g > MAX_GPR_REGS || ssecount + s > MAX_SSE_REGS)
422cdf0e10cSrcweir {
423cdf0e10cSrcweir /* Pass this argument in memory. */
424cdf0e10cSrcweir argp = (void *)ALIGN(argp, (*p_arg)->alignment);
425cdf0e10cSrcweir memcpy (argp, *p_argv, (*p_arg)->size);
426cdf0e10cSrcweir argp += (*p_arg)->size;
427cdf0e10cSrcweir }
428cdf0e10cSrcweir else
429cdf0e10cSrcweir {
430cdf0e10cSrcweir /* All easy cases are eliminated. Now fire the big guns. */
431cdf0e10cSrcweir
432cdf0e10cSrcweir enum x86_64_reg_class classes[MAX_CLASSES];
433942d46e3SPedro Giffuni int j, num;
434cdf0e10cSrcweir void *a;
435cdf0e10cSrcweir
436942d46e3SPedro Giffuni num = classify_argument (*p_arg, classes, 0);
437cdf0e10cSrcweir for (j=0, a=*p_argv; j<num; j++, a+=8)
438cdf0e10cSrcweir {
439cdf0e10cSrcweir switch (classes[j])
440cdf0e10cSrcweir {
441cdf0e10cSrcweir case X86_64_INTEGER_CLASS:
442cdf0e10cSrcweir case X86_64_INTEGERSI_CLASS:
443cdf0e10cSrcweir stack->gpr[gprcount++] = *(long long *)a;
444cdf0e10cSrcweir break;
445cdf0e10cSrcweir case X86_64_SSE_CLASS:
446cdf0e10cSrcweir floatfloat2sse (a, &stack->sse[ssecount++]);
447cdf0e10cSrcweir break;
448cdf0e10cSrcweir case X86_64_SSESF_CLASS:
449cdf0e10cSrcweir float2sse (*(float *)a, &stack->sse[ssecount++]);
450cdf0e10cSrcweir break;
451cdf0e10cSrcweir case X86_64_SSEDF_CLASS:
452cdf0e10cSrcweir double2sse (*(double *)a, &stack->sse[ssecount++]);
453cdf0e10cSrcweir break;
454cdf0e10cSrcweir default:
455cdf0e10cSrcweir abort();
456cdf0e10cSrcweir }
457cdf0e10cSrcweir }
458cdf0e10cSrcweir }
459cdf0e10cSrcweir }
460cdf0e10cSrcweir }
461cdf0e10cSrcweir
462cdf0e10cSrcweir /* Perform machine dependent cif processing. */
463cdf0e10cSrcweir ffi_status
464cdf0e10cSrcweir ffi_prep_cif_machdep (ffi_cif *cif)
465cdf0e10cSrcweir {
466cdf0e10cSrcweir int gprcount, ssecount, i, g, s;
467cdf0e10cSrcweir
468cdf0e10cSrcweir gprcount = ssecount = 0;
469cdf0e10cSrcweir
470cdf0e10cSrcweir /* Reset the byte count. We handle this size estimation here. */
471cdf0e10cSrcweir cif->bytes = 0;
472cdf0e10cSrcweir
473cdf0e10cSrcweir /* If the return value should be passed in memory, pass the pointer
474cdf0e10cSrcweir as the first argument. The actual memory isn't allocated here. */
475cdf0e10cSrcweir if (cif->rtype->type != FFI_TYPE_VOID
476cdf0e10cSrcweir && examine_argument (cif->rtype, 1, &g, &s) == 0)
477cdf0e10cSrcweir gprcount = 1;
478cdf0e10cSrcweir
479cdf0e10cSrcweir /* Go over all arguments and determine the way they should be passed.
480cdf0e10cSrcweir If it's in a register and there is space for it, let that be so. If
481cdf0e10cSrcweir not, add it's size to the stack byte count. */
482cdf0e10cSrcweir for (i=0; i<cif->nargs; i++)
483cdf0e10cSrcweir {
484cdf0e10cSrcweir if (examine_argument (cif->arg_types[i], 0, &g, &s) == 0
485cdf0e10cSrcweir || gprcount + g > MAX_GPR_REGS || ssecount + s > MAX_SSE_REGS)
486cdf0e10cSrcweir {
487cdf0e10cSrcweir /* This is passed in memory. First align to the basic type. */
488cdf0e10cSrcweir cif->bytes = ALIGN(cif->bytes, cif->arg_types[i]->alignment);
489cdf0e10cSrcweir
490cdf0e10cSrcweir /* Stack arguments are *always* at least 8 byte aligned. */
491cdf0e10cSrcweir cif->bytes = ALIGN(cif->bytes, 8);
492cdf0e10cSrcweir
493cdf0e10cSrcweir /* Now add the size of this argument. */
494cdf0e10cSrcweir cif->bytes += cif->arg_types[i]->size;
495cdf0e10cSrcweir }
496cdf0e10cSrcweir else
497cdf0e10cSrcweir {
498cdf0e10cSrcweir gprcount += g;
499cdf0e10cSrcweir ssecount += s;
500cdf0e10cSrcweir }
501cdf0e10cSrcweir }
502cdf0e10cSrcweir
503cdf0e10cSrcweir /* Set the flag for the closures return. */
504cdf0e10cSrcweir switch (cif->rtype->type)
505cdf0e10cSrcweir {
506cdf0e10cSrcweir case FFI_TYPE_VOID:
507cdf0e10cSrcweir case FFI_TYPE_STRUCT:
508cdf0e10cSrcweir case FFI_TYPE_SINT64:
509cdf0e10cSrcweir case FFI_TYPE_FLOAT:
510cdf0e10cSrcweir case FFI_TYPE_DOUBLE:
511cdf0e10cSrcweir case FFI_TYPE_LONGDOUBLE:
512cdf0e10cSrcweir cif->flags = (unsigned) cif->rtype->type;
513cdf0e10cSrcweir break;
514cdf0e10cSrcweir
515cdf0e10cSrcweir case FFI_TYPE_UINT64:
516cdf0e10cSrcweir cif->flags = FFI_TYPE_SINT64;
517cdf0e10cSrcweir break;
518cdf0e10cSrcweir
519cdf0e10cSrcweir default:
520cdf0e10cSrcweir cif->flags = FFI_TYPE_INT;
521cdf0e10cSrcweir break;
522cdf0e10cSrcweir }
523cdf0e10cSrcweir
524cdf0e10cSrcweir return FFI_OK;
525cdf0e10cSrcweir }
526cdf0e10cSrcweir
527cdf0e10cSrcweir typedef struct
528cdf0e10cSrcweir {
529cdf0e10cSrcweir long gpr[2];
530cdf0e10cSrcweir __int128_t sse[2];
531cdf0e10cSrcweir long double st0;
532cdf0e10cSrcweir } return_value;
533cdf0e10cSrcweir
534cdf0e10cSrcweir //#endif
535cdf0e10cSrcweir
536cdf0e10cSrcweir void
537cdf0e10cSrcweir ffi_fill_return_value (return_value *rv, extended_cif *ecif)
538cdf0e10cSrcweir {
539cdf0e10cSrcweir enum x86_64_reg_class classes[MAX_CLASSES];
540cdf0e10cSrcweir int i = 0, num;
541cdf0e10cSrcweir long *gpr = rv->gpr;
542cdf0e10cSrcweir __int128_t *sse = rv->sse;
543cdf0e10cSrcweir signed char sc;
544cdf0e10cSrcweir signed short ss;
545cdf0e10cSrcweir
546cdf0e10cSrcweir /* This is needed because of the way x86-64 handles signed short
547cdf0e10cSrcweir integers. */
548cdf0e10cSrcweir switch (ecif->cif->rtype->type)
549cdf0e10cSrcweir {
550cdf0e10cSrcweir case FFI_TYPE_SINT8:
551cdf0e10cSrcweir sc = *(signed char *)gpr;
552cdf0e10cSrcweir *(long long *)ecif->rvalue = (long long)sc;
553cdf0e10cSrcweir return;
554cdf0e10cSrcweir case FFI_TYPE_SINT16:
555cdf0e10cSrcweir ss = *(signed short *)gpr;
556cdf0e10cSrcweir *(long long *)ecif->rvalue = (long long)ss;
557cdf0e10cSrcweir return;
558cdf0e10cSrcweir default:
559cdf0e10cSrcweir /* Just continue. */
560cdf0e10cSrcweir ;
561cdf0e10cSrcweir }
562cdf0e10cSrcweir
563942d46e3SPedro Giffuni num = classify_argument (ecif->cif->rtype, classes, 0);
564cdf0e10cSrcweir
565cdf0e10cSrcweir if (num == 0)
566cdf0e10cSrcweir /* Return in memory. */
567cdf0e10cSrcweir ecif->rvalue = (void *) rv->gpr[0];
568cdf0e10cSrcweir else if (num == 2 && classes[0] == X86_64_X87_CLASS &&
569cdf0e10cSrcweir classes[1] == X86_64_X87UP_CLASS)
570cdf0e10cSrcweir /* This is a long double (this is easiest to handle this way instead
571cdf0e10cSrcweir of an eightbyte at a time as in the loop below. */
572cdf0e10cSrcweir *((long double *)ecif->rvalue) = rv->st0;
573cdf0e10cSrcweir else
574cdf0e10cSrcweir {
575cdf0e10cSrcweir void *a;
576cdf0e10cSrcweir
577cdf0e10cSrcweir for (i=0, a=ecif->rvalue; i<num; i++, a+=8)
578cdf0e10cSrcweir {
579cdf0e10cSrcweir switch (classes[i])
580cdf0e10cSrcweir {
581cdf0e10cSrcweir case X86_64_INTEGER_CLASS:
582cdf0e10cSrcweir case X86_64_INTEGERSI_CLASS:
583cdf0e10cSrcweir *(long long *)a = *gpr;
584cdf0e10cSrcweir gpr++;
585cdf0e10cSrcweir break;
586cdf0e10cSrcweir case X86_64_SSE_CLASS:
587cdf0e10cSrcweir sse2floatfloat (sse++, a);
588cdf0e10cSrcweir break;
589cdf0e10cSrcweir case X86_64_SSESF_CLASS:
590cdf0e10cSrcweir *(float *)a = sse2float (sse++);
591cdf0e10cSrcweir break;
592cdf0e10cSrcweir case X86_64_SSEDF_CLASS:
593cdf0e10cSrcweir *(double *)a = sse2double (sse++);
594cdf0e10cSrcweir break;
595cdf0e10cSrcweir default:
596cdf0e10cSrcweir abort();
597cdf0e10cSrcweir }
598cdf0e10cSrcweir }
599cdf0e10cSrcweir }
600cdf0e10cSrcweir }
601cdf0e10cSrcweir
602cdf0e10cSrcweir //#if 0
603cdf0e10cSrcweir
604cdf0e10cSrcweir /*@-declundef@*/
605cdf0e10cSrcweir /*@-exportheader@*/
606cdf0e10cSrcweir extern void ffi_call_UNIX64(void (*)(stackLayout *, extended_cif *),
607cdf0e10cSrcweir void (*) (return_value *, extended_cif *),
608cdf0e10cSrcweir /*@out@*/ extended_cif *,
609cdf0e10cSrcweir unsigned, /*@out@*/ unsigned *, void (*fn)());
610cdf0e10cSrcweir /*@=declundef@*/
611cdf0e10cSrcweir /*@=exportheader@*/
612cdf0e10cSrcweir
613cdf0e10cSrcweir void ffi_call(/*@dependent@*/ ffi_cif *cif,
614cdf0e10cSrcweir void (*fn)(),
615cdf0e10cSrcweir /*@out@*/ void *rvalue,
616cdf0e10cSrcweir /*@dependent@*/ void **avalue)
617cdf0e10cSrcweir {
618cdf0e10cSrcweir extended_cif ecif;
619cdf0e10cSrcweir int dummy;
620cdf0e10cSrcweir
621cdf0e10cSrcweir ecif.cif = cif;
622cdf0e10cSrcweir ecif.avalue = avalue;
623cdf0e10cSrcweir
624cdf0e10cSrcweir /* If the return value is a struct and we don't have a return */
625cdf0e10cSrcweir /* value address then we need to make one */
626cdf0e10cSrcweir
627cdf0e10cSrcweir if ((rvalue == NULL) &&
628cdf0e10cSrcweir (examine_argument (cif->rtype, 1, &dummy, &dummy) == 0))
629cdf0e10cSrcweir {
630cdf0e10cSrcweir /*@-sysunrecog@*/
631cdf0e10cSrcweir ecif.rvalue = alloca(cif->rtype->size);
632cdf0e10cSrcweir /*@=sysunrecog@*/
633cdf0e10cSrcweir }
634cdf0e10cSrcweir else
635cdf0e10cSrcweir ecif.rvalue = rvalue;
636cdf0e10cSrcweir
637cdf0e10cSrcweir /* Stack must always be 16byte aligned. Make it so. */
638cdf0e10cSrcweir cif->bytes = ALIGN(cif->bytes, 16);
639cdf0e10cSrcweir
640cdf0e10cSrcweir switch (cif->abi)
641cdf0e10cSrcweir {
642cdf0e10cSrcweir case FFI_SYSV:
643cdf0e10cSrcweir /* Calling 32bit code from 64bit is not possible */
644cdf0e10cSrcweir FFI_ASSERT(0);
645cdf0e10cSrcweir break;
646cdf0e10cSrcweir
647cdf0e10cSrcweir case FFI_UNIX64:
648cdf0e10cSrcweir /*@-usedef@*/
649cdf0e10cSrcweir ffi_call_UNIX64 (ffi_prep_args, ffi_fill_return_value, &ecif,
650cdf0e10cSrcweir cif->bytes, ecif.rvalue, fn);
651cdf0e10cSrcweir /*@=usedef@*/
652cdf0e10cSrcweir break;
653cdf0e10cSrcweir
654cdf0e10cSrcweir default:
655cdf0e10cSrcweir FFI_ASSERT(0);
656cdf0e10cSrcweir break;
657cdf0e10cSrcweir }
658cdf0e10cSrcweir }
659cdf0e10cSrcweir
660cdf0e10cSrcweir extern void ffi_closure_UNIX64(void);
661cdf0e10cSrcweir
662cdf0e10cSrcweir ffi_status
663cdf0e10cSrcweir ffi_prep_closure (ffi_closure* closure,
664cdf0e10cSrcweir ffi_cif* cif,
665cdf0e10cSrcweir void (*fun)(ffi_cif*, void*, void**, void*),
666cdf0e10cSrcweir void *user_data)
667cdf0e10cSrcweir {
668cdf0e10cSrcweir volatile unsigned short *tramp;
669cdf0e10cSrcweir
670cdf0e10cSrcweir /* FFI_ASSERT (cif->abi == FFI_OSF); */
671cdf0e10cSrcweir
672cdf0e10cSrcweir tramp = (volatile unsigned short *) &closure->tramp[0];
673cdf0e10cSrcweir tramp[0] = 0xbb49; /* mov <code>, %r11 */
674cdf0e10cSrcweir tramp[5] = 0xba49; /* mov <data>, %r10 */
675cdf0e10cSrcweir tramp[10] = 0xff49; /* jmp *%r11 */
676cdf0e10cSrcweir tramp[11] = 0x00e3;
677cdf0e10cSrcweir *(void * volatile *) &tramp[1] = ffi_closure_UNIX64;
678cdf0e10cSrcweir *(void * volatile *) &tramp[6] = closure;
679cdf0e10cSrcweir
680cdf0e10cSrcweir closure->cif = cif;
681cdf0e10cSrcweir closure->fun = fun;
682cdf0e10cSrcweir closure->user_data = user_data;
683cdf0e10cSrcweir
684cdf0e10cSrcweir return FFI_OK;
685cdf0e10cSrcweir }
686cdf0e10cSrcweir
687cdf0e10cSrcweir int
688cdf0e10cSrcweir ffi_closure_UNIX64_inner(ffi_closure *closure, va_list l, void *rp)
689cdf0e10cSrcweir {
690cdf0e10cSrcweir ffi_cif *cif;
691cdf0e10cSrcweir void **avalue;
692cdf0e10cSrcweir ffi_type **arg_types;
693cdf0e10cSrcweir long i, avn, argn;
694cdf0e10cSrcweir
695cdf0e10cSrcweir cif = closure->cif;
696cdf0e10cSrcweir avalue = alloca(cif->nargs * sizeof(void *));
697cdf0e10cSrcweir
698cdf0e10cSrcweir argn = 0;
699cdf0e10cSrcweir
700cdf0e10cSrcweir i = 0;
701cdf0e10cSrcweir avn = cif->nargs;
702cdf0e10cSrcweir arg_types = cif->arg_types;
703cdf0e10cSrcweir
704cdf0e10cSrcweir /* Grab the addresses of the arguments from the stack frame. */
705cdf0e10cSrcweir while (i < avn)
706cdf0e10cSrcweir {
707cdf0e10cSrcweir switch (arg_types[i]->type)
708cdf0e10cSrcweir {
709cdf0e10cSrcweir case FFI_TYPE_SINT8:
710cdf0e10cSrcweir case FFI_TYPE_UINT8:
711cdf0e10cSrcweir case FFI_TYPE_SINT16:
712cdf0e10cSrcweir case FFI_TYPE_UINT16:
713cdf0e10cSrcweir case FFI_TYPE_SINT32:
714cdf0e10cSrcweir case FFI_TYPE_UINT32:
715cdf0e10cSrcweir case FFI_TYPE_SINT64:
716cdf0e10cSrcweir case FFI_TYPE_UINT64:
717cdf0e10cSrcweir case FFI_TYPE_POINTER:
718cdf0e10cSrcweir {
719cdf0e10cSrcweir if (l->gp_offset > 48-8)
720cdf0e10cSrcweir {
721cdf0e10cSrcweir avalue[i] = l->overflow_arg_area;
722cdf0e10cSrcweir l->overflow_arg_area = (char *)l->overflow_arg_area + 8;
723cdf0e10cSrcweir }
724cdf0e10cSrcweir else
725cdf0e10cSrcweir {
726cdf0e10cSrcweir avalue[i] = (char *)l->reg_save_area + l->gp_offset;
727cdf0e10cSrcweir l->gp_offset += 8;
728cdf0e10cSrcweir }
729cdf0e10cSrcweir }
730cdf0e10cSrcweir break;
731cdf0e10cSrcweir
732cdf0e10cSrcweir case FFI_TYPE_STRUCT:
733cdf0e10cSrcweir /* FIXME */
734cdf0e10cSrcweir FFI_ASSERT(0);
735cdf0e10cSrcweir break;
736cdf0e10cSrcweir
737cdf0e10cSrcweir case FFI_TYPE_DOUBLE:
738cdf0e10cSrcweir {
739cdf0e10cSrcweir if (l->fp_offset > 176-16)
740cdf0e10cSrcweir {
741cdf0e10cSrcweir avalue[i] = l->overflow_arg_area;
742cdf0e10cSrcweir l->overflow_arg_area = (char *)l->overflow_arg_area + 8;
743cdf0e10cSrcweir }
744cdf0e10cSrcweir else
745cdf0e10cSrcweir {
746cdf0e10cSrcweir avalue[i] = (char *)l->reg_save_area + l->fp_offset;
747cdf0e10cSrcweir l->fp_offset += 16;
748cdf0e10cSrcweir }
749cdf0e10cSrcweir }
750cdf0e10cSrcweir #if DEBUG_FFI
751cdf0e10cSrcweir fprintf (stderr, "double arg %d = %g\n", i, *(double *)avalue[i]);
752cdf0e10cSrcweir #endif
753cdf0e10cSrcweir break;
754cdf0e10cSrcweir
755cdf0e10cSrcweir case FFI_TYPE_FLOAT:
756cdf0e10cSrcweir {
757cdf0e10cSrcweir if (l->fp_offset > 176-16)
758cdf0e10cSrcweir {
759cdf0e10cSrcweir avalue[i] = l->overflow_arg_area;
760cdf0e10cSrcweir l->overflow_arg_area = (char *)l->overflow_arg_area + 8;
761cdf0e10cSrcweir }
762cdf0e10cSrcweir else
763cdf0e10cSrcweir {
764cdf0e10cSrcweir avalue[i] = (char *)l->reg_save_area + l->fp_offset;
765cdf0e10cSrcweir l->fp_offset += 16;
766cdf0e10cSrcweir }
767cdf0e10cSrcweir }
768cdf0e10cSrcweir #if DEBUG_FFI
769cdf0e10cSrcweir fprintf (stderr, "float arg %d = %g\n", i, *(float *)avalue[i]);
770cdf0e10cSrcweir #endif
771cdf0e10cSrcweir break;
772cdf0e10cSrcweir
773cdf0e10cSrcweir default:
774cdf0e10cSrcweir FFI_ASSERT(0);
775cdf0e10cSrcweir }
776cdf0e10cSrcweir
777cdf0e10cSrcweir argn += ALIGN(arg_types[i]->size, SIZEOF_ARG) / SIZEOF_ARG;
778cdf0e10cSrcweir i++;
779cdf0e10cSrcweir }
780cdf0e10cSrcweir
781cdf0e10cSrcweir /* Invoke the closure. */
782cdf0e10cSrcweir (closure->fun) (cif, rp, avalue, closure->user_data);
783cdf0e10cSrcweir
784cdf0e10cSrcweir /* FIXME: Structs not supported. */
785cdf0e10cSrcweir FFI_ASSERT(cif->rtype->type != FFI_TYPE_STRUCT);
786cdf0e10cSrcweir
787cdf0e10cSrcweir /* Tell ffi_closure_UNIX64 how to perform return type promotions. */
788cdf0e10cSrcweir
789cdf0e10cSrcweir return cif->rtype->type;
790cdf0e10cSrcweir }
791cdf0e10cSrcweir
792cdf0e10cSrcweir #endif
793