modffi.c 12.6 KB
Newer Older
1
2
3
4
5
6
#include <assert.h>
#include <string.h>
#include <errno.h>
#include <dlfcn.h>
#include <ffi.h>

7
#include "mpconfig.h"
8
9
10
11
12
#include "nlr.h"
#include "misc.h"
#include "qstr.h"
#include "obj.h"
#include "runtime.h"
13
#include "binary.h"
14

15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/*
 * modffi uses character codes to encode a value type, based on "struct"
 * module type codes, with some extensions and overridings.
 *
 * Extra/overridden typecodes:
 *      v - void, can be used only as return type
 *      P - const void*, pointer to read-only memory
 *      p - void*, meaning pointer to a writable memory (note that this
 *          clashes with struct's "p" as "Pascal string").
 *      s - as argument, the same as "p", as return value, causes string
 *          to be allocated and returned, instead of pointer value.
 *
 * Note: all constraint specified by typecode can be not enforced at this time,
 * but may be later.
 */

31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
typedef struct _mp_obj_opaque_t {
    mp_obj_base_t base;
    void *val;
} mp_obj_opaque_t;

typedef struct _mp_obj_ffimod_t {
    mp_obj_base_t base;
    void *handle;
} mp_obj_ffimod_t;

typedef struct _mp_obj_ffivar_t {
    mp_obj_base_t base;
    void *var;
    char type;
//    ffi_type *type;
} mp_obj_ffivar_t;

typedef struct _mp_obj_ffifunc_t {
    mp_obj_base_t base;
    void *func;
    char rettype;
    ffi_cif cif;
    ffi_type *params[];
} mp_obj_ffifunc_t;

typedef struct _mp_obj_fficallback_t {
    mp_obj_base_t base;
    void *func;
    ffi_closure *clo;
    char rettype;
    ffi_cif cif;
    ffi_type *params[];
} mp_obj_fficallback_t;

65
66
67
68
69
//STATIC const mp_obj_type_t opaque_type;
STATIC const mp_obj_type_t ffimod_type;
STATIC const mp_obj_type_t ffifunc_type;
STATIC const mp_obj_type_t fficallback_type;
STATIC const mp_obj_type_t ffivar_type;
70

71
STATIC ffi_type *char2ffi_type(char c)
72
73
74
75
76
77
78
79
{
    switch (c) {
        case 'b': return &ffi_type_schar;
        case 'B': return &ffi_type_uchar;
        case 'i': return &ffi_type_sint;
        case 'I': return &ffi_type_uint;
        case 'l': return &ffi_type_slong;
        case 'L': return &ffi_type_ulong;
Paul Sokolovsky's avatar
Paul Sokolovsky committed
80
81
        case 'f': return &ffi_type_float;
        case 'd': return &ffi_type_double;
82
83
        case 'P': // const void*
        case 'p': // void*
84
85
86
87
88
89
        case 's': return &ffi_type_pointer;
        case 'v': return &ffi_type_void;
        default: return NULL;
    }
}

90
STATIC ffi_type *get_ffi_type(mp_obj_t o_in)
91
92
93
{
    if (MP_OBJ_IS_STR(o_in)) {
        uint len;
94
        const char *s = mp_obj_str_get_data(o_in, &len);
95
96
97
98
99
100
101
        ffi_type *t = char2ffi_type(*s);
        if (t != NULL) {
            return t;
        }
    }
    // TODO: Support actual libffi type objects

102
    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "Unknown type"));
103
104
}

105
STATIC mp_obj_t return_ffi_value(ffi_arg val, char type)
106
107
108
109
110
111
112
113
{
    switch (type) {
        case 's': {
            const char *s = (const char *)val;
            return mp_obj_new_str((const byte *)s, strlen(s), false);
        }
        case 'v':
            return mp_const_none;
Paul Sokolovsky's avatar
Paul Sokolovsky committed
114
115
116
117
118
119
120
121
        case 'f': {
            float *p = (float*)&val;
            return mp_obj_new_float(*p);
        }
        case 'd': {
            double *p = (double*)&val;
            return mp_obj_new_float(*p);
        }
122
123
124
125
126
127
128
        default:
            return mp_obj_new_int(val);
    }
}

// FFI module

129
STATIC void ffimod_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
130
131
132
133
    mp_obj_ffimod_t *self = self_in;
    print(env, "<ffimod %p>", self->handle);
}

134
STATIC mp_obj_t ffimod_close(mp_obj_t self_in) {
135
136
137
138
    mp_obj_ffimod_t *self = self_in;
    dlclose(self->handle);
    return mp_const_none;
}
139
STATIC MP_DEFINE_CONST_FUN_OBJ_1(ffimod_close_obj, ffimod_close);
140

141
STATIC mp_obj_t ffimod_func(uint n_args, const mp_obj_t *args) {
142
143
144
145
146
147
    mp_obj_ffimod_t *self = args[0];
    const char *rettype = mp_obj_str_get_str(args[1]);
    const char *symname = mp_obj_str_get_str(args[2]);

    void *sym = dlsym(self->handle, symname);
    if (sym == NULL) {
148
        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT((machine_int_t)errno)));
149
150
151
152
153
154
155
156
    }
    int nparams = MP_OBJ_SMALL_INT_VALUE(mp_obj_len_maybe(args[3]));
    mp_obj_ffifunc_t *o = m_new_obj_var(mp_obj_ffifunc_t, ffi_type*, nparams);
    o->base.type = &ffifunc_type;

    o->func = sym;
    o->rettype = *rettype;

Damien George's avatar
Damien George committed
157
    mp_obj_t iterable = mp_getiter(args[3]);
158
159
    mp_obj_t item;
    int i = 0;
160
    while ((item = mp_iternext(iterable)) != MP_OBJ_STOP_ITERATION) {
161
162
163
164
165
        o->params[i++] = get_ffi_type(item);
    }

    int res = ffi_prep_cif(&o->cif, FFI_DEFAULT_ABI, nparams, char2ffi_type(*rettype), o->params);
    if (res != FFI_OK) {
166
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Error in ffi_prep_cif"));
167
168
169
170
171
172
    }

    return o;
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(ffimod_func_obj, 4, 4, ffimod_func);

173
STATIC void call_py_func(ffi_cif *cif, void *ret, void** args, mp_obj_t func) {
174
175
176
177
    mp_obj_t pyargs[cif->nargs];
    for (int i = 0; i < cif->nargs; i++) {
        pyargs[i] = mp_obj_new_int(*(int*)args[i]);
    }
Damien George's avatar
Damien George committed
178
    mp_obj_t res = mp_call_function_n_kw(func, cif->nargs, 0, pyargs);
179
180
181
182

    *(ffi_arg*)ret = mp_obj_int_get(res);
}

183
STATIC mp_obj_t mod_ffi_callback(mp_obj_t rettype_in, mp_obj_t func_in, mp_obj_t paramtypes_in) {
184
185
186
187
188
189
190
191
192
193
    const char *rettype = mp_obj_str_get_str(rettype_in);

    int nparams = MP_OBJ_SMALL_INT_VALUE(mp_obj_len_maybe(paramtypes_in));
    mp_obj_fficallback_t *o = m_new_obj_var(mp_obj_fficallback_t, ffi_type*, nparams);
    o->base.type = &fficallback_type;

    o->clo = ffi_closure_alloc(sizeof(ffi_closure), &o->func);

    o->rettype = *rettype;

Damien George's avatar
Damien George committed
194
    mp_obj_t iterable = mp_getiter(paramtypes_in);
195
196
    mp_obj_t item;
    int i = 0;
197
    while ((item = mp_iternext(iterable)) != MP_OBJ_STOP_ITERATION) {
198
199
200
201
202
        o->params[i++] = get_ffi_type(item);
    }

    int res = ffi_prep_cif(&o->cif, FFI_DEFAULT_ABI, nparams, char2ffi_type(*rettype), o->params);
    if (res != FFI_OK) {
203
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Error in ffi_prep_cif"));
204
205
206
207
    }

    res = ffi_prep_closure_loc(o->clo, &o->cif, call_py_func, func_in, o->func);
    if (res != FFI_OK) {
208
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "ffi_prep_closure_loc"));
209
210
211
212
213
214
    }

    return o;
}
MP_DEFINE_CONST_FUN_OBJ_3(mod_ffi_callback_obj, mod_ffi_callback);

215
STATIC mp_obj_t ffimod_var(mp_obj_t self_in, mp_obj_t vartype_in, mp_obj_t symname_in) {
216
217
218
219
220
221
    mp_obj_ffimod_t *self = self_in;
    const char *rettype = mp_obj_str_get_str(vartype_in);
    const char *symname = mp_obj_str_get_str(symname_in);

    void *sym = dlsym(self->handle, symname);
    if (sym == NULL) {
222
        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT((machine_int_t)errno)));
223
224
225
226
227
228
229
230
231
232
    }
    mp_obj_ffivar_t *o = m_new_obj(mp_obj_ffivar_t);
    o->base.type = &ffivar_type;

    o->var = sym;
    o->type = *rettype;
    return o;
}
MP_DEFINE_CONST_FUN_OBJ_3(ffimod_var_obj, ffimod_var);

233
STATIC mp_obj_t ffimod_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
234
235
236
237
    const char *fname = mp_obj_str_get_str(args[0]);
    void *mod = dlopen(fname, RTLD_NOW | RTLD_LOCAL);

    if (mod == NULL) {
238
        nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT((machine_int_t)errno)));
239
240
241
242
243
244
245
    }
    mp_obj_ffimod_t *o = m_new_obj(mp_obj_ffimod_t);
    o->base.type = type_in;
    o->handle = mod;
    return o;
}

246
STATIC const mp_map_elem_t ffimod_locals_dict_table[] = {
247
248
249
    { MP_OBJ_NEW_QSTR(MP_QSTR_func), (mp_obj_t) &ffimod_func_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_var), (mp_obj_t) &ffimod_var_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_close), (mp_obj_t) &ffimod_close_obj },
250
251
};

252
253
STATIC MP_DEFINE_CONST_DICT(ffimod_locals_dict, ffimod_locals_dict_table);

254
STATIC const mp_obj_type_t ffimod_type = {
255
256
    { &mp_type_type },
    .name = MP_QSTR_ffimod,
257
258
    .print = ffimod_print,
    .make_new = ffimod_make_new,
259
    .locals_dict = (mp_obj_t)&ffimod_locals_dict,
260
261
262
263
};

// FFI function

264
STATIC void ffifunc_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
265
266
267
268
269
270
271
272
273
    mp_obj_ffifunc_t *self = self_in;
    print(env, "<ffifunc %p>", self->func);
}

mp_obj_t ffifunc_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
    mp_obj_ffifunc_t *self = self_in;
    assert(n_kw == 0);
    assert(n_args == self->cif.nargs);

274
    ffi_arg values[n_args];
275
276
277
278
279
280
281
282
    void *valueptrs[n_args];
    int i;
    for (i = 0; i < n_args; i++) {
        mp_obj_t a = args[i];
        if (a == mp_const_none) {
            values[i] = 0;
        } else if (MP_OBJ_IS_INT(a)) {
            values[i] = mp_obj_int_get(a);
283
        } else if (MP_OBJ_IS_STR(a)) {
284
            const char *s = mp_obj_str_get_str(a);
285
            values[i] = (ffi_arg)s;
286
287
        } else if (((mp_obj_base_t*)a)->type->buffer_p.get_buffer != NULL) {
            mp_obj_base_t *o = (mp_obj_base_t*)a;
288
289
290
            mp_buffer_info_t bufinfo;
            int ret = o->type->buffer_p.get_buffer(o, &bufinfo, MP_BUFFER_READ); // TODO: MP_BUFFER_READ?
            if (ret != 0 || bufinfo.buf == NULL) {
291
292
293
                goto error;
            }
            values[i] = (ffi_arg)bufinfo.buf;
294
295
        } else if (MP_OBJ_IS_TYPE(a, &fficallback_type)) {
            mp_obj_fficallback_t *p = a;
296
            values[i] = (ffi_arg)p->func;
297
        } else {
298
            goto error;
299
300
301
302
        }
        valueptrs[i] = &values[i];
    }

303
    ffi_arg retval;
304
305
    ffi_call(&self->cif, self->func, &retval, valueptrs);
    return return_ffi_value(retval, self->rettype);
306
307
308

error:
    nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "Don't know how to pass object to native function"));
309
310
}

311
STATIC const mp_obj_type_t ffifunc_type = {
312
313
    { &mp_type_type },
    .name = MP_QSTR_ffifunc,
314
315
316
317
318
319
    .print = ffifunc_print,
    .call = ffifunc_call,
};

// FFI callback for Python function

320
STATIC void fficallback_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
321
322
323
324
    mp_obj_fficallback_t *self = self_in;
    print(env, "<fficallback %p>", self->func);
}

325
STATIC const mp_obj_type_t fficallback_type = {
326
327
    { &mp_type_type },
    .name = MP_QSTR_fficallback,
328
329
330
331
332
    .print = fficallback_print,
};

// FFI variable

333
STATIC void ffivar_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
334
335
336
337
    mp_obj_ffivar_t *self = self_in;
    print(env, "<ffivar @%p: 0x%x>", self->var, *(int*)self->var);
}

338
STATIC mp_obj_t ffivar_get(mp_obj_t self_in) {
339
    mp_obj_ffivar_t *self = self_in;
340
    return mp_binary_get_val_array(self->type, self->var, 0);
341
342
343
}
MP_DEFINE_CONST_FUN_OBJ_1(ffivar_get_obj, ffivar_get);

344
STATIC mp_obj_t ffivar_set(mp_obj_t self_in, mp_obj_t val_in) {
345
    mp_obj_ffivar_t *self = self_in;
346
    mp_binary_set_val_array(self->type, self->var, 0, val_in);
347
348
349
350
    return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_2(ffivar_set_obj, ffivar_set);

351
352
353
STATIC const mp_map_elem_t ffivar_locals_dict_table[] = {
    { MP_OBJ_NEW_QSTR(MP_QSTR_get), (mp_obj_t)&ffivar_get_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_set), (mp_obj_t)&ffivar_set_obj },
354
355
};

356
357
358
STATIC MP_DEFINE_CONST_DICT(ffivar_locals_dict, ffivar_locals_dict_table);

STATIC const mp_obj_type_t ffivar_type = {
359
360
    { &mp_type_type },
    .name = MP_QSTR_ffivar,
361
    .print = ffivar_print,
362
    .locals_dict = (mp_obj_t)&ffivar_locals_dict,
363
364
};

365
// Generic opaque storage object (unused)
366

367
/*
368
STATIC const mp_obj_type_t opaque_type = {
369
370
    { &mp_type_type },
    .name = MP_QSTR_opaqueval,
371
372
//    .print = opaque_print,
};
373
*/
374
375
376
377
378
379
380
381
382
383
384

mp_obj_t mod_ffi_open(uint n_args, const mp_obj_t *args) {
    return ffimod_make_new((mp_obj_t)&ffimod_type, n_args, 0, args);
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_ffi_open_obj, 1, 2, mod_ffi_open);

mp_obj_t mod_ffi_as_bytearray(mp_obj_t ptr, mp_obj_t size) {
    return mp_obj_new_bytearray_by_ref(mp_obj_int_get(size), (void*)mp_obj_int_get(ptr));
}
MP_DEFINE_CONST_FUN_OBJ_2(mod_ffi_as_bytearray_obj, mod_ffi_as_bytearray);

385
386
387
388
389
390
STATIC const mp_map_elem_t mp_module_ffi_globals_table[] = {
    { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_ffi) },
    { MP_OBJ_NEW_QSTR(MP_QSTR_open), (mp_obj_t)&mod_ffi_open_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_callback), (mp_obj_t)&mod_ffi_callback_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_as_bytearray), (mp_obj_t)&mod_ffi_as_bytearray_obj },
};
391

392
393
394
395
396
STATIC const mp_obj_dict_t mp_module_ffi_globals = {
    .base = {&mp_type_dict},
    .map = {
        .all_keys_are_qstrs = 1,
        .table_is_fixed_array = 1,
397
398
        .used = ARRAY_SIZE(mp_module_ffi_globals_table),
        .alloc = ARRAY_SIZE(mp_module_ffi_globals_table),
399
400
401
402
403
404
405
406
407
        .table = (mp_map_elem_t*)mp_module_ffi_globals_table,
    },
};

const mp_obj_module_t mp_module_ffi = {
    .base = { &mp_type_module },
    .name = MP_QSTR_ffi,
    .globals = (mp_obj_dict_t*)&mp_module_ffi_globals,
};