Damien George | 04b9147 | 2014-05-03 23:27:38 +0100 | [diff] [blame] | 1 | /* |
| 2 | * This file is part of the Micro Python project, http://micropython.org/ |
| 3 | * |
| 4 | * The MIT License (MIT) |
| 5 | * |
| 6 | * Copyright (c) 2013, 2014 Damien P. George |
Paul Sokolovsky | da9f092 | 2014-05-13 08:44:45 +0300 | [diff] [blame] | 7 | * Copyright (c) 2014 Paul Sokolovsky |
Damien George | 04b9147 | 2014-05-03 23:27:38 +0100 | [diff] [blame] | 8 | * |
| 9 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
| 10 | * of this software and associated documentation files (the "Software"), to deal |
| 11 | * in the Software without restriction, including without limitation the rights |
| 12 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| 13 | * copies of the Software, and to permit persons to whom the Software is |
| 14 | * furnished to do so, subject to the following conditions: |
| 15 | * |
| 16 | * The above copyright notice and this permission notice shall be included in |
| 17 | * all copies or substantial portions of the Software. |
| 18 | * |
| 19 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 20 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 21 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| 22 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 23 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 24 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| 25 | * THE SOFTWARE. |
| 26 | */ |
| 27 | |
Damien | 429d719 | 2013-10-04 19:53:11 +0100 | [diff] [blame] | 28 | #include <stdio.h> |
Paul Sokolovsky | 55ca075 | 2014-03-30 17:35:53 +0300 | [diff] [blame] | 29 | #include <string.h> |
Damien | 429d719 | 2013-10-04 19:53:11 +0100 | [diff] [blame] | 30 | #include <assert.h> |
| 31 | |
Damien George | b4b10fd | 2015-01-01 23:30:53 +0000 | [diff] [blame] | 32 | #include "py/mpstate.h" |
Damien George | 51dfcb4 | 2015-01-01 20:27:54 +0000 | [diff] [blame] | 33 | #include "py/nlr.h" |
| 34 | #include "py/emitglue.h" |
Damien George | 7ee91cf | 2015-01-06 12:51:39 +0000 | [diff] [blame] | 35 | #include "py/objtype.h" |
Damien George | 51dfcb4 | 2015-01-01 20:27:54 +0000 | [diff] [blame] | 36 | #include "py/runtime.h" |
| 37 | #include "py/bc0.h" |
| 38 | #include "py/bc.h" |
Damien | 429d719 | 2013-10-04 19:53:11 +0100 | [diff] [blame] | 39 | |
Paul Sokolovsky | c5e32c6 | 2014-04-23 03:40:24 +0300 | [diff] [blame] | 40 | #if 0 |
Damien George | a0973b0 | 2017-03-27 10:52:04 +1100 | [diff] [blame] | 41 | #define TRACE(ip) printf("sp=%d ", (int)(sp - &code_state->state[0] + 1)); mp_bytecode_print2(ip, 1, code_state->fun_bc->const_table); |
Paul Sokolovsky | c5e32c6 | 2014-04-23 03:40:24 +0300 | [diff] [blame] | 42 | #else |
| 43 | #define TRACE(ip) |
| 44 | #endif |
Damien George | e90be0d | 2014-04-10 16:21:34 +0000 | [diff] [blame] | 45 | |
Paul Sokolovsky | 8519342 | 2014-01-31 19:45:15 +0200 | [diff] [blame] | 46 | // Value stack grows up (this makes it incompatible with native C stack, but |
| 47 | // makes sure that arguments to functions are in natural order arg1..argN |
| 48 | // (Python semantics mandates left-to-right evaluation order, including for |
| 49 | // function arguments). Stack pointer is pre-incremented and points at the |
| 50 | // top element. |
| 51 | // Exception stack also grows up, top element is also pointed at. |
| 52 | |
Paul Sokolovsky | 6472dea | 2014-02-01 00:55:05 +0200 | [diff] [blame] | 53 | // Exception stack unwind reasons (WHY_* in CPython-speak) |
Damien George | cbddb27 | 2014-02-01 20:08:18 +0000 | [diff] [blame] | 54 | // TODO perhaps compress this to RETURN=0, JUMP>0, with number of unwinds |
| 55 | // left to do encoded in the JUMP number |
Paul Sokolovsky | 6472dea | 2014-02-01 00:55:05 +0200 | [diff] [blame] | 56 | typedef enum { |
| 57 | UNWIND_RETURN = 1, |
Damien George | cbddb27 | 2014-02-01 20:08:18 +0000 | [diff] [blame] | 58 | UNWIND_JUMP, |
Paul Sokolovsky | 6472dea | 2014-02-01 00:55:05 +0200 | [diff] [blame] | 59 | } mp_unwind_reason_t; |
| 60 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 61 | #define DECODE_UINT \ |
| 62 | mp_uint_t unum = 0; \ |
Paul Sokolovsky | 0f96ec8 | 2014-02-18 21:21:22 +0200 | [diff] [blame] | 63 | do { \ |
| 64 | unum = (unum << 7) + (*ip & 0x7f); \ |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 65 | } while ((*ip++ & 0x80) != 0) |
Damien George | 101886f | 2017-02-16 16:48:33 +1100 | [diff] [blame] | 66 | #define DECODE_ULABEL size_t ulab = (ip[0] | (ip[1] << 8)); ip += 2 |
| 67 | #define DECODE_SLABEL size_t slab = (ip[0] | (ip[1] << 8)) - 0x8000; ip += 2 |
Damien George | c8e9c0d | 2015-11-02 17:27:18 +0000 | [diff] [blame] | 68 | |
| 69 | #if MICROPY_PERSISTENT_CODE |
| 70 | |
| 71 | #define DECODE_QSTR \ |
| 72 | qstr qst = ip[0] | ip[1] << 8; \ |
| 73 | ip += 2; |
| 74 | #define DECODE_PTR \ |
| 75 | DECODE_UINT; \ |
Damien George | 71a3d6e | 2017-03-17 14:54:53 +1100 | [diff] [blame] | 76 | void *ptr = (void*)(uintptr_t)code_state->fun_bc->const_table[unum] |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 77 | #define DECODE_OBJ \ |
| 78 | DECODE_UINT; \ |
Damien George | 71a3d6e | 2017-03-17 14:54:53 +1100 | [diff] [blame] | 79 | mp_obj_t obj = (mp_obj_t)code_state->fun_bc->const_table[unum] |
Damien George | c8e9c0d | 2015-11-02 17:27:18 +0000 | [diff] [blame] | 80 | |
| 81 | #else |
| 82 | |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 83 | #define DECODE_QSTR qstr qst = 0; \ |
Paul Sokolovsky | 0f96ec8 | 2014-02-18 21:21:22 +0200 | [diff] [blame] | 84 | do { \ |
| 85 | qst = (qst << 7) + (*ip & 0x7f); \ |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 86 | } while ((*ip++ & 0x80) != 0) |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 87 | #define DECODE_PTR \ |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 88 | ip = (byte*)MP_ALIGN(ip, sizeof(void*)); \ |
| 89 | void *ptr = *(void**)ip; \ |
| 90 | ip += sizeof(void*) |
| 91 | #define DECODE_OBJ \ |
| 92 | ip = (byte*)MP_ALIGN(ip, sizeof(mp_obj_t)); \ |
| 93 | mp_obj_t obj = *(mp_obj_t*)ip; \ |
| 94 | ip += sizeof(mp_obj_t) |
Damien George | c8e9c0d | 2015-11-02 17:27:18 +0000 | [diff] [blame] | 95 | |
| 96 | #endif |
| 97 | |
Damien George | 20006db | 2014-01-18 14:10:48 +0000 | [diff] [blame] | 98 | #define PUSH(val) *++sp = (val) |
| 99 | #define POP() (*sp--) |
Damien | db4c361 | 2013-12-10 17:27:24 +0000 | [diff] [blame] | 100 | #define TOP() (*sp) |
| 101 | #define SET_TOP(val) *sp = (val) |
Damien | 429d719 | 2013-10-04 19:53:11 +0100 | [diff] [blame] | 102 | |
Paul Sokolovsky | ae2c81f | 2015-04-26 01:20:49 +0300 | [diff] [blame] | 103 | #if MICROPY_PY_SYS_EXC_INFO |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 104 | #define CLEAR_SYS_EXC_INFO() MP_STATE_VM(cur_exception) = NULL; |
Paul Sokolovsky | ae2c81f | 2015-04-26 01:20:49 +0300 | [diff] [blame] | 105 | #else |
| 106 | #define CLEAR_SYS_EXC_INFO() |
| 107 | #endif |
| 108 | |
Damien George | 74eb44c | 2014-12-22 12:49:57 +0000 | [diff] [blame] | 109 | #define PUSH_EXC_BLOCK(with_or_finally) do { \ |
Paul Sokolovsky | 4fff26a | 2014-03-29 02:49:07 +0200 | [diff] [blame] | 110 | DECODE_ULABEL; /* except labels are always forward */ \ |
| 111 | ++exc_sp; \ |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 112 | exc_sp->handler = ip + ulab; \ |
Damien George | 74eb44c | 2014-12-22 12:49:57 +0000 | [diff] [blame] | 113 | exc_sp->val_sp = MP_TAGPTR_MAKE(sp, ((with_or_finally) << 1) | currently_in_except_block); \ |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 114 | exc_sp->prev_exc = NULL; \ |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 115 | currently_in_except_block = 0; /* in a try block now */ \ |
| 116 | } while (0) |
Paul Sokolovsky | 4fff26a | 2014-03-29 02:49:07 +0200 | [diff] [blame] | 117 | |
Paul Sokolovsky | a0ad77b | 2014-03-29 23:16:27 +0200 | [diff] [blame] | 118 | #define POP_EXC_BLOCK() \ |
Damien George | 74eb44c | 2014-12-22 12:49:57 +0000 | [diff] [blame] | 119 | currently_in_except_block = MP_TAGPTR_TAG0(exc_sp->val_sp); /* restore previous state */ \ |
Paul Sokolovsky | ae2c81f | 2015-04-26 01:20:49 +0300 | [diff] [blame] | 120 | exc_sp--; /* pop back to previous exception handler */ \ |
| 121 | CLEAR_SYS_EXC_INFO() /* just clear sys.exc_info(), not compliant, but it shouldn't be used in 1st place */ |
Paul Sokolovsky | a0ad77b | 2014-03-29 23:16:27 +0200 | [diff] [blame] | 122 | |
Damien George | 20006db | 2014-01-18 14:10:48 +0000 | [diff] [blame] | 123 | // fastn has items in reverse order (fastn[0] is local[0], fastn[-1] is local[1], etc) |
| 124 | // sp points to bottom of stack which grows up |
Damien George | c8f78bc | 2014-02-15 22:55:00 +0000 | [diff] [blame] | 125 | // returns: |
| 126 | // MP_VM_RETURN_NORMAL, sp valid, return value in *sp |
| 127 | // MP_VM_RETURN_YIELD, ip, sp valid, yielded value in *sp |
| 128 | // MP_VM_RETURN_EXCEPTION, exception in fastn[0] |
Damien George | 581a59a | 2016-08-27 23:21:00 +1000 | [diff] [blame] | 129 | mp_vm_return_kind_t mp_execute_bytecode(mp_code_state_t *code_state, volatile mp_obj_t inject_exc) { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 130 | #define SELECTIVE_EXC_IP (0) |
| 131 | #if SELECTIVE_EXC_IP |
Damien George | f89d659 | 2014-12-29 00:29:59 +0000 | [diff] [blame] | 132 | #define MARK_EXC_IP_SELECTIVE() { code_state->ip = ip; } /* stores ip 1 byte past last opcode */ |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 133 | #define MARK_EXC_IP_GLOBAL() |
| 134 | #else |
| 135 | #define MARK_EXC_IP_SELECTIVE() |
Damien George | f89d659 | 2014-12-29 00:29:59 +0000 | [diff] [blame] | 136 | #define MARK_EXC_IP_GLOBAL() { code_state->ip = ip; } /* stores ip pointing to last opcode */ |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 137 | #endif |
Damien George | 58ebde4 | 2014-05-21 20:32:59 +0100 | [diff] [blame] | 138 | #if MICROPY_OPT_COMPUTED_GOTO |
Damien George | 51dfcb4 | 2015-01-01 20:27:54 +0000 | [diff] [blame] | 139 | #include "py/vmentrytable.h" |
AZ Huang | 9309d99 | 2014-04-15 15:57:01 +0800 | [diff] [blame] | 140 | #define DISPATCH() do { \ |
Paul Sokolovsky | c5e32c6 | 2014-04-23 03:40:24 +0300 | [diff] [blame] | 141 | TRACE(ip); \ |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 142 | MARK_EXC_IP_GLOBAL(); \ |
Damien George | db12891 | 2014-04-27 18:19:06 +0100 | [diff] [blame] | 143 | goto *entry_table[*ip++]; \ |
Damien George | 4dea922 | 2015-04-09 15:29:54 +0000 | [diff] [blame] | 144 | } while (0) |
Damien George | 124df6f | 2014-10-25 18:19:55 +0100 | [diff] [blame] | 145 | #define DISPATCH_WITH_PEND_EXC_CHECK() goto pending_exception_check |
AZ Huang | 9309d99 | 2014-04-15 15:57:01 +0800 | [diff] [blame] | 146 | #define ENTRY(op) entry_##op |
| 147 | #define ENTRY_DEFAULT entry_default |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 148 | #else |
AZ Huang | 9309d99 | 2014-04-15 15:57:01 +0800 | [diff] [blame] | 149 | #define DISPATCH() break |
Damien George | 124df6f | 2014-10-25 18:19:55 +0100 | [diff] [blame] | 150 | #define DISPATCH_WITH_PEND_EXC_CHECK() goto pending_exception_check |
AZ Huang | 9309d99 | 2014-04-15 15:57:01 +0800 | [diff] [blame] | 151 | #define ENTRY(op) case op |
| 152 | #define ENTRY_DEFAULT default |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 153 | #endif |
| 154 | |
Damien George | 66ae8c9 | 2014-04-17 16:50:23 +0100 | [diff] [blame] | 155 | // nlr_raise needs to be implemented as a goto, so that the C compiler's flow analyser |
| 156 | // sees that it's possible for us to jump from the dispatch loop to the exception |
| 157 | // handler. Without this, the code may have a different stack layout in the dispatch |
| 158 | // loop and the exception handler, leading to very obscure bugs. |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 159 | #define RAISE(o) do { nlr_pop(); nlr.ret_val = MP_OBJ_TO_PTR(o); goto exception_handler; } while (0) |
Damien | 429d719 | 2013-10-04 19:53:11 +0100 | [diff] [blame] | 160 | |
Paul Sokolovsky | 2039757 | 2015-03-28 01:14:44 +0200 | [diff] [blame] | 161 | #if MICROPY_STACKLESS |
| 162 | run_code_state: ; |
| 163 | #endif |
Damien George | aabd83e | 2014-06-07 14:16:08 +0100 | [diff] [blame] | 164 | // Pointers which are constant for particular invocation of mp_execute_bytecode() |
Damien George | 5640e6d | 2017-03-17 16:38:46 +1100 | [diff] [blame] | 165 | size_t n_state = mp_decode_uint_value(code_state->fun_bc->bytecode); |
Damien George | 71a3d6e | 2017-03-17 14:54:53 +1100 | [diff] [blame] | 166 | mp_obj_t * /*const*/ fastn = &code_state->state[n_state - 1]; |
| 167 | mp_exc_stack_t * /*const*/ exc_stack = (mp_exc_stack_t*)(code_state->state + n_state); |
Paul Sokolovsky | b4ebad3 | 2014-05-31 16:50:46 +0300 | [diff] [blame] | 168 | |
Damien George | 66ae8c9 | 2014-04-17 16:50:23 +0100 | [diff] [blame] | 169 | // variables that are visible to the exception handler (declared volatile) |
Damien George | 74eb44c | 2014-12-22 12:49:57 +0000 | [diff] [blame] | 170 | volatile bool currently_in_except_block = MP_TAGPTR_TAG0(code_state->exc_sp); // 0 or 1, to detect nested exceptions |
Paul Sokolovsky | b4ebad3 | 2014-05-31 16:50:46 +0300 | [diff] [blame] | 171 | mp_exc_stack_t *volatile exc_sp = MP_TAGPTR_PTR(code_state->exc_sp); // stack grows up, exc_sp points to top of stack |
Damien | c9f9197 | 2013-10-15 23:46:01 +0100 | [diff] [blame] | 172 | |
Damien George | f6c22a0 | 2017-02-06 10:50:43 +1100 | [diff] [blame] | 173 | #if MICROPY_PY_THREAD_GIL && MICROPY_PY_THREAD_GIL_VM_DIVISOR |
| 174 | // This needs to be volatile and outside the VM loop so it persists across handling |
| 175 | // of any exceptions. Otherwise it's possible that the VM never gives up the GIL. |
| 176 | volatile int gil_divisor = MICROPY_PY_THREAD_GIL_VM_DIVISOR; |
| 177 | #endif |
| 178 | |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 179 | // outer exception handling loop |
Damien | 429d719 | 2013-10-04 19:53:11 +0100 | [diff] [blame] | 180 | for (;;) { |
Damien George | 66ae8c9 | 2014-04-17 16:50:23 +0100 | [diff] [blame] | 181 | nlr_buf_t nlr; |
Damien George | 9e6e935 | 2014-03-26 18:37:06 +0000 | [diff] [blame] | 182 | outer_dispatch_loop: |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 183 | if (nlr_push(&nlr) == 0) { |
Damien George | 66ae8c9 | 2014-04-17 16:50:23 +0100 | [diff] [blame] | 184 | // local variables that are not visible to the exception handler |
Paul Sokolovsky | b4ebad3 | 2014-05-31 16:50:46 +0300 | [diff] [blame] | 185 | const byte *ip = code_state->ip; |
| 186 | mp_obj_t *sp = code_state->sp; |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 187 | mp_obj_t obj_shared; |
Damien George | 40d8430 | 2016-02-15 22:46:21 +0000 | [diff] [blame] | 188 | MICROPY_VM_HOOK_INIT |
Damien George | 66ae8c9 | 2014-04-17 16:50:23 +0100 | [diff] [blame] | 189 | |
Paul Sokolovsky | 48caa09 | 2014-03-22 17:50:12 +0200 | [diff] [blame] | 190 | // If we have exception to inject, now that we finish setting up |
| 191 | // execution context, raise it. This works as if RAISE_VARARGS |
| 192 | // bytecode was executed. |
Paul Sokolovsky | cf21a4e | 2014-03-26 17:36:12 +0200 | [diff] [blame] | 193 | // Injecting exc into yield from generator is a special case, |
| 194 | // handled by MP_BC_YIELD_FROM itself |
| 195 | if (inject_exc != MP_OBJ_NULL && *ip != MP_BC_YIELD_FROM) { |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 196 | mp_obj_t exc = inject_exc; |
Paul Sokolovsky | 48caa09 | 2014-03-22 17:50:12 +0200 | [diff] [blame] | 197 | inject_exc = MP_OBJ_NULL; |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 198 | exc = mp_make_raise_obj(exc); |
| 199 | RAISE(exc); |
Paul Sokolovsky | 48caa09 | 2014-03-22 17:50:12 +0200 | [diff] [blame] | 200 | } |
Damien George | 66ae8c9 | 2014-04-17 16:50:23 +0100 | [diff] [blame] | 201 | |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 202 | // loop to execute byte code |
| 203 | for (;;) { |
Paul Sokolovsky | 6472dea | 2014-02-01 00:55:05 +0200 | [diff] [blame] | 204 | dispatch_loop: |
Damien George | 58ebde4 | 2014-05-21 20:32:59 +0100 | [diff] [blame] | 205 | #if MICROPY_OPT_COMPUTED_GOTO |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 206 | DISPATCH(); |
| 207 | #else |
Paul Sokolovsky | c5e32c6 | 2014-04-23 03:40:24 +0300 | [diff] [blame] | 208 | TRACE(ip); |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 209 | MARK_EXC_IP_GLOBAL(); |
Damien George | db12891 | 2014-04-27 18:19:06 +0100 | [diff] [blame] | 210 | switch (*ip++) { |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 211 | #endif |
Damien | 429d719 | 2013-10-04 19:53:11 +0100 | [diff] [blame] | 212 | |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 213 | ENTRY(MP_BC_LOAD_CONST_FALSE): |
| 214 | PUSH(mp_const_false); |
| 215 | DISPATCH(); |
Damien | 429d719 | 2013-10-04 19:53:11 +0100 | [diff] [blame] | 216 | |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 217 | ENTRY(MP_BC_LOAD_CONST_NONE): |
| 218 | PUSH(mp_const_none); |
| 219 | DISPATCH(); |
Damien | 429d719 | 2013-10-04 19:53:11 +0100 | [diff] [blame] | 220 | |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 221 | ENTRY(MP_BC_LOAD_CONST_TRUE): |
| 222 | PUSH(mp_const_true); |
| 223 | DISPATCH(); |
Damien George | e9906ac | 2014-01-04 18:44:46 +0000 | [diff] [blame] | 224 | |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 225 | ENTRY(MP_BC_LOAD_CONST_SMALL_INT): { |
Damien George | 40f3c02 | 2014-07-03 13:25:24 +0100 | [diff] [blame] | 226 | mp_int_t num = 0; |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 227 | if ((ip[0] & 0x40) != 0) { |
| 228 | // Number is negative |
| 229 | num--; |
Paul Sokolovsky | 047cd40 | 2014-02-19 15:47:59 +0200 | [diff] [blame] | 230 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 231 | do { |
| 232 | num = (num << 7) | (*ip & 0x7f); |
| 233 | } while ((*ip++ & 0x80) != 0); |
| 234 | PUSH(MP_OBJ_NEW_SMALL_INT(num)); |
| 235 | DISPATCH(); |
| 236 | } |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 237 | |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 238 | ENTRY(MP_BC_LOAD_CONST_STRING): { |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 239 | DECODE_QSTR; |
Damien George | ed570e4 | 2015-06-25 13:58:41 +0000 | [diff] [blame] | 240 | PUSH(MP_OBJ_NEW_QSTR(qst)); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 241 | DISPATCH(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 242 | } |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 243 | |
Damien George | dab1385 | 2015-01-13 15:55:54 +0000 | [diff] [blame] | 244 | ENTRY(MP_BC_LOAD_CONST_OBJ): { |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 245 | DECODE_OBJ; |
| 246 | PUSH(obj); |
Damien George | dab1385 | 2015-01-13 15:55:54 +0000 | [diff] [blame] | 247 | DISPATCH(); |
| 248 | } |
| 249 | |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 250 | ENTRY(MP_BC_LOAD_NULL): |
| 251 | PUSH(MP_OBJ_NULL); |
| 252 | DISPATCH(); |
Damien George | 523b575 | 2014-03-31 11:59:23 +0100 | [diff] [blame] | 253 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 254 | ENTRY(MP_BC_LOAD_FAST_N): { |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 255 | DECODE_UINT; |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 256 | obj_shared = fastn[-unum]; |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 257 | load_check: |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 258 | if (obj_shared == MP_OBJ_NULL) { |
| 259 | local_name_error: { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 260 | MARK_EXC_IP_SELECTIVE(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 261 | mp_obj_t obj = mp_obj_new_exception_msg(&mp_type_NameError, "local variable referenced before assignment"); |
| 262 | RAISE(obj); |
| 263 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 264 | } |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 265 | PUSH(obj_shared); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 266 | DISPATCH(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 267 | } |
Damien George | 2bf7c09 | 2014-04-09 15:26:46 +0100 | [diff] [blame] | 268 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 269 | ENTRY(MP_BC_LOAD_DEREF): { |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 270 | DECODE_UINT; |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 271 | obj_shared = mp_obj_cell_get(fastn[-unum]); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 272 | goto load_check; |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 273 | } |
Damien | 9ecbcff | 2013-12-11 00:41:43 +0000 | [diff] [blame] | 274 | |
Damien George | 7ee91cf | 2015-01-06 12:51:39 +0000 | [diff] [blame] | 275 | #if !MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 276 | ENTRY(MP_BC_LOAD_NAME): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 277 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 278 | DECODE_QSTR; |
| 279 | PUSH(mp_load_name(qst)); |
| 280 | DISPATCH(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 281 | } |
Damien George | 7ee91cf | 2015-01-06 12:51:39 +0000 | [diff] [blame] | 282 | #else |
| 283 | ENTRY(MP_BC_LOAD_NAME): { |
| 284 | MARK_EXC_IP_SELECTIVE(); |
| 285 | DECODE_QSTR; |
| 286 | mp_obj_t key = MP_OBJ_NEW_QSTR(qst); |
| 287 | mp_uint_t x = *ip; |
Damien George | 707f16b | 2017-03-24 18:41:11 +1100 | [diff] [blame] | 288 | if (x < mp_locals_get()->map.alloc && mp_locals_get()->map.table[x].key == key) { |
| 289 | PUSH(mp_locals_get()->map.table[x].value); |
Damien George | 7ee91cf | 2015-01-06 12:51:39 +0000 | [diff] [blame] | 290 | } else { |
Damien George | 707f16b | 2017-03-24 18:41:11 +1100 | [diff] [blame] | 291 | mp_map_elem_t *elem = mp_map_lookup(&mp_locals_get()->map, MP_OBJ_NEW_QSTR(qst), MP_MAP_LOOKUP); |
Damien George | 7ee91cf | 2015-01-06 12:51:39 +0000 | [diff] [blame] | 292 | if (elem != NULL) { |
Damien George | 707f16b | 2017-03-24 18:41:11 +1100 | [diff] [blame] | 293 | *(byte*)ip = (elem - &mp_locals_get()->map.table[0]) & 0xff; |
Damien George | 7ee91cf | 2015-01-06 12:51:39 +0000 | [diff] [blame] | 294 | PUSH(elem->value); |
| 295 | } else { |
| 296 | PUSH(mp_load_name(MP_OBJ_QSTR_VALUE(key))); |
| 297 | } |
| 298 | } |
| 299 | ip++; |
| 300 | DISPATCH(); |
| 301 | } |
| 302 | #endif |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 303 | |
Damien George | 7ee91cf | 2015-01-06 12:51:39 +0000 | [diff] [blame] | 304 | #if !MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 305 | ENTRY(MP_BC_LOAD_GLOBAL): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 306 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 307 | DECODE_QSTR; |
| 308 | PUSH(mp_load_global(qst)); |
| 309 | DISPATCH(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 310 | } |
Damien George | 7ee91cf | 2015-01-06 12:51:39 +0000 | [diff] [blame] | 311 | #else |
| 312 | ENTRY(MP_BC_LOAD_GLOBAL): { |
| 313 | MARK_EXC_IP_SELECTIVE(); |
| 314 | DECODE_QSTR; |
| 315 | mp_obj_t key = MP_OBJ_NEW_QSTR(qst); |
| 316 | mp_uint_t x = *ip; |
Damien George | 707f16b | 2017-03-24 18:41:11 +1100 | [diff] [blame] | 317 | if (x < mp_globals_get()->map.alloc && mp_globals_get()->map.table[x].key == key) { |
| 318 | PUSH(mp_globals_get()->map.table[x].value); |
Damien George | 7ee91cf | 2015-01-06 12:51:39 +0000 | [diff] [blame] | 319 | } else { |
Damien George | 707f16b | 2017-03-24 18:41:11 +1100 | [diff] [blame] | 320 | mp_map_elem_t *elem = mp_map_lookup(&mp_globals_get()->map, MP_OBJ_NEW_QSTR(qst), MP_MAP_LOOKUP); |
Damien George | 7ee91cf | 2015-01-06 12:51:39 +0000 | [diff] [blame] | 321 | if (elem != NULL) { |
Damien George | 707f16b | 2017-03-24 18:41:11 +1100 | [diff] [blame] | 322 | *(byte*)ip = (elem - &mp_globals_get()->map.table[0]) & 0xff; |
Damien George | 7ee91cf | 2015-01-06 12:51:39 +0000 | [diff] [blame] | 323 | PUSH(elem->value); |
| 324 | } else { |
| 325 | PUSH(mp_load_global(MP_OBJ_QSTR_VALUE(key))); |
| 326 | } |
| 327 | } |
| 328 | ip++; |
| 329 | DISPATCH(); |
| 330 | } |
| 331 | #endif |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 332 | |
Damien George | 7ee91cf | 2015-01-06 12:51:39 +0000 | [diff] [blame] | 333 | #if !MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 334 | ENTRY(MP_BC_LOAD_ATTR): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 335 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 336 | DECODE_QSTR; |
| 337 | SET_TOP(mp_load_attr(TOP(), qst)); |
| 338 | DISPATCH(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 339 | } |
Damien George | 7ee91cf | 2015-01-06 12:51:39 +0000 | [diff] [blame] | 340 | #else |
| 341 | ENTRY(MP_BC_LOAD_ATTR): { |
| 342 | MARK_EXC_IP_SELECTIVE(); |
| 343 | DECODE_QSTR; |
| 344 | mp_obj_t top = TOP(); |
Damien George | b1bbe96 | 2015-04-01 14:10:50 +0000 | [diff] [blame] | 345 | if (mp_obj_get_type(top)->attr == mp_obj_instance_attr) { |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 346 | mp_obj_instance_t *self = MP_OBJ_TO_PTR(top); |
Damien George | 7ee91cf | 2015-01-06 12:51:39 +0000 | [diff] [blame] | 347 | mp_uint_t x = *ip; |
| 348 | mp_obj_t key = MP_OBJ_NEW_QSTR(qst); |
| 349 | mp_map_elem_t *elem; |
| 350 | if (x < self->members.alloc && self->members.table[x].key == key) { |
| 351 | elem = &self->members.table[x]; |
| 352 | } else { |
| 353 | elem = mp_map_lookup(&self->members, key, MP_MAP_LOOKUP); |
| 354 | if (elem != NULL) { |
| 355 | *(byte*)ip = elem - &self->members.table[0]; |
| 356 | } else { |
| 357 | goto load_attr_cache_fail; |
| 358 | } |
| 359 | } |
| 360 | SET_TOP(elem->value); |
| 361 | ip++; |
| 362 | DISPATCH(); |
| 363 | } |
| 364 | load_attr_cache_fail: |
| 365 | SET_TOP(mp_load_attr(top, qst)); |
| 366 | ip++; |
| 367 | DISPATCH(); |
| 368 | } |
| 369 | #endif |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 370 | |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 371 | ENTRY(MP_BC_LOAD_METHOD): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 372 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 373 | DECODE_QSTR; |
| 374 | mp_load_method(*sp, qst, sp); |
| 375 | sp += 1; |
| 376 | DISPATCH(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 377 | } |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 378 | |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 379 | ENTRY(MP_BC_LOAD_BUILD_CLASS): |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 380 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 381 | PUSH(mp_load_build_class()); |
| 382 | DISPATCH(); |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 383 | |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 384 | ENTRY(MP_BC_LOAD_SUBSCR): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 385 | MARK_EXC_IP_SELECTIVE(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 386 | mp_obj_t index = POP(); |
| 387 | SET_TOP(mp_obj_subscr(TOP(), index, MP_OBJ_SENTINEL)); |
Damien George | 729f7b4 | 2014-04-17 22:10:53 +0100 | [diff] [blame] | 388 | DISPATCH(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 389 | } |
Damien George | 729f7b4 | 2014-04-17 22:10:53 +0100 | [diff] [blame] | 390 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 391 | ENTRY(MP_BC_STORE_FAST_N): { |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 392 | DECODE_UINT; |
| 393 | fastn[-unum] = POP(); |
| 394 | DISPATCH(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 395 | } |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 396 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 397 | ENTRY(MP_BC_STORE_DEREF): { |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 398 | DECODE_UINT; |
| 399 | mp_obj_cell_set(fastn[-unum], POP()); |
| 400 | DISPATCH(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 401 | } |
Damien | 9ecbcff | 2013-12-11 00:41:43 +0000 | [diff] [blame] | 402 | |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 403 | ENTRY(MP_BC_STORE_NAME): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 404 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 405 | DECODE_QSTR; |
| 406 | mp_store_name(qst, POP()); |
| 407 | DISPATCH(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 408 | } |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 409 | |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 410 | ENTRY(MP_BC_STORE_GLOBAL): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 411 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 412 | DECODE_QSTR; |
| 413 | mp_store_global(qst, POP()); |
| 414 | DISPATCH(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 415 | } |
Damien | 6addc89 | 2013-11-04 23:04:50 +0000 | [diff] [blame] | 416 | |
Damien George | 7ee91cf | 2015-01-06 12:51:39 +0000 | [diff] [blame] | 417 | #if !MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 418 | ENTRY(MP_BC_STORE_ATTR): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 419 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 420 | DECODE_QSTR; |
| 421 | mp_store_attr(sp[0], qst, sp[-1]); |
| 422 | sp -= 2; |
| 423 | DISPATCH(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 424 | } |
Damien George | 7ee91cf | 2015-01-06 12:51:39 +0000 | [diff] [blame] | 425 | #else |
stijn | 28fa84b | 2015-02-14 18:43:54 +0100 | [diff] [blame] | 426 | // This caching code works with MICROPY_PY_BUILTINS_PROPERTY and/or |
| 427 | // MICROPY_PY_DESCRIPTORS enabled because if the attr exists in |
| 428 | // self->members then it can't be a property or have descriptors. A |
Damien George | 7ee91cf | 2015-01-06 12:51:39 +0000 | [diff] [blame] | 429 | // consequence of this is that we can't use MP_MAP_LOOKUP_ADD_IF_NOT_FOUND |
| 430 | // in the fast-path below, because that store could override a property. |
| 431 | ENTRY(MP_BC_STORE_ATTR): { |
| 432 | MARK_EXC_IP_SELECTIVE(); |
| 433 | DECODE_QSTR; |
| 434 | mp_obj_t top = TOP(); |
Damien George | b1bbe96 | 2015-04-01 14:10:50 +0000 | [diff] [blame] | 435 | if (mp_obj_get_type(top)->attr == mp_obj_instance_attr && sp[-1] != MP_OBJ_NULL) { |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 436 | mp_obj_instance_t *self = MP_OBJ_TO_PTR(top); |
Damien George | 7ee91cf | 2015-01-06 12:51:39 +0000 | [diff] [blame] | 437 | mp_uint_t x = *ip; |
| 438 | mp_obj_t key = MP_OBJ_NEW_QSTR(qst); |
| 439 | mp_map_elem_t *elem; |
| 440 | if (x < self->members.alloc && self->members.table[x].key == key) { |
| 441 | elem = &self->members.table[x]; |
| 442 | } else { |
| 443 | elem = mp_map_lookup(&self->members, key, MP_MAP_LOOKUP); |
| 444 | if (elem != NULL) { |
| 445 | *(byte*)ip = elem - &self->members.table[0]; |
| 446 | } else { |
| 447 | goto store_attr_cache_fail; |
| 448 | } |
| 449 | } |
| 450 | elem->value = sp[-1]; |
| 451 | sp -= 2; |
| 452 | ip++; |
| 453 | DISPATCH(); |
| 454 | } |
| 455 | store_attr_cache_fail: |
| 456 | mp_store_attr(sp[0], qst, sp[-1]); |
| 457 | sp -= 2; |
| 458 | ip++; |
| 459 | DISPATCH(); |
| 460 | } |
| 461 | #endif |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 462 | |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 463 | ENTRY(MP_BC_STORE_SUBSCR): |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 464 | MARK_EXC_IP_SELECTIVE(); |
Damien George | 729f7b4 | 2014-04-17 22:10:53 +0100 | [diff] [blame] | 465 | mp_obj_subscr(sp[-1], sp[0], sp[-2]); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 466 | sp -= 3; |
| 467 | DISPATCH(); |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 468 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 469 | ENTRY(MP_BC_DELETE_FAST): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 470 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 471 | DECODE_UINT; |
| 472 | if (fastn[-unum] == MP_OBJ_NULL) { |
| 473 | goto local_name_error; |
| 474 | } |
| 475 | fastn[-unum] = MP_OBJ_NULL; |
| 476 | DISPATCH(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 477 | } |
Damien George | 2bf7c09 | 2014-04-09 15:26:46 +0100 | [diff] [blame] | 478 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 479 | ENTRY(MP_BC_DELETE_DEREF): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 480 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 481 | DECODE_UINT; |
| 482 | if (mp_obj_cell_get(fastn[-unum]) == MP_OBJ_NULL) { |
| 483 | goto local_name_error; |
| 484 | } |
| 485 | mp_obj_cell_set(fastn[-unum], MP_OBJ_NULL); |
| 486 | DISPATCH(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 487 | } |
Damien George | 2bf7c09 | 2014-04-09 15:26:46 +0100 | [diff] [blame] | 488 | |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 489 | ENTRY(MP_BC_DELETE_NAME): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 490 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 491 | DECODE_QSTR; |
| 492 | mp_delete_name(qst); |
| 493 | DISPATCH(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 494 | } |
Paul Sokolovsky | f909034 | 2014-03-23 21:19:02 +0200 | [diff] [blame] | 495 | |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 496 | ENTRY(MP_BC_DELETE_GLOBAL): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 497 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 498 | DECODE_QSTR; |
| 499 | mp_delete_global(qst); |
| 500 | DISPATCH(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 501 | } |
Damien George | 1d24ea5 | 2014-04-08 21:11:49 +0100 | [diff] [blame] | 502 | |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 503 | ENTRY(MP_BC_DUP_TOP): { |
| 504 | mp_obj_t top = TOP(); |
| 505 | PUSH(top); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 506 | DISPATCH(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 507 | } |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 508 | |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 509 | ENTRY(MP_BC_DUP_TOP_TWO): |
| 510 | sp += 2; |
| 511 | sp[0] = sp[-2]; |
| 512 | sp[-1] = sp[-3]; |
| 513 | DISPATCH(); |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 514 | |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 515 | ENTRY(MP_BC_POP_TOP): |
| 516 | sp -= 1; |
| 517 | DISPATCH(); |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 518 | |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 519 | ENTRY(MP_BC_ROT_TWO): { |
| 520 | mp_obj_t top = sp[0]; |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 521 | sp[0] = sp[-1]; |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 522 | sp[-1] = top; |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 523 | DISPATCH(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 524 | } |
Damien | 4ebb32f | 2013-11-02 14:33:10 +0000 | [diff] [blame] | 525 | |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 526 | ENTRY(MP_BC_ROT_THREE): { |
| 527 | mp_obj_t top = sp[0]; |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 528 | sp[0] = sp[-1]; |
| 529 | sp[-1] = sp[-2]; |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 530 | sp[-2] = top; |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 531 | DISPATCH(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 532 | } |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 533 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 534 | ENTRY(MP_BC_JUMP): { |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 535 | DECODE_SLABEL; |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 536 | ip += slab; |
Damien George | 124df6f | 2014-10-25 18:19:55 +0100 | [diff] [blame] | 537 | DISPATCH_WITH_PEND_EXC_CHECK(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 538 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 539 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 540 | ENTRY(MP_BC_POP_JUMP_IF_TRUE): { |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 541 | DECODE_SLABEL; |
| 542 | if (mp_obj_is_true(POP())) { |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 543 | ip += slab; |
Paul Sokolovsky | 44307d5 | 2014-03-29 04:10:11 +0200 | [diff] [blame] | 544 | } |
Damien George | 124df6f | 2014-10-25 18:19:55 +0100 | [diff] [blame] | 545 | DISPATCH_WITH_PEND_EXC_CHECK(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 546 | } |
Paul Sokolovsky | 44307d5 | 2014-03-29 04:10:11 +0200 | [diff] [blame] | 547 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 548 | ENTRY(MP_BC_POP_JUMP_IF_FALSE): { |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 549 | DECODE_SLABEL; |
| 550 | if (!mp_obj_is_true(POP())) { |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 551 | ip += slab; |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 552 | } |
Damien George | 124df6f | 2014-10-25 18:19:55 +0100 | [diff] [blame] | 553 | DISPATCH_WITH_PEND_EXC_CHECK(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 554 | } |
Damien George | 600ae73 | 2014-01-21 23:48:04 +0000 | [diff] [blame] | 555 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 556 | ENTRY(MP_BC_JUMP_IF_TRUE_OR_POP): { |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 557 | DECODE_SLABEL; |
| 558 | if (mp_obj_is_true(TOP())) { |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 559 | ip += slab; |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 560 | } else { |
| 561 | sp--; |
| 562 | } |
Damien George | 124df6f | 2014-10-25 18:19:55 +0100 | [diff] [blame] | 563 | DISPATCH_WITH_PEND_EXC_CHECK(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 564 | } |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 565 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 566 | ENTRY(MP_BC_JUMP_IF_FALSE_OR_POP): { |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 567 | DECODE_SLABEL; |
| 568 | if (mp_obj_is_true(TOP())) { |
| 569 | sp--; |
| 570 | } else { |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 571 | ip += slab; |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 572 | } |
Damien George | 124df6f | 2014-10-25 18:19:55 +0100 | [diff] [blame] | 573 | DISPATCH_WITH_PEND_EXC_CHECK(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 574 | } |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 575 | |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 576 | ENTRY(MP_BC_SETUP_WITH): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 577 | MARK_EXC_IP_SELECTIVE(); |
Damien George | 8c1d23a | 2015-04-24 01:52:28 +0100 | [diff] [blame] | 578 | // stack: (..., ctx_mgr) |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 579 | mp_obj_t obj = TOP(); |
Damien George | 8c1d23a | 2015-04-24 01:52:28 +0100 | [diff] [blame] | 580 | mp_load_method(obj, MP_QSTR___exit__, sp); |
| 581 | mp_load_method(obj, MP_QSTR___enter__, sp + 2); |
| 582 | mp_obj_t ret = mp_call_method_n_kw(0, 0, sp + 2); |
| 583 | sp += 1; |
Damien George | 74eb44c | 2014-12-22 12:49:57 +0000 | [diff] [blame] | 584 | PUSH_EXC_BLOCK(1); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 585 | PUSH(ret); |
Damien George | 8c1d23a | 2015-04-24 01:52:28 +0100 | [diff] [blame] | 586 | // stack: (..., __exit__, ctx_mgr, as_value) |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 587 | DISPATCH(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 588 | } |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 589 | |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 590 | ENTRY(MP_BC_WITH_CLEANUP): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 591 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 592 | // Arriving here, there's "exception control block" on top of stack, |
Damien George | 8c1d23a | 2015-04-24 01:52:28 +0100 | [diff] [blame] | 593 | // and __exit__ method (with self) underneath it. Bytecode calls __exit__, |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 594 | // and "deletes" it off stack, shifting "exception control block" |
| 595 | // to its place. |
Damien George | f040685 | 2016-09-27 12:37:21 +1000 | [diff] [blame] | 596 | // The bytecode emitter ensures that there is enough space on the Python |
| 597 | // value stack to hold the __exit__ method plus an additional 4 entries. |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 598 | if (TOP() == mp_const_none) { |
Damien George | 8c1d23a | 2015-04-24 01:52:28 +0100 | [diff] [blame] | 599 | // stack: (..., __exit__, ctx_mgr, None) |
| 600 | sp[1] = mp_const_none; |
| 601 | sp[2] = mp_const_none; |
| 602 | sp -= 2; |
| 603 | mp_call_method_n_kw(3, 0, sp); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 604 | SET_TOP(mp_const_none); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 605 | } else if (MP_OBJ_IS_SMALL_INT(TOP())) { |
Damien George | 5e1d993 | 2015-03-25 22:20:37 +0000 | [diff] [blame] | 606 | mp_int_t cause_val = MP_OBJ_SMALL_INT_VALUE(TOP()); |
| 607 | if (cause_val == UNWIND_RETURN) { |
Damien George | 8c1d23a | 2015-04-24 01:52:28 +0100 | [diff] [blame] | 608 | // stack: (..., __exit__, ctx_mgr, ret_val, UNWIND_RETURN) |
| 609 | mp_obj_t ret_val = sp[-1]; |
| 610 | sp[-1] = mp_const_none; |
| 611 | sp[0] = mp_const_none; |
| 612 | sp[1] = mp_const_none; |
| 613 | mp_call_method_n_kw(3, 0, sp - 3); |
| 614 | sp[-3] = ret_val; |
| 615 | sp[-2] = MP_OBJ_NEW_SMALL_INT(UNWIND_RETURN); |
Damien George | 5e1d993 | 2015-03-25 22:20:37 +0000 | [diff] [blame] | 616 | } else { |
| 617 | assert(cause_val == UNWIND_JUMP); |
Damien George | 8c1d23a | 2015-04-24 01:52:28 +0100 | [diff] [blame] | 618 | // stack: (..., __exit__, ctx_mgr, dest_ip, num_exc, UNWIND_JUMP) |
| 619 | mp_obj_t dest_ip = sp[-2]; |
| 620 | mp_obj_t num_exc = sp[-1]; |
| 621 | sp[-2] = mp_const_none; |
| 622 | sp[-1] = mp_const_none; |
| 623 | sp[0] = mp_const_none; |
| 624 | mp_call_method_n_kw(3, 0, sp - 4); |
| 625 | sp[-4] = dest_ip; |
| 626 | sp[-3] = num_exc; |
| 627 | sp[-2] = MP_OBJ_NEW_SMALL_INT(UNWIND_JUMP); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 628 | } |
Damien George | 8c1d23a | 2015-04-24 01:52:28 +0100 | [diff] [blame] | 629 | sp -= 2; // we removed (__exit__, ctx_mgr) |
Damien George | 5e1d993 | 2015-03-25 22:20:37 +0000 | [diff] [blame] | 630 | } else { |
Damien George | f040685 | 2016-09-27 12:37:21 +1000 | [diff] [blame] | 631 | assert(mp_obj_is_exception_instance(TOP())); |
| 632 | // stack: (..., __exit__, ctx_mgr, exc_instance) |
| 633 | // Need to pass (exc_type, exc_instance, None) as arguments to __exit__. |
| 634 | sp[1] = sp[0]; |
Damien George | 71fec07 | 2016-09-27 13:21:23 +1000 | [diff] [blame] | 635 | sp[0] = MP_OBJ_FROM_PTR(mp_obj_get_type(sp[0])); |
Damien George | f040685 | 2016-09-27 12:37:21 +1000 | [diff] [blame] | 636 | sp[2] = mp_const_none; |
| 637 | sp -= 2; |
| 638 | mp_obj_t ret_value = mp_call_method_n_kw(3, 0, sp); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 639 | if (mp_obj_is_true(ret_value)) { |
Damien George | 8c1d23a | 2015-04-24 01:52:28 +0100 | [diff] [blame] | 640 | // We need to silence/swallow the exception. This is done |
| 641 | // by popping the exception and the __exit__ handler and |
| 642 | // replacing it with None, which signals END_FINALLY to just |
| 643 | // execute the finally handler normally. |
Damien George | 8c1d23a | 2015-04-24 01:52:28 +0100 | [diff] [blame] | 644 | SET_TOP(mp_const_none); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 645 | assert(exc_sp >= exc_stack); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 646 | POP_EXC_BLOCK(); |
Damien George | 596f41d | 2015-02-10 13:21:42 +0000 | [diff] [blame] | 647 | } else { |
Damien George | 8c1d23a | 2015-04-24 01:52:28 +0100 | [diff] [blame] | 648 | // We need to re-raise the exception. We pop __exit__ handler |
Damien George | f040685 | 2016-09-27 12:37:21 +1000 | [diff] [blame] | 649 | // by copying the exception instance down to the new top-of-stack. |
| 650 | sp[0] = sp[3]; |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 651 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 652 | } |
| 653 | DISPATCH(); |
| 654 | } |
Damien | c226dca | 2013-10-16 16:12:52 +0100 | [diff] [blame] | 655 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 656 | ENTRY(MP_BC_UNWIND_JUMP): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 657 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 658 | DECODE_SLABEL; |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 659 | PUSH((mp_obj_t)(mp_uint_t)(uintptr_t)(ip + slab)); // push destination ip for jump |
| 660 | PUSH((mp_obj_t)(mp_uint_t)(*ip)); // push number of exception handlers to unwind (0x80 bit set if we also need to pop stack) |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 661 | unwind_jump:; |
| 662 | mp_uint_t unum = (mp_uint_t)POP(); // get number of exception handlers to unwind |
Damien George | 25c8464 | 2014-05-30 15:20:41 +0100 | [diff] [blame] | 663 | while ((unum & 0x7f) > 0) { |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 664 | unum -= 1; |
| 665 | assert(exc_sp >= exc_stack); |
Damien George | 74eb44c | 2014-12-22 12:49:57 +0000 | [diff] [blame] | 666 | if (MP_TAGPTR_TAG1(exc_sp->val_sp)) { |
Damien George | 4bf3f2d | 2015-10-15 17:48:28 +0100 | [diff] [blame] | 667 | // Getting here the stack looks like: |
| 668 | // (..., X, dest_ip) |
| 669 | // where X is pointed to by exc_sp->val_sp and in the case |
| 670 | // of a "with" block contains the context manager info. |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 671 | // We're going to run "finally" code as a coroutine |
| 672 | // (not calling it recursively). Set up a sentinel |
| 673 | // on a stack so it can return back to us when it is |
Damien George | 4bf3f2d | 2015-10-15 17:48:28 +0100 | [diff] [blame] | 674 | // done (when WITH_CLEANUP or END_FINALLY reached). |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 675 | PUSH((mp_obj_t)unum); // push number of exception handlers left to unwind |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 676 | PUSH(MP_OBJ_NEW_SMALL_INT(UNWIND_JUMP)); // push sentinel |
| 677 | ip = exc_sp->handler; // get exception handler byte code address |
| 678 | exc_sp--; // pop exception handler |
| 679 | goto dispatch_loop; // run the exception handler |
| 680 | } |
Damien George | 93bb7df | 2016-02-01 16:07:21 +0000 | [diff] [blame] | 681 | POP_EXC_BLOCK(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 682 | } |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 683 | ip = (const byte*)MP_OBJ_TO_PTR(POP()); // pop destination ip for jump |
Damien George | 25c8464 | 2014-05-30 15:20:41 +0100 | [diff] [blame] | 684 | if (unum != 0) { |
Damien George | f4df3aa | 2016-01-09 23:59:52 +0000 | [diff] [blame] | 685 | // pop iter and iter_buf |
Damien George | 25c8464 | 2014-05-30 15:20:41 +0100 | [diff] [blame] | 686 | sp--; |
Damien George | 60656ea | 2017-03-23 16:36:08 +1100 | [diff] [blame] | 687 | sp -= MP_OBJ_ITER_BUF_NSLOTS; |
Damien George | 25c8464 | 2014-05-30 15:20:41 +0100 | [diff] [blame] | 688 | } |
Damien George | 124df6f | 2014-10-25 18:19:55 +0100 | [diff] [blame] | 689 | DISPATCH_WITH_PEND_EXC_CHECK(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 690 | } |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 691 | |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 692 | // matched against: POP_BLOCK or POP_EXCEPT (anything else?) |
| 693 | ENTRY(MP_BC_SETUP_EXCEPT): |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 694 | ENTRY(MP_BC_SETUP_FINALLY): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 695 | MARK_EXC_IP_SELECTIVE(); |
Damien George | f89d659 | 2014-12-29 00:29:59 +0000 | [diff] [blame] | 696 | #if SELECTIVE_EXC_IP |
| 697 | PUSH_EXC_BLOCK((code_state->ip[-1] == MP_BC_SETUP_FINALLY) ? 1 : 0); |
| 698 | #else |
| 699 | PUSH_EXC_BLOCK((code_state->ip[0] == MP_BC_SETUP_FINALLY) ? 1 : 0); |
| 700 | #endif |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 701 | DISPATCH(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 702 | } |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 703 | |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 704 | ENTRY(MP_BC_END_FINALLY): |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 705 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 706 | // if TOS is None, just pops it and continues |
Damien George | f040685 | 2016-09-27 12:37:21 +1000 | [diff] [blame] | 707 | // if TOS is an integer, finishes coroutine and returns control to caller |
| 708 | // if TOS is an exception, reraises the exception |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 709 | if (TOP() == mp_const_none) { |
Damien George | 20006db | 2014-01-18 14:10:48 +0000 | [diff] [blame] | 710 | sp--; |
Damien George | f040685 | 2016-09-27 12:37:21 +1000 | [diff] [blame] | 711 | } else if (MP_OBJ_IS_SMALL_INT(TOP())) { |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 712 | // We finished "finally" coroutine and now dispatch back |
| 713 | // to our caller, based on TOS value |
| 714 | mp_unwind_reason_t reason = MP_OBJ_SMALL_INT_VALUE(POP()); |
Damien George | 5e1d993 | 2015-03-25 22:20:37 +0000 | [diff] [blame] | 715 | if (reason == UNWIND_RETURN) { |
| 716 | goto unwind_return; |
| 717 | } else { |
| 718 | assert(reason == UNWIND_JUMP); |
| 719 | goto unwind_jump; |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 720 | } |
Damien George | f040685 | 2016-09-27 12:37:21 +1000 | [diff] [blame] | 721 | } else { |
| 722 | assert(mp_obj_is_exception_instance(TOP())); |
| 723 | RAISE(TOP()); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 724 | } |
| 725 | DISPATCH(); |
| 726 | |
| 727 | ENTRY(MP_BC_GET_ITER): |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 728 | MARK_EXC_IP_SELECTIVE(); |
Damien George | ae8d867 | 2016-01-09 23:14:54 +0000 | [diff] [blame] | 729 | SET_TOP(mp_getiter(TOP(), NULL)); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 730 | DISPATCH(); |
| 731 | |
Damien George | 60656ea | 2017-03-23 16:36:08 +1100 | [diff] [blame] | 732 | // An iterator for a for-loop takes MP_OBJ_ITER_BUF_NSLOTS slots on |
| 733 | // the Python value stack. These slots are either used to store the |
| 734 | // iterator object itself, or the first slot is MP_OBJ_NULL and |
Damien George | 088740e | 2017-01-17 15:27:37 +1100 | [diff] [blame] | 735 | // the second slot holds a reference to the iterator object. |
Damien George | f4df3aa | 2016-01-09 23:59:52 +0000 | [diff] [blame] | 736 | ENTRY(MP_BC_GET_ITER_STACK): { |
| 737 | MARK_EXC_IP_SELECTIVE(); |
| 738 | mp_obj_t obj = TOP(); |
| 739 | mp_obj_iter_buf_t *iter_buf = (mp_obj_iter_buf_t*)sp; |
Damien George | 60656ea | 2017-03-23 16:36:08 +1100 | [diff] [blame] | 740 | sp += MP_OBJ_ITER_BUF_NSLOTS - 1; |
Damien George | 088740e | 2017-01-17 15:27:37 +1100 | [diff] [blame] | 741 | obj = mp_getiter(obj, iter_buf); |
| 742 | if (obj != MP_OBJ_FROM_PTR(iter_buf)) { |
| 743 | // Iterator didn't use the stack so indicate that with MP_OBJ_NULL. |
Damien George | 60656ea | 2017-03-23 16:36:08 +1100 | [diff] [blame] | 744 | sp[-MP_OBJ_ITER_BUF_NSLOTS + 1] = MP_OBJ_NULL; |
| 745 | sp[-MP_OBJ_ITER_BUF_NSLOTS + 2] = obj; |
Damien George | 088740e | 2017-01-17 15:27:37 +1100 | [diff] [blame] | 746 | } |
Damien George | f4df3aa | 2016-01-09 23:59:52 +0000 | [diff] [blame] | 747 | DISPATCH(); |
| 748 | } |
| 749 | |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 750 | ENTRY(MP_BC_FOR_ITER): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 751 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 752 | DECODE_ULABEL; // the jump offset if iteration finishes; for labels are always forward |
Damien George | c60a261 | 2014-06-01 12:32:28 +0100 | [diff] [blame] | 753 | code_state->sp = sp; |
Damien George | 088740e | 2017-01-17 15:27:37 +1100 | [diff] [blame] | 754 | mp_obj_t obj; |
Damien George | 60656ea | 2017-03-23 16:36:08 +1100 | [diff] [blame] | 755 | if (sp[-MP_OBJ_ITER_BUF_NSLOTS + 1] == MP_OBJ_NULL) { |
| 756 | obj = sp[-MP_OBJ_ITER_BUF_NSLOTS + 2]; |
Damien George | 088740e | 2017-01-17 15:27:37 +1100 | [diff] [blame] | 757 | } else { |
Damien George | 60656ea | 2017-03-23 16:36:08 +1100 | [diff] [blame] | 758 | obj = MP_OBJ_FROM_PTR(&sp[-MP_OBJ_ITER_BUF_NSLOTS + 1]); |
Damien George | 088740e | 2017-01-17 15:27:37 +1100 | [diff] [blame] | 759 | } |
| 760 | mp_obj_t value = mp_iternext_allow_raise(obj); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 761 | if (value == MP_OBJ_STOP_ITERATION) { |
Damien George | 60656ea | 2017-03-23 16:36:08 +1100 | [diff] [blame] | 762 | sp -= MP_OBJ_ITER_BUF_NSLOTS; // pop the exhausted iterator |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 763 | ip += ulab; // jump to after for-block |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 764 | } else { |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 765 | PUSH(value); // push the next iteration value |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 766 | } |
| 767 | DISPATCH(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 768 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 769 | |
| 770 | // matched against: SETUP_EXCEPT, SETUP_FINALLY, SETUP_WITH |
| 771 | ENTRY(MP_BC_POP_BLOCK): |
| 772 | // we are exiting an exception handler, so pop the last one of the exception-stack |
| 773 | assert(exc_sp >= exc_stack); |
| 774 | POP_EXC_BLOCK(); |
| 775 | DISPATCH(); |
| 776 | |
| 777 | // matched against: SETUP_EXCEPT |
| 778 | ENTRY(MP_BC_POP_EXCEPT): |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 779 | assert(exc_sp >= exc_stack); |
| 780 | assert(currently_in_except_block); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 781 | POP_EXC_BLOCK(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 782 | DISPATCH(); |
| 783 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 784 | ENTRY(MP_BC_BUILD_TUPLE): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 785 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 786 | DECODE_UINT; |
| 787 | sp -= unum - 1; |
| 788 | SET_TOP(mp_obj_new_tuple(unum, sp)); |
| 789 | DISPATCH(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 790 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 791 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 792 | ENTRY(MP_BC_BUILD_LIST): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 793 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 794 | DECODE_UINT; |
| 795 | sp -= unum - 1; |
| 796 | SET_TOP(mp_obj_new_list(unum, sp)); |
| 797 | DISPATCH(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 798 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 799 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 800 | ENTRY(MP_BC_BUILD_MAP): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 801 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 802 | DECODE_UINT; |
| 803 | PUSH(mp_obj_new_dict(unum)); |
| 804 | DISPATCH(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 805 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 806 | |
| 807 | ENTRY(MP_BC_STORE_MAP): |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 808 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 809 | sp -= 2; |
| 810 | mp_obj_dict_store(sp[0], sp[2], sp[1]); |
| 811 | DISPATCH(); |
| 812 | |
Damien George | 3ebd4d0 | 2014-06-01 13:46:47 +0100 | [diff] [blame] | 813 | #if MICROPY_PY_BUILTINS_SET |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 814 | ENTRY(MP_BC_BUILD_SET): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 815 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 816 | DECODE_UINT; |
| 817 | sp -= unum - 1; |
| 818 | SET_TOP(mp_obj_new_set(unum, sp)); |
| 819 | DISPATCH(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 820 | } |
Damien George | 3ebd4d0 | 2014-06-01 13:46:47 +0100 | [diff] [blame] | 821 | #endif |
Damien | c12aa46 | 2013-10-16 20:57:49 +0100 | [diff] [blame] | 822 | |
Damien George | fb510b3 | 2014-06-01 13:32:54 +0100 | [diff] [blame] | 823 | #if MICROPY_PY_BUILTINS_SLICE |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 824 | ENTRY(MP_BC_BUILD_SLICE): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 825 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 826 | DECODE_UINT; |
| 827 | if (unum == 2) { |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 828 | mp_obj_t stop = POP(); |
| 829 | mp_obj_t start = TOP(); |
| 830 | SET_TOP(mp_obj_new_slice(start, stop, mp_const_none)); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 831 | } else { |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 832 | mp_obj_t step = POP(); |
| 833 | mp_obj_t stop = POP(); |
| 834 | mp_obj_t start = TOP(); |
| 835 | SET_TOP(mp_obj_new_slice(start, stop, step)); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 836 | } |
| 837 | DISPATCH(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 838 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 839 | #endif |
| 840 | |
Damien George | adaf0d8 | 2016-09-19 08:46:01 +1000 | [diff] [blame] | 841 | ENTRY(MP_BC_STORE_COMP): { |
| 842 | MARK_EXC_IP_SELECTIVE(); |
| 843 | DECODE_UINT; |
| 844 | mp_obj_t obj = sp[-(unum >> 2)]; |
| 845 | if ((unum & 3) == 0) { |
| 846 | mp_obj_list_append(obj, sp[0]); |
| 847 | sp--; |
| 848 | } else if (!MICROPY_PY_BUILTINS_SET || (unum & 3) == 1) { |
| 849 | mp_obj_dict_store(obj, sp[0], sp[-1]); |
| 850 | sp -= 2; |
| 851 | #if MICROPY_PY_BUILTINS_SET |
| 852 | } else { |
| 853 | mp_obj_set_store(obj, sp[0]); |
| 854 | sp--; |
| 855 | #endif |
| 856 | } |
| 857 | DISPATCH(); |
| 858 | } |
| 859 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 860 | ENTRY(MP_BC_UNPACK_SEQUENCE): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 861 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 862 | DECODE_UINT; |
| 863 | mp_unpack_sequence(sp[0], unum, sp); |
| 864 | sp += unum - 1; |
| 865 | DISPATCH(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 866 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 867 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 868 | ENTRY(MP_BC_UNPACK_EX): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 869 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 870 | DECODE_UINT; |
| 871 | mp_unpack_ex(sp[0], unum, sp); |
| 872 | sp += (unum & 0xff) + ((unum >> 8) & 0xff); |
| 873 | DISPATCH(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 874 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 875 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 876 | ENTRY(MP_BC_MAKE_FUNCTION): { |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 877 | DECODE_PTR; |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 878 | PUSH(mp_make_function_from_raw_code(ptr, MP_OBJ_NULL, MP_OBJ_NULL)); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 879 | DISPATCH(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 880 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 881 | |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 882 | ENTRY(MP_BC_MAKE_FUNCTION_DEFARGS): { |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 883 | DECODE_PTR; |
| 884 | // Stack layout: def_tuple def_dict <- TOS |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 885 | mp_obj_t def_dict = POP(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 886 | SET_TOP(mp_make_function_from_raw_code(ptr, TOP(), def_dict)); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 887 | DISPATCH(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 888 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 889 | |
Damien George | 3558f62 | 2014-04-20 17:50:40 +0100 | [diff] [blame] | 890 | ENTRY(MP_BC_MAKE_CLOSURE): { |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 891 | DECODE_PTR; |
Damien George | 101886f | 2017-02-16 16:48:33 +1100 | [diff] [blame] | 892 | size_t n_closed_over = *ip++; |
Damien George | 3558f62 | 2014-04-20 17:50:40 +0100 | [diff] [blame] | 893 | // Stack layout: closed_overs <- TOS |
| 894 | sp -= n_closed_over - 1; |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 895 | SET_TOP(mp_make_closure_from_raw_code(ptr, n_closed_over, sp)); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 896 | DISPATCH(); |
Damien George | 3558f62 | 2014-04-20 17:50:40 +0100 | [diff] [blame] | 897 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 898 | |
Damien George | 3558f62 | 2014-04-20 17:50:40 +0100 | [diff] [blame] | 899 | ENTRY(MP_BC_MAKE_CLOSURE_DEFARGS): { |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 900 | DECODE_PTR; |
Damien George | 101886f | 2017-02-16 16:48:33 +1100 | [diff] [blame] | 901 | size_t n_closed_over = *ip++; |
Damien George | 3558f62 | 2014-04-20 17:50:40 +0100 | [diff] [blame] | 902 | // Stack layout: def_tuple def_dict closed_overs <- TOS |
| 903 | sp -= 2 + n_closed_over - 1; |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 904 | SET_TOP(mp_make_closure_from_raw_code(ptr, 0x100 | n_closed_over, sp)); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 905 | DISPATCH(); |
Damien George | 3558f62 | 2014-04-20 17:50:40 +0100 | [diff] [blame] | 906 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 907 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 908 | ENTRY(MP_BC_CALL_FUNCTION): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 909 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 910 | DECODE_UINT; |
| 911 | // unum & 0xff == n_positional |
| 912 | // (unum >> 8) & 0xff == n_keyword |
| 913 | sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe); |
Paul Sokolovsky | 2039757 | 2015-03-28 01:14:44 +0200 | [diff] [blame] | 914 | #if MICROPY_STACKLESS |
| 915 | if (mp_obj_get_type(*sp) == &mp_type_fun_bc) { |
| 916 | code_state->ip = ip; |
| 917 | code_state->sp = sp; |
| 918 | code_state->exc_sp = MP_TAGPTR_MAKE(exc_sp, currently_in_except_block); |
Damien George | 581a59a | 2016-08-27 23:21:00 +1000 | [diff] [blame] | 919 | mp_code_state_t *new_state = mp_obj_fun_bc_prepare_codestate(*sp, unum & 0xff, (unum >> 8) & 0xff, sp + 1); |
Paul Sokolovsky | 332a909 | 2015-03-28 01:14:44 +0200 | [diff] [blame] | 920 | if (new_state) { |
| 921 | new_state->prev = code_state; |
| 922 | code_state = new_state; |
| 923 | nlr_pop(); |
| 924 | goto run_code_state; |
| 925 | } |
Paul Sokolovsky | 7f1c981 | 2015-03-28 01:14:45 +0200 | [diff] [blame] | 926 | #if MICROPY_STACKLESS_STRICT |
| 927 | else { |
| 928 | deep_recursion_error: |
| 929 | mp_exc_recursion_depth(); |
| 930 | } |
| 931 | #endif |
Paul Sokolovsky | 2039757 | 2015-03-28 01:14:44 +0200 | [diff] [blame] | 932 | } |
| 933 | #endif |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 934 | SET_TOP(mp_call_function_n_kw(*sp, unum & 0xff, (unum >> 8) & 0xff, sp + 1)); |
| 935 | DISPATCH(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 936 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 937 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 938 | ENTRY(MP_BC_CALL_FUNCTION_VAR_KW): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 939 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 940 | DECODE_UINT; |
| 941 | // unum & 0xff == n_positional |
| 942 | // (unum >> 8) & 0xff == n_keyword |
| 943 | // We have folowing stack layout here: |
| 944 | // fun arg0 arg1 ... kw0 val0 kw1 val1 ... seq dict <- TOS |
| 945 | sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe) + 2; |
Paul Sokolovsky | f0a8f21 | 2015-03-28 01:14:45 +0200 | [diff] [blame] | 946 | #if MICROPY_STACKLESS |
| 947 | if (mp_obj_get_type(*sp) == &mp_type_fun_bc) { |
| 948 | code_state->ip = ip; |
| 949 | code_state->sp = sp; |
| 950 | code_state->exc_sp = MP_TAGPTR_MAKE(exc_sp, currently_in_except_block); |
| 951 | |
Damien George | 12a5e17 | 2015-04-01 23:31:30 +0100 | [diff] [blame] | 952 | mp_call_args_t out_args; |
Paul Sokolovsky | f0a8f21 | 2015-03-28 01:14:45 +0200 | [diff] [blame] | 953 | mp_call_prepare_args_n_kw_var(false, unum, sp, &out_args); |
| 954 | |
Damien George | 581a59a | 2016-08-27 23:21:00 +1000 | [diff] [blame] | 955 | mp_code_state_t *new_state = mp_obj_fun_bc_prepare_codestate(out_args.fun, |
Paul Sokolovsky | f0a8f21 | 2015-03-28 01:14:45 +0200 | [diff] [blame] | 956 | out_args.n_args, out_args.n_kw, out_args.args); |
| 957 | m_del(mp_obj_t, out_args.args, out_args.n_alloc); |
| 958 | if (new_state) { |
| 959 | new_state->prev = code_state; |
| 960 | code_state = new_state; |
| 961 | nlr_pop(); |
| 962 | goto run_code_state; |
| 963 | } |
Paul Sokolovsky | 7f1c981 | 2015-03-28 01:14:45 +0200 | [diff] [blame] | 964 | #if MICROPY_STACKLESS_STRICT |
| 965 | else { |
| 966 | goto deep_recursion_error; |
| 967 | } |
| 968 | #endif |
Paul Sokolovsky | f0a8f21 | 2015-03-28 01:14:45 +0200 | [diff] [blame] | 969 | } |
| 970 | #endif |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 971 | SET_TOP(mp_call_method_n_kw_var(false, unum, sp)); |
| 972 | DISPATCH(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 973 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 974 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 975 | ENTRY(MP_BC_CALL_METHOD): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 976 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 977 | DECODE_UINT; |
| 978 | // unum & 0xff == n_positional |
| 979 | // (unum >> 8) & 0xff == n_keyword |
| 980 | sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe) + 1; |
Paul Sokolovsky | 390e926 | 2015-03-28 01:14:44 +0200 | [diff] [blame] | 981 | #if MICROPY_STACKLESS |
| 982 | if (mp_obj_get_type(*sp) == &mp_type_fun_bc) { |
| 983 | code_state->ip = ip; |
| 984 | code_state->sp = sp; |
| 985 | code_state->exc_sp = MP_TAGPTR_MAKE(exc_sp, currently_in_except_block); |
| 986 | |
Damien George | 101886f | 2017-02-16 16:48:33 +1100 | [diff] [blame] | 987 | size_t n_args = unum & 0xff; |
| 988 | size_t n_kw = (unum >> 8) & 0xff; |
Damien George | 7a30e87 | 2015-12-17 12:32:41 +0000 | [diff] [blame] | 989 | int adjust = (sp[1] == MP_OBJ_NULL) ? 0 : 1; |
Paul Sokolovsky | 390e926 | 2015-03-28 01:14:44 +0200 | [diff] [blame] | 990 | |
Damien George | 581a59a | 2016-08-27 23:21:00 +1000 | [diff] [blame] | 991 | mp_code_state_t *new_state = mp_obj_fun_bc_prepare_codestate(*sp, n_args + adjust, n_kw, sp + 2 - adjust); |
Paul Sokolovsky | 390e926 | 2015-03-28 01:14:44 +0200 | [diff] [blame] | 992 | if (new_state) { |
| 993 | new_state->prev = code_state; |
| 994 | code_state = new_state; |
| 995 | nlr_pop(); |
| 996 | goto run_code_state; |
| 997 | } |
Paul Sokolovsky | 7f1c981 | 2015-03-28 01:14:45 +0200 | [diff] [blame] | 998 | #if MICROPY_STACKLESS_STRICT |
| 999 | else { |
| 1000 | goto deep_recursion_error; |
| 1001 | } |
| 1002 | #endif |
Paul Sokolovsky | 390e926 | 2015-03-28 01:14:44 +0200 | [diff] [blame] | 1003 | } |
| 1004 | #endif |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1005 | SET_TOP(mp_call_method_n_kw(unum & 0xff, (unum >> 8) & 0xff, sp)); |
| 1006 | DISPATCH(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 1007 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1008 | |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 1009 | ENTRY(MP_BC_CALL_METHOD_VAR_KW): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 1010 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1011 | DECODE_UINT; |
| 1012 | // unum & 0xff == n_positional |
| 1013 | // (unum >> 8) & 0xff == n_keyword |
| 1014 | // We have folowing stack layout here: |
| 1015 | // fun self arg0 arg1 ... kw0 val0 kw1 val1 ... seq dict <- TOS |
| 1016 | sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe) + 3; |
Paul Sokolovsky | f0a8f21 | 2015-03-28 01:14:45 +0200 | [diff] [blame] | 1017 | #if MICROPY_STACKLESS |
| 1018 | if (mp_obj_get_type(*sp) == &mp_type_fun_bc) { |
| 1019 | code_state->ip = ip; |
| 1020 | code_state->sp = sp; |
| 1021 | code_state->exc_sp = MP_TAGPTR_MAKE(exc_sp, currently_in_except_block); |
| 1022 | |
Damien George | 12a5e17 | 2015-04-01 23:31:30 +0100 | [diff] [blame] | 1023 | mp_call_args_t out_args; |
Paul Sokolovsky | f0a8f21 | 2015-03-28 01:14:45 +0200 | [diff] [blame] | 1024 | mp_call_prepare_args_n_kw_var(true, unum, sp, &out_args); |
| 1025 | |
Damien George | 581a59a | 2016-08-27 23:21:00 +1000 | [diff] [blame] | 1026 | mp_code_state_t *new_state = mp_obj_fun_bc_prepare_codestate(out_args.fun, |
Paul Sokolovsky | f0a8f21 | 2015-03-28 01:14:45 +0200 | [diff] [blame] | 1027 | out_args.n_args, out_args.n_kw, out_args.args); |
| 1028 | m_del(mp_obj_t, out_args.args, out_args.n_alloc); |
| 1029 | if (new_state) { |
| 1030 | new_state->prev = code_state; |
| 1031 | code_state = new_state; |
| 1032 | nlr_pop(); |
| 1033 | goto run_code_state; |
| 1034 | } |
Paul Sokolovsky | 7f1c981 | 2015-03-28 01:14:45 +0200 | [diff] [blame] | 1035 | #if MICROPY_STACKLESS_STRICT |
| 1036 | else { |
| 1037 | goto deep_recursion_error; |
| 1038 | } |
| 1039 | #endif |
Paul Sokolovsky | f0a8f21 | 2015-03-28 01:14:45 +0200 | [diff] [blame] | 1040 | } |
| 1041 | #endif |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1042 | SET_TOP(mp_call_method_n_kw_var(true, unum, sp)); |
| 1043 | DISPATCH(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 1044 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1045 | |
| 1046 | ENTRY(MP_BC_RETURN_VALUE): |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 1047 | MARK_EXC_IP_SELECTIVE(); |
Damien George | 8047340 | 2015-12-24 12:47:39 +0000 | [diff] [blame] | 1048 | // These next 3 lines pop a try-finally exception handler, if one |
| 1049 | // is there on the exception stack. Without this the finally block |
| 1050 | // is executed a second time when the return is executed, because |
| 1051 | // the try-finally exception handler is still on the stack. |
| 1052 | // TODO Possibly find a better way to handle this case. |
| 1053 | if (currently_in_except_block) { |
| 1054 | POP_EXC_BLOCK(); |
| 1055 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1056 | unwind_return: |
| 1057 | while (exc_sp >= exc_stack) { |
Damien George | 74eb44c | 2014-12-22 12:49:57 +0000 | [diff] [blame] | 1058 | if (MP_TAGPTR_TAG1(exc_sp->val_sp)) { |
Damien George | 4bf3f2d | 2015-10-15 17:48:28 +0100 | [diff] [blame] | 1059 | // Getting here the stack looks like: |
| 1060 | // (..., X, [iter0, iter1, ...,] ret_val) |
| 1061 | // where X is pointed to by exc_sp->val_sp and in the case |
| 1062 | // of a "with" block contains the context manager info. |
| 1063 | // There may be 0 or more for-iterators between X and the |
| 1064 | // return value, and these must be removed before control can |
| 1065 | // pass to the finally code. We simply copy the ret_value down |
| 1066 | // over these iterators, if they exist. If they don't then the |
| 1067 | // following is a null operation. |
| 1068 | mp_obj_t *finally_sp = MP_TAGPTR_PTR(exc_sp->val_sp); |
| 1069 | finally_sp[1] = sp[0]; |
| 1070 | sp = &finally_sp[1]; |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1071 | // We're going to run "finally" code as a coroutine |
| 1072 | // (not calling it recursively). Set up a sentinel |
| 1073 | // on a stack so it can return back to us when it is |
Damien George | 4bf3f2d | 2015-10-15 17:48:28 +0100 | [diff] [blame] | 1074 | // done (when WITH_CLEANUP or END_FINALLY reached). |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1075 | PUSH(MP_OBJ_NEW_SMALL_INT(UNWIND_RETURN)); |
| 1076 | ip = exc_sp->handler; |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1077 | exc_sp--; |
| 1078 | goto dispatch_loop; |
| 1079 | } |
| 1080 | exc_sp--; |
| 1081 | } |
| 1082 | nlr_pop(); |
Paul Sokolovsky | b4ebad3 | 2014-05-31 16:50:46 +0300 | [diff] [blame] | 1083 | code_state->sp = sp; |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1084 | assert(exc_sp == exc_stack - 1); |
Damien George | 40d8430 | 2016-02-15 22:46:21 +0000 | [diff] [blame] | 1085 | MICROPY_VM_HOOK_RETURN |
Paul Sokolovsky | 2039757 | 2015-03-28 01:14:44 +0200 | [diff] [blame] | 1086 | #if MICROPY_STACKLESS |
| 1087 | if (code_state->prev != NULL) { |
| 1088 | mp_obj_t res = *sp; |
| 1089 | mp_globals_set(code_state->old_globals); |
| 1090 | code_state = code_state->prev; |
| 1091 | *code_state->sp = res; |
| 1092 | goto run_code_state; |
| 1093 | } |
| 1094 | #endif |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1095 | return MP_VM_RETURN_NORMAL; |
| 1096 | |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1097 | ENTRY(MP_BC_RAISE_VARARGS): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 1098 | MARK_EXC_IP_SELECTIVE(); |
Damien George | cd97a43 | 2014-12-02 19:25:10 +0000 | [diff] [blame] | 1099 | mp_uint_t unum = *ip++; |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1100 | mp_obj_t obj; |
Paul Sokolovsky | 2ff2ea5 | 2015-09-01 10:35:58 +0300 | [diff] [blame] | 1101 | if (unum == 2) { |
| 1102 | mp_warning("exception chaining not supported"); |
| 1103 | // ignore (pop) "from" argument |
| 1104 | sp--; |
| 1105 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1106 | if (unum == 0) { |
| 1107 | // search for the inner-most previous exception, to reraise it |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1108 | obj = MP_OBJ_NULL; |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1109 | for (mp_exc_stack_t *e = exc_sp; e >= exc_stack; e--) { |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 1110 | if (e->prev_exc != NULL) { |
| 1111 | obj = MP_OBJ_FROM_PTR(e->prev_exc); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1112 | break; |
| 1113 | } |
| 1114 | } |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1115 | if (obj == MP_OBJ_NULL) { |
| 1116 | obj = mp_obj_new_exception_msg(&mp_type_RuntimeError, "No active exception to reraise"); |
| 1117 | RAISE(obj); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1118 | } |
| 1119 | } else { |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1120 | obj = POP(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1121 | } |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1122 | obj = mp_make_raise_obj(obj); |
| 1123 | RAISE(obj); |
| 1124 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1125 | |
| 1126 | ENTRY(MP_BC_YIELD_VALUE): |
| 1127 | yield: |
| 1128 | nlr_pop(); |
Paul Sokolovsky | b4ebad3 | 2014-05-31 16:50:46 +0300 | [diff] [blame] | 1129 | code_state->ip = ip; |
| 1130 | code_state->sp = sp; |
| 1131 | code_state->exc_sp = MP_TAGPTR_MAKE(exc_sp, currently_in_except_block); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1132 | return MP_VM_RETURN_YIELD; |
| 1133 | |
| 1134 | ENTRY(MP_BC_YIELD_FROM): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 1135 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1136 | //#define EXC_MATCH(exc, type) MP_OBJ_IS_TYPE(exc, type) |
| 1137 | #define EXC_MATCH(exc, type) mp_obj_exception_match(exc, type) |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 1138 | #define GENERATOR_EXIT_IF_NEEDED(t) if (t != MP_OBJ_NULL && EXC_MATCH(t, MP_OBJ_FROM_PTR(&mp_type_GeneratorExit))) { RAISE(t); } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1139 | mp_vm_return_kind_t ret_kind; |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1140 | mp_obj_t send_value = POP(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1141 | mp_obj_t t_exc = MP_OBJ_NULL; |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1142 | mp_obj_t ret_value; |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1143 | if (inject_exc != MP_OBJ_NULL) { |
| 1144 | t_exc = inject_exc; |
| 1145 | inject_exc = MP_OBJ_NULL; |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1146 | ret_kind = mp_resume(TOP(), MP_OBJ_NULL, t_exc, &ret_value); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1147 | } else { |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1148 | ret_kind = mp_resume(TOP(), send_value, MP_OBJ_NULL, &ret_value); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1149 | } |
| 1150 | |
| 1151 | if (ret_kind == MP_VM_RETURN_YIELD) { |
| 1152 | ip--; |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1153 | PUSH(ret_value); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1154 | goto yield; |
| 1155 | } |
| 1156 | if (ret_kind == MP_VM_RETURN_NORMAL) { |
| 1157 | // Pop exhausted gen |
| 1158 | sp--; |
Paul Sokolovsky | eff85bb | 2016-04-28 01:54:23 +0300 | [diff] [blame] | 1159 | // TODO: When ret_value can be MP_OBJ_NULL here?? |
| 1160 | if (ret_value == MP_OBJ_NULL || ret_value == MP_OBJ_STOP_ITERATION) { |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1161 | // Optimize StopIteration |
| 1162 | // TODO: get StopIteration's value |
| 1163 | PUSH(mp_const_none); |
| 1164 | } else { |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1165 | PUSH(ret_value); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1166 | } |
| 1167 | |
| 1168 | // If we injected GeneratorExit downstream, then even |
| 1169 | // if it was swallowed, we re-raise GeneratorExit |
| 1170 | GENERATOR_EXIT_IF_NEEDED(t_exc); |
| 1171 | DISPATCH(); |
| 1172 | } |
| 1173 | if (ret_kind == MP_VM_RETURN_EXCEPTION) { |
| 1174 | // Pop exhausted gen |
| 1175 | sp--; |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 1176 | if (EXC_MATCH(ret_value, MP_OBJ_FROM_PTR(&mp_type_StopIteration))) { |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1177 | PUSH(mp_obj_exception_get_value(ret_value)); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1178 | // If we injected GeneratorExit downstream, then even |
| 1179 | // if it was swallowed, we re-raise GeneratorExit |
| 1180 | GENERATOR_EXIT_IF_NEEDED(t_exc); |
| 1181 | DISPATCH(); |
| 1182 | } else { |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1183 | RAISE(ret_value); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1184 | } |
| 1185 | } |
Damien | 429d719 | 2013-10-04 19:53:11 +0100 | [diff] [blame] | 1186 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1187 | |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1188 | ENTRY(MP_BC_IMPORT_NAME): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 1189 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1190 | DECODE_QSTR; |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1191 | mp_obj_t obj = POP(); |
| 1192 | SET_TOP(mp_import_name(qst, obj, TOP())); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1193 | DISPATCH(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1194 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1195 | |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1196 | ENTRY(MP_BC_IMPORT_FROM): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 1197 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1198 | DECODE_QSTR; |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1199 | mp_obj_t obj = mp_import_from(TOP(), qst); |
| 1200 | PUSH(obj); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1201 | DISPATCH(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1202 | } |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1203 | |
| 1204 | ENTRY(MP_BC_IMPORT_STAR): |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 1205 | MARK_EXC_IP_SELECTIVE(); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1206 | mp_import_all(POP()); |
| 1207 | DISPATCH(); |
| 1208 | |
Damien George | 8456cc0 | 2014-10-25 16:43:46 +0100 | [diff] [blame] | 1209 | #if MICROPY_OPT_COMPUTED_GOTO |
| 1210 | ENTRY(MP_BC_LOAD_CONST_SMALL_INT_MULTI): |
| 1211 | PUSH(MP_OBJ_NEW_SMALL_INT((mp_int_t)ip[-1] - MP_BC_LOAD_CONST_SMALL_INT_MULTI - 16)); |
| 1212 | DISPATCH(); |
| 1213 | |
| 1214 | ENTRY(MP_BC_LOAD_FAST_MULTI): |
| 1215 | obj_shared = fastn[MP_BC_LOAD_FAST_MULTI - (mp_int_t)ip[-1]]; |
| 1216 | goto load_check; |
| 1217 | |
| 1218 | ENTRY(MP_BC_STORE_FAST_MULTI): |
| 1219 | fastn[MP_BC_STORE_FAST_MULTI - (mp_int_t)ip[-1]] = POP(); |
| 1220 | DISPATCH(); |
| 1221 | |
| 1222 | ENTRY(MP_BC_UNARY_OP_MULTI): |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 1223 | MARK_EXC_IP_SELECTIVE(); |
Damien George | 8456cc0 | 2014-10-25 16:43:46 +0100 | [diff] [blame] | 1224 | SET_TOP(mp_unary_op(ip[-1] - MP_BC_UNARY_OP_MULTI, TOP())); |
| 1225 | DISPATCH(); |
| 1226 | |
| 1227 | ENTRY(MP_BC_BINARY_OP_MULTI): { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 1228 | MARK_EXC_IP_SELECTIVE(); |
Damien George | 8456cc0 | 2014-10-25 16:43:46 +0100 | [diff] [blame] | 1229 | mp_obj_t rhs = POP(); |
| 1230 | mp_obj_t lhs = TOP(); |
| 1231 | SET_TOP(mp_binary_op(ip[-1] - MP_BC_BINARY_OP_MULTI, lhs, rhs)); |
| 1232 | DISPATCH(); |
| 1233 | } |
| 1234 | |
| 1235 | ENTRY_DEFAULT: |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 1236 | MARK_EXC_IP_SELECTIVE(); |
Damien George | 8456cc0 | 2014-10-25 16:43:46 +0100 | [diff] [blame] | 1237 | #else |
| 1238 | ENTRY_DEFAULT: |
| 1239 | if (ip[-1] < MP_BC_LOAD_CONST_SMALL_INT_MULTI + 64) { |
| 1240 | PUSH(MP_OBJ_NEW_SMALL_INT((mp_int_t)ip[-1] - MP_BC_LOAD_CONST_SMALL_INT_MULTI - 16)); |
| 1241 | DISPATCH(); |
| 1242 | } else if (ip[-1] < MP_BC_LOAD_FAST_MULTI + 16) { |
| 1243 | obj_shared = fastn[MP_BC_LOAD_FAST_MULTI - (mp_int_t)ip[-1]]; |
| 1244 | goto load_check; |
| 1245 | } else if (ip[-1] < MP_BC_STORE_FAST_MULTI + 16) { |
| 1246 | fastn[MP_BC_STORE_FAST_MULTI - (mp_int_t)ip[-1]] = POP(); |
| 1247 | DISPATCH(); |
Damien George | bdbe8c9 | 2015-12-08 12:28:11 +0000 | [diff] [blame] | 1248 | } else if (ip[-1] < MP_BC_UNARY_OP_MULTI + 7) { |
Damien George | 8456cc0 | 2014-10-25 16:43:46 +0100 | [diff] [blame] | 1249 | SET_TOP(mp_unary_op(ip[-1] - MP_BC_UNARY_OP_MULTI, TOP())); |
| 1250 | DISPATCH(); |
Damien George | c5029bc | 2015-06-13 22:00:10 +0100 | [diff] [blame] | 1251 | } else if (ip[-1] < MP_BC_BINARY_OP_MULTI + 36) { |
Damien George | 8456cc0 | 2014-10-25 16:43:46 +0100 | [diff] [blame] | 1252 | mp_obj_t rhs = POP(); |
| 1253 | mp_obj_t lhs = TOP(); |
| 1254 | SET_TOP(mp_binary_op(ip[-1] - MP_BC_BINARY_OP_MULTI, lhs, rhs)); |
| 1255 | DISPATCH(); |
| 1256 | } else |
| 1257 | #endif |
| 1258 | { |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1259 | mp_obj_t obj = mp_obj_new_exception_msg(&mp_type_NotImplementedError, "byte code not implemented"); |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1260 | nlr_pop(); |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1261 | fastn[0] = obj; |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1262 | return MP_VM_RETURN_EXCEPTION; |
Damien George | d867554 | 2014-05-25 22:58:04 +0100 | [diff] [blame] | 1263 | } |
Damien George | 66ae8c9 | 2014-04-17 16:50:23 +0100 | [diff] [blame] | 1264 | |
Damien George | 58ebde4 | 2014-05-21 20:32:59 +0100 | [diff] [blame] | 1265 | #if !MICROPY_OPT_COMPUTED_GOTO |
AZ Huang | 9309d99 | 2014-04-15 15:57:01 +0800 | [diff] [blame] | 1266 | } // switch |
AZ Huang | b1f692e | 2014-04-14 23:22:44 +0800 | [diff] [blame] | 1267 | #endif |
Damien George | 124df6f | 2014-10-25 18:19:55 +0100 | [diff] [blame] | 1268 | |
| 1269 | pending_exception_check: |
Damien George | 40d8430 | 2016-02-15 22:46:21 +0000 | [diff] [blame] | 1270 | MICROPY_VM_HOOK_LOOP |
Damien George | 6e74d24 | 2017-02-16 18:05:06 +1100 | [diff] [blame] | 1271 | |
| 1272 | #if MICROPY_ENABLE_SCHEDULER |
| 1273 | // This is an inlined variant of mp_handle_pending |
| 1274 | if (MP_STATE_VM(sched_state) == MP_SCHED_PENDING) { |
| 1275 | MARK_EXC_IP_SELECTIVE(); |
| 1276 | mp_uint_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION(); |
| 1277 | mp_obj_t obj = MP_STATE_VM(mp_pending_exception); |
| 1278 | if (obj != MP_OBJ_NULL) { |
| 1279 | MP_STATE_VM(mp_pending_exception) = MP_OBJ_NULL; |
| 1280 | if (!mp_sched_num_pending()) { |
| 1281 | MP_STATE_VM(sched_state) = MP_SCHED_IDLE; |
| 1282 | } |
| 1283 | MICROPY_END_ATOMIC_SECTION(atomic_state); |
| 1284 | RAISE(obj); |
| 1285 | } |
| 1286 | mp_handle_pending_tail(atomic_state); |
| 1287 | } |
| 1288 | #else |
| 1289 | // This is an inlined variant of mp_handle_pending |
Damien George | b4b10fd | 2015-01-01 23:30:53 +0000 | [diff] [blame] | 1290 | if (MP_STATE_VM(mp_pending_exception) != MP_OBJ_NULL) { |
Paul Sokolovsky | 7495750 | 2014-12-28 07:17:43 +0200 | [diff] [blame] | 1291 | MARK_EXC_IP_SELECTIVE(); |
Damien George | b4b10fd | 2015-01-01 23:30:53 +0000 | [diff] [blame] | 1292 | mp_obj_t obj = MP_STATE_VM(mp_pending_exception); |
| 1293 | MP_STATE_VM(mp_pending_exception) = MP_OBJ_NULL; |
Damien George | 124df6f | 2014-10-25 18:19:55 +0100 | [diff] [blame] | 1294 | RAISE(obj); |
| 1295 | } |
Damien George | 6e74d24 | 2017-02-16 18:05:06 +1100 | [diff] [blame] | 1296 | #endif |
Damien George | 124df6f | 2014-10-25 18:19:55 +0100 | [diff] [blame] | 1297 | |
Damien George | f6c22a0 | 2017-02-06 10:50:43 +1100 | [diff] [blame] | 1298 | #if MICROPY_PY_THREAD_GIL |
| 1299 | #if MICROPY_PY_THREAD_GIL_VM_DIVISOR |
| 1300 | if (--gil_divisor == 0) { |
| 1301 | gil_divisor = MICROPY_PY_THREAD_GIL_VM_DIVISOR; |
| 1302 | #else |
| 1303 | { |
| 1304 | #endif |
Damien George | 1a5c8d1 | 2017-03-20 18:42:27 +1100 | [diff] [blame] | 1305 | #if MICROPY_ENABLE_SCHEDULER |
| 1306 | // can only switch threads if the scheduler is unlocked |
| 1307 | if (MP_STATE_VM(sched_state) == MP_SCHED_IDLE) |
| 1308 | #endif |
| 1309 | { |
Damien George | f6c22a0 | 2017-02-06 10:50:43 +1100 | [diff] [blame] | 1310 | MP_THREAD_GIL_EXIT(); |
| 1311 | MP_THREAD_GIL_ENTER(); |
Damien George | 1a5c8d1 | 2017-03-20 18:42:27 +1100 | [diff] [blame] | 1312 | } |
Damien George | f6c22a0 | 2017-02-06 10:50:43 +1100 | [diff] [blame] | 1313 | } |
| 1314 | #endif |
Damien George | 4cec63a | 2016-05-26 10:42:53 +0000 | [diff] [blame] | 1315 | |
Damien George | 66ae8c9 | 2014-04-17 16:50:23 +0100 | [diff] [blame] | 1316 | } // for loop |
Damien | 429d719 | 2013-10-04 19:53:11 +0100 | [diff] [blame] | 1317 | |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 1318 | } else { |
Damien George | 66ae8c9 | 2014-04-17 16:50:23 +0100 | [diff] [blame] | 1319 | exception_handler: |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 1320 | // exception occurred |
Damien | 429d719 | 2013-10-04 19:53:11 +0100 | [diff] [blame] | 1321 | |
Paul Sokolovsky | 8b85d14 | 2015-04-25 03:17:41 +0300 | [diff] [blame] | 1322 | #if MICROPY_PY_SYS_EXC_INFO |
| 1323 | MP_STATE_VM(cur_exception) = nlr.ret_val; |
| 1324 | #endif |
| 1325 | |
Damien George | f89d659 | 2014-12-29 00:29:59 +0000 | [diff] [blame] | 1326 | #if SELECTIVE_EXC_IP |
| 1327 | // with selective ip, we store the ip 1 byte past the opcode, so move ptr back |
| 1328 | code_state->ip -= 1; |
| 1329 | #endif |
| 1330 | |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 1331 | if (mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(((mp_obj_base_t*)nlr.ret_val)->type), MP_OBJ_FROM_PTR(&mp_type_StopIteration))) { |
Paul Sokolovsky | a7c02c4 | 2015-05-10 17:18:10 +0300 | [diff] [blame] | 1332 | if (code_state->ip) { |
| 1333 | // check if it's a StopIteration within a for block |
| 1334 | if (*code_state->ip == MP_BC_FOR_ITER) { |
| 1335 | const byte *ip = code_state->ip + 1; |
| 1336 | DECODE_ULABEL; // the jump offset if iteration finishes; for labels are always forward |
| 1337 | code_state->ip = ip + ulab; // jump to after for-block |
Damien George | 60656ea | 2017-03-23 16:36:08 +1100 | [diff] [blame] | 1338 | code_state->sp -= MP_OBJ_ITER_BUF_NSLOTS; // pop the exhausted iterator |
Paul Sokolovsky | a7c02c4 | 2015-05-10 17:18:10 +0300 | [diff] [blame] | 1339 | goto outer_dispatch_loop; // continue with dispatch loop |
Paul Sokolovsky | 6738c1d | 2015-05-11 02:59:25 +0300 | [diff] [blame] | 1340 | } else if (*code_state->ip == MP_BC_YIELD_FROM) { |
| 1341 | // StopIteration inside yield from call means return a value of |
| 1342 | // yield from, so inject exception's value as yield from's result |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 1343 | *++code_state->sp = mp_obj_exception_get_value(MP_OBJ_FROM_PTR(nlr.ret_val)); |
Paul Sokolovsky | 6738c1d | 2015-05-11 02:59:25 +0300 | [diff] [blame] | 1344 | code_state->ip++; // yield from is over, move to next instruction |
| 1345 | goto outer_dispatch_loop; // continue with dispatch loop |
Paul Sokolovsky | a7c02c4 | 2015-05-10 17:18:10 +0300 | [diff] [blame] | 1346 | } |
| 1347 | } |
Damien George | 9e6e935 | 2014-03-26 18:37:06 +0000 | [diff] [blame] | 1348 | } |
| 1349 | |
Paul Sokolovsky | 2039757 | 2015-03-28 01:14:44 +0200 | [diff] [blame] | 1350 | #if MICROPY_STACKLESS |
| 1351 | unwind_loop: |
| 1352 | #endif |
Damien George | 0833500 | 2014-01-18 23:24:36 +0000 | [diff] [blame] | 1353 | // set file and line number that the exception occurred at |
Paul Sokolovsky | 382e8ee | 2014-01-30 13:49:18 +0200 | [diff] [blame] | 1354 | // TODO: don't set traceback for exceptions re-raised by END_FINALLY. |
| 1355 | // But consider how to handle nested exceptions. |
Damien George | 6902eed | 2014-04-04 10:52:59 +0000 | [diff] [blame] | 1356 | // TODO need a better way of not adding traceback to constant objects (right now, just GeneratorExit_obj and MemoryError_obj) |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 1357 | if (nlr.ret_val != &mp_const_GeneratorExit_obj && nlr.ret_val != &mp_const_MemoryError_obj) { |
Damien George | 71a3d6e | 2017-03-17 14:54:53 +1100 | [diff] [blame] | 1358 | const byte *ip = code_state->fun_bc->bytecode; |
| 1359 | mp_decode_uint(&ip); // skip n_state |
| 1360 | mp_decode_uint(&ip); // skip n_exc_stack |
| 1361 | ip++; // skip scope_params |
| 1362 | ip++; // skip n_pos_args |
| 1363 | ip++; // skip n_kwonly_args |
| 1364 | ip++; // skip n_def_pos_args |
| 1365 | size_t bc = code_state->ip - ip; |
Damien George | 101886f | 2017-02-16 16:48:33 +1100 | [diff] [blame] | 1366 | size_t code_info_size = mp_decode_uint(&ip); |
Damien George | 71a3d6e | 2017-03-17 14:54:53 +1100 | [diff] [blame] | 1367 | bc -= code_info_size; |
Damien George | c8e9c0d | 2015-11-02 17:27:18 +0000 | [diff] [blame] | 1368 | #if MICROPY_PERSISTENT_CODE |
| 1369 | qstr block_name = ip[0] | (ip[1] << 8); |
| 1370 | qstr source_file = ip[2] | (ip[3] << 8); |
| 1371 | ip += 4; |
| 1372 | #else |
Damien George | b534e1b | 2014-09-04 14:44:01 +0100 | [diff] [blame] | 1373 | qstr block_name = mp_decode_uint(&ip); |
| 1374 | qstr source_file = mp_decode_uint(&ip); |
Damien George | c8e9c0d | 2015-11-02 17:27:18 +0000 | [diff] [blame] | 1375 | #endif |
Damien George | 3d2daa2 | 2016-01-02 22:04:12 +0000 | [diff] [blame] | 1376 | size_t source_line = 1; |
| 1377 | size_t c; |
Damien George | b534e1b | 2014-09-04 14:44:01 +0100 | [diff] [blame] | 1378 | while ((c = *ip)) { |
Damien George | 101886f | 2017-02-16 16:48:33 +1100 | [diff] [blame] | 1379 | size_t b, l; |
Damien George | b427d6a | 2014-08-26 23:35:57 +0100 | [diff] [blame] | 1380 | if ((c & 0x80) == 0) { |
| 1381 | // 0b0LLBBBBB encoding |
| 1382 | b = c & 0x1f; |
| 1383 | l = c >> 5; |
Damien George | b534e1b | 2014-09-04 14:44:01 +0100 | [diff] [blame] | 1384 | ip += 1; |
Damien George | b427d6a | 2014-08-26 23:35:57 +0100 | [diff] [blame] | 1385 | } else { |
| 1386 | // 0b1LLLBBBB 0bLLLLLLLL encoding (l's LSB in second byte) |
| 1387 | b = c & 0xf; |
Damien George | b534e1b | 2014-09-04 14:44:01 +0100 | [diff] [blame] | 1388 | l = ((c << 4) & 0x700) | ip[1]; |
| 1389 | ip += 2; |
Damien George | b427d6a | 2014-08-26 23:35:57 +0100 | [diff] [blame] | 1390 | } |
| 1391 | if (bc >= b) { |
| 1392 | bc -= b; |
| 1393 | source_line += l; |
| 1394 | } else { |
| 1395 | // found source line corresponding to bytecode offset |
| 1396 | break; |
Paul Sokolovsky | 411732e | 2014-06-02 18:24:34 +0300 | [diff] [blame] | 1397 | } |
Damien George | 0833500 | 2014-01-18 23:24:36 +0000 | [diff] [blame] | 1398 | } |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 1399 | mp_obj_exception_add_traceback(MP_OBJ_FROM_PTR(nlr.ret_val), source_file, source_line, block_name); |
Damien George | 0833500 | 2014-01-18 23:24:36 +0000 | [diff] [blame] | 1400 | } |
| 1401 | |
Damien | 8f9e2ee | 2013-12-29 16:54:59 +0000 | [diff] [blame] | 1402 | while (currently_in_except_block) { |
| 1403 | // nested exception |
| 1404 | |
Paul Sokolovsky | c0abc28 | 2014-03-22 13:49:31 +0200 | [diff] [blame] | 1405 | assert(exc_sp >= exc_stack); |
Damien | 8f9e2ee | 2013-12-29 16:54:59 +0000 | [diff] [blame] | 1406 | |
| 1407 | // TODO make a proper message for nested exception |
| 1408 | // at the moment we are just raising the very last exception (the one that caused the nested exception) |
| 1409 | |
| 1410 | // move up to previous exception handler |
Paul Sokolovsky | a0ad77b | 2014-03-29 23:16:27 +0200 | [diff] [blame] | 1411 | POP_EXC_BLOCK(); |
Damien | 8f9e2ee | 2013-12-29 16:54:59 +0000 | [diff] [blame] | 1412 | } |
| 1413 | |
Paul Sokolovsky | c0abc28 | 2014-03-22 13:49:31 +0200 | [diff] [blame] | 1414 | if (exc_sp >= exc_stack) { |
Damien | 8f9e2ee | 2013-12-29 16:54:59 +0000 | [diff] [blame] | 1415 | // set flag to indicate that we are now handling an exception |
| 1416 | currently_in_except_block = 1; |
| 1417 | |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 1418 | // catch exception and pass to byte code |
Paul Sokolovsky | b4ebad3 | 2014-05-31 16:50:46 +0300 | [diff] [blame] | 1419 | code_state->ip = exc_sp->handler; |
Damien George | 66ae8c9 | 2014-04-17 16:50:23 +0100 | [diff] [blame] | 1420 | mp_obj_t *sp = MP_TAGPTR_PTR(exc_sp->val_sp); |
Damien George | d7592a1 | 2014-03-30 00:54:48 +0000 | [diff] [blame] | 1421 | // save this exception in the stack so it can be used in a reraise, if needed |
| 1422 | exc_sp->prev_exc = nlr.ret_val; |
Damien George | f040685 | 2016-09-27 12:37:21 +1000 | [diff] [blame] | 1423 | // push exception object so it can be handled by bytecode |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 1424 | PUSH(MP_OBJ_FROM_PTR(nlr.ret_val)); |
Paul Sokolovsky | b4ebad3 | 2014-05-31 16:50:46 +0300 | [diff] [blame] | 1425 | code_state->sp = sp; |
Damien | 8f9e2ee | 2013-12-29 16:54:59 +0000 | [diff] [blame] | 1426 | |
Paul Sokolovsky | 2039757 | 2015-03-28 01:14:44 +0200 | [diff] [blame] | 1427 | #if MICROPY_STACKLESS |
| 1428 | } else if (code_state->prev != NULL) { |
| 1429 | mp_globals_set(code_state->old_globals); |
| 1430 | code_state = code_state->prev; |
Damien George | 71a3d6e | 2017-03-17 14:54:53 +1100 | [diff] [blame] | 1431 | fastn = &code_state->state[n_state - 1]; |
| 1432 | exc_stack = (mp_exc_stack_t*)(code_state->state + n_state); |
Paul Sokolovsky | 2039757 | 2015-03-28 01:14:44 +0200 | [diff] [blame] | 1433 | // variables that are visible to the exception handler (declared volatile) |
| 1434 | currently_in_except_block = MP_TAGPTR_TAG0(code_state->exc_sp); // 0 or 1, to detect nested exceptions |
| 1435 | exc_sp = MP_TAGPTR_PTR(code_state->exc_sp); // stack grows up, exc_sp points to top of stack |
| 1436 | goto unwind_loop; |
| 1437 | |
| 1438 | #endif |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 1439 | } else { |
Damien George | c8f78bc | 2014-02-15 22:55:00 +0000 | [diff] [blame] | 1440 | // propagate exception to higher level |
| 1441 | // TODO what to do about ip and sp? they don't really make sense at this point |
Damien George | 999cedb | 2015-11-27 17:01:44 +0000 | [diff] [blame] | 1442 | fastn[0] = MP_OBJ_FROM_PTR(nlr.ret_val); // must put exception here because sp is invalid |
Damien George | c8f78bc | 2014-02-15 22:55:00 +0000 | [diff] [blame] | 1443 | return MP_VM_RETURN_EXCEPTION; |
Damien | ce89a21 | 2013-10-15 22:25:17 +0100 | [diff] [blame] | 1444 | } |
Damien | 429d719 | 2013-10-04 19:53:11 +0100 | [diff] [blame] | 1445 | } |
| 1446 | } |
| 1447 | } |