runtime.c 33.4 KB
Newer Older
1
// in principle, rt_xxx functions are called only by vm/native/viper and make assumptions about args
2
// mp_xxx functions are safer and can be called by anyone
3
// note that rt_assign_xxx are called only from emit*, and maybe we can rename them to reflect this
4

Damien's avatar
Damien committed
5
6
7
8
9
10
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>

11
#include "nlr.h"
Damien's avatar
Damien committed
12
#include "misc.h"
13
#include "mpconfig.h"
14
#include "mpqstr.h"
15
16
#include "obj.h"
#include "runtime0.h"
Damien's avatar
Damien committed
17
#include "runtime.h"
18
19
20
#include "map.h"
#include "builtin.h"

21
#if 0 // print debugging info
22
#define DEBUG_PRINT (1)
23
#define WRITE_CODE (1)
24
25
26
#define DEBUG_printf(args...) printf(args)
#define DEBUG_OP_printf(args...) printf(args)
#else // don't print debugging info
27
#define DEBUG_printf(args...) (void)0
Damien's avatar
Damien committed
28
#define DEBUG_OP_printf(args...) (void)0
29
#endif
Damien's avatar
Damien committed
30

31
// locals and globals need to be pointers because they can be the same in outer module scope
32
33
34
static mp_map_t *map_locals;
static mp_map_t *map_globals;
static mp_map_t map_builtins;
35

Damien's avatar
Damien committed
36
typedef enum {
37
38
39
40
41
42
43
44
    MP_CODE_NONE,
    MP_CODE_BYTE,
    MP_CODE_NATIVE,
    MP_CODE_INLINE_ASM,
} mp_code_kind_t;

typedef struct _mp_code_t {
    mp_code_kind_t kind;
Damien's avatar
Damien committed
45
    int n_args;
46
47
    int n_locals;
    int n_stack;
ian-v's avatar
ian-v committed
48
    MP_BOOL is_generator;
Damien's avatar
Damien committed
49
50
51
52
53
    union {
        struct {
            byte *code;
            uint len;
        } u_byte;
54
        struct {
55
            mp_fun_t fun;
56
57
        } u_native;
        struct {
58
            void *fun;
59
        } u_inline_asm;
Damien's avatar
Damien committed
60
    };
61
} mp_code_t;
Damien's avatar
Damien committed
62
63

static int next_unique_code_id;
64
static mp_code_t *unique_codes;
Damien's avatar
Damien committed
65

66
67
#ifdef WRITE_CODE
FILE *fp_write_code = NULL;
68
#endif
Damien's avatar
Damien committed
69

70
void rt_init(void) {
71
    // locals = globals for outer module (see Objects/frameobject.c/PyFrame_New())
72
    map_locals = map_globals = mp_map_new(MP_MAP_QSTR, 1);
ian-v's avatar
ian-v committed
73
    mp_qstr_map_lookup(map_globals, MP_QSTR___name__, MP_TRUE)->value = mp_obj_new_str(MP_QSTR___main__);
74

75
    // init built-in hash table
76
    mp_map_init(&map_builtins, MP_MAP_QSTR, 3);
77
78

    // built-in exceptions (TODO, make these proper classes)
ian-v's avatar
ian-v committed
79
80
81
82
83
84
85
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_AttributeError, MP_TRUE)->value = mp_obj_new_exception(MP_QSTR_AttributeError);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_IndexError, MP_TRUE)->value = mp_obj_new_exception(MP_QSTR_IndexError);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_KeyError, MP_TRUE)->value = mp_obj_new_exception(MP_QSTR_KeyError);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_NameError, MP_TRUE)->value = mp_obj_new_exception(MP_QSTR_NameError);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_TypeError, MP_TRUE)->value = mp_obj_new_exception(MP_QSTR_TypeError);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_SyntaxError, MP_TRUE)->value = mp_obj_new_exception(MP_QSTR_SyntaxError);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_ValueError, MP_TRUE)->value = mp_obj_new_exception(MP_QSTR_ValueError);
86

Damien George's avatar
Damien George committed
87
    // built-in objects
ian-v's avatar
ian-v committed
88
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_Ellipsis, MP_TRUE)->value = mp_const_ellipsis;
Damien George's avatar
Damien George committed
89

90
    // built-in core functions
ian-v's avatar
ian-v committed
91
92
    mp_qstr_map_lookup(&map_builtins, MP_QSTR___build_class__, MP_TRUE)->value = rt_make_function_2(mp_builtin___build_class__);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR___repl_print__, MP_TRUE)->value = rt_make_function_1(mp_builtin___repl_print__);
93

94
    // built-in types
ian-v's avatar
ian-v committed
95
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_bool, MP_TRUE)->value = (mp_obj_t)&bool_type;
96
#if MICROPY_ENABLE_FLOAT
ian-v's avatar
ian-v committed
97
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_complex, MP_TRUE)->value = (mp_obj_t)&complex_type;
98
#endif
ian-v's avatar
ian-v committed
99
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_dict, MP_TRUE)->value = (mp_obj_t)&dict_type;
100
#if MICROPY_ENABLE_FLOAT
ian-v's avatar
ian-v committed
101
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_float, MP_TRUE)->value = (mp_obj_t)&float_type;
102
#endif
ian-v's avatar
ian-v committed
103
104
105
106
107
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_int, MP_TRUE)->value = (mp_obj_t)&int_type;
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_list, MP_TRUE)->value = (mp_obj_t)&list_type;
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_set, MP_TRUE)->value = (mp_obj_t)&set_type;
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_tuple, MP_TRUE)->value = (mp_obj_t)&tuple_type;
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_type, MP_TRUE)->value = (mp_obj_t)&mp_builtin_type_obj; // TODO
108
109

    // built-in user functions; TODO covert all to &mp_builtin_xxx's
ian-v's avatar
ian-v committed
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_abs, MP_TRUE)->value = rt_make_function_1(mp_builtin_abs);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_all, MP_TRUE)->value = rt_make_function_1(mp_builtin_all);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_any, MP_TRUE)->value = rt_make_function_1(mp_builtin_any);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_callable, MP_TRUE)->value = rt_make_function_1(mp_builtin_callable);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_chr, MP_TRUE)->value = rt_make_function_1(mp_builtin_chr);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_divmod, MP_TRUE)->value = rt_make_function_2(mp_builtin_divmod);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_hash, MP_TRUE)->value = (mp_obj_t)&mp_builtin_hash_obj;
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_iter, MP_TRUE)->value = (mp_obj_t)&mp_builtin_iter_obj;
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_len, MP_TRUE)->value = rt_make_function_1(mp_builtin_len);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_max, MP_TRUE)->value = rt_make_function_var(1, mp_builtin_max);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_min, MP_TRUE)->value = rt_make_function_var(1, mp_builtin_min);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_next, MP_TRUE)->value = (mp_obj_t)&mp_builtin_next_obj;
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_ord, MP_TRUE)->value = rt_make_function_1(mp_builtin_ord);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_pow, MP_TRUE)->value = rt_make_function_var(2, mp_builtin_pow);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_print, MP_TRUE)->value = rt_make_function_var(0, mp_builtin_print);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_range, MP_TRUE)->value = rt_make_function_var(1, mp_builtin_range);
    mp_qstr_map_lookup(&map_builtins, MP_QSTR_sum, MP_TRUE)->value = rt_make_function_var(1, mp_builtin_sum);
127
128

    next_unique_code_id = 1; // 0 indicates "no code"
Damien's avatar
Damien committed
129
130
    unique_codes = NULL;

131
132
#ifdef WRITE_CODE
    fp_write_code = fopen("out-code", "wb");
133
#endif
Damien's avatar
Damien committed
134
135
}

136
void rt_deinit(void) {
137
138
139
#ifdef WRITE_CODE
    if (fp_write_code != NULL) {
        fclose(fp_write_code);
Damien's avatar
Damien committed
140
    }
141
#endif
Damien's avatar
Damien committed
142
143
}

144
145
int rt_get_unique_code_id(void) {
    return next_unique_code_id++;
Damien's avatar
Damien committed
146
147
}

148
static void alloc_unique_codes(void) {
Damien's avatar
Damien committed
149
    if (unique_codes == NULL) {
150
        unique_codes = m_new(mp_code_t, next_unique_code_id + 10); // XXX hack until we fix the REPL allocation problem
151
        for (int i = 0; i < next_unique_code_id; i++) {
152
            unique_codes[i].kind = MP_CODE_NONE;
153
        }
Damien's avatar
Damien committed
154
    }
155
156
}

ian-v's avatar
ian-v committed
157
void rt_assign_byte_code(int unique_code_id, byte *code, uint len, int n_args, int n_locals, int n_stack, MP_BOOL is_generator) {
158
159
    alloc_unique_codes();

160
    assert(1 <= unique_code_id && unique_code_id < next_unique_code_id);
161
    unique_codes[unique_code_id].kind = MP_CODE_BYTE;
162
    unique_codes[unique_code_id].n_args = n_args;
163
164
165
    unique_codes[unique_code_id].n_locals = n_locals;
    unique_codes[unique_code_id].n_stack = n_stack;
    unique_codes[unique_code_id].is_generator = is_generator;
166
167
168
    unique_codes[unique_code_id].u_byte.code = code;
    unique_codes[unique_code_id].u_byte.len = len;

Damien's avatar
Damien committed
169
    //printf("byte code: %d bytes\n", len);
170
171

#ifdef DEBUG_PRINT
172
    DEBUG_printf("assign byte code: id=%d code=%p len=%u n_args=%d\n", unique_code_id, code, len, n_args);
173
174
175
176
177
178
179
    for (int i = 0; i < 128 && i < len; i++) {
        if (i > 0 && i % 16 == 0) {
            DEBUG_printf("\n");
        }
        DEBUG_printf(" %02x", code[i]);
    }
    DEBUG_printf("\n");
180
181
    extern void mp_show_byte_code(const byte *code, int len);
    mp_show_byte_code(code, len);
182
183
184
185
186
187
188
189

#ifdef WRITE_CODE
    if (fp_write_code != NULL) {
        fwrite(code, len, 1, fp_write_code);
        fflush(fp_write_code);
    }
#endif
#endif
190
191
}

192
void rt_assign_native_code(int unique_code_id, void *fun, uint len, int n_args) {
193
194
    alloc_unique_codes();

195
    assert(1 <= unique_code_id && unique_code_id < next_unique_code_id);
196
    unique_codes[unique_code_id].kind = MP_CODE_NATIVE;
Damien's avatar
Damien committed
197
    unique_codes[unique_code_id].n_args = n_args;
198
199
    unique_codes[unique_code_id].n_locals = 0;
    unique_codes[unique_code_id].n_stack = 0;
ian-v's avatar
ian-v committed
200
    unique_codes[unique_code_id].is_generator = MP_FALSE;
Damien's avatar
Damien committed
201
202
    unique_codes[unique_code_id].u_native.fun = fun;

203
    //printf("native code: %d bytes\n", len);
204

205
#ifdef DEBUG_PRINT
Damien's avatar
Damien committed
206
207
208
209
210
211
212
213
214
215
    DEBUG_printf("assign native code: id=%d fun=%p len=%u n_args=%d\n", unique_code_id, fun, len, n_args);
    byte *fun_data = (byte*)(((machine_uint_t)fun) & (~1)); // need to clear lower bit in case it's thumb code
    for (int i = 0; i < 128 && i < len; i++) {
        if (i > 0 && i % 16 == 0) {
            DEBUG_printf("\n");
        }
        DEBUG_printf(" %02x", fun_data[i]);
    }
    DEBUG_printf("\n");

216
217
218
219
#ifdef WRITE_CODE
    if (fp_write_code != NULL) {
        fwrite(fun_data, len, 1, fp_write_code);
        fflush(fp_write_code);
Damien's avatar
Damien committed
220
    }
221
222
#endif
#endif
Damien's avatar
Damien committed
223
224
}

225
void rt_assign_inline_asm_code(int unique_code_id, void *fun, uint len, int n_args) {
226
227
228
    alloc_unique_codes();

    assert(1 <= unique_code_id && unique_code_id < next_unique_code_id);
229
    unique_codes[unique_code_id].kind = MP_CODE_INLINE_ASM;
Damien's avatar
Damien committed
230
    unique_codes[unique_code_id].n_args = n_args;
231
232
    unique_codes[unique_code_id].n_locals = 0;
    unique_codes[unique_code_id].n_stack = 0;
ian-v's avatar
ian-v committed
233
    unique_codes[unique_code_id].is_generator = MP_FALSE;
234
    unique_codes[unique_code_id].u_inline_asm.fun = fun;
Damien's avatar
Damien committed
235

236
#ifdef DEBUG_PRINT
237
238
239
240
241
242
243
244
245
246
    DEBUG_printf("assign inline asm code: id=%d fun=%p len=%u n_args=%d\n", unique_code_id, fun, len, n_args);
    byte *fun_data = (byte*)(((machine_uint_t)fun) & (~1)); // need to clear lower bit in case it's thumb code
    for (int i = 0; i < 128 && i < len; i++) {
        if (i > 0 && i % 16 == 0) {
            DEBUG_printf("\n");
        }
        DEBUG_printf(" %02x", fun_data[i]);
    }
    DEBUG_printf("\n");

247
248
249
#ifdef WRITE_CODE
    if (fp_write_code != NULL) {
        fwrite(fun_data, len, 1, fp_write_code);
250
    }
251
252
#endif
#endif
Damien's avatar
Damien committed
253
254
}

ian-v's avatar
ian-v committed
255
256
static MP_BOOL fit_small_int(mp_small_int_t o) {
    return MP_TRUE;
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
}

int rt_is_true(mp_obj_t arg) {
    DEBUG_OP_printf("is true %p\n", arg);
    if (MP_OBJ_IS_SMALL_INT(arg)) {
        if (MP_OBJ_SMALL_INT_VALUE(arg) == 0) {
            return 0;
        } else {
            return 1;
        }
    } else if (arg == mp_const_none) {
        return 0;
    } else if (arg == mp_const_false) {
        return 0;
    } else if (arg == mp_const_true) {
        return 1;
    } else {
        assert(0);
        return 0;
    }
}

mp_obj_t rt_list_append(mp_obj_t self_in, mp_obj_t arg) {
    return mp_obj_list_append(self_in, arg);
}

Damien's avatar
Damien committed
283
284
285
286
#define PARSE_DEC_IN_INTG (1)
#define PARSE_DEC_IN_FRAC (2)
#define PARSE_DEC_IN_EXP  (3)

287
mp_obj_t rt_load_const_dec(qstr qstr) {
Damien's avatar
Damien committed
288
289
290
291
#if MICROPY_ENABLE_FLOAT
    DEBUG_OP_printf("load '%s'\n", qstr_str(qstr));
    const char *s = qstr_str(qstr);
    int in = PARSE_DEC_IN_INTG;
292
    mp_float_t dec_val = 0;
ian-v's avatar
ian-v committed
293
    MP_BOOL exp_neg = MP_FALSE;
Damien's avatar
Damien committed
294
295
    int exp_val = 0;
    int exp_extra = 0;
ian-v's avatar
ian-v committed
296
    MP_BOOL imag = MP_FALSE;
Damien's avatar
Damien committed
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
    for (; *s; s++) {
        int dig = *s;
        if ('0' <= dig && dig <= '9') {
            dig -= '0';
            if (in == PARSE_DEC_IN_EXP) {
                exp_val = 10 * exp_val + dig;
            } else {
                dec_val = 10 * dec_val + dig;
                if (in == PARSE_DEC_IN_FRAC) {
                    exp_extra -= 1;
                }
            }
        } else if (in == PARSE_DEC_IN_INTG && dig == '.') {
            in = PARSE_DEC_IN_FRAC;
        } else if (in != PARSE_DEC_IN_EXP && (dig == 'E' || dig == 'e')) {
            in = PARSE_DEC_IN_EXP;
            if (s[1] == '+') {
                s++;
            } else if (s[1] == '-') {
                s++;
ian-v's avatar
ian-v committed
317
                exp_neg = MP_TRUE;
Damien's avatar
Damien committed
318
319
320
            }
        } else if (dig == 'J' || dig == 'j') {
            s++;
ian-v's avatar
ian-v committed
321
            imag = MP_TRUE;
Damien's avatar
Damien committed
322
323
324
325
326
327
328
            break;
        } else {
            // unknown character
            break;
        }
    }
    if (*s != 0) {
329
        nlr_jump(mp_obj_new_exception_msg(MP_QSTR_SyntaxError, "invalid syntax for number"));
Damien's avatar
Damien committed
330
331
332
333
334
335
336
337
338
339
340
341
    }
    if (exp_neg) {
        exp_val = -exp_val;
    }
    exp_val += exp_extra;
    for (; exp_val > 0; exp_val--) {
        dec_val *= 10;
    }
    for (; exp_val < 0; exp_val++) {
        dec_val *= 0.1;
    }
    if (imag) {
342
        return mp_obj_new_complex(0, dec_val);
Damien's avatar
Damien committed
343
    } else {
344
        return mp_obj_new_float(dec_val);
Damien's avatar
Damien committed
345
346
    }
#else
347
    nlr_jump(mp_obj_new_exception_msg(MP_QSTR_SyntaxError, "decimal numbers not supported"));
Damien's avatar
Damien committed
348
349
350
#endif
}

351
mp_obj_t rt_load_const_str(qstr qstr) {
Damien's avatar
Damien committed
352
    DEBUG_OP_printf("load '%s'\n", qstr_str(qstr));
353
    return mp_obj_new_str(qstr);
Damien's avatar
Damien committed
354
355
}

356
mp_obj_t rt_load_name(qstr qstr) {
Damien's avatar
Damien committed
357
    // logic: search locals, globals, builtins
358
    DEBUG_OP_printf("load name %s\n", qstr_str(qstr));
ian-v's avatar
ian-v committed
359
    mp_map_elem_t *elem = mp_qstr_map_lookup(map_locals, qstr, MP_FALSE);
Damien's avatar
Damien committed
360
    if (elem == NULL) {
ian-v's avatar
ian-v committed
361
        elem = mp_qstr_map_lookup(map_globals, qstr, MP_FALSE);
Damien's avatar
Damien committed
362
        if (elem == NULL) {
ian-v's avatar
ian-v committed
363
            elem = mp_qstr_map_lookup(&map_builtins, qstr, MP_FALSE);
364
            if (elem == NULL) {
365
                nlr_jump(mp_obj_new_exception_msg_1_arg(MP_QSTR_NameError, "name '%s' is not defined", qstr_str(qstr)));
366
            }
Damien's avatar
Damien committed
367
368
369
370
371
        }
    }
    return elem->value;
}

372
mp_obj_t rt_load_global(qstr qstr) {
373
374
    // logic: search globals, builtins
    DEBUG_OP_printf("load global %s\n", qstr_str(qstr));
ian-v's avatar
ian-v committed
375
    mp_map_elem_t *elem = mp_qstr_map_lookup(map_globals, qstr, MP_FALSE);
376
    if (elem == NULL) {
ian-v's avatar
ian-v committed
377
        elem = mp_qstr_map_lookup(&map_builtins, qstr, MP_FALSE);
378
        if (elem == NULL) {
379
            nlr_jump(mp_obj_new_exception_msg_1_arg(MP_QSTR_NameError, "name '%s' is not defined", qstr_str(qstr)));
380
381
382
        }
    }
    return elem->value;
Damien's avatar
Damien committed
383
384
}

385
mp_obj_t rt_load_build_class(void) {
Damien's avatar
Damien committed
386
    DEBUG_OP_printf("load_build_class\n");
ian-v's avatar
ian-v committed
387
    mp_map_elem_t *elem = mp_qstr_map_lookup(&map_builtins, MP_QSTR___build_class__, MP_FALSE);
Damien's avatar
Damien committed
388
    if (elem == NULL) {
389
        nlr_jump(mp_obj_new_exception_msg(MP_QSTR_NameError, "name '__build_class__' is not defined"));
Damien's avatar
Damien committed
390
391
392
393
    }
    return elem->value;
}

394
395
mp_obj_t rt_get_cell(mp_obj_t cell) {
    return mp_obj_cell_get(cell);
396
397
}

398
399
void rt_set_cell(mp_obj_t cell, mp_obj_t val) {
    mp_obj_cell_set(cell, val);
400
401
}

402
void rt_store_name(qstr qstr, mp_obj_t obj) {
403
    DEBUG_OP_printf("store name %s <- %p\n", qstr_str(qstr), obj);
ian-v's avatar
ian-v committed
404
    mp_qstr_map_lookup(map_locals, qstr, MP_TRUE)->value = obj;
405
406
}

407
void rt_store_global(qstr qstr, mp_obj_t obj) {
408
    DEBUG_OP_printf("store global %s <- %p\n", qstr_str(qstr), obj);
ian-v's avatar
ian-v committed
409
    mp_qstr_map_lookup(map_globals, qstr, MP_TRUE)->value = obj;
Damien's avatar
Damien committed
410
411
}

412
mp_obj_t rt_unary_op(int op, mp_obj_t arg) {
Damien's avatar
Damien committed
413
    DEBUG_OP_printf("unary %d %p\n", op, arg);
414
415
    if (MP_OBJ_IS_SMALL_INT(arg)) {
        mp_small_int_t val = MP_OBJ_SMALL_INT_VALUE(arg);
Damien's avatar
Damien committed
416
        switch (op) {
417
            case RT_UNARY_OP_NOT: if (val != 0) { return mp_const_true;} else { return mp_const_false; }
Damien's avatar
Damien committed
418
419
420
421
422
423
            case RT_UNARY_OP_POSITIVE: break;
            case RT_UNARY_OP_NEGATIVE: val = -val; break;
            case RT_UNARY_OP_INVERT: val = ~val; break;
            default: assert(0); val = 0;
        }
        if (fit_small_int(val)) {
424
425
426
427
428
429
430
431
432
433
434
435
436
            return MP_OBJ_NEW_SMALL_INT(val);
        } else {
            // TODO make a bignum
            assert(0);
            return mp_const_none;
        }
    } else { // will be an object (small ints are caught in previous if)
        mp_obj_base_t *o = arg;
        if (o->type->unary_op != NULL) {
            mp_obj_t result = o->type->unary_op(op, arg);
            if (result != NULL) {
                return result;
            }
Damien's avatar
Damien committed
437
        }
438
        // TODO specify in error message what the operator is
439
        nlr_jump(mp_obj_new_exception_msg_1_arg(MP_QSTR_TypeError, "bad operand type for unary operator: '%s'", o->type->name));
Damien's avatar
Damien committed
440
    }
Damien's avatar
Damien committed
441
442
}

443
mp_obj_t rt_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
Damien's avatar
Damien committed
444
    DEBUG_OP_printf("binary %d %p %p\n", op, lhs, rhs);
445
446
447
448
449
450
451
452
453
454

    // TODO correctly distinguish inplace operators for mutable objects
    // lookup logic that CPython uses for +=:
    //   check for implemented +=
    //   then check for implemented +
    //   then check for implemented seq.inplace_concat
    //   then check for implemented seq.concat
    //   then fail
    // note that list does not implement + or +=, so that inplace_concat is reached first for +=

455
456
457
    if (MP_OBJ_IS_SMALL_INT(lhs) && MP_OBJ_IS_SMALL_INT(rhs)) {
        mp_small_int_t lhs_val = MP_OBJ_SMALL_INT_VALUE(lhs);
        mp_small_int_t rhs_val = MP_OBJ_SMALL_INT_VALUE(rhs);
Damien's avatar
Damien committed
458
        switch (op) {
459
            case RT_BINARY_OP_OR:
Damien's avatar
Damien committed
460
            case RT_BINARY_OP_INPLACE_OR: lhs_val |= rhs_val; break;
461
            case RT_BINARY_OP_XOR:
Damien's avatar
Damien committed
462
            case RT_BINARY_OP_INPLACE_XOR: lhs_val ^= rhs_val; break;
463
            case RT_BINARY_OP_AND:
Damien's avatar
Damien committed
464
            case RT_BINARY_OP_INPLACE_AND: lhs_val &= rhs_val; break;
465
            case RT_BINARY_OP_LSHIFT:
Damien's avatar
Damien committed
466
            case RT_BINARY_OP_INPLACE_LSHIFT: lhs_val <<= rhs_val; break;
467
            case RT_BINARY_OP_RSHIFT:
Damien's avatar
Damien committed
468
            case RT_BINARY_OP_INPLACE_RSHIFT: lhs_val >>= rhs_val; break;
Damien's avatar
Damien committed
469
            case RT_BINARY_OP_ADD:
Damien's avatar
Damien committed
470
            case RT_BINARY_OP_INPLACE_ADD: lhs_val += rhs_val; break;
471
            case RT_BINARY_OP_SUBTRACT:
Damien's avatar
Damien committed
472
            case RT_BINARY_OP_INPLACE_SUBTRACT: lhs_val -= rhs_val; break;
473
            case RT_BINARY_OP_MULTIPLY:
Damien's avatar
Damien committed
474
            case RT_BINARY_OP_INPLACE_MULTIPLY: lhs_val *= rhs_val; break;
475
            case RT_BINARY_OP_FLOOR_DIVIDE:
Damien's avatar
Damien committed
476
            case RT_BINARY_OP_INPLACE_FLOOR_DIVIDE: lhs_val /= rhs_val; break;
477
#if MICROPY_ENABLE_FLOAT
478
            case RT_BINARY_OP_TRUE_DIVIDE:
479
            case RT_BINARY_OP_INPLACE_TRUE_DIVIDE: return mp_obj_new_float((mp_float_t)lhs_val / (mp_float_t)rhs_val);
Damien's avatar
Damien committed
480
#endif
481
482
483
484
485
486

            // TODO implement modulo as specified by Python
            case RT_BINARY_OP_MODULO:
            case RT_BINARY_OP_INPLACE_MODULO: lhs_val %= rhs_val; break;

            // TODO check for negative power, and overflow
487
488
            case RT_BINARY_OP_POWER:
            case RT_BINARY_OP_INPLACE_POWER:
489
490
491
492
493
494
495
496
            {
                int ans = 1;
                while (rhs_val > 0) {
                    if (rhs_val & 1) {
                        ans *= lhs_val;
                    }
                    lhs_val *= lhs_val;
                    rhs_val /= 2;
497
                }
498
499
500
501
                lhs_val = ans;
                break;
            }

502
            default: assert(0);
Damien's avatar
Damien committed
503
        }
Damien's avatar
Damien committed
504
        if (fit_small_int(lhs_val)) {
505
506
507
508
509
510
511
512
            return MP_OBJ_NEW_SMALL_INT(lhs_val);
        }
    } else if (MP_OBJ_IS_OBJ(lhs)) {
        mp_obj_base_t *o = lhs;
        if (o->type->binary_op != NULL) {
            mp_obj_t result = o->type->binary_op(op, lhs, rhs);
            if (result != NULL) {
                return result;
Damien's avatar
Damien committed
513
            }
Damien's avatar
Damien committed
514
515
        }
    }
516
517

    // TODO specify in error message what the operator is
518
    nlr_jump(mp_obj_new_exception_msg_1_arg(MP_QSTR_TypeError, "unsupported operand type for binary operator: '%s'", mp_obj_get_type_str(lhs)));
Damien's avatar
Damien committed
519
520
}

521
mp_obj_t rt_compare_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
Damien's avatar
Damien committed
522
    DEBUG_OP_printf("compare %d %p %p\n", op, lhs, rhs);
523
524
525

    // deal with == and !=
    if (op == RT_COMPARE_OP_EQUAL || op == RT_COMPARE_OP_NOT_EQUAL) {
526
        if (mp_obj_equal(lhs, rhs)) {
527
            if (op == RT_COMPARE_OP_EQUAL) {
528
                return mp_const_true;
529
            } else {
530
                return mp_const_false;
531
532
533
            }
        } else {
            if (op == RT_COMPARE_OP_EQUAL) {
534
                return mp_const_false;
535
            } else {
536
                return mp_const_true;
537
538
539
540
            }
        }
    }

541
542
543
544
545
546
547
548
549
550
551
552
    // deal with exception_match
    if (op == RT_COMPARE_OP_EXCEPTION_MATCH) {
        // TODO properly! at the moment it just compares the exception identifier for equality
        if (MP_OBJ_IS_TYPE(lhs, &exception_type) && MP_OBJ_IS_TYPE(rhs, &exception_type)) {
            if (mp_obj_exception_get_type(lhs) == mp_obj_exception_get_type(rhs)) {
                return mp_const_true;
            } else {
                return mp_const_false;
            }
        }
    }

553
    // deal with small ints
554
555
556
    if (MP_OBJ_IS_SMALL_INT(lhs) && MP_OBJ_IS_SMALL_INT(rhs)) {
        mp_small_int_t lhs_val = MP_OBJ_SMALL_INT_VALUE(lhs);
        mp_small_int_t rhs_val = MP_OBJ_SMALL_INT_VALUE(rhs);
557
558
559
560
561
562
563
564
565
        int cmp;
        switch (op) {
            case RT_COMPARE_OP_LESS: cmp = lhs_val < rhs_val; break;
            case RT_COMPARE_OP_MORE: cmp = lhs_val > rhs_val; break;
            case RT_COMPARE_OP_LESS_EQUAL: cmp = lhs_val <= rhs_val; break;
            case RT_COMPARE_OP_MORE_EQUAL: cmp = lhs_val >= rhs_val; break;
            default: assert(0); cmp = 0;
        }
        if (cmp) {
566
            return mp_const_true;
567
        } else {
568
            return mp_const_false;
569
570
571
572
573
        }
    }

#if MICROPY_ENABLE_FLOAT
    // deal with floats
574
575
576
    if (MP_OBJ_IS_TYPE(lhs, &float_type) || MP_OBJ_IS_TYPE(rhs, &float_type)) {
        mp_float_t lhs_val = mp_obj_get_float(lhs);
        mp_float_t rhs_val = mp_obj_get_float(rhs);
Damien's avatar
Damien committed
577
578
        int cmp;
        switch (op) {
579
580
581
582
            case RT_COMPARE_OP_LESS: cmp = lhs_val < rhs_val; break;
            case RT_COMPARE_OP_MORE: cmp = lhs_val > rhs_val; break;
            case RT_COMPARE_OP_LESS_EQUAL: cmp = lhs_val <= rhs_val; break;
            case RT_COMPARE_OP_MORE_EQUAL: cmp = lhs_val >= rhs_val; break;
Damien's avatar
Damien committed
583
584
585
            default: assert(0); cmp = 0;
        }
        if (cmp) {
586
            return mp_const_true;
Damien's avatar
Damien committed
587
        } else {
588
            return mp_const_false;
Damien's avatar
Damien committed
589
590
        }
    }
591
#endif
592
593

    // not implemented
Damien's avatar
Damien committed
594
    assert(0);
595
    return mp_const_none;
Damien's avatar
Damien committed
596
597
}

598
mp_obj_t rt_make_function_from_id(int unique_code_id) {
599
600
    DEBUG_OP_printf("make_function_from_id %d\n", unique_code_id);
    if (unique_code_id < 1 || unique_code_id >= next_unique_code_id) {
Damien's avatar
Damien committed
601
        // illegal code id
602
        return mp_const_none;
Damien's avatar
Damien committed
603
    }
604
605
606
607

    // make the function, depending on the code kind
    mp_code_t *c = &unique_codes[unique_code_id];
    mp_obj_t fun;
Damien's avatar
Damien committed
608
    switch (c->kind) {
609
        case MP_CODE_BYTE:
Damien George's avatar
Damien George committed
610
            fun = mp_obj_new_fun_bc(c->n_args, c->n_locals + c->n_stack, c->u_byte.code);
611
            break;
612
        case MP_CODE_NATIVE:
Damien's avatar
Damien committed
613
            switch (c->n_args) {
614
615
616
617
                case 0: fun = rt_make_function_0(c->u_native.fun); break;
                case 1: fun = rt_make_function_1((mp_fun_1_t)c->u_native.fun); break;
                case 2: fun = rt_make_function_2((mp_fun_2_t)c->u_native.fun); break;
                default: assert(0); fun = mp_const_none;
Damien's avatar
Damien committed
618
619
            }
            break;
620
621
        case MP_CODE_INLINE_ASM:
            fun = mp_obj_new_fun_asm(c->n_args, c->u_inline_asm.fun);
Damien's avatar
Damien committed
622
623
624
            break;
        default:
            assert(0);
625
            fun = mp_const_none;
Damien's avatar
Damien committed
626
    }
627
628
629

    // check for generator functions and if so wrap in generator object
    if (c->is_generator) {
Damien George's avatar
Damien George committed
630
        fun = mp_obj_new_gen_wrap(c->n_locals, c->n_stack, fun);
631
632
    }

633
    return fun;
Damien's avatar
Damien committed
634
635
}

636
mp_obj_t rt_make_closure_from_id(int unique_code_id, mp_obj_t closure_tuple) {
Damien George's avatar
Damien George committed
637
    DEBUG_OP_printf("make_closure_from_id %d\n", unique_code_id);
638
639
    // make function object
    mp_obj_t ffun = rt_make_function_from_id(unique_code_id);
Damien's avatar
Damien committed
640
    // wrap function in closure object
641
    return mp_obj_new_closure(ffun, closure_tuple);
Damien's avatar
Damien committed
642
643
}

644
mp_obj_t rt_call_function_0(mp_obj_t fun) {
645
646
647
    return rt_call_function_n(fun, 0, NULL);
}

648
mp_obj_t rt_call_function_1(mp_obj_t fun, mp_obj_t arg) {
649
650
651
    return rt_call_function_n(fun, 1, &arg);
}

652
653
mp_obj_t rt_call_function_2(mp_obj_t fun, mp_obj_t arg1, mp_obj_t arg2) {
    mp_obj_t args[2];
654
655
656
657
658
659
    args[1] = arg1;
    args[0] = arg2;
    return rt_call_function_n(fun, 2, args);
}

// args are in reverse order in the array
660
661
662
mp_obj_t rt_call_function_n(mp_obj_t fun_in, int n_args, const mp_obj_t *args) {
    // TODO improve this: fun object can specify its type and we parse here the arguments,
    // passing to the function arrays of fixed and keyword arguments
663

664
    DEBUG_OP_printf("calling function %p(n_args=%d, args=%p)\n", fun_in, n_args, args);
665

666
    if (MP_OBJ_IS_SMALL_INT(fun_in)) {
667
        nlr_jump(mp_obj_new_exception_msg(MP_QSTR_TypeError, "'int' object is not callable"));
668
669
670
671
    } else {
        mp_obj_base_t *fun = fun_in;
        if (fun->type->call_n != NULL) {
            return fun->type->call_n(fun_in, n_args, args);
672
        } else {
673
            nlr_jump(mp_obj_new_exception_msg_1_arg(MP_QSTR_TypeError, "'%s' object is not callable", fun->type->name));
674
        }
Damien's avatar
Damien committed
675
676
677
    }
}

678
679
// args are in reverse order in the array; keyword arguments come first, value then key
// eg: (value1, key1, value0, key0, arg1, arg0)
680
mp_obj_t rt_call_function_n_kw(mp_obj_t fun, uint n_args, uint n_kw, const mp_obj_t *args) {
681
682
    // TODO
    assert(0);
683
    return mp_const_none;
684
685
}

686
687
// args contains: arg(n_args-1)  arg(n_args-2)  ...  arg(0)  self/NULL  fun
// if n_args==0 then there are only self/NULL and fun
688
mp_obj_t rt_call_method_n(uint n_args, const mp_obj_t *args) {
689
    DEBUG_OP_printf("call method %p(self=%p, n_args=%u)\n", args[n_args + 1], args[n_args], n_args);
690
691
692
    return rt_call_function_n(args[n_args + 1], n_args + ((args[n_args] == NULL) ? 0 : 1), args);
}

693
// args contains: kw_val(n_kw-1)  kw_key(n_kw-1) ... kw_val(0)  kw_key(0)  arg(n_args-1)  arg(n_args-2)  ...  arg(0)  self/NULL  fun
694
mp_obj_t rt_call_method_n_kw(uint n_args, uint n_kw, const mp_obj_t *args) {
695
696
697
698
699
    uint n = n_args + 2 * n_kw;
    DEBUG_OP_printf("call method %p(self=%p, n_args=%u, n_kw=%u)\n", args[n + 1], args[n], n_args, n_kw);
    return rt_call_function_n_kw(args[n + 1], n_args + ((args[n] == NULL) ? 0 : 1), n_kw, args);
}

700
// items are in reverse order
701
702
mp_obj_t rt_build_tuple(int n_args, mp_obj_t *items) {
    return mp_obj_new_tuple_reverse(n_args, items);
703
704
}

Damien's avatar
Damien committed
705
// items are in reverse order
706
707
mp_obj_t rt_build_list(int n_args, mp_obj_t *items) {
    return mp_obj_new_list_reverse(n_args, items);
Damien's avatar
Damien committed
708
709
}

710
711
mp_obj_t rt_build_set(int n_args, mp_obj_t *items) {
    return mp_obj_new_set(n_args, items);
Damien's avatar
Damien committed
712
713
}

714
mp_obj_t rt_store_set(mp_obj_t set, mp_obj_t item) {
715
    mp_obj_set_store(set, item);
Damien's avatar
Damien committed
716
717
718
    return set;
}

719
// unpacked items are stored in order into the array pointed to by items
720
721
722
723
724
725
726
727
void rt_unpack_sequence(mp_obj_t seq_in, uint num, mp_obj_t *items) {
    if (MP_OBJ_IS_TYPE(seq_in, &tuple_type) || MP_OBJ_IS_TYPE(seq_in, &list_type)) {
        uint seq_len;
        mp_obj_t *seq_items;
        if (MP_OBJ_IS_TYPE(seq_in, &tuple_type)) {
            mp_obj_tuple_get(seq_in, &seq_len, &seq_items);
        } else {
            mp_obj_list_get(seq_in, &seq_len, &seq_items);
728
        }
729
        if (seq_len < num) {
730
            nlr_jump(mp_obj_new_exception_msg_1_arg(MP_QSTR_ValueError, "need more than %d values to unpack", (void*)(machine_uint_t)seq_len));
731
        } else if (seq_len > num) {
732
            nlr_jump(mp_obj_new_exception_msg_1_arg(MP_QSTR_ValueError, "too many values to unpack (expected %d)", (void*)(machine_uint_t)num));
733
734
        }
        memcpy(items, seq_items, num * sizeof(mp_obj_t));
735
736
    } else {
        // TODO call rt_getiter and extract via rt_iternext
737
        nlr_jump(mp_obj_new_exception_msg_1_arg(MP_QSTR_TypeError, "'%s' object is not iterable", mp_obj_get_type_str(seq_in)));
738
739
740
    }
}

741
742
mp_obj_t rt_build_map(int n_args) {
    return mp_obj_new_dict(n_args);
Damien's avatar
Damien committed
743
744
}

745
746
747
mp_obj_t rt_store_map(mp_obj_t map, mp_obj_t key, mp_obj_t value) {
    // map should always be a dict
    return mp_obj_dict_store(map, key, value);
Damien's avatar
Damien committed
748
749
}

750
mp_obj_t rt_load_attr(mp_obj_t base, qstr attr) {
751
    DEBUG_OP_printf("load attr %s\n", qstr_str(attr));
752
    if (MP_OBJ_IS_TYPE(base, &class_type)) {
ian-v's avatar
ian-v committed
753
        mp_map_elem_t *elem = mp_qstr_map_lookup(mp_obj_class_get_locals(base), attr, MP_FALSE);
Damien's avatar
Damien committed
754
        if (elem == NULL) {
755
756
            // TODO what about generic method lookup?
            goto no_attr;
Damien's avatar
Damien committed
757
758
        }
        return elem->value;
759
760
    } else if (MP_OBJ_IS_TYPE(base, &instance_type)) {
        return mp_obj_instance_load_attr(base, attr);
761
    } else if (MP_OBJ_IS_TYPE(base, &module_type)) {
762
        DEBUG_OP_printf("lookup module map %p\n", mp_obj_module_get_globals(base));
ian-v's avatar
ian-v committed
763
        mp_map_elem_t *elem = mp_qstr_map_lookup(mp_obj_module_get_globals(base), attr, MP_FALSE);
764
765
766
767
768
        if (elem == NULL) {
            // TODO what about generic method lookup?
            goto no_attr;
        }
        return elem->value;
769
770
771
    } else if (MP_OBJ_IS_OBJ(base)) {
        // generic method lookup
        mp_obj_base_t *o = base;
ian-v's avatar
ian-v committed
772
773
774
775
776
777
        const mp_method_t *meth = o->type->methods;
        if (meth != NULL) {
            for (; meth->name != NULL; meth++) {
                if (strcmp(meth->name, qstr_str(attr)) == 0) {
                    return mp_obj_new_bound_meth(base, (mp_obj_t)meth->fun);
                }
778
779
            }
        }
Damien's avatar
Damien committed
780
    }
781
782

no_attr:
783
    nlr_jump(mp_obj_new_exception_msg_2_args(MP_QSTR_AttributeError, "'%s' object has no attribute '%s'", mp_obj_get_type_str(base), qstr_str(attr)));
Damien's avatar
Damien committed
784
785
}

786
void rt_load_method(mp_obj_t base, qstr attr, mp_obj_t *dest) {
Damien's avatar
Damien committed
787
    DEBUG_OP_printf("load method %s\n", qstr_str(attr));
788
    if (MP_OBJ_IS_TYPE(base, &gen_instance_type) && attr == MP_QSTR___next__) {
789
        dest[1] = (mp_obj_t)&mp_builtin_next_obj;
790
791
        dest[0] = base;
        return;
792
793
    } else if (MP_OBJ_IS_TYPE(base, &instance_type)) {
        mp_obj_instance_load_method(base, attr, dest);
794
        return;
795
796
797
    } else if (MP_OBJ_IS_OBJ(base)) {
        // generic method lookup
        mp_obj_base_t *o = base;
ian-v's avatar
ian-v committed
798
799
800
801
802
803
804
805
        const mp_method_t *meth = o->type->methods;
        if (meth != NULL) {
            for (; meth->name != NULL; meth++) {
                if (strcmp(meth->name, qstr_str(attr)) == 0) {
                    dest[1] = (mp_obj_t)meth->fun;
                    dest[0] = base;
                    return;
                }
Damien's avatar
Damien committed
806
807
            }
        }
808
809
    }

810
    // no method; fallback to load_attr
811
812
813
814
    dest[1] = rt_load_attr(base, attr);
    dest[0] = NULL;
}

815
void rt_store_attr(mp_obj_t base, qstr attr, mp_obj_t value) {
Damien's avatar
Damien committed
816
    DEBUG_OP_printf("store attr %p.%s <- %p\n", base, qstr_str(attr), value);
817
    if (MP_OBJ_IS_TYPE(base, &class_type)) {
Damien's avatar
Damien committed
818
        // TODO CPython allows STORE_ATTR to a class, but is this the correct implementation?
819
        mp_map_t *locals = mp_obj_class_get_locals(base);
ian-v's avatar
ian-v committed
820
        mp_qstr_map_lookup(locals, attr, MP_TRUE)->value = value;
821
822
    } else if (MP_OBJ_IS_TYPE(base, &instance_type)) {
        mp_obj_instance_store_attr(base, attr, value);
823
824
825
    } else if (MP_OBJ_IS_TYPE(base, &module_type)) {
        // TODO CPython allows STORE_ATTR to a module, but is this the correct implementation?
        mp_map_t *globals = mp_obj_module_get_globals(base);
ian-v's avatar
ian-v committed
826
        mp_qstr_map_lookup(globals, attr, MP_TRUE)->value = value;
827
    } else {
828
        nlr_jump(mp_obj_new_exception_msg_2_args(MP_QSTR_AttributeError, "'%s' object has no attribute '%s'", mp_obj_get_type_str(base), qstr_str(attr)));
829
830
831
    }
}

832
void rt_store_subscr(mp_obj_t base, mp_obj_t index, mp_obj_t value) {
Damien's avatar
Damien committed
833
    DEBUG_OP_printf("store subscr %p[%p] <- %p\n", base, index, value);
834
    if (MP_OBJ_IS_TYPE(base, &list_type)) {
835
        // list store
836
837
838
839
        mp_obj_list_store(base, index, value);
    } else if (MP_OBJ_IS_TYPE(base, &dict_type)) {
        // dict store
        mp_obj_dict_store(base, index, value);
Damien's avatar
Damien committed
840
    } else {
841
        assert(0);
Damien's avatar
Damien committed
842
843
844
    }
}

845
846
mp_obj_t rt_getiter(mp_obj_t o_in) {
    if (MP_OBJ_IS_SMALL_INT(o_in)) {
847
        nlr_jump(mp_obj_new_exception_msg(MP_QSTR_TypeError, "'int' object is not iterable"));
848
    } else {
849
850
851
        mp_obj_base_t *o = o_in;
        if (o->type->getiter != NULL) {
            return o->type->getiter(o_in);
852
        } else {
853
            nlr_jump(mp_obj_new_exception_msg_1_arg(MP_QSTR_TypeError, "'%s' object is not iterable", o->type->name));
854
        }
855
856
    }
}
857

858
859
mp_obj_t rt_iternext(mp_obj_t o_in) {
    if (MP_OBJ_IS_SMALL_INT(o_in)) {
860
        nlr_jump(mp_obj_new_exception_msg(MP_QSTR_TypeError, "? 'int' object is not iterable"));
861
862
863
864
    } else {
        mp_obj_base_t *o = o_in;
        if (o->type->iternext != NULL) {
            return o->type->iternext(o_in);
865
        } else {
866
            nlr_jump(mp_obj_new_exception_msg_1_arg(MP_QSTR_TypeError, "? '%s' object is not iterable", o->type->name));
867
        }
868
869
870
    }
}

871
mp_obj_t rt_import_name(qstr name, mp_obj_t fromlist, mp_obj_t level) {
872
    // build args array
873
874
875
876
    mp_obj_t args[5];
    args[0] = mp_obj_new_str(name);
    args[1] = mp_const_none; // TODO should be globals
    args[2] = mp_const_none; // TODO should be locals
877
878
879
880
    args[3] = fromlist;
    args[4] = level; // must be 0; we don't yet support other values

    // TODO lookup __import__ and call that instead of going straight to builtin implementation
881
    return mp_builtin___import__(5, args);
882
883
}

884
885
mp_obj_t rt_import_from(mp_obj_t module, qstr name) {
    mp_obj_t x = rt_load_attr(module, name);
886
887
888
889
890
891
892
893
    /* TODO convert AttributeError to ImportError
    if (fail) {
        (ImportError, "cannot import name %s", qstr_str(name), NULL)
    }
    */
    return x;
}

894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
mp_map_t *rt_locals_get(void) {
    return map_locals;
}

void rt_locals_set(mp_map_t *m) {
    DEBUG_OP_printf("rt_locals_set(%p)\n", m);