1 /* ----------------------------------------------------------------------- 2 raw_api.c - Copyright (c) 1999, 2008 Red Hat, Inc. 3 4 Author: Kresten Krab Thorup <krab@gnu.org> 5 6 Permission is hereby granted, free of charge, to any person obtaining 7 a copy of this software and associated documentation files (the 8 ``Software''), to deal in the Software without restriction, including 9 without limitation the rights to use, copy, modify, merge, publish, 10 distribute, sublicense, and/or sell copies of the Software, and to 11 permit persons to whom the Software is furnished to do so, subject to 12 the following conditions: 13 14 The above copyright notice and this permission notice shall be included 15 in all copies or substantial portions of the Software. 16 17 THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, 18 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 19 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 20 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 21 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 22 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 23 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 24 DEALINGS IN THE SOFTWARE. 25 ----------------------------------------------------------------------- */ 26 27 /* This file defines generic functions for use with the raw api. */ 28 29 #include <ffi.h> 30 #include <ffi_common.h> 31 32 #if !FFI_NO_RAW_API 33 34 size_t 35 ffi_raw_size (ffi_cif *cif) 36 { 37 size_t result = 0; 38 int i; 39 40 ffi_type **at = cif->arg_types; 41 42 for (i = cif->nargs-1; i >= 0; i--, at++) 43 { 44 #if !FFI_NO_STRUCTS 45 if ((*at)->type == FFI_TYPE_STRUCT) 46 result += ALIGN (sizeof (void*), FFI_SIZEOF_ARG); 47 else 48 #endif 49 result += ALIGN ((*at)->size, FFI_SIZEOF_ARG); 50 } 51 52 return result; 53 } 54 55 56 void 57 ffi_raw_to_ptrarray (ffi_cif *cif, ffi_raw *raw, void **args) 58 { 59 unsigned i; 60 ffi_type **tp = cif->arg_types; 61 62 #if WORDS_BIGENDIAN 63 64 for (i = 0; i < cif->nargs; i++, tp++, args++) 65 { 66 switch ((*tp)->type) 67 { 68 case FFI_TYPE_UINT8: 69 case FFI_TYPE_SINT8: 70 *args = (void*) ((char*)(raw++) + FFI_SIZEOF_ARG - 1); 71 break; 72 73 case FFI_TYPE_UINT16: 74 case FFI_TYPE_SINT16: 75 *args = (void*) ((char*)(raw++) + FFI_SIZEOF_ARG - 2); 76 break; 77 78 #if FFI_SIZEOF_ARG >= 4 79 case FFI_TYPE_UINT32: 80 case FFI_TYPE_SINT32: 81 *args = (void*) ((char*)(raw++) + FFI_SIZEOF_ARG - 4); 82 break; 83 #endif 84 85 #if !FFI_NO_STRUCTS 86 case FFI_TYPE_STRUCT: 87 *args = (raw++)->ptr; 88 break; 89 #endif 90 91 case FFI_TYPE_COMPLEX: 92 *args = (raw++)->ptr; 93 break; 94 95 case FFI_TYPE_POINTER: 96 *args = (void*) &(raw++)->ptr; 97 break; 98 99 default: 100 *args = raw; 101 raw += ALIGN ((*tp)->size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG; 102 } 103 } 104 105 #else /* WORDS_BIGENDIAN */ 106 107 #if !PDP 108 109 /* then assume little endian */ 110 for (i = 0; i < cif->nargs; i++, tp++, args++) 111 { 112 #if !FFI_NO_STRUCTS 113 if ((*tp)->type == FFI_TYPE_STRUCT) 114 { 115 *args = (raw++)->ptr; 116 } 117 else 118 #endif 119 if ((*tp)->type == FFI_TYPE_COMPLEX) 120 { 121 *args = (raw++)->ptr; 122 } 123 else 124 { 125 *args = (void*) raw; 126 raw += ALIGN ((*tp)->size, sizeof (void*)) / sizeof (void*); 127 } 128 } 129 130 #else 131 #error "pdp endian not supported" 132 #endif /* ! PDP */ 133 134 #endif /* WORDS_BIGENDIAN */ 135 } 136 137 void 138 ffi_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_raw *raw) 139 { 140 unsigned i; 141 ffi_type **tp = cif->arg_types; 142 143 for (i = 0; i < cif->nargs; i++, tp++, args++) 144 { 145 switch ((*tp)->type) 146 { 147 case FFI_TYPE_UINT8: 148 (raw++)->uint = *(UINT8*) (*args); 149 break; 150 151 case FFI_TYPE_SINT8: 152 (raw++)->sint = *(SINT8*) (*args); 153 break; 154 155 case FFI_TYPE_UINT16: 156 (raw++)->uint = *(UINT16*) (*args); 157 break; 158 159 case FFI_TYPE_SINT16: 160 (raw++)->sint = *(SINT16*) (*args); 161 break; 162 163 #if FFI_SIZEOF_ARG >= 4 164 case FFI_TYPE_UINT32: 165 (raw++)->uint = *(UINT32*) (*args); 166 break; 167 168 case FFI_TYPE_SINT32: 169 (raw++)->sint = *(SINT32*) (*args); 170 break; 171 #endif 172 173 #if !FFI_NO_STRUCTS 174 case FFI_TYPE_STRUCT: 175 (raw++)->ptr = *args; 176 break; 177 #endif 178 179 case FFI_TYPE_COMPLEX: 180 (raw++)->ptr = *args; 181 break; 182 183 case FFI_TYPE_POINTER: 184 (raw++)->ptr = **(void***) args; 185 break; 186 187 default: 188 memcpy ((void*) raw->data, (void*)*args, (*tp)->size); 189 raw += ALIGN ((*tp)->size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG; 190 } 191 } 192 } 193 194 #if !FFI_NATIVE_RAW_API 195 196 197 /* This is a generic definition of ffi_raw_call, to be used if the 198 * native system does not provide a machine-specific implementation. 199 * Having this, allows code to be written for the raw API, without 200 * the need for system-specific code to handle input in that format; 201 * these following couple of functions will handle the translation forth 202 * and back automatically. */ 203 204 void ffi_raw_call (ffi_cif *cif, void (*fn)(void), void *rvalue, ffi_raw *raw) 205 { 206 void **avalue = (void**) alloca (cif->nargs * sizeof (void*)); 207 ffi_raw_to_ptrarray (cif, raw, avalue); 208 ffi_call (cif, fn, rvalue, avalue); 209 } 210 211 #if FFI_CLOSURES /* base system provides closures */ 212 213 static void 214 ffi_translate_args (ffi_cif *cif, void *rvalue, 215 void **avalue, void *user_data) 216 { 217 ffi_raw *raw = (ffi_raw*)alloca (ffi_raw_size (cif)); 218 ffi_raw_closure *cl = (ffi_raw_closure*)user_data; 219 220 ffi_ptrarray_to_raw (cif, avalue, raw); 221 (*cl->fun) (cif, rvalue, raw, cl->user_data); 222 } 223 224 ffi_status 225 ffi_prep_raw_closure_loc (ffi_raw_closure* cl, 226 ffi_cif *cif, 227 void (*fun)(ffi_cif*,void*,ffi_raw*,void*), 228 void *user_data, 229 void *codeloc) 230 { 231 ffi_status status; 232 233 status = ffi_prep_closure_loc ((ffi_closure*) cl, 234 cif, 235 &ffi_translate_args, 236 codeloc, 237 codeloc); 238 if (status == FFI_OK) 239 { 240 cl->fun = fun; 241 cl->user_data = user_data; 242 } 243 244 return status; 245 } 246 247 #endif /* FFI_CLOSURES */ 248 #endif /* !FFI_NATIVE_RAW_API */ 249 250 #if FFI_CLOSURES 251 252 /* Again, here is the generic version of ffi_prep_raw_closure, which 253 * will install an intermediate "hub" for translation of arguments from 254 * the pointer-array format, to the raw format */ 255 256 ffi_status 257 ffi_prep_raw_closure (ffi_raw_closure* cl, 258 ffi_cif *cif, 259 void (*fun)(ffi_cif*,void*,ffi_raw*,void*), 260 void *user_data) 261 { 262 return ffi_prep_raw_closure_loc (cl, cif, fun, user_data, cl); 263 } 264 265 #endif /* FFI_CLOSURES */ 266 267 #endif /* !FFI_NO_RAW_API */