vm.c 35.2 KB
Newer Older
Damien's avatar
Damien committed
1
2
3
#include <stdio.h>
#include <assert.h>

4
#include "nlr.h"
Damien's avatar
Damien committed
5
#include "misc.h"
6
#include "mpconfig.h"
7
#include "qstr.h"
8
#include "obj.h"
Damien's avatar
Damien committed
9
#include "runtime.h"
10
#include "bc0.h"
11
#include "bc.h"
12
#include "objgenerator.h"
Damien's avatar
Damien committed
13

Paul Sokolovsky's avatar
Paul Sokolovsky committed
14
15
16
17
18
19
20
// 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.

21
// Exception stack unwind reasons (WHY_* in CPython-speak)
22
23
// TODO perhaps compress this to RETURN=0, JUMP>0, with number of unwinds
// left to do encoded in the JUMP number
24
25
typedef enum {
    UNWIND_RETURN = 1,
26
    UNWIND_JUMP,
27
28
} mp_unwind_reason_t;

29
30
31
32
33
34
#define DECODE_UINT { \
    unum = 0; \
    do { \
        unum = (unum << 7) + (*ip & 0x7f); \
    } while ((*ip++ & 0x80) != 0); \
}
Damien's avatar
Damien committed
35
36
#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)
37
38
39
40
41
42
#define DECODE_QSTR { \
    qst = 0; \
    do { \
        qst = (qst << 7) + (*ip & 0x7f); \
    } while ((*ip++ & 0x80) != 0); \
}
43
44
#define PUSH(val) *++sp = (val)
#define POP() (*sp--)
45
46
#define TOP() (*sp)
#define SET_TOP(val) *sp = (val)
Damien's avatar
Damien committed
47

48
49
50
51
52
53
54
55
#define SETUP_BLOCK() \
    DECODE_ULABEL; /* except labels are always forward */ \
    ++exc_sp; \
    exc_sp->opcode = op; \
    exc_sp->handler = ip + unum; \
    exc_sp->val_sp = MP_TAGPTR_MAKE(sp, currently_in_except_block); \
    currently_in_except_block = 0; /* in a try block now */

56
mp_vm_return_kind_t mp_execute_byte_code(const byte *code, const mp_obj_t *args, uint n_args, const mp_obj_t *args2, uint n_args2, mp_obj_t *ret) {
57
58
59
60
61
62
    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;

63
64
65
66
    // 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;
67

68
69
    // allocate state for locals and stack
    mp_obj_t temp_state[10];
70
    mp_obj_t *state = &temp_state[0];
71
    if (n_state > 10) {
72
        state = m_new(mp_obj_t, n_state);
73
    }
74
75
    mp_obj_t *sp = &state[0] - 1;

76
77
78
79
80
81
82
83
    // allocate state for exceptions
    mp_exc_stack exc_state[4];
    mp_exc_stack *exc_stack = &exc_state[0];
    if (n_exc_stack > 4) {
        exc_stack = m_new(mp_exc_stack, n_exc_stack);
    }
    mp_exc_stack *exc_sp = &exc_stack[0] - 1;

84
    // init args
85
    for (uint i = 0; i < n_args; i++) {
86
        state[n_state - 1 - i] = args[i];
87
    }
88
89
90
    for (uint i = 0; i < n_args2; i++) {
        state[n_state - 1 - n_args - i] = args2[i];
    }
91

92
93
94
95
96
97
98
    // bytecode prelude: initialise closed over variables
    for (uint n_local = *ip++; n_local > 0; n_local--) {
        uint local_num = *ip++;
        if (local_num < n_args + n_args2) {
            state[n_state - 1 - local_num] = mp_obj_new_cell(state[n_state - 1 - local_num]);
        } else {
            state[n_state - 1 - local_num] = mp_obj_new_cell(MP_OBJ_NULL);
Damien George's avatar
Damien George committed
99
100
101
102
        }
    }

    // execute the byte code
103
    mp_vm_return_kind_t vm_return_kind = mp_execute_byte_code_2(code, &ip, &state[n_state - 1], &sp, exc_stack, &exc_sp, MP_OBJ_NULL);
104
105
106
107
108
109
110
111
112
113
114
115
116

    switch (vm_return_kind) {
        case MP_VM_RETURN_NORMAL:
            *ret = *sp;
            return MP_VM_RETURN_NORMAL;
        case MP_VM_RETURN_EXCEPTION:
            *ret = state[n_state - 1];
            return MP_VM_RETURN_EXCEPTION;
        case MP_VM_RETURN_YIELD: // byte-code shouldn't yield
        default:
            assert(0);
            *ret = mp_const_none;
            return MP_VM_RETURN_NORMAL;
117
118
119
    }
}

120
121
// 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
122
123
124
125
// 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]
126
127
mp_vm_return_kind_t mp_execute_byte_code_2(const byte *code_info, const byte **ip_in_out,
                                           mp_obj_t *fastn, mp_obj_t **sp_in_out,
128
129
                                           mp_exc_stack *exc_stack, mp_exc_stack **exc_sp_in_out,
                                           volatile mp_obj_t inject_exc) {
Damien's avatar
Damien committed
130
131
    // careful: be sure to declare volatile any variables read in the exception handler (written is ok, I think)

132
    const byte *ip = *ip_in_out;
133
    mp_obj_t *sp = *sp_in_out;
Damien's avatar
Damien committed
134
    machine_uint_t unum;
135
    qstr qst;
136
    mp_obj_t obj1, obj2;
137
    nlr_buf_t nlr;
Damien's avatar
Damien committed
138

139
140
    volatile bool currently_in_except_block = MP_TAGPTR_TAG(*exc_sp_in_out); // 0 or 1, to detect nested exceptions
    mp_exc_stack *volatile exc_sp = MP_TAGPTR_PTR(*exc_sp_in_out); // stack grows up, exc_sp points to top of stack
141
    const byte *volatile save_ip = ip; // 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)
Damien's avatar
Damien committed
142

143
    // outer exception handling loop
Damien's avatar
Damien committed
144
    for (;;) {
145
outer_dispatch_loop:
146
        if (nlr_push(&nlr) == 0) {
147
148
149
            // 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.
150
151
152
            // 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) {
153
154
155
156
                mp_obj_t t = inject_exc;
                inject_exc = MP_OBJ_NULL;
                nlr_jump(rt_make_raise_obj(t));
            }
157
158
            // loop to execute byte code
            for (;;) {
159
dispatch_loop:
160
                save_ip = ip;
161
162
                int op = *ip++;
                switch (op) {
163
164
                    case MP_BC_LOAD_CONST_FALSE:
                        PUSH(mp_const_false);
165
166
                        break;

167
168
                    case MP_BC_LOAD_CONST_NONE:
                        PUSH(mp_const_none);
169
170
                        break;

171
172
                    case MP_BC_LOAD_CONST_TRUE:
                        PUSH(mp_const_true);
173
                        break;
Damien George's avatar
Damien George committed
174
175

                    case MP_BC_LOAD_CONST_ELLIPSIS:
176
                        PUSH((mp_obj_t)&mp_const_ellipsis_obj);
Damien George's avatar
Damien George committed
177
                        break;
178

179
                    case MP_BC_LOAD_CONST_SMALL_INT: {
180
                        machine_int_t num = 0;
181
182
183
184
185
186
187
188
                        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));
189
                        break;
190
                    }
191

192
193
                    case MP_BC_LOAD_CONST_INT:
                        DECODE_QSTR;
194
                        PUSH(mp_obj_new_int_from_long_str(qstr_str(qst)));
195
196
                        break;

197
                    case MP_BC_LOAD_CONST_DEC:
Damien's avatar
Damien committed
198
                        DECODE_QSTR;
199
                        PUSH(rt_load_const_dec(qst));
Damien's avatar
Damien committed
200
201
                        break;

202
                    case MP_BC_LOAD_CONST_ID:
203
                        DECODE_QSTR;
204
                        PUSH(rt_load_const_str(qst)); // TODO
205
206
                        break;

207
208
                    case MP_BC_LOAD_CONST_BYTES:
                        DECODE_QSTR;
209
                        PUSH(rt_load_const_bytes(qst));
210
211
                        break;

212
                    case MP_BC_LOAD_CONST_STRING:
213
                        DECODE_QSTR;
214
                        PUSH(rt_load_const_str(qst));
215
216
                        break;

217
                    case MP_BC_LOAD_FAST_0:
218
                        PUSH(fastn[0]);
219
220
                        break;

221
                    case MP_BC_LOAD_FAST_1:
222
                        PUSH(fastn[-1]);
223
224
                        break;

225
                    case MP_BC_LOAD_FAST_2:
226
                        PUSH(fastn[-2]);
227
228
                        break;

229
                    case MP_BC_LOAD_FAST_N:
230
                        DECODE_UINT;
231
                        PUSH(fastn[-unum]);
232
233
                        break;

234
                    case MP_BC_LOAD_DEREF:
Damien's avatar
Damien committed
235
                        DECODE_UINT;
236
                        PUSH(rt_get_cell(fastn[-unum]));
Damien's avatar
Damien committed
237
238
                        break;

239
                    case MP_BC_LOAD_NAME:
240
                        DECODE_QSTR;
241
                        PUSH(rt_load_name(qst));
242
243
                        break;

244
                    case MP_BC_LOAD_GLOBAL:
245
                        DECODE_QSTR;
246
                        PUSH(rt_load_global(qst));
247
248
                        break;

249
                    case MP_BC_LOAD_ATTR:
250
                        DECODE_QSTR;
251
                        SET_TOP(rt_load_attr(TOP(), qst));
252
253
                        break;

254
                    case MP_BC_LOAD_METHOD:
255
                        DECODE_QSTR;
256
                        rt_load_method(*sp, qst, sp);
257
                        sp += 1;
258
259
                        break;

260
                    case MP_BC_LOAD_BUILD_CLASS:
261
262
263
                        PUSH(rt_load_build_class());
                        break;

264
                    case MP_BC_STORE_FAST_0:
265
                        fastn[0] = POP();
266
267
                        break;

268
                    case MP_BC_STORE_FAST_1:
269
                        fastn[-1] = POP();
270
271
                        break;

272
                    case MP_BC_STORE_FAST_2:
273
                        fastn[-2] = POP();
274
275
                        break;

276
                    case MP_BC_STORE_FAST_N:
277
                        DECODE_UINT;
278
                        fastn[-unum] = POP();
279
280
                        break;

281
                    case MP_BC_STORE_DEREF:
Damien's avatar
Damien committed
282
                        DECODE_UINT;
283
                        rt_set_cell(fastn[-unum], POP());
Damien's avatar
Damien committed
284
285
                        break;

286
                    case MP_BC_STORE_NAME:
287
                        DECODE_QSTR;
288
                        rt_store_name(qst, POP());
289
290
                        break;

291
                    case MP_BC_STORE_GLOBAL:
292
                        DECODE_QSTR;
293
                        rt_store_global(qst, POP());
294
295
                        break;

296
                    case MP_BC_STORE_ATTR:
297
                        DECODE_QSTR;
298
                        rt_store_attr(sp[0], qst, sp[-1]);
299
                        sp -= 2;
300
301
                        break;

302
                    case MP_BC_STORE_SUBSCR:
303
304
                        rt_store_subscr(sp[-1], sp[0], sp[-2]);
                        sp -= 3;
305
306
                        break;

307
308
309
310
311
                    case MP_BC_DELETE_NAME:
                        DECODE_QSTR;
                        rt_delete_name(qst);
                        break;

312
                    case MP_BC_DUP_TOP:
313
                        obj1 = TOP();
314
315
316
                        PUSH(obj1);
                        break;

317
                    case MP_BC_DUP_TOP_TWO:
318
319
320
                        sp += 2;
                        sp[0] = sp[-2];
                        sp[-1] = sp[-3];
321
322
                        break;

323
                    case MP_BC_POP_TOP:
324
                        sp -= 1;
325
326
                        break;

327
                    case MP_BC_ROT_TWO:
328
                        obj1 = sp[0];
329
330
                        sp[0] = sp[-1];
                        sp[-1] = obj1;
331
332
                        break;

333
                    case MP_BC_ROT_THREE:
334
                        obj1 = sp[0];
335
336
337
                        sp[0] = sp[-1];
                        sp[-1] = sp[-2];
                        sp[-2] = obj1;
338
339
                        break;

340
                    case MP_BC_JUMP:
Damien's avatar
Damien committed
341
342
                        DECODE_SLABEL;
                        ip += unum;
343
344
                        break;

345
                    case MP_BC_POP_JUMP_IF_TRUE:
Damien's avatar
Damien committed
346
                        DECODE_SLABEL;
347
                        if (rt_is_true(POP())) {
Damien's avatar
Damien committed
348
                            ip += unum;
349
350
351
                        }
                        break;

352
                    case MP_BC_POP_JUMP_IF_FALSE:
Damien's avatar
Damien committed
353
                        DECODE_SLABEL;
354
                        if (!rt_is_true(POP())) {
Damien's avatar
Damien committed
355
                            ip += unum;
356
357
358
                        }
                        break;

359
                    case MP_BC_JUMP_IF_TRUE_OR_POP:
Damien's avatar
Damien committed
360
                        DECODE_SLABEL;
361
                        if (rt_is_true(TOP())) {
Damien's avatar
Damien committed
362
363
                            ip += unum;
                        } else {
364
                            sp--;
Damien's avatar
Damien committed
365
366
367
                        }
                        break;

368
                    case MP_BC_JUMP_IF_FALSE_OR_POP:
Damien's avatar
Damien committed
369
                        DECODE_SLABEL;
370
                        if (rt_is_true(TOP())) {
371
                            sp--;
Damien's avatar
Damien committed
372
373
374
375
376
                        } else {
                            ip += unum;
                        }
                        break;

377
                        /* we are trying to get away without using this opcode
378
                    case MP_BC_SETUP_LOOP:
379
                        DECODE_UINT;
380
                        // push_block(MP_BC_SETUP_LOOP, ip + unum, sp)
381
382
383
                        break;
                        */

384
                    case MP_BC_SETUP_WITH:
385
386
                        obj1 = TOP();
                        SET_TOP(rt_load_attr(obj1, MP_QSTR___exit__));
387
388
                        rt_load_method(obj1, MP_QSTR___enter__, sp + 1);
                        obj2 = rt_call_method_n_kw(0, 0, sp + 1);
389
390
391
392
393
                        SETUP_BLOCK();
                        PUSH(obj2);
                        break;

                    case MP_BC_WITH_CLEANUP: {
394
395
396
397
                        // 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.
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
                        static const mp_obj_t no_exc[] = {mp_const_none, mp_const_none, mp_const_none};
                        if (TOP() == mp_const_none) {
                            sp--;
                            obj1 = TOP();
                            SET_TOP(mp_const_none);
                            obj2 = rt_call_function_n_kw(obj1, 3, 0, no_exc);
                        } 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();
                                    obj2 = rt_call_function_n_kw(TOP(), 3, 0, no_exc);
                                    SET_TOP(retval);
                                    PUSH(cause);
                                    break;
                                }
                                case UNWIND_JUMP: {
                                    obj2 = rt_call_function_n_kw(sp[-2], 3, 0, no_exc);
                                    // Pop __exit__ boundmethod at sp[-2]
                                    sp[-2] = sp[-1];
                                    sp[-1] = sp[0];
                                    SET_TOP(cause);
                                    break;
                                }
                                default:
                                    assert(0);
                            }
                        } else if (mp_obj_is_exception_type(TOP())) {
                            mp_obj_t args[3] = {sp[0], sp[-1], sp[-2]};
                            obj2 = rt_call_function_n_kw(sp[-3], 3, 0, args);
                            // Pop __exit__ boundmethod at sp[-3]
                            // TODO: Once semantics is proven, optimize for case when obj2 == True
                            sp[-3] = sp[-2];
                            sp[-2] = sp[-1];
                            sp[-1] = sp[0];
                            sp--;
                            if (rt_is_true(obj2)) {
                                // 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;
439
440
                                // ... pop "with" exception handler, and signal END_FINALLY
                                // to just execute finally handler normally (by pushing None
441
442
443
444
445
446
447
448
449
450
451
452
                                // on value stack)
                                assert(exc_sp >= exc_stack);
                                assert(exc_sp->opcode == MP_BC_SETUP_WITH);
                                exc_sp--;
                                PUSH(mp_const_none);
                            }
                        } else {
                            assert(0);
                        }
                        break;
                    }

453
454
455
456
457
458
459
460
461
                    case 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;
                            assert(exc_sp >= exc_stack);
462
                            if (exc_sp->opcode == MP_BC_SETUP_FINALLY || exc_sp->opcode == MP_BC_SETUP_WITH) {
463
464
465
466
467
468
469
470
471
472
473
474
475
                                // 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
                            }
                            exc_sp--;
                        }
                        ip = (const byte*)POP(); // pop destination ip for jump
476
477
                        break;

Damien's avatar
Damien committed
478
                    // matched against: POP_BLOCK or POP_EXCEPT (anything else?)
479
                    case MP_BC_SETUP_EXCEPT:
480
                    case MP_BC_SETUP_FINALLY:
481
                        SETUP_BLOCK();
482
483
                        break;

484
                    case MP_BC_END_FINALLY:
485
                        // not fully implemented
486
487
                        // if TOS is an exception, reraises the exception (3 values on TOS)
                        // if TOS is None, just pops it and continues
488
                        // if TOS is an integer, does something else
489
                        // else error
490
491
                        if (mp_obj_is_exception_type(TOP())) {
                            nlr_jump(sp[-1]);
492
493
494
                        }
                        if (TOP() == mp_const_none) {
                            sp--;
495
496
497
498
499
500
501
                        } 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;
502
503
                                case UNWIND_JUMP:
                                    goto unwind_jump;
504
505
                            }
                            assert(0);
506
507
508
                        } else {
                            assert(0);
                        }
509
510
                        break;

511
                    case MP_BC_GET_ITER:
512
                        SET_TOP(rt_getiter(TOP()));
513
514
                        break;

515
                    case MP_BC_FOR_ITER:
Damien's avatar
Damien committed
516
                        DECODE_ULABEL; // the jump offset if iteration finishes; for labels are always forward
517
518
                        obj1 = rt_iternext_allow_raise(TOP());
                        if (obj1 == MP_OBJ_NULL) {
519
                            --sp; // pop the exhausted iterator
Damien's avatar
Damien committed
520
                            ip += unum; // jump to after for-block
521
522
523
524
525
                        } else {
                            PUSH(obj1); // push the next iteration value
                        }
                        break;

Damien's avatar
Damien committed
526
                    // matched against: SETUP_EXCEPT, SETUP_FINALLY, SETUP_WITH
527
                    case MP_BC_POP_BLOCK:
Damien's avatar
Damien committed
528
                        // we are exiting an exception handler, so pop the last one of the exception-stack
529
                        assert(exc_sp >= exc_stack);
530
                        currently_in_except_block = MP_TAGPTR_TAG(exc_sp->val_sp); // restore previous state
531
                        exc_sp--; // pop back to previous exception handler
532
533
                        break;

534
                    // matched against: SETUP_EXCEPT
535
                    case MP_BC_POP_EXCEPT:
Damien's avatar
Damien committed
536
                        // TODO need to work out how blocks work etc
537
                        // pops block, checks it's an exception block, and restores the stack, saving the 3 exception values to local threadstate
538
                        assert(exc_sp >= exc_stack);
539
                        assert(currently_in_except_block);
540
                        //sp = (mp_obj_t*)(*exc_sp--);
Damien's avatar
Damien committed
541
                        //exc_sp--; // discard ip
542
                        currently_in_except_block = MP_TAGPTR_TAG(exc_sp->val_sp); // restore previous state
543
                        exc_sp--; // pop back to previous exception handler
544
                        //sp -= 3; // pop 3 exception values
545
546
                        break;

547
548
549
550
551
552
553
554
                    case MP_BC_NOT:
                        if (TOP() == mp_const_true) {
                            SET_TOP(mp_const_false);
                        } else {
                            SET_TOP(mp_const_true);
                        }
                        break;

555
                    case MP_BC_UNARY_OP:
Damien's avatar
Damien committed
556
                        unum = *ip++;
557
                        SET_TOP(rt_unary_op(unum, TOP()));
Damien's avatar
Damien committed
558
559
                        break;

560
                    case MP_BC_BINARY_OP:
561
562
                        unum = *ip++;
                        obj2 = POP();
563
564
                        obj1 = TOP();
                        SET_TOP(rt_binary_op(unum, obj1, obj2));
565
566
                        break;

567
                    case MP_BC_BUILD_TUPLE:
568
                        DECODE_UINT;
569
570
                        sp -= unum - 1;
                        SET_TOP(rt_build_tuple(unum, sp));
571
572
                        break;

573
                    case MP_BC_BUILD_LIST:
574
                        DECODE_UINT;
575
576
                        sp -= unum - 1;
                        SET_TOP(rt_build_list(unum, sp));
577
578
                        break;

579
                    case MP_BC_LIST_APPEND:
580
581
                        DECODE_UINT;
                        // I think it's guaranteed by the compiler that sp[unum] is a list
582
583
                        rt_list_append(sp[-unum], sp[0]);
                        sp--;
584
585
                        break;

586
                    case MP_BC_BUILD_MAP:
587
588
589
590
                        DECODE_UINT;
                        PUSH(rt_build_map(unum));
                        break;

591
                    case MP_BC_STORE_MAP:
592
593
                        sp -= 2;
                        rt_store_map(sp[0], sp[2], sp[1]);
594
595
                        break;

596
                    case MP_BC_MAP_ADD:
Damien's avatar
Damien committed
597
                        DECODE_UINT;
598
599
600
                        // I think it's guaranteed by the compiler that sp[-unum - 1] is a map
                        rt_store_map(sp[-unum - 1], sp[0], sp[-1]);
                        sp -= 2;
Damien's avatar
Damien committed
601
602
                        break;

603
                    case MP_BC_BUILD_SET:
604
                        DECODE_UINT;
605
606
                        sp -= unum - 1;
                        SET_TOP(rt_build_set(unum, sp));
607
608
                        break;

609
                    case MP_BC_SET_ADD:
Damien's avatar
Damien committed
610
                        DECODE_UINT;
611
612
613
                        // I think it's guaranteed by the compiler that sp[-unum] is a set
                        rt_store_set(sp[-unum], sp[0]);
                        sp--;
Damien's avatar
Damien committed
614
615
                        break;

616
#if MICROPY_ENABLE_SLICE
617
618
619
620
621
622
623
624
625
626
627
                    case MP_BC_BUILD_SLICE:
                        DECODE_UINT;
                        if (unum == 2) {
                            obj2 = POP();
                            obj1 = TOP();
                            SET_TOP(mp_obj_new_slice(obj1, obj2, NULL));
                        } else {
                            printf("3-argument slice is not supported\n");
                            assert(0);
                        }
                        break;
628
#endif
629

630
                    case MP_BC_UNPACK_SEQUENCE:
631
                        DECODE_UINT;
632
                        rt_unpack_sequence(sp[0], unum, sp);
633
                        sp += unum - 1;
634
635
                        break;

636
                    case MP_BC_MAKE_FUNCTION:
637
                        DECODE_UINT;
638
                        PUSH(rt_make_function_from_id(unum, false, MP_OBJ_NULL));
639
640
641
642
                        break;

                    case MP_BC_MAKE_FUNCTION_DEFARGS:
                        DECODE_UINT;
643
                        SET_TOP(rt_make_function_from_id(unum, false, TOP()));
644
645
                        break;

646
                    case MP_BC_MAKE_CLOSURE:
Damien's avatar
Damien committed
647
                        DECODE_UINT;
648
649
650
651
652
653
654
                        SET_TOP(rt_make_closure_from_id(unum, TOP(), MP_OBJ_NULL));
                        break;

                    case MP_BC_MAKE_CLOSURE_DEFARGS:
                        DECODE_UINT;
                        obj1 = POP();
                        SET_TOP(rt_make_closure_from_id(unum, obj1, TOP()));
Damien's avatar
Damien committed
655
656
                        break;

657
                    case MP_BC_CALL_FUNCTION:
658
                        DECODE_UINT;
659
660
661
662
                        // unum & 0xff == n_positional
                        // (unum >> 8) & 0xff == n_keyword
                        sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe);
                        SET_TOP(rt_call_function_n_kw(*sp, unum & 0xff, (unum >> 8) & 0xff, sp + 1));
663
664
                        break;

665
                    case MP_BC_CALL_METHOD:
666
                        DECODE_UINT;
667
668
669
670
                        // unum & 0xff == n_positional
                        // (unum >> 8) & 0xff == n_keyword
                        sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe) + 1;
                        SET_TOP(rt_call_method_n_kw(unum & 0xff, (unum >> 8) & 0xff, sp));
671
672
                        break;

673
                    case MP_BC_RETURN_VALUE:
674
675
unwind_return:
                        while (exc_sp >= exc_stack) {
676
                            if (exc_sp->opcode == MP_BC_SETUP_FINALLY || exc_sp->opcode == MP_BC_SETUP_WITH) {
677
678
679
680
681
682
683
684
685
686
687
688
689
690
                                // 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 =
                                exc_sp--;
                                goto dispatch_loop;
                            }
                            exc_sp--;
                        }
691
                        nlr_pop();
692
                        *sp_in_out = sp;
693
                        assert(exc_sp == exc_stack - 1);
694
                        return MP_VM_RETURN_NORMAL;
695

696
697
                    case MP_BC_RAISE_VARARGS:
                        unum = *ip++;
698
699
700
701
702
703
704
705
                        assert(unum <= 1);
                        if (unum == 0) {
                            // This assumes that nlr.ret_val holds last raised
                            // exception and is not overwritten since then.
                            obj1 = nlr.ret_val;
                        } else {
                            obj1 = POP();
                        }
706
                        nlr_jump(rt_make_raise_obj(obj1));
707

708
                    case MP_BC_YIELD_VALUE:
709
yield:
710
711
712
                        nlr_pop();
                        *ip_in_out = ip;
                        *sp_in_out = sp;
713
                        *exc_sp_in_out = MP_TAGPTR_MAKE(exc_sp, currently_in_except_block);
714
                        return MP_VM_RETURN_YIELD;
715

716
                    case MP_BC_YIELD_FROM: {
717
718
//#define EXC_MATCH(exc, type) MP_OBJ_IS_TYPE(exc, type)
#define EXC_MATCH(exc, type) mp_obj_exception_match(exc, type)
719
#define GENERATOR_EXIT_IF_NEEDED(t) if (t != MP_OBJ_NULL && EXC_MATCH(t, &mp_type_GeneratorExit)) { nlr_jump(t); }
720
721
                        mp_vm_return_kind_t ret_kind;
                        obj1 = POP();
722
                        mp_obj_t t_exc = MP_OBJ_NULL;
723
                        if (inject_exc != MP_OBJ_NULL) {
724
                            t_exc = inject_exc;
725
                            inject_exc = MP_OBJ_NULL;
726
                            ret_kind = mp_obj_gen_resume(TOP(), mp_const_none, t_exc, &obj2);
727
                        } else {
728
                            ret_kind = mp_obj_gen_resume(TOP(), obj1, MP_OBJ_NULL, &obj2);
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
                        }

                        if (ret_kind == MP_VM_RETURN_YIELD) {
                            ip--;
                            PUSH(obj2);
                            goto yield;
                        }
                        if (ret_kind == MP_VM_RETURN_NORMAL) {
                            // Pop exhausted gen
                            sp--;
                            if (obj2 == MP_OBJ_NULL) {
                                // Optimize StopIteration
                                // TODO: get StopIteration's value
                                PUSH(mp_const_none);
                            } else {
                                PUSH(obj2);
                            }

747
748
749
                            // If we injected GeneratorExit downstream, then even
                            // if it was swallowed, we re-raise GeneratorExit
                            GENERATOR_EXIT_IF_NEEDED(t_exc);
750
751
752
753
754
755
                            break;
                        }
                        if (ret_kind == MP_VM_RETURN_EXCEPTION) {
                            // Pop exhausted gen
                            sp--;
                            if (EXC_MATCH(obj2, &mp_type_StopIteration)) {
756
757
758
759
                                PUSH(mp_obj_exception_get_value(obj2));
                                // If we injected GeneratorExit downstream, then even
                                // if it was swallowed, we re-raise GeneratorExit
                                GENERATOR_EXIT_IF_NEEDED(t_exc);
760
761
762
763
764
765
766
                                break;
                            } else {
                                nlr_jump(obj2);
                            }
                        }
                    }

767
                    case MP_BC_IMPORT_NAME:
768
769
                        DECODE_QSTR;
                        obj1 = POP();
770
                        SET_TOP(rt_import_name(qst, obj1, TOP()));
771
772
                        break;

773
                    case MP_BC_IMPORT_FROM:
774
                        DECODE_QSTR;
775
                        obj1 = rt_import_from(TOP(), qst);
776
777
778
                        PUSH(obj1);
                        break;

779
                    case MP_BC_IMPORT_STAR:
780
                        rt_import_all(POP());
781
782
                        break;

783
                    default:
Damien's avatar
Damien committed
784
                        printf("code %p, byte code 0x%02x not implemented\n", ip, op);
785
786
                        assert(0);
                        nlr_pop();
787
                        return MP_VM_RETURN_NORMAL;
Damien's avatar
Damien committed
788
                }
789
790
791
792
793
            }

        } else {
            // exception occurred

794
795
796
797
798
799
800
801
802
            // 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)) {
                ip = save_ip + 1;
                DECODE_ULABEL; // the jump offset if iteration finishes; for labels are always forward
                --sp; // pop the exhausted iterator
                ip += unum; // jump to after for-block
                goto outer_dispatch_loop; // continue with dispatch loop
            }

803
            // set file and line number that the exception occurred at
804
805
            // TODO: don't set traceback for exceptions re-raised by END_FINALLY.
            // But consider how to handle nested exceptions.
806
807
            // TODO need a better way of not adding traceback to constant objects (right now, just GeneratorExit_obj)
            if (mp_obj_is_exception_instance(nlr.ret_val) && nlr.ret_val != &mp_const_GeneratorExit_obj) {
808
                machine_uint_t code_info_size = code_info[0] | (code_info[1] << 8) | (code_info[2] << 16) | (code_info[3] << 24);
809
810
                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);
811
812
                machine_uint_t source_line = 1;
                machine_uint_t bc = save_ip - code_info - code_info_size;
813
                //printf("find %lu %d %d\n", bc, code_info[12], code_info[13]);
814
815
816
                for (const byte* ci = code_info + 12; *ci && bc >= ((*ci) & 31); ci++) {
                    bc -= *ci & 31;
                    source_line += *ci >> 5;
817
                }
818
                mp_obj_exception_add_traceback(nlr.ret_val, source_file, source_line, block_name);
819
820
            }

821
822
823
            while (currently_in_except_block) {
                // nested exception

824
                assert(exc_sp >= exc_stack);
825
826
827
828
829

                // TODO make a proper message for nested exception
                // at the moment we are just raising the very last exception (the one that caused the nested exception)

                // move up to previous exception handler
830
                currently_in_except_block = MP_TAGPTR_TAG(exc_sp->val_sp); // restore previous state
831
                exc_sp--; // pop back to previous exception handler
832
833
            }

834
            if (exc_sp >= exc_stack) {
835
836
837
                // set flag to indicate that we are now handling an exception
                currently_in_except_block = 1;

838
                // catch exception and pass to byte code
839
                sp = MP_TAGPTR_PTR(exc_sp->val_sp);
840
                ip = exc_sp->handler;
Damien's avatar
Damien committed
841
                // push(traceback, exc-val, exc-type)
842
                PUSH(mp_const_none);
Damien's avatar
Damien committed
843
                PUSH(nlr.ret_val);
844
                PUSH(mp_obj_get_type(nlr.ret_val));
845

846
            } else {
847
848
849
850
                // propagate exception to higher level
                // TODO what to do about ip and sp? they don't really make sense at this point
                fastn[0] = nlr.ret_val; // must put exception here because sp is invalid
                return MP_VM_RETURN_EXCEPTION;
851
            }
Damien's avatar
Damien committed
852
853
854
        }
    }
}