1 /* ----------------------------------------------------------------------- 2 prep_cif.c - Copyright (c) 2011, 2012 Anthony Green 3 Copyright (c) 1996, 1998, 2007 Red Hat, Inc. 4 5 Permission is hereby granted, free of charge, to any person obtaining 6 a copy of this software and associated documentation files (the 7 ``Software''), to deal in the Software without restriction, including 8 without limitation the rights to use, copy, modify, merge, publish, 9 distribute, sublicense, and/or sell copies of the Software, and to 10 permit persons to whom the Software is furnished to do so, subject to 11 the following conditions: 12 13 The above copyright notice and this permission notice shall be included 14 in all copies or substantial portions of the Software. 15 16 THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, 17 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 18 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 19 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 20 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 21 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 23 DEALINGS IN THE SOFTWARE. 24 ----------------------------------------------------------------------- */ 25 26 #include <ffi.h> 27 #include <ffi_common.h> 28 #include <stdlib.h> 29 30 /* Round up to FFI_SIZEOF_ARG. */ 31 32 #define STACK_ARG_SIZE(x) ALIGN(x, FFI_SIZEOF_ARG) 33 34 /* Perform machine independent initialization of aggregate type 35 specifications. */ 36 37 static ffi_status initialize_aggregate(ffi_type *arg) 38 { 39 ffi_type **ptr; 40 41 if (UNLIKELY(arg == NULL || arg->elements == NULL)) 42 return FFI_BAD_TYPEDEF; 43 44 arg->size = 0; 45 arg->alignment = 0; 46 47 ptr = &(arg->elements[0]); 48 49 if (UNLIKELY(ptr == 0)) 50 return FFI_BAD_TYPEDEF; 51 52 while ((*ptr) != NULL) 53 { 54 if (UNLIKELY(((*ptr)->size == 0) 55 && (initialize_aggregate((*ptr)) != FFI_OK))) 56 return FFI_BAD_TYPEDEF; 57 58 /* Perform a sanity check on the argument type */ 59 FFI_ASSERT_VALID_TYPE(*ptr); 60 61 arg->size = ALIGN(arg->size, (*ptr)->alignment); 62 arg->size += (*ptr)->size; 63 64 arg->alignment = (arg->alignment > (*ptr)->alignment) ? 65 arg->alignment : (*ptr)->alignment; 66 67 ptr++; 68 } 69 70 /* Structure size includes tail padding. This is important for 71 structures that fit in one register on ABIs like the PowerPC64 72 Linux ABI that right justify small structs in a register. 73 It's also needed for nested structure layout, for example 74 struct A { long a; char b; }; struct B { struct A x; char y; }; 75 should find y at an offset of 2*sizeof(long) and result in a 76 total size of 3*sizeof(long). */ 77 arg->size = ALIGN (arg->size, arg->alignment); 78 79 /* On some targets, the ABI defines that structures have an additional 80 alignment beyond the "natural" one based on their elements. */ 81 #ifdef FFI_AGGREGATE_ALIGNMENT 82 if (FFI_AGGREGATE_ALIGNMENT > arg->alignment) 83 arg->alignment = FFI_AGGREGATE_ALIGNMENT; 84 #endif 85 86 if (arg->size == 0) 87 return FFI_BAD_TYPEDEF; 88 else 89 return FFI_OK; 90 } 91 92 #ifndef __CRIS__ 93 /* The CRIS ABI specifies structure elements to have byte 94 alignment only, so it completely overrides this functions, 95 which assumes "natural" alignment and padding. */ 96 97 /* Perform machine independent ffi_cif preparation, then call 98 machine dependent routine. */ 99 100 /* For non variadic functions isvariadic should be 0 and 101 nfixedargs==ntotalargs. 102 103 For variadic calls, isvariadic should be 1 and nfixedargs 104 and ntotalargs set as appropriate. nfixedargs must always be >=1 */ 105 106 107 ffi_status FFI_HIDDEN ffi_prep_cif_core(ffi_cif *cif, ffi_abi abi, 108 unsigned int isvariadic, 109 unsigned int nfixedargs, 110 unsigned int ntotalargs, 111 ffi_type *rtype, ffi_type **atypes) 112 { 113 unsigned bytes = 0; 114 unsigned int i; 115 ffi_type **ptr; 116 117 FFI_ASSERT(cif != NULL); 118 FFI_ASSERT((!isvariadic) || (nfixedargs >= 1)); 119 FFI_ASSERT(nfixedargs <= ntotalargs); 120 121 if (! (abi > FFI_FIRST_ABI && abi < FFI_LAST_ABI)) 122 return FFI_BAD_ABI; 123 124 cif->abi = abi; 125 cif->arg_types = atypes; 126 cif->nargs = ntotalargs; 127 cif->rtype = rtype; 128 129 cif->flags = 0; 130 131 #if HAVE_LONG_DOUBLE_VARIANT 132 ffi_prep_types (abi); 133 #endif 134 135 /* Initialize the return type if necessary */ 136 if ((cif->rtype->size == 0) && (initialize_aggregate(cif->rtype) != FFI_OK)) 137 return FFI_BAD_TYPEDEF; 138 139 #ifndef FFI_TARGET_HAS_COMPLEX_TYPE 140 if (rtype->type == FFI_TYPE_COMPLEX) 141 abort(); 142 #endif 143 /* Perform a sanity check on the return type */ 144 FFI_ASSERT_VALID_TYPE(cif->rtype); 145 146 /* x86, x86-64 and s390 stack space allocation is handled in prep_machdep. */ 147 #if !defined FFI_TARGET_SPECIFIC_STACK_SPACE_ALLOCATION 148 /* Make space for the return structure pointer */ 149 if (cif->rtype->type == FFI_TYPE_STRUCT 150 #ifdef SPARC 151 && (cif->abi != FFI_V9 || cif->rtype->size > 32) 152 #endif 153 #ifdef TILE 154 && (cif->rtype->size > 10 * FFI_SIZEOF_ARG) 155 #endif 156 #ifdef XTENSA 157 && (cif->rtype->size > 16) 158 #endif 159 #ifdef NIOS2 160 && (cif->rtype->size > 8) 161 #endif 162 ) 163 bytes = STACK_ARG_SIZE(sizeof(void*)); 164 #endif 165 166 for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++) 167 { 168 169 /* Initialize any uninitialized aggregate type definitions */ 170 if (((*ptr)->size == 0) && (initialize_aggregate((*ptr)) != FFI_OK)) 171 return FFI_BAD_TYPEDEF; 172 173 #ifndef FFI_TARGET_HAS_COMPLEX_TYPE 174 if ((*ptr)->type == FFI_TYPE_COMPLEX) 175 abort(); 176 #endif 177 /* Perform a sanity check on the argument type, do this 178 check after the initialization. */ 179 FFI_ASSERT_VALID_TYPE(*ptr); 180 181 #if !defined FFI_TARGET_SPECIFIC_STACK_SPACE_ALLOCATION 182 #ifdef SPARC 183 if (((*ptr)->type == FFI_TYPE_STRUCT 184 && ((*ptr)->size > 16 || cif->abi != FFI_V9)) 185 || ((*ptr)->type == FFI_TYPE_LONGDOUBLE 186 && cif->abi != FFI_V9)) 187 bytes += sizeof(void*); 188 else 189 #endif 190 { 191 /* Add any padding if necessary */ 192 if (((*ptr)->alignment - 1) & bytes) 193 bytes = (unsigned)ALIGN(bytes, (*ptr)->alignment); 194 195 #ifdef TILE 196 if (bytes < 10 * FFI_SIZEOF_ARG && 197 bytes + STACK_ARG_SIZE((*ptr)->size) > 10 * FFI_SIZEOF_ARG) 198 { 199 /* An argument is never split between the 10 parameter 200 registers and the stack. */ 201 bytes = 10 * FFI_SIZEOF_ARG; 202 } 203 #endif 204 #ifdef XTENSA 205 if (bytes <= 6*4 && bytes + STACK_ARG_SIZE((*ptr)->size) > 6*4) 206 bytes = 6*4; 207 #endif 208 209 bytes += STACK_ARG_SIZE((*ptr)->size); 210 } 211 #endif 212 } 213 214 cif->bytes = bytes; 215 216 /* Perform machine dependent cif processing */ 217 #ifdef FFI_TARGET_SPECIFIC_VARIADIC 218 if (isvariadic) 219 return ffi_prep_cif_machdep_var(cif, nfixedargs, ntotalargs); 220 #endif 221 222 return ffi_prep_cif_machdep(cif); 223 } 224 #endif /* not __CRIS__ */ 225 226 ffi_status ffi_prep_cif(ffi_cif *cif, ffi_abi abi, unsigned int nargs, 227 ffi_type *rtype, ffi_type **atypes) 228 { 229 return ffi_prep_cif_core(cif, abi, 0, nargs, nargs, rtype, atypes); 230 } 231 232 ffi_status ffi_prep_cif_var(ffi_cif *cif, 233 ffi_abi abi, 234 unsigned int nfixedargs, 235 unsigned int ntotalargs, 236 ffi_type *rtype, 237 ffi_type **atypes) 238 { 239 return ffi_prep_cif_core(cif, abi, 1, nfixedargs, ntotalargs, rtype, atypes); 240 } 241 242 #if FFI_CLOSURES 243 244 ffi_status 245 ffi_prep_closure (ffi_closure* closure, 246 ffi_cif* cif, 247 void (*fun)(ffi_cif*,void*,void**,void*), 248 void *user_data) 249 { 250 return ffi_prep_closure_loc (closure, cif, fun, user_data, closure); 251 } 252 253 #endif