1 : /* -----------------------------------------------------------------------
2 : prep_cif.c - Copyright (c) 1996, 1998, 2007 Red Hat, Inc.
3 :
4 : Permission is hereby granted, free of charge, to any person obtaining
5 : a copy of this software and associated documentation files (the
6 : ``Software''), to deal in the Software without restriction, including
7 : without limitation the rights to use, copy, modify, merge, publish,
8 : distribute, sublicense, and/or sell copies of the Software, and to
9 : permit persons to whom the Software is furnished to do so, subject to
10 : the following conditions:
11 :
12 : The above copyright notice and this permission notice shall be included
13 : in all copies or substantial portions of the Software.
14 :
15 : THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
16 : EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 : MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 : NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
19 : HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
20 : WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 : OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 : DEALINGS IN THE SOFTWARE.
23 : ----------------------------------------------------------------------- */
24 :
25 : #include <ffi.h>
26 : #include <ffi_common.h>
27 : #include <stdlib.h>
28 :
29 : /* Round up to FFI_SIZEOF_ARG. */
30 :
31 : #define STACK_ARG_SIZE(x) ALIGN(x, FFI_SIZEOF_ARG)
32 :
33 : /* Perform machine independent initialization of aggregate type
34 : specifications. */
35 :
36 0 : static ffi_status initialize_aggregate(ffi_type *arg)
37 : {
38 : ffi_type **ptr;
39 :
40 0 : FFI_ASSERT(arg != NULL);
41 :
42 0 : FFI_ASSERT(arg->elements != NULL);
43 0 : FFI_ASSERT(arg->size == 0);
44 0 : FFI_ASSERT(arg->alignment == 0);
45 :
46 0 : ptr = &(arg->elements[0]);
47 :
48 0 : while ((*ptr) != NULL)
49 : {
50 0 : if (((*ptr)->size == 0) && (initialize_aggregate((*ptr)) != FFI_OK))
51 0 : return FFI_BAD_TYPEDEF;
52 :
53 : /* Perform a sanity check on the argument type */
54 0 : FFI_ASSERT_VALID_TYPE(*ptr);
55 :
56 0 : arg->size = ALIGN(arg->size, (*ptr)->alignment);
57 0 : arg->size += (*ptr)->size;
58 :
59 0 : arg->alignment = (arg->alignment > (*ptr)->alignment) ?
60 0 : arg->alignment : (*ptr)->alignment;
61 :
62 0 : ptr++;
63 : }
64 :
65 : /* Structure size includes tail padding. This is important for
66 : structures that fit in one register on ABIs like the PowerPC64
67 : Linux ABI that right justify small structs in a register.
68 : It's also needed for nested structure layout, for example
69 : struct A { long a; char b; }; struct B { struct A x; char y; };
70 : should find y at an offset of 2*sizeof(long) and result in a
71 : total size of 3*sizeof(long). */
72 0 : arg->size = ALIGN (arg->size, arg->alignment);
73 :
74 0 : if (arg->size == 0)
75 0 : return FFI_BAD_TYPEDEF;
76 : else
77 0 : return FFI_OK;
78 : }
79 :
80 : #ifndef __CRIS__
81 : /* The CRIS ABI specifies structure elements to have byte
82 : alignment only, so it completely overrides this functions,
83 : which assumes "natural" alignment and padding. */
84 :
85 : /* Perform machine independent ffi_cif preparation, then call
86 : machine dependent routine. */
87 :
88 0 : ffi_status ffi_prep_cif(ffi_cif *cif, ffi_abi abi, unsigned int nargs,
89 : ffi_type *rtype, ffi_type **atypes)
90 : {
91 0 : unsigned bytes = 0;
92 : unsigned int i;
93 : ffi_type **ptr;
94 :
95 0 : FFI_ASSERT(cif != NULL);
96 0 : FFI_ASSERT(abi > FFI_FIRST_ABI && abi < FFI_LAST_ABI);
97 :
98 0 : cif->abi = abi;
99 0 : cif->arg_types = atypes;
100 0 : cif->nargs = nargs;
101 0 : cif->rtype = rtype;
102 :
103 0 : cif->flags = 0;
104 :
105 : /* Initialize the return type if necessary */
106 0 : if ((cif->rtype->size == 0) && (initialize_aggregate(cif->rtype) != FFI_OK))
107 0 : return FFI_BAD_TYPEDEF;
108 :
109 : /* Perform a sanity check on the return type */
110 0 : FFI_ASSERT_VALID_TYPE(cif->rtype);
111 :
112 : /* x86, x86-64 and s390 stack space allocation is handled in prep_machdep. */
113 : #if !defined M68K && !defined X86_ANY && !defined S390 && !defined PA
114 : /* Make space for the return structure pointer */
115 : if (cif->rtype->type == FFI_TYPE_STRUCT
116 : #ifdef SPARC
117 : && (cif->abi != FFI_V9 || cif->rtype->size > 32)
118 : #endif
119 : )
120 : bytes = STACK_ARG_SIZE(sizeof(void*));
121 : #endif
122 :
123 0 : for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
124 : {
125 :
126 : /* Initialize any uninitialized aggregate type definitions */
127 0 : if (((*ptr)->size == 0) && (initialize_aggregate((*ptr)) != FFI_OK))
128 0 : return FFI_BAD_TYPEDEF;
129 :
130 : /* Perform a sanity check on the argument type, do this
131 : check after the initialization. */
132 0 : FFI_ASSERT_VALID_TYPE(*ptr);
133 :
134 : #if !defined X86_ANY && !defined S390 && !defined PA
135 : #ifdef SPARC
136 : if (((*ptr)->type == FFI_TYPE_STRUCT
137 : && ((*ptr)->size > 16 || cif->abi != FFI_V9))
138 : || ((*ptr)->type == FFI_TYPE_LONGDOUBLE
139 : && cif->abi != FFI_V9))
140 : bytes += sizeof(void*);
141 : else
142 : #endif
143 : {
144 : /* Add any padding if necessary */
145 : if (((*ptr)->alignment - 1) & bytes)
146 : bytes = ALIGN(bytes, (*ptr)->alignment);
147 :
148 : bytes += STACK_ARG_SIZE((*ptr)->size);
149 : }
150 : #endif
151 : }
152 :
153 0 : cif->bytes = bytes;
154 :
155 : /* Perform machine dependent cif processing */
156 0 : return ffi_prep_cif_machdep(cif);
157 : }
158 : #endif /* not __CRIS__ */
159 :
160 : #if FFI_CLOSURES
161 :
162 : ffi_status
163 0 : ffi_prep_closure (ffi_closure* closure,
164 : ffi_cif* cif,
165 : void (*fun)(ffi_cif*,void*,void**,void*),
166 : void *user_data)
167 : {
168 0 : return ffi_prep_closure_loc (closure, cif, fun, user_data, closure);
169 : }
170 :
171 : #endif
|