vm.c 42.3 KB
Newer Older
1
2
3
4
5
6
/*
 * This file is part of the Micro Python project, http://micropython.org/
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2013, 2014 Damien P. George
7
 * Copyright (c) 2014 Paul Sokolovsky
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

Damien's avatar
Damien committed
28
#include <stdio.h>
29
#include <string.h>
Damien's avatar
Damien committed
30
31
#include <assert.h>

32
#include "mpconfig.h"
33
#include "nlr.h"
Damien's avatar
Damien committed
34
#include "misc.h"
35
#include "qstr.h"
36
#include "obj.h"
37
#include "emitglue.h"
Damien's avatar
Damien committed
38
#include "runtime.h"
39
#include "bc0.h"
40
#include "bc.h"
41
#include "objgenerator.h"
Damien's avatar
Damien committed
42

43
44
45
46
47
48
// With these macros you can tune the maximum number of state slots
// that will be allocated on the stack.  Any function that needs more
// than this will use the heap.
#define VM_MAX_STATE_ON_STACK (10)
#define VM_MAX_EXC_STATE_ON_STACK (4)

49
#define DETECT_VM_STACK_OVERFLOW (0)
50
#if 0
51
#define TRACE(ip) mp_bytecode_print2(ip, 1);
52
53
54
#else
#define TRACE(ip)
#endif
55

Paul Sokolovsky's avatar
Paul Sokolovsky committed
56
57
58
59
60
61
62
// Value stack grows up (this makes it incompatible with native C stack, but
// makes sure that arguments to functions are in natural order arg1..argN
// (Python semantics mandates left-to-right evaluation order, including for
// function arguments). Stack pointer is pre-incremented and points at the
// top element.
// Exception stack also grows up, top element is also pointed at.

63
// Exception stack unwind reasons (WHY_* in CPython-speak)
64
65
// TODO perhaps compress this to RETURN=0, JUMP>0, with number of unwinds
// left to do encoded in the JUMP number
66
67
typedef enum {
    UNWIND_RETURN = 1,
68
    UNWIND_JUMP,
69
70
} mp_unwind_reason_t;

71
#define DECODE_UINT do { \
72
73
74
75
    unum = 0; \
    do { \
        unum = (unum << 7) + (*ip & 0x7f); \
    } while ((*ip++ & 0x80) != 0); \
76
} while (0)
Damien's avatar
Damien committed
77
78
#define DECODE_ULABEL do { unum = (ip[0] | (ip[1] << 8)); ip += 2; } while (0)
#define DECODE_SLABEL do { unum = (ip[0] | (ip[1] << 8)) - 0x8000; ip += 2; } while (0)
79
#define DECODE_QSTR qstr qst = 0; \
80
81
    do { \
        qst = (qst << 7) + (*ip & 0x7f); \
82
    } while ((*ip++ & 0x80) != 0)
83
84
85
86
87
#define DECODE_PTR do { \
    ip = (byte*)(((machine_uint_t)ip + sizeof(machine_uint_t) - 1) & (~(sizeof(machine_uint_t) - 1))); /* align ip */ \
    unum = *(machine_uint_t*)ip; \
    ip += sizeof(machine_uint_t); \
} while (0)
88
89
#define PUSH(val) *++sp = (val)
#define POP() (*sp--)
90
91
#define TOP() (*sp)
#define SET_TOP(val) *sp = (val)
Damien's avatar
Damien committed
92

93
#define PUSH_EXC_BLOCK() \
94
95
    DECODE_ULABEL; /* except labels are always forward */ \
    ++exc_sp; \
96
    exc_sp->opcode = *save_ip; \
97
98
    exc_sp->handler = ip + unum; \
    exc_sp->val_sp = MP_TAGPTR_MAKE(sp, currently_in_except_block); \
Damien George's avatar
Damien George committed
99
    exc_sp->prev_exc = MP_OBJ_NULL; \
100
101
    currently_in_except_block = 0; /* in a try block now */

102
103
104
105
#define POP_EXC_BLOCK() \
    currently_in_except_block = MP_TAGPTR_TAG(exc_sp->val_sp); /* restore previous state */ \
    exc_sp--; /* pop back to previous exception handler */

106
mp_vm_return_kind_t mp_execute_bytecode(const byte *code, const mp_obj_t *args, uint n_args, const mp_obj_t *args2, uint n_args2, mp_obj_t *ret) {
107
108
109
110
111
112
    const byte *ip = code;

    // get code info size, and skip line number table
    machine_uint_t code_info_size = ip[0] | (ip[1] << 8) | (ip[2] << 16) | (ip[3] << 24);
    ip += code_info_size;

113
114
115
116
    // bytecode prelude: state size and exception stack size; 16 bit uints
    machine_uint_t n_state = ip[0] | (ip[1] << 8);
    machine_uint_t n_exc_stack = ip[2] | (ip[3] << 8);
    ip += 4;
117

118
    // allocate state for locals and stack
119
    mp_obj_t temp_state[VM_MAX_STATE_ON_STACK];
120
    mp_obj_t *state = &temp_state[0];
121
#if DETECT_VM_STACK_OVERFLOW
122
123
    n_state += 1;
#endif
124
    if (n_state > VM_MAX_STATE_ON_STACK) {
125
        state = m_new(mp_obj_t, n_state);
126
    }
127
128
    mp_obj_t *sp = &state[0] - 1;

129
    // allocate state for exceptions
130
    mp_exc_stack_t exc_state[VM_MAX_EXC_STATE_ON_STACK];
131
    mp_exc_stack_t *exc_stack = &exc_state[0];
132
    if (n_exc_stack > VM_MAX_EXC_STATE_ON_STACK) {
133
        exc_stack = m_new(mp_exc_stack_t, n_exc_stack);
134
    }
135
    mp_exc_stack_t *exc_sp = &exc_stack[0] - 1;
136

137
    // init args
138
    for (uint i = 0; i < n_args; i++) {
139
        state[n_state - 1 - i] = args[i];
140
    }
141
142
143
    for (uint i = 0; i < n_args2; i++) {
        state[n_state - 1 - n_args - i] = args2[i];
    }
144

145
146
147
148
149
    // set rest of state to MP_OBJ_NULL
    for (uint i = 0; i < n_state - n_args - n_args2; i++) {
        state[i] = MP_OBJ_NULL;
    }

150
151
152
    // bytecode prelude: initialise closed over variables
    for (uint n_local = *ip++; n_local > 0; n_local--) {
        uint local_num = *ip++;
153
        state[n_state - 1 - local_num] = mp_obj_new_cell(state[n_state - 1 - local_num]);
Damien George's avatar
Damien George committed
154
155
156
    }

    // execute the byte code
157
    mp_vm_return_kind_t vm_return_kind = mp_execute_bytecode2(code, &ip, &state[n_state - 1], &sp, exc_stack, &exc_sp, MP_OBJ_NULL);
158

159
#if DETECT_VM_STACK_OVERFLOW
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
    // We can't check the case when an exception is returned in state[n_state - 1]
    // and there are no arguments, because in this case our detection slot may have
    // been overwritten by the returned exception (which is allowed).
    if (!(vm_return_kind == MP_VM_RETURN_EXCEPTION && n_args == 0 && n_args2 == 0)) {
        // Just check to see that we have at least 1 null object left in the state.
        bool overflow = true;
        for (uint i = 0; i < n_state - n_args - n_args2; i++) {
            if (state[i] == MP_OBJ_NULL) {
                overflow = false;
                break;
            }
        }
        if (overflow) {
            printf("VM stack overflow state=%p n_state+1=%u\n", state, n_state);
            assert(0);
        }
176
177
178
    }
#endif

179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
    mp_vm_return_kind_t ret_kind;
    switch (vm_return_kind) {
        case MP_VM_RETURN_NORMAL:
            // return value is in *sp
            *ret = *sp;
            ret_kind = MP_VM_RETURN_NORMAL;
            break;

        case MP_VM_RETURN_EXCEPTION:
            // return value is in state[n_state - 1]
            *ret = state[n_state - 1];
            ret_kind = MP_VM_RETURN_EXCEPTION;
            break;

        case MP_VM_RETURN_YIELD: // byte-code shouldn't yield
        default:
            assert(0);
            *ret = mp_const_none;
            ret_kind = MP_VM_RETURN_NORMAL;
    }
199
200
201
202
203

    // free the state if it was allocated on the heap
    if (n_state > VM_MAX_STATE_ON_STACK) {
        m_free(state, n_state);
    }
204
205

    // free the exception state if it was allocated on the heap
206
207
208
209
    if (n_exc_stack > VM_MAX_EXC_STATE_ON_STACK) {
        m_free(exc_stack, n_exc_stack);
    }

210
    return ret_kind;
211
212
}

213
214
// fastn has items in reverse order (fastn[0] is local[0], fastn[-1] is local[1], etc)
// sp points to bottom of stack which grows up
215
216
217
218
// returns:
//  MP_VM_RETURN_NORMAL, sp valid, return value in *sp
//  MP_VM_RETURN_YIELD, ip, sp valid, yielded value in *sp
//  MP_VM_RETURN_EXCEPTION, exception in fastn[0]
219
220
221
222
mp_vm_return_kind_t mp_execute_bytecode2(const byte *code_info, const byte **ip_in_out,
                                         mp_obj_t *fastn, mp_obj_t **sp_in_out,
                                         mp_exc_stack_t *exc_stack, mp_exc_stack_t **exc_sp_in_out,
                                         volatile mp_obj_t inject_exc) {
223
#if MICROPY_OPT_COMPUTED_GOTO
AZ Huang's avatar
AZ Huang committed
224
    #include "vmentrytable.h"
225
    #define DISPATCH() do { \
226
        TRACE(ip); \
227
        save_ip = ip; \
228
        goto *entry_table[*ip++]; \
229
    } while(0)
230
231
    #define ENTRY(op) entry_##op
    #define ENTRY_DEFAULT entry_default
232
#else
233
234
235
    #define DISPATCH() break
    #define ENTRY(op) case op
    #define ENTRY_DEFAULT default
236
237
#endif

238
239
240
241
242
    // nlr_raise needs to be implemented as a goto, so that the C compiler's flow analyser
    // sees that it's possible for us to jump from the dispatch loop to the exception
    // handler.  Without this, the code may have a different stack layout in the dispatch
    // loop and the exception handler, leading to very obscure bugs.
    #define RAISE(o) do { nlr_pop(); nlr.ret_val = o; goto exception_handler; } while(0)
Damien's avatar
Damien committed
243

244
    // variables that are visible to the exception handler (declared volatile)
245
    volatile bool currently_in_except_block = MP_TAGPTR_TAG(*exc_sp_in_out); // 0 or 1, to detect nested exceptions
246
    mp_exc_stack_t *volatile exc_sp = MP_TAGPTR_PTR(*exc_sp_in_out); // stack grows up, exc_sp points to top of stack
247
248
    const byte *volatile save_ip = *ip_in_out; // this is so we can access ip in the exception handler without making ip volatile (which means the compiler can't keep it in a register in the main loop)
    mp_obj_t *volatile save_sp = *sp_in_out; // this is so we can access sp in the exception handler when needed
Damien's avatar
Damien committed
249

250
    // outer exception handling loop
Damien's avatar
Damien committed
251
    for (;;) {
252
        nlr_buf_t nlr;
253
outer_dispatch_loop:
254
        if (nlr_push(&nlr) == 0) {
255
256
257
258
            // local variables that are not visible to the exception handler
            const byte *ip = *ip_in_out;
            mp_obj_t *sp = *sp_in_out;
            machine_uint_t unum;
259
            mp_obj_t obj_shared;
260

261
262
263
            // If we have exception to inject, now that we finish setting up
            // execution context, raise it. This works as if RAISE_VARARGS
            // bytecode was executed.
264
265
266
            // Injecting exc into yield from generator is a special case,
            // handled by MP_BC_YIELD_FROM itself
            if (inject_exc != MP_OBJ_NULL && *ip != MP_BC_YIELD_FROM) {
267
                mp_obj_t exc = inject_exc;
268
                inject_exc = MP_OBJ_NULL;
269
270
                exc = mp_make_raise_obj(exc);
                RAISE(exc);
271
            }
272

273
274
            // loop to execute byte code
            for (;;) {
275
dispatch_loop:
276
#if MICROPY_OPT_COMPUTED_GOTO
277
278
                DISPATCH();
#else
279
                TRACE(ip);
280
                save_ip = ip;
281
                switch (*ip++) {
282
#endif
283

284
285
286
                ENTRY(MP_BC_LOAD_CONST_FALSE):
                    PUSH(mp_const_false);
                    DISPATCH();
287

288
289
290
                ENTRY(MP_BC_LOAD_CONST_NONE):
                    PUSH(mp_const_none);
                    DISPATCH();
291

292
293
294
                ENTRY(MP_BC_LOAD_CONST_TRUE):
                    PUSH(mp_const_true);
                    DISPATCH();
295

296
297
298
                ENTRY(MP_BC_LOAD_CONST_ELLIPSIS):
                    PUSH((mp_obj_t)&mp_const_ellipsis_obj);
                    DISPATCH();
299

300
301
302
303
304
305
306
307
308
309
310
311
                ENTRY(MP_BC_LOAD_CONST_SMALL_INT): {
                    machine_int_t num = 0;
                    if ((ip[0] & 0x40) != 0) {
                        // Number is negative
                        num--;
                    }
                    do {
                        num = (num << 7) | (*ip & 0x7f);
                    } while ((*ip++ & 0x80) != 0);
                    PUSH(MP_OBJ_NEW_SMALL_INT(num));
                    DISPATCH();
                }
312

313
                ENTRY(MP_BC_LOAD_CONST_INT): {
314
                    DECODE_QSTR;
315
                    PUSH(mp_load_const_int(qst));
316
                    DISPATCH();
317
                }
318

319
                ENTRY(MP_BC_LOAD_CONST_DEC): {
320
321
322
                    DECODE_QSTR;
                    PUSH(mp_load_const_dec(qst));
                    DISPATCH();
323
                }
324

325
                ENTRY(MP_BC_LOAD_CONST_BYTES): {
326
327
328
                    DECODE_QSTR;
                    PUSH(mp_load_const_bytes(qst));
                    DISPATCH();
329
                }
330

331
                ENTRY(MP_BC_LOAD_CONST_STRING): {
332
333
334
                    DECODE_QSTR;
                    PUSH(mp_load_const_str(qst));
                    DISPATCH();
335
                }
336
337
338
339
340
341

                ENTRY(MP_BC_LOAD_NULL):
                    PUSH(MP_OBJ_NULL);
                    DISPATCH();

                ENTRY(MP_BC_LOAD_FAST_0):
342
                    obj_shared = fastn[0];
343
344
345
                    goto load_check;

                ENTRY(MP_BC_LOAD_FAST_1):
346
                    obj_shared = fastn[-1];
347
348
349
                    goto load_check;

                ENTRY(MP_BC_LOAD_FAST_2):
350
                    obj_shared = fastn[-2];
351
352
353
354
                    goto load_check;

                ENTRY(MP_BC_LOAD_FAST_N):
                    DECODE_UINT;
355
                    obj_shared = fastn[-unum];
356
                    load_check:
357
358
359
360
361
                    if (obj_shared == MP_OBJ_NULL) {
                        local_name_error: {
                            mp_obj_t obj = mp_obj_new_exception_msg(&mp_type_NameError, "local variable referenced before assignment");
                            RAISE(obj);
                        }
362
                    }
363
                    PUSH(obj_shared);
364
365
366
367
                    DISPATCH();

                ENTRY(MP_BC_LOAD_DEREF):
                    DECODE_UINT;
368
                    obj_shared = mp_obj_cell_get(fastn[-unum]);
369
370
                    goto load_check;

371
                ENTRY(MP_BC_LOAD_NAME): {
372
373
374
                    DECODE_QSTR;
                    PUSH(mp_load_name(qst));
                    DISPATCH();
375
                }
376

377
                ENTRY(MP_BC_LOAD_GLOBAL): {
378
379
380
                    DECODE_QSTR;
                    PUSH(mp_load_global(qst));
                    DISPATCH();
381
                }
382

383
                ENTRY(MP_BC_LOAD_ATTR): {
384
385
386
                    DECODE_QSTR;
                    SET_TOP(mp_load_attr(TOP(), qst));
                    DISPATCH();
387
                }
388

389
                ENTRY(MP_BC_LOAD_METHOD): {
390
391
392
393
                    DECODE_QSTR;
                    mp_load_method(*sp, qst, sp);
                    sp += 1;
                    DISPATCH();
394
                }
395
396
397
398
399

                ENTRY(MP_BC_LOAD_BUILD_CLASS):
                    PUSH(mp_load_build_class());
                    DISPATCH();

400
401
402
                ENTRY(MP_BC_LOAD_SUBSCR): {
                    mp_obj_t index = POP();
                    SET_TOP(mp_obj_subscr(TOP(), index, MP_OBJ_SENTINEL));
403
                    DISPATCH();
404
                }
405

406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
                ENTRY(MP_BC_STORE_FAST_0):
                    fastn[0] = POP();
                    DISPATCH();

                ENTRY(MP_BC_STORE_FAST_1):
                    fastn[-1] = POP();
                    DISPATCH();

                ENTRY(MP_BC_STORE_FAST_2):
                    fastn[-2] = POP();
                    DISPATCH();

                ENTRY(MP_BC_STORE_FAST_N):
                    DECODE_UINT;
                    fastn[-unum] = POP();
                    DISPATCH();

                ENTRY(MP_BC_STORE_DEREF):
                    DECODE_UINT;
                    mp_obj_cell_set(fastn[-unum], POP());
                    DISPATCH();

428
                ENTRY(MP_BC_STORE_NAME): {
429
430
431
                    DECODE_QSTR;
                    mp_store_name(qst, POP());
                    DISPATCH();
432
                }
433

434
                ENTRY(MP_BC_STORE_GLOBAL): {
435
436
437
                    DECODE_QSTR;
                    mp_store_global(qst, POP());
                    DISPATCH();
438
                }
439

440
                ENTRY(MP_BC_STORE_ATTR): {
441
442
443
444
                    DECODE_QSTR;
                    mp_store_attr(sp[0], qst, sp[-1]);
                    sp -= 2;
                    DISPATCH();
445
                }
446
447

                ENTRY(MP_BC_STORE_SUBSCR):
448
                    mp_obj_subscr(sp[-1], sp[0], sp[-2]);
449
450
451
452
453
454
455
456
457
458
                    sp -= 3;
                    DISPATCH();

                ENTRY(MP_BC_DELETE_FAST):
                    DECODE_UINT;
                    if (fastn[-unum] == MP_OBJ_NULL) {
                        goto local_name_error;
                    }
                    fastn[-unum] = MP_OBJ_NULL;
                    DISPATCH();
459

460
461
462
463
464
465
466
467
                ENTRY(MP_BC_DELETE_DEREF):
                    DECODE_UINT;
                    if (mp_obj_cell_get(fastn[-unum]) == MP_OBJ_NULL) {
                        goto local_name_error;
                    }
                    mp_obj_cell_set(fastn[-unum], MP_OBJ_NULL);
                    DISPATCH();

468
                ENTRY(MP_BC_DELETE_NAME): {
469
470
471
                    DECODE_QSTR;
                    mp_delete_name(qst);
                    DISPATCH();
472
                }
473

474
                ENTRY(MP_BC_DELETE_GLOBAL): {
475
476
477
                    DECODE_QSTR;
                    mp_delete_global(qst);
                    DISPATCH();
478
                }
479

480
481
482
                ENTRY(MP_BC_DUP_TOP): {
                    mp_obj_t top = TOP();
                    PUSH(top);
483
                    DISPATCH();
484
                }
485
486
487
488
489
490
491
492
493
494
495

                ENTRY(MP_BC_DUP_TOP_TWO):
                    sp += 2;
                    sp[0] = sp[-2];
                    sp[-1] = sp[-3];
                    DISPATCH();

                ENTRY(MP_BC_POP_TOP):
                    sp -= 1;
                    DISPATCH();

496
497
                ENTRY(MP_BC_ROT_TWO): {
                    mp_obj_t top = sp[0];
498
                    sp[0] = sp[-1];
499
                    sp[-1] = top;
500
                    DISPATCH();
501
                }
502

503
504
                ENTRY(MP_BC_ROT_THREE): {
                    mp_obj_t top = sp[0];
505
506
                    sp[0] = sp[-1];
                    sp[-1] = sp[-2];
507
                    sp[-2] = top;
508
                    DISPATCH();
509
                }
510
511
512
513
514
515
516
517
518
519
520
521

                ENTRY(MP_BC_JUMP):
                    DECODE_SLABEL;
                    ip += unum;
                    DISPATCH();

                ENTRY(MP_BC_POP_JUMP_IF_TRUE):
                    DECODE_SLABEL;
                    if (mp_obj_is_true(POP())) {
                        ip += unum;
                    }
                    DISPATCH();
Damien's avatar
Damien committed
522

523
524
525
526
527
528
                ENTRY(MP_BC_POP_JUMP_IF_FALSE):
                    DECODE_SLABEL;
                    if (!mp_obj_is_true(POP())) {
                        ip += unum;
                    }
                    DISPATCH();
Damien's avatar
Damien committed
529

530
531
532
533
534
535
536
537
                ENTRY(MP_BC_JUMP_IF_TRUE_OR_POP):
                    DECODE_SLABEL;
                    if (mp_obj_is_true(TOP())) {
                        ip += unum;
                    } else {
                        sp--;
                    }
                    DISPATCH();
538

539
540
541
542
543
544
545
546
547
                ENTRY(MP_BC_JUMP_IF_FALSE_OR_POP):
                    DECODE_SLABEL;
                    if (mp_obj_is_true(TOP())) {
                        sp--;
                    } else {
                        ip += unum;
                    }
                    DISPATCH();

548
549
550
551
552
                ENTRY(MP_BC_SETUP_WITH): {
                    mp_obj_t obj = TOP();
                    SET_TOP(mp_load_attr(obj, MP_QSTR___exit__));
                    mp_load_method(obj, MP_QSTR___enter__, sp + 1);
                    mp_obj_t ret = mp_call_method_n_kw(0, 0, sp + 1);
553
                    PUSH_EXC_BLOCK();
554
                    PUSH(ret);
555
                    DISPATCH();
556
                }
557
558
559
560
561
562
563
564
565

                ENTRY(MP_BC_WITH_CLEANUP): {
                    // Arriving here, there's "exception control block" on top of stack,
                    // and __exit__ bound method underneath it. Bytecode calls __exit__,
                    // and "deletes" it off stack, shifting "exception control block"
                    // to its place.
                    static const mp_obj_t no_exc[] = {mp_const_none, mp_const_none, mp_const_none};
                    if (TOP() == mp_const_none) {
                        sp--;
566
                        mp_obj_t obj = TOP();
567
                        SET_TOP(mp_const_none);
568
                        mp_call_function_n_kw(obj, 3, 0, no_exc);
569
570
571
572
573
                    } else if (MP_OBJ_IS_SMALL_INT(TOP())) {
                        mp_obj_t cause = POP();
                        switch (MP_OBJ_SMALL_INT_VALUE(cause)) {
                            case UNWIND_RETURN: {
                                mp_obj_t retval = POP();
574
                                mp_call_function_n_kw(TOP(), 3, 0, no_exc);
575
576
577
                                SET_TOP(retval);
                                PUSH(cause);
                                break;
578
                            }
579
                            case UNWIND_JUMP: {
580
                                mp_call_function_n_kw(sp[-2], 3, 0, no_exc);
581
582
583
584
585
                                // Pop __exit__ boundmethod at sp[-2]
                                sp[-2] = sp[-1];
                                sp[-1] = sp[0];
                                SET_TOP(cause);
                                break;
586
                            }
587
588
                            default:
                                assert(0);
589
                        }
590
591
                    } else if (mp_obj_is_exception_type(TOP())) {
                        mp_obj_t args[3] = {sp[0], sp[-1], sp[-2]};
592
                        mp_obj_t ret_value = mp_call_function_n_kw(sp[-3], 3, 0, args);
593
                        // Pop __exit__ boundmethod at sp[-3]
594
                        // TODO: Once semantics is proven, optimize for case when ret_value == True
595
596
597
598
                        sp[-3] = sp[-2];
                        sp[-2] = sp[-1];
                        sp[-1] = sp[0];
                        sp--;
599
                        if (mp_obj_is_true(ret_value)) {
600
601
602
603
604
605
606
                            // This is what CPython does
                            //PUSH(MP_OBJ_NEW_SMALL_INT(UNWIND_SILENCED));
                            // But what we need to do is - pop exception from value stack...
                            sp -= 3;
                            // ... pop "with" exception handler, and signal END_FINALLY
                            // to just execute finally handler normally (by pushing None
                            // on value stack)
607
                            assert(exc_sp >= exc_stack);
608
609
610
                            assert(exc_sp->opcode == MP_BC_SETUP_WITH);
                            POP_EXC_BLOCK();
                            PUSH(mp_const_none);
611
                        }
612
613
614
615
616
                    } else {
                        assert(0);
                    }
                    DISPATCH();
                }
617

618
619
620
621
622
623
624
625
                ENTRY(MP_BC_UNWIND_JUMP):
                    DECODE_SLABEL;
                    PUSH((void*)(ip + unum)); // push destination ip for jump
                    PUSH((void*)(machine_uint_t)(*ip)); // push number of exception handlers to unwind
unwind_jump:
                    unum = (machine_uint_t)POP(); // get number of exception handlers to unwind
                    while (unum > 0) {
                        unum -= 1;
626
                        assert(exc_sp >= exc_stack);
627
628
629
630
631
632
633
634
635
636
                        if (exc_sp->opcode == MP_BC_SETUP_FINALLY || exc_sp->opcode == MP_BC_SETUP_WITH) {
                            // We're going to run "finally" code as a coroutine
                            // (not calling it recursively). Set up a sentinel
                            // on a stack so it can return back to us when it is
                            // done (when END_FINALLY reached).
                            PUSH((void*)unum); // push number of exception handlers left to unwind
                            PUSH(MP_OBJ_NEW_SMALL_INT(UNWIND_JUMP)); // push sentinel
                            ip = exc_sp->handler; // get exception handler byte code address
                            exc_sp--; // pop exception handler
                            goto dispatch_loop; // run the exception handler
637
                        }
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
                        exc_sp--;
                    }
                    ip = (const byte*)POP(); // pop destination ip for jump
                    DISPATCH();

                // matched against: POP_BLOCK or POP_EXCEPT (anything else?)
                ENTRY(MP_BC_SETUP_EXCEPT):
                ENTRY(MP_BC_SETUP_FINALLY):
                    PUSH_EXC_BLOCK();
                    DISPATCH();

                ENTRY(MP_BC_END_FINALLY):
                    // not fully implemented
                    // if TOS is an exception, reraises the exception (3 values on TOS)
                    // if TOS is None, just pops it and continues
                    // if TOS is an integer, does something else
                    // else error
                    if (mp_obj_is_exception_type(TOP())) {
656
                        RAISE(sp[-1]);
657
658
                    }
                    if (TOP() == mp_const_none) {
659
                        sp--;
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
                    } else if (MP_OBJ_IS_SMALL_INT(TOP())) {
                        // We finished "finally" coroutine and now dispatch back
                        // to our caller, based on TOS value
                        mp_unwind_reason_t reason = MP_OBJ_SMALL_INT_VALUE(POP());
                        switch (reason) {
                            case UNWIND_RETURN:
                                goto unwind_return;
                            case UNWIND_JUMP:
                                goto unwind_jump;
                        }
                        assert(0);
                    } else {
                        assert(0);
                    }
                    DISPATCH();

                ENTRY(MP_BC_GET_ITER):
                    SET_TOP(mp_getiter(TOP()));
                    DISPATCH();

680
                ENTRY(MP_BC_FOR_ITER): {
681
                    DECODE_ULABEL; // the jump offset if iteration finishes; for labels are always forward
682
                    save_sp = sp;
683
                    assert(TOP());
684
685
                    mp_obj_t value = mp_iternext_allow_raise(TOP());
                    if (value == MP_OBJ_STOP_ITERATION) {
686
687
688
                        --sp; // pop the exhausted iterator
                        ip += unum; // jump to after for-block
                    } else {
689
                        PUSH(value); // push the next iteration value
690
691
                    }
                    DISPATCH();
692
                }
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725

                // matched against: SETUP_EXCEPT, SETUP_FINALLY, SETUP_WITH
                ENTRY(MP_BC_POP_BLOCK):
                    // we are exiting an exception handler, so pop the last one of the exception-stack
                    assert(exc_sp >= exc_stack);
                    POP_EXC_BLOCK();
                    DISPATCH();

                // matched against: SETUP_EXCEPT
                ENTRY(MP_BC_POP_EXCEPT):
                    // TODO need to work out how blocks work etc
                    // pops block, checks it's an exception block, and restores the stack, saving the 3 exception values to local threadstate
                    assert(exc_sp >= exc_stack);
                    assert(currently_in_except_block);
                    //sp = (mp_obj_t*)(*exc_sp--);
                    //exc_sp--; // discard ip
                    POP_EXC_BLOCK();
                    //sp -= 3; // pop 3 exception values
                    DISPATCH();

                ENTRY(MP_BC_NOT):
                    if (TOP() == mp_const_true) {
                        SET_TOP(mp_const_false);
                    } else {
                        SET_TOP(mp_const_true);
                    }
                    DISPATCH();

                ENTRY(MP_BC_UNARY_OP):
                    unum = *ip++;
                    SET_TOP(mp_unary_op(unum, TOP()));
                    DISPATCH();

726
                ENTRY(MP_BC_BINARY_OP): {
727
                    unum = *ip++;
728
729
730
                    mp_obj_t rhs = POP();
                    mp_obj_t lhs = TOP();
                    SET_TOP(mp_binary_op(unum, lhs, rhs));
731
                    DISPATCH();
732
                }
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781

                ENTRY(MP_BC_BUILD_TUPLE):
                    DECODE_UINT;
                    sp -= unum - 1;
                    SET_TOP(mp_obj_new_tuple(unum, sp));
                    DISPATCH();

                ENTRY(MP_BC_BUILD_LIST):
                    DECODE_UINT;
                    sp -= unum - 1;
                    SET_TOP(mp_obj_new_list(unum, sp));
                    DISPATCH();

                ENTRY(MP_BC_LIST_APPEND):
                    DECODE_UINT;
                    // I think it's guaranteed by the compiler that sp[unum] is a list
                    mp_obj_list_append(sp[-unum], sp[0]);
                    sp--;
                    DISPATCH();

                ENTRY(MP_BC_BUILD_MAP):
                    DECODE_UINT;
                    PUSH(mp_obj_new_dict(unum));
                    DISPATCH();

                ENTRY(MP_BC_STORE_MAP):
                    sp -= 2;
                    mp_obj_dict_store(sp[0], sp[2], sp[1]);
                    DISPATCH();

                ENTRY(MP_BC_MAP_ADD):
                    DECODE_UINT;
                    // I think it's guaranteed by the compiler that sp[-unum - 1] is a map
                    mp_obj_dict_store(sp[-unum - 1], sp[0], sp[-1]);
                    sp -= 2;
                    DISPATCH();

                ENTRY(MP_BC_BUILD_SET):
                    DECODE_UINT;
                    sp -= unum - 1;
                    SET_TOP(mp_obj_new_set(unum, sp));
                    DISPATCH();

                ENTRY(MP_BC_SET_ADD):
                    DECODE_UINT;
                    // I think it's guaranteed by the compiler that sp[-unum] is a set
                    mp_obj_set_store(sp[-unum], sp[0]);
                    sp--;
                    DISPATCH();
Damien's avatar
Damien committed
782

783
#if MICROPY_PY_SLICE
784
785
786
                ENTRY(MP_BC_BUILD_SLICE):
                    DECODE_UINT;
                    if (unum == 2) {
787
788
789
                        mp_obj_t stop = POP();
                        mp_obj_t start = TOP();
                        SET_TOP(mp_obj_new_slice(start, stop, mp_const_none));
790
                    } else {
791
792
793
794
                        mp_obj_t step = POP();
                        mp_obj_t stop = POP();
                        mp_obj_t start = TOP();
                        SET_TOP(mp_obj_new_slice(start, stop, step));
795
796
                    }
                    DISPATCH();
797
#endif
798

799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
                ENTRY(MP_BC_UNPACK_SEQUENCE):
                    DECODE_UINT;
                    mp_unpack_sequence(sp[0], unum, sp);
                    sp += unum - 1;
                    DISPATCH();

                ENTRY(MP_BC_UNPACK_EX):
                    DECODE_UINT;
                    mp_unpack_ex(sp[0], unum, sp);
                    sp += (unum & 0xff) + ((unum >> 8) & 0xff);
                    DISPATCH();

                ENTRY(MP_BC_MAKE_FUNCTION):
                    DECODE_PTR;
                    PUSH(mp_make_function_from_raw_code((mp_raw_code_t*)unum, MP_OBJ_NULL, MP_OBJ_NULL));
                    DISPATCH();

816
                ENTRY(MP_BC_MAKE_FUNCTION_DEFARGS): {
817
818
                    DECODE_PTR;
                    // Stack layout: def_tuple def_dict <- TOS
819
820
                    mp_obj_t def_dict = POP();
                    SET_TOP(mp_make_function_from_raw_code((mp_raw_code_t*)unum, TOP(), def_dict));
821
                    DISPATCH();
822
                }
823

824
                ENTRY(MP_BC_MAKE_CLOSURE): {
825
                    DECODE_PTR;
826
827
828
829
                    machine_uint_t n_closed_over = *ip++;
                    // Stack layout: closed_overs <- TOS
                    sp -= n_closed_over - 1;
                    SET_TOP(mp_make_closure_from_raw_code((mp_raw_code_t*)unum, n_closed_over, sp));
830
                    DISPATCH();
831
                }
832

833
                ENTRY(MP_BC_MAKE_CLOSURE_DEFARGS): {
834
                    DECODE_PTR;
835
836
837
838
                    machine_uint_t n_closed_over = *ip++;
                    // Stack layout: def_tuple def_dict closed_overs <- TOS
                    sp -= 2 + n_closed_over - 1;
                    SET_TOP(mp_make_closure_from_raw_code((mp_raw_code_t*)unum, 0x100 | n_closed_over, sp));
839
                    DISPATCH();
840
                }
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878

                ENTRY(MP_BC_CALL_FUNCTION):
                    DECODE_UINT;
                    // unum & 0xff == n_positional
                    // (unum >> 8) & 0xff == n_keyword
                    sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe);
                    SET_TOP(mp_call_function_n_kw(*sp, unum & 0xff, (unum >> 8) & 0xff, sp + 1));
                    DISPATCH();

                ENTRY(MP_BC_CALL_FUNCTION_VAR_KW):
                    DECODE_UINT;
                    // unum & 0xff == n_positional
                    // (unum >> 8) & 0xff == n_keyword
                    // We have folowing stack layout here:
                    // fun arg0 arg1 ... kw0 val0 kw1 val1 ... seq dict <- TOS
                    sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe) + 2;
                    SET_TOP(mp_call_method_n_kw_var(false, unum, sp));
                    DISPATCH();

                ENTRY(MP_BC_CALL_METHOD):
                    DECODE_UINT;
                    // unum & 0xff == n_positional
                    // (unum >> 8) & 0xff == n_keyword
                    sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe) + 1;
                    SET_TOP(mp_call_method_n_kw(unum & 0xff, (unum >> 8) & 0xff, sp));
                    DISPATCH();

                ENTRY(MP_BC_CALL_METHOD_VAR_KW):
                    DECODE_UINT;
                    // unum & 0xff == n_positional
                    // (unum >> 8) & 0xff == n_keyword
                    // We have folowing stack layout here:
                    // fun self arg0 arg1 ... kw0 val0 kw1 val1 ... seq dict <- TOS
                    sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe) + 3;
                    SET_TOP(mp_call_method_n_kw_var(true, unum, sp));
                    DISPATCH();

                ENTRY(MP_BC_RETURN_VALUE):
879
unwind_return:
880
881
882
883
884
885
886
887
888
889
890
                    while (exc_sp >= exc_stack) {
                        if (exc_sp->opcode == MP_BC_SETUP_FINALLY || exc_sp->opcode == MP_BC_SETUP_WITH) {
                            // We're going to run "finally" code as a coroutine
                            // (not calling it recursively). Set up a sentinel
                            // on a stack so it can return back to us when it is
                            // done (when END_FINALLY reached).
                            PUSH(MP_OBJ_NEW_SMALL_INT(UNWIND_RETURN));
                            ip = exc_sp->handler;
                            // We don't need to do anything with sp, finally is just
                            // syntactic sugar for sequential execution??
                            // sp =
891
                            exc_sp--;
892
                            goto dispatch_loop;
893
                        }
894
895
896
897
898
899
900
                        exc_sp--;
                    }
                    nlr_pop();
                    *sp_in_out = sp;
                    assert(exc_sp == exc_stack - 1);
                    return MP_VM_RETURN_NORMAL;

901
                ENTRY(MP_BC_RAISE_VARARGS): {
902
                    unum = *ip++;
903
                    mp_obj_t obj;
904
905
906
                    assert(unum <= 1);
                    if (unum == 0) {
                        // search for the inner-most previous exception, to reraise it
907
                        obj = MP_OBJ_NULL;
908
909
                        for (mp_exc_stack_t *e = exc_sp; e >= exc_stack; e--) {
                            if (e->prev_exc != MP_OBJ_NULL) {
910
                                obj = e->prev_exc;
911
                                break;
912
                            }
913
                        }
914
915
916
                        if (obj == MP_OBJ_NULL) {
                            obj = mp_obj_new_exception_msg(&mp_type_RuntimeError, "No active exception to reraise");
                            RAISE(obj);
917
918
                        }
                    } else {
919
                        obj = POP();
920
                    }
921
922
923
                    obj = mp_make_raise_obj(obj);
                    RAISE(obj);
                }
924

925
                ENTRY(MP_BC_YIELD_VALUE):
926
yield:
927
928
929
930
931
                    nlr_pop();
                    *ip_in_out = ip;
                    *sp_in_out = sp;
                    *exc_sp_in_out = MP_TAGPTR_MAKE(exc_sp, currently_in_except_block);
                    return MP_VM_RETURN_YIELD;
932

933
                ENTRY(MP_BC_YIELD_FROM): {
934
935
//#define EXC_MATCH(exc, type) MP_OBJ_IS_TYPE(exc, type)
#define EXC_MATCH(exc, type) mp_obj_exception_match(exc, type)
936
#define GENERATOR_EXIT_IF_NEEDED(t) if (t != MP_OBJ_NULL && EXC_MATCH(t, &mp_type_GeneratorExit)) { RAISE(t); }
937
                    mp_vm_return_kind_t ret_kind;
938
                    mp_obj_t send_value = POP();
939
                    mp_obj_t t_exc = MP_OBJ_NULL;
940
                    mp_obj_t ret_value;
941
942
943
                    if (inject_exc != MP_OBJ_NULL) {
                        t_exc = inject_exc;
                        inject_exc = MP_OBJ_NULL;
944
                        ret_kind = mp_resume(TOP(), MP_OBJ_NULL, t_exc, &ret_value);
945
                    } else {
946
                        ret_kind = mp_resume(TOP(), send_value, MP_OBJ_NULL, &ret_value);
947
                    }
948

949
950
                    if (ret_kind == MP_VM_RETURN_YIELD) {
                        ip--;
951
                        PUSH(ret_value);
952
953
954
955
956
                        goto yield;
                    }
                    if (ret_kind == MP_VM_RETURN_NORMAL) {
                        // Pop exhausted gen
                        sp--;
957
                        if (ret_value == MP_OBJ_NULL) {
958
959
960
961
                            // Optimize StopIteration
                            // TODO: get StopIteration's value
                            PUSH(mp_const_none);
                        } else {
962
                            PUSH(ret_value);
963
964
                        }

965
966
967
968
969
970
971
972
                        // If we injected GeneratorExit downstream, then even
                        // if it was swallowed, we re-raise GeneratorExit
                        GENERATOR_EXIT_IF_NEEDED(t_exc);
                        DISPATCH();
                    }
                    if (ret_kind == MP_VM_RETURN_EXCEPTION) {
                        // Pop exhausted gen
                        sp--;
973
974
                        if (EXC_MATCH(ret_value, &mp_type_StopIteration)) {
                            PUSH(mp_obj_exception_get_value(ret_value));
975
976
977
                            // If we injected GeneratorExit downstream, then even
                            // if it was swallowed, we re-raise GeneratorExit
                            GENERATOR_EXIT_IF_NEEDED(t_exc);
978
979
                            DISPATCH();
                        } else {
980
                            RAISE(ret_value);
981
982
                        }
                    }
983
                }
984

985
                ENTRY(MP_BC_IMPORT_NAME): {
986
                    DECODE_QSTR;
987
988
                    mp_obj_t obj = POP();
                    SET_TOP(mp_import_name(qst, obj, TOP()));
989
                    DISPATCH();
990
                }
991

992
                ENTRY(MP_BC_IMPORT_FROM): {
993
                    DECODE_QSTR;
994
995
                    mp_obj_t obj = mp_import_from(TOP(), qst);
                    PUSH(obj);
996
                    DISPATCH();
997
                }
998
999
1000
1001
1002

                ENTRY(MP_BC_IMPORT_STAR):
                    mp_import_all(POP());
                    DISPATCH();

1003
1004
                ENTRY_DEFAULT: {
                    mp_obj_t obj = mp_obj_new_exception_msg(&mp_type_NotImplementedError, "byte code not implemented");
1005
                    nlr_pop();
1006
                    fastn[0] = obj;
1007
                    return MP_VM_RETURN_EXCEPTION;
1008
                }
1009

1010
#if !MICROPY_OPT_COMPUTED_GOTO
1011
                } // switch
1012
#endif
1013
            } // for loop
1014
1015

        } else {
1016
exception_handler:
1017
1018
            // exception occurred

1019
1020
            // check if it's a StopIteration within a for block
            if (*save_ip == MP_BC_FOR_ITER && mp_obj_is_subclass_fast(mp_obj_get_type(nlr.ret_val), &mp_type_StopIteration)) {
1021
1022
                const byte *ip = save_ip + 1;
                machine_uint_t unum;
1023
                DECODE_ULABEL; // the jump offset if iteration finishes; for labels are always forward
1024
1025
                *ip_in_out = ip + unum; // jump to after for-block
                *sp_in_out = save_sp - 1; // pop the exhausted iterator
1026
1027
1028
                goto outer_dispatch_loop; // continue with dispatch loop
            }

1029
            // set file and line number that the exception occurred at
1030
1031
            // TODO: don't set traceback for exceptions re-raised by END_FINALLY.
            // But consider how to handle nested exceptions.
1032
1033
            // TODO need a better way of not adding traceback to constant objects (right now, just GeneratorExit_obj and MemoryError_obj)
            if (mp_obj_is_exception_instance(nlr.ret_val) && nlr.ret_val != &mp_const_GeneratorExit_obj && nlr.ret_val != &mp_const_MemoryError_obj) {
1034
                machine_uint_t code_info_size = code_info[0] | (code_info[1] << 8) | (code_info[2] << 16) | (code_info[3] << 24);
1035
1036
                qstr source_file = code_info[4] | (code_info[5] << 8) | (code_info[6] << 16) | (code_info[7] << 24);
                qstr block_name = code_info[8] | (code_info[9] << 8) | (code_info[10] << 16) | (code_info[11] << 24);
1037
1038
                machine_uint_t source_line = 1;
                machine_uint_t bc = save_ip - code_info - code_info_size;
1039
                //printf("find %lu %d %d\n", bc, code_info[12], code_info[13]);
1040
1041
1042
                for (const byte* ci = code_info + 12; *ci && bc >= ((*ci) & 31); ci++) {
                    bc -= *ci & 31;
                    source_line += *ci >> 5;
1043
                }