LCOV - code coverage report
Current view: top level - py - vm.c (source / functions) Hit Total Coverage
Test: unix_coverage_v1.19.1-724-gfb7d21153.info Lines: 601 601 100.0 %
Date: 2022-12-01 09:37:31 Functions: 1 1 100.0 %
Branches: 190 236 80.5 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * This file is part of the MicroPython project, http://micropython.org/
       3                 :            :  *
       4                 :            :  * The MIT License (MIT)
       5                 :            :  *
       6                 :            :  * Copyright (c) 2013-2019 Damien P. George
       7                 :            :  * Copyright (c) 2014-2015 Paul Sokolovsky
       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                 :            : 
      28                 :            : #include <stdio.h>
      29                 :            : #include <string.h>
      30                 :            : #include <assert.h>
      31                 :            : 
      32                 :            : #include "py/emitglue.h"
      33                 :            : #include "py/objtype.h"
      34                 :            : #include "py/objfun.h"
      35                 :            : #include "py/runtime.h"
      36                 :            : #include "py/bc0.h"
      37                 :            : #include "py/profile.h"
      38                 :            : 
      39                 :            : // *FORMAT-OFF*
      40                 :            : 
      41                 :            : #if 0
      42                 :            : #if MICROPY_PY_THREAD
      43                 :            : #define TRACE_PREFIX mp_printf(&mp_plat_print, "ts=%p sp=%d ", mp_thread_get_state(), (int)(sp - &code_state->state[0] + 1))
      44                 :            : #else
      45                 :            : #define TRACE_PREFIX mp_printf(&mp_plat_print, "sp=%d ", (int)(sp - &code_state->state[0] + 1))
      46                 :            : #endif
      47                 :            : #define TRACE(ip) TRACE_PREFIX; mp_bytecode_print2(&mp_plat_print, ip, 1, code_state->fun_bc->child_table, &code_state->fun_bc->context->constants);
      48                 :            : #else
      49                 :            : #define TRACE(ip)
      50                 :            : #endif
      51                 :            : 
      52                 :            : // Value stack grows up (this makes it incompatible with native C stack, but
      53                 :            : // makes sure that arguments to functions are in natural order arg1..argN
      54                 :            : // (Python semantics mandates left-to-right evaluation order, including for
      55                 :            : // function arguments). Stack pointer is pre-incremented and points at the
      56                 :            : // top element.
      57                 :            : // Exception stack also grows up, top element is also pointed at.
      58                 :            : 
      59                 :            : #define DECODE_UINT \
      60                 :            :     mp_uint_t unum = 0; \
      61                 :            :     do { \
      62                 :            :         unum = (unum << 7) + (*ip & 0x7f); \
      63                 :            :     } while ((*ip++ & 0x80) != 0)
      64                 :            : 
      65                 :            : #define DECODE_ULABEL \
      66                 :            :     size_t ulab; \
      67                 :            :     do { \
      68                 :            :         if (ip[0] & 0x80) { \
      69                 :            :             ulab = ((ip[0] & 0x7f) | (ip[1] << 7)); \
      70                 :            :             ip += 2; \
      71                 :            :         } else { \
      72                 :            :             ulab = ip[0]; \
      73                 :            :             ip += 1; \
      74                 :            :         } \
      75                 :            :     } while (0)
      76                 :            : 
      77                 :            : #define DECODE_SLABEL \
      78                 :            :     size_t slab; \
      79                 :            :     do { \
      80                 :            :         if (ip[0] & 0x80) { \
      81                 :            :             slab = ((ip[0] & 0x7f) | (ip[1] << 7)) - 0x4000; \
      82                 :            :             ip += 2; \
      83                 :            :         } else { \
      84                 :            :             slab = ip[0] - 0x40; \
      85                 :            :             ip += 1; \
      86                 :            :         } \
      87                 :            :     } while (0)
      88                 :            : 
      89                 :            : #if MICROPY_EMIT_BYTECODE_USES_QSTR_TABLE
      90                 :            : 
      91                 :            : #define DECODE_QSTR \
      92                 :            :     DECODE_UINT; \
      93                 :            :     qstr qst = qstr_table[unum]
      94                 :            : 
      95                 :            : #else
      96                 :            : 
      97                 :            : #define DECODE_QSTR \
      98                 :            :     DECODE_UINT; \
      99                 :            :     qstr qst = unum;
     100                 :            : 
     101                 :            : #endif
     102                 :            : 
     103                 :            : #define DECODE_PTR \
     104                 :            :     DECODE_UINT; \
     105                 :            :     void *ptr = (void *)(uintptr_t)code_state->fun_bc->child_table[unum]
     106                 :            : 
     107                 :            : #define DECODE_OBJ \
     108                 :            :     DECODE_UINT; \
     109                 :            :     mp_obj_t obj = (mp_obj_t)code_state->fun_bc->context->constants.obj_table[unum]
     110                 :            : 
     111                 :            : #define PUSH(val) *++sp = (val)
     112                 :            : #define POP() (*sp--)
     113                 :            : #define TOP() (*sp)
     114                 :            : #define SET_TOP(val) *sp = (val)
     115                 :            : 
     116                 :            : #if MICROPY_PY_SYS_EXC_INFO
     117                 :            : #define CLEAR_SYS_EXC_INFO() MP_STATE_VM(cur_exception) = NULL;
     118                 :            : #else
     119                 :            : #define CLEAR_SYS_EXC_INFO()
     120                 :            : #endif
     121                 :            : 
     122                 :            : #define PUSH_EXC_BLOCK(with_or_finally) do { \
     123                 :            :     DECODE_ULABEL; /* except labels are always forward */ \
     124                 :            :     ++exc_sp; \
     125                 :            :     exc_sp->handler = ip + ulab; \
     126                 :            :     exc_sp->val_sp = MP_TAGPTR_MAKE(sp, ((with_or_finally) << 1)); \
     127                 :            :     exc_sp->prev_exc = NULL; \
     128                 :            : } while (0)
     129                 :            : 
     130                 :            : #define POP_EXC_BLOCK() \
     131                 :            :     exc_sp--; /* pop back to previous exception handler */ \
     132                 :            :     CLEAR_SYS_EXC_INFO() /* just clear sys.exc_info(), not compliant, but it shouldn't be used in 1st place */
     133                 :            : 
     134                 :            : #define CANCEL_ACTIVE_FINALLY(sp) do { \
     135                 :            :     if (mp_obj_is_small_int(sp[-1])) { \
     136                 :            :         /* Stack: (..., prev_dest_ip, prev_cause, dest_ip) */ \
     137                 :            :         /* Cancel the unwind through the previous finally, replace with current one */ \
     138                 :            :         sp[-2] = sp[0]; \
     139                 :            :         sp -= 2; \
     140                 :            :     } else { \
     141                 :            :         assert(sp[-1] == mp_const_none || mp_obj_is_exception_instance(sp[-1])); \
     142                 :            :         /* Stack: (..., None/exception, dest_ip) */ \
     143                 :            :         /* Silence the finally's exception value (may be None or an exception) */ \
     144                 :            :         sp[-1] = sp[0]; \
     145                 :            :         --sp; \
     146                 :            :     } \
     147                 :            : } while (0)
     148                 :            : 
     149                 :            : #if MICROPY_PY_SYS_SETTRACE
     150                 :            : 
     151                 :            : #define FRAME_SETUP() do { \
     152                 :            :     assert(code_state != code_state->prev_state); \
     153                 :            :     MP_STATE_THREAD(current_code_state) = code_state; \
     154                 :            :     assert(code_state != code_state->prev_state); \
     155                 :            : } while(0)
     156                 :            : 
     157                 :            : #define FRAME_ENTER() do { \
     158                 :            :     assert(code_state != code_state->prev_state); \
     159                 :            :     code_state->prev_state = MP_STATE_THREAD(current_code_state); \
     160                 :            :     assert(code_state != code_state->prev_state); \
     161                 :            :     if (!mp_prof_is_executing) { \
     162                 :            :         mp_prof_frame_enter(code_state); \
     163                 :            :     } \
     164                 :            : } while(0)
     165                 :            : 
     166                 :            : #define FRAME_LEAVE() do { \
     167                 :            :     assert(code_state != code_state->prev_state); \
     168                 :            :     MP_STATE_THREAD(current_code_state) = code_state->prev_state; \
     169                 :            :     assert(code_state != code_state->prev_state); \
     170                 :            : } while(0)
     171                 :            : 
     172                 :            : #define FRAME_UPDATE() do { \
     173                 :            :     assert(MP_STATE_THREAD(current_code_state) == code_state); \
     174                 :            :     if (!mp_prof_is_executing) { \
     175                 :            :         code_state->frame = MP_OBJ_TO_PTR(mp_prof_frame_update(code_state)); \
     176                 :            :     } \
     177                 :            : } while(0)
     178                 :            : 
     179                 :            : #define TRACE_TICK(current_ip, current_sp, is_exception) do { \
     180                 :            :     assert(code_state != code_state->prev_state); \
     181                 :            :     assert(MP_STATE_THREAD(current_code_state) == code_state); \
     182                 :            :     if (!mp_prof_is_executing && code_state->frame && MP_STATE_THREAD(prof_trace_callback)) { \
     183                 :            :         MP_PROF_INSTR_DEBUG_PRINT(code_state->ip); \
     184                 :            :     } \
     185                 :            :     if (!mp_prof_is_executing && code_state->frame && code_state->frame->callback) { \
     186                 :            :         mp_prof_instr_tick(code_state, is_exception); \
     187                 :            :     } \
     188                 :            : } while(0)
     189                 :            : 
     190                 :            : #else // MICROPY_PY_SYS_SETTRACE
     191                 :            : #define FRAME_SETUP()
     192                 :            : #define FRAME_ENTER()
     193                 :            : #define FRAME_LEAVE()
     194                 :            : #define FRAME_UPDATE()
     195                 :            : #define TRACE_TICK(current_ip, current_sp, is_exception)
     196                 :            : #endif // MICROPY_PY_SYS_SETTRACE
     197                 :            : 
     198                 :            : // fastn has items in reverse order (fastn[0] is local[0], fastn[-1] is local[1], etc)
     199                 :            : // sp points to bottom of stack which grows up
     200                 :            : // returns:
     201                 :            : //  MP_VM_RETURN_NORMAL, sp valid, return value in *sp
     202                 :            : //  MP_VM_RETURN_YIELD, ip, sp valid, yielded value in *sp
     203                 :            : //  MP_VM_RETURN_EXCEPTION, exception in state[0]
     204                 :    8282675 : mp_vm_return_kind_t MICROPY_WRAP_MP_EXECUTE_BYTECODE(mp_execute_bytecode)(mp_code_state_t *code_state, volatile mp_obj_t inject_exc) {
     205                 :            : 
     206                 :            : #define SELECTIVE_EXC_IP (0)
     207                 :            : // When disabled, code_state->ip is updated unconditionally during op
     208                 :            : // dispatch, and this is subsequently used in the exception handler
     209                 :            : // (either NLR jump or direct RAISE). This is good for code size because it
     210                 :            : // happens in a single place but is more work than necessary, as many opcodes
     211                 :            : // cannot raise. Enabling SELECTIVE_EXC_IP means that code_state->ip
     212                 :            : // is "selectively" updated only during handling of opcodes that might raise.
     213                 :            : // This costs about 360 bytes on PYBV11 for a 1-3% performance gain (e.g. 3%
     214                 :            : // in bm_fft.py). On rp2040, there is zero code size diff for a 0-1% gain.
     215                 :            : // (Both with computed goto enabled).
     216                 :            : #if SELECTIVE_EXC_IP
     217                 :            : // Note: Because ip has already been advanced by one byte in the dispatch, the
     218                 :            : // value of ip here is one byte past the last opcode.
     219                 :            : #define MARK_EXC_IP_SELECTIVE() { code_state->ip = ip; }
     220                 :            : // No need to update in dispatch.
     221                 :            : #define MARK_EXC_IP_GLOBAL()
     222                 :            : #else
     223                 :            : #define MARK_EXC_IP_SELECTIVE()
     224                 :            : // Immediately before dispatch, save the current ip, which will be the opcode
     225                 :            : // about to be dispatched.
     226                 :            : #define MARK_EXC_IP_GLOBAL() { code_state->ip = ip; }
     227                 :            : #endif
     228                 :            : 
     229                 :            : #if MICROPY_OPT_COMPUTED_GOTO
     230                 :            :     #include "py/vmentrytable.h"
     231                 :            :     #define DISPATCH() do { \
     232                 :            :         TRACE(ip); \
     233                 :            :         MARK_EXC_IP_GLOBAL(); \
     234                 :            :         TRACE_TICK(ip, sp, false); \
     235                 :            :         goto *entry_table[*ip++]; \
     236                 :            :     } while (0)
     237                 :            :     #define DISPATCH_WITH_PEND_EXC_CHECK() goto pending_exception_check
     238                 :            :     #define ENTRY(op) entry_##op
     239                 :            :     #define ENTRY_DEFAULT entry_default
     240                 :            : #else
     241                 :            :     #define DISPATCH() goto dispatch_loop
     242                 :            :     #define DISPATCH_WITH_PEND_EXC_CHECK() goto pending_exception_check
     243                 :            :     #define ENTRY(op) case op
     244                 :            :     #define ENTRY_DEFAULT default
     245                 :            : #endif
     246                 :            : 
     247                 :            :     // nlr_raise needs to be implemented as a goto, so that the C compiler's flow analyser
     248                 :            :     // sees that it's possible for us to jump from the dispatch loop to the exception
     249                 :            :     // handler.  Without this, the code may have a different stack layout in the dispatch
     250                 :            :     // loop and the exception handler, leading to very obscure bugs.
     251                 :            :     #define RAISE(o) do { nlr_pop(); nlr.ret_val = MP_OBJ_TO_PTR(o); goto exception_handler; } while (0)
     252                 :            : 
     253                 :            : #if MICROPY_STACKLESS
     254                 :            : run_code_state: ;
     255                 :            : #endif
     256                 :    8282675 : FRAME_ENTER();
     257                 :            : 
     258                 :            : #if MICROPY_STACKLESS
     259                 :            : run_code_state_from_return: ;
     260                 :            : #endif
     261                 :    8282675 : FRAME_SETUP();
     262                 :            : 
     263                 :            :     // Pointers which are constant for particular invocation of mp_execute_bytecode()
     264                 :    8282675 :     mp_obj_t * /*const*/ fastn;
     265                 :    8282675 :     mp_exc_stack_t * /*const*/ exc_stack;
     266                 :            :     {
     267                 :    8282675 :         size_t n_state = code_state->n_state;
     268                 :    8282675 :         fastn = &code_state->state[n_state - 1];
     269                 :    8282675 :         exc_stack = (mp_exc_stack_t*)(code_state->state + n_state);
     270                 :            :     }
     271                 :            : 
     272                 :            :     // variables that are visible to the exception handler (declared volatile)
     273                 :    8282675 :     mp_exc_stack_t *volatile exc_sp = MP_CODE_STATE_EXC_SP_IDX_TO_PTR(exc_stack, code_state->exc_sp_idx); // stack grows up, exc_sp points to top of stack
     274                 :            : 
     275                 :            :     #if MICROPY_PY_THREAD_GIL && MICROPY_PY_THREAD_GIL_VM_DIVISOR
     276                 :            :     // This needs to be volatile and outside the VM loop so it persists across handling
     277                 :            :     // of any exceptions.  Otherwise it's possible that the VM never gives up the GIL.
     278                 :            :     volatile int gil_divisor = MICROPY_PY_THREAD_GIL_VM_DIVISOR;
     279                 :            :     #endif
     280                 :            : 
     281                 :            :     // outer exception handling loop
     282                 :    8354369 :     for (;;) {
     283                 :    8354369 :         nlr_buf_t nlr;
     284                 :            : outer_dispatch_loop:
     285         [ +  + ]:    8354369 :         if (nlr_push(&nlr) == 0) {
     286                 :            :             // local variables that are not visible to the exception handler
     287                 :    8267441 :             const byte *ip = code_state->ip;
     288                 :    8267441 :             mp_obj_t *sp = code_state->sp;
     289                 :            :             #if MICROPY_EMIT_BYTECODE_USES_QSTR_TABLE
     290                 :    8267441 :             const qstr_short_t *qstr_table = code_state->fun_bc->context->constants.qstr_table;
     291                 :            :             #endif
     292                 :    8267441 :             mp_obj_t obj_shared;
     293                 :            :             MICROPY_VM_HOOK_INIT
     294                 :            : 
     295                 :            :             // If we have exception to inject, now that we finish setting up
     296                 :            :             // execution context, raise it. This works as if MP_BC_RAISE_OBJ
     297                 :            :             // bytecode was executed.
     298                 :            :             // Injecting exc into yield from generator is a special case,
     299                 :            :             // handled by MP_BC_YIELD_FROM itself
     300   [ +  +  +  + ]:    8267441 :             if (inject_exc != MP_OBJ_NULL && *ip != MP_BC_YIELD_FROM) {
     301                 :         85 :                 mp_obj_t exc = inject_exc;
     302                 :         85 :                 inject_exc = MP_OBJ_NULL;
     303                 :         85 :                 exc = mp_make_raise_obj(exc);
     304                 :         85 :                 RAISE(exc);
     305                 :            :             }
     306                 :            : 
     307                 :            :             // loop to execute byte code
     308                 :   21882772 :             for (;;) {
     309                 :    8267356 : dispatch_loop:
     310                 :            :                 #if MICROPY_OPT_COMPUTED_GOTO
     311                 :   21882772 :                 DISPATCH();
     312                 :            :                 #else
     313                 :            :                 TRACE(ip);
     314                 :            :                 MARK_EXC_IP_GLOBAL();
     315                 :            :                 TRACE_TICK(ip, sp, false);
     316                 :            :                 switch (*ip++) {
     317                 :            :                 #endif
     318                 :            : 
     319                 :        541 :                 ENTRY(MP_BC_LOAD_CONST_FALSE):
     320                 :        541 :                     PUSH(mp_const_false);
     321                 :        541 :                     DISPATCH();
     322                 :            : 
     323                 :     974913 :                 ENTRY(MP_BC_LOAD_CONST_NONE):
     324                 :     974913 :                     PUSH(mp_const_none);
     325                 :     974913 :                     DISPATCH();
     326                 :            : 
     327                 :        755 :                 ENTRY(MP_BC_LOAD_CONST_TRUE):
     328                 :        755 :                     PUSH(mp_const_true);
     329                 :        755 :                     DISPATCH();
     330                 :            : 
     331                 :    7724587 :                 ENTRY(MP_BC_LOAD_CONST_SMALL_INT): {
     332                 :    7724587 :                     mp_uint_t num = 0;
     333         [ +  + ]:    7724587 :                     if ((ip[0] & 0x40) != 0) {
     334                 :            :                         // Number is negative
     335                 :        219 :                         num--;
     336                 :            :                     }
     337                 :   15574647 :                     do {
     338                 :   15574647 :                         num = (num << 7) | (*ip & 0x7f);
     339         [ +  + ]:   15574647 :                     } while ((*ip++ & 0x80) != 0);
     340                 :    7724587 :                     PUSH(MP_OBJ_NEW_SMALL_INT(num));
     341                 :    7724587 :                     DISPATCH();
     342                 :            :                 }
     343                 :            : 
     344                 :     158662 :                 ENTRY(MP_BC_LOAD_CONST_STRING): {
     345         [ -  + ]:     158662 :                     DECODE_QSTR;
     346                 :     158662 :                     PUSH(MP_OBJ_NEW_QSTR(qst));
     347                 :     158662 :                     DISPATCH();
     348                 :            :                 }
     349                 :            : 
     350                 :      46470 :                 ENTRY(MP_BC_LOAD_CONST_OBJ): {
     351         [ -  + ]:      46470 :                     DECODE_OBJ;
     352                 :      46470 :                     PUSH(obj);
     353                 :      46470 :                     DISPATCH();
     354                 :            :                 }
     355                 :            : 
     356                 :       1290 :                 ENTRY(MP_BC_LOAD_NULL):
     357                 :       1290 :                     PUSH(MP_OBJ_NULL);
     358                 :       1290 :                     DISPATCH();
     359                 :            : 
     360                 :          2 :                 ENTRY(MP_BC_LOAD_FAST_N): {
     361         [ -  + ]:          2 :                     DECODE_UINT;
     362                 :          2 :                     obj_shared = fastn[-unum];
     363                 :   64006612 :                     load_check:
     364         [ +  + ]:   64006612 :                     if (obj_shared == MP_OBJ_NULL) {
     365                 :         12 :                         local_name_error: {
     366                 :         16 :                             MARK_EXC_IP_SELECTIVE();
     367                 :         16 :                             mp_obj_t obj = mp_obj_new_exception_msg(&mp_type_NameError, MP_ERROR_TEXT("local variable referenced before assignment"));
     368                 :         16 :                             RAISE(obj);
     369                 :            :                         }
     370                 :            :                     }
     371                 :   64006600 :                     PUSH(obj_shared);
     372                 :   64006600 :                     DISPATCH();
     373                 :            :                 }
     374                 :            : 
     375                 :      48489 :                 ENTRY(MP_BC_LOAD_DEREF): {
     376         [ -  + ]:      48489 :                     DECODE_UINT;
     377                 :      48489 :                     obj_shared = mp_obj_cell_get(fastn[-unum]);
     378                 :      48489 :                     goto load_check;
     379                 :            :                 }
     380                 :            : 
     381                 :     773237 :                 ENTRY(MP_BC_LOAD_NAME): {
     382                 :     773237 :                     MARK_EXC_IP_SELECTIVE();
     383         [ -  + ]:     773237 :                     DECODE_QSTR;
     384                 :     773237 :                     PUSH(mp_load_name(qst));
     385                 :     773179 :                     DISPATCH();
     386                 :            :                 }
     387                 :            : 
     388                 :   12156386 :                 ENTRY(MP_BC_LOAD_GLOBAL): {
     389                 :   12156386 :                     MARK_EXC_IP_SELECTIVE();
     390         [ -  + ]:   12156386 :                     DECODE_QSTR;
     391                 :   12156386 :                     PUSH(mp_load_global(qst));
     392                 :   12141004 :                     DISPATCH();
     393                 :            :                 }
     394                 :            : 
     395                 :    2861715 :                 ENTRY(MP_BC_LOAD_ATTR): {
     396                 :    2861715 :                     FRAME_UPDATE();
     397                 :    2861715 :                     MARK_EXC_IP_SELECTIVE();
     398         [ -  + ]:    2861715 :                     DECODE_QSTR;
     399                 :    2861715 :                     mp_obj_t top = TOP();
     400                 :    2861715 :                     mp_obj_t obj;
     401                 :            :                     #if MICROPY_OPT_LOAD_ATTR_FAST_PATH
     402                 :            :                     // For the specific case of an instance type, it implements .attr
     403                 :            :                     // and forwards to its members map. Attribute lookups on instance
     404                 :            :                     // types are extremely common, so avoid all the other checks and
     405                 :            :                     // calls that normally happen first.
     406                 :    2861715 :                     mp_map_elem_t *elem = NULL;
     407         [ +  + ]:    2861715 :                     if (mp_obj_is_instance_type(mp_obj_get_type(top))) {
     408                 :    2626075 :                         mp_obj_instance_t *self = MP_OBJ_TO_PTR(top);
     409                 :    2626075 :                         elem = mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(qst), MP_MAP_LOOKUP);
     410                 :            :                     }
     411         [ +  + ]:    2626136 :                     if (elem) {
     412                 :    2398288 :                         obj = elem->value;
     413                 :            :                     } else
     414                 :            :                     #endif
     415                 :            :                     {
     416                 :     463394 :                         obj = mp_load_attr(top, qst);
     417                 :            :                     }
     418                 :    2861640 :                     SET_TOP(obj);
     419                 :    2861640 :                     DISPATCH();
     420                 :            :                 }
     421                 :            : 
     422                 :     683880 :                 ENTRY(MP_BC_LOAD_METHOD): {
     423                 :     683880 :                     MARK_EXC_IP_SELECTIVE();
     424         [ -  + ]:     683880 :                     DECODE_QSTR;
     425                 :     683880 :                     mp_load_method(*sp, qst, sp);
     426                 :     683935 :                     sp += 1;
     427                 :     683935 :                     DISPATCH();
     428                 :            :                 }
     429                 :            : 
     430                 :         29 :                 ENTRY(MP_BC_LOAD_SUPER_METHOD): {
     431                 :         29 :                     MARK_EXC_IP_SELECTIVE();
     432         [ -  + ]:         29 :                     DECODE_QSTR;
     433                 :         29 :                     sp -= 1;
     434                 :         29 :                     mp_load_super_method(qst, sp - 1);
     435                 :         29 :                     DISPATCH();
     436                 :            :                 }
     437                 :            : 
     438                 :        770 :                 ENTRY(MP_BC_LOAD_BUILD_CLASS):
     439                 :        770 :                     MARK_EXC_IP_SELECTIVE();
     440                 :        770 :                     PUSH(mp_load_build_class());
     441                 :        770 :                     DISPATCH();
     442                 :            : 
     443                 :   13119840 :                 ENTRY(MP_BC_LOAD_SUBSCR): {
     444                 :   13119840 :                     MARK_EXC_IP_SELECTIVE();
     445                 :   13119840 :                     mp_obj_t index = POP();
     446                 :   13119840 :                     SET_TOP(mp_obj_subscr(TOP(), index, MP_OBJ_SENTINEL));
     447                 :   13083098 :                     DISPATCH();
     448                 :            :                 }
     449                 :            : 
     450                 :        226 :                 ENTRY(MP_BC_STORE_FAST_N): {
     451         [ -  + ]:        226 :                     DECODE_UINT;
     452                 :        226 :                     fastn[-unum] = POP();
     453                 :        226 :                     DISPATCH();
     454                 :            :                 }
     455                 :            : 
     456                 :       1284 :                 ENTRY(MP_BC_STORE_DEREF): {
     457         [ -  + ]:       1284 :                     DECODE_UINT;
     458                 :       1284 :                     mp_obj_cell_set(fastn[-unum], POP());
     459                 :       1284 :                     DISPATCH();
     460                 :            :                 }
     461                 :            : 
     462                 :     312106 :                 ENTRY(MP_BC_STORE_NAME): {
     463                 :     312106 :                     MARK_EXC_IP_SELECTIVE();
     464         [ -  + ]:     312106 :                     DECODE_QSTR;
     465                 :     312106 :                     mp_store_name(qst, POP());
     466                 :     312105 :                     DISPATCH();
     467                 :            :                 }
     468                 :            : 
     469                 :      82452 :                 ENTRY(MP_BC_STORE_GLOBAL): {
     470                 :      82452 :                     MARK_EXC_IP_SELECTIVE();
     471         [ -  + ]:      82452 :                     DECODE_QSTR;
     472                 :      82452 :                     mp_store_global(qst, POP());
     473                 :      82452 :                     DISPATCH();
     474                 :            :                 }
     475                 :            : 
     476                 :     233735 :                 ENTRY(MP_BC_STORE_ATTR): {
     477                 :     233735 :                     FRAME_UPDATE();
     478                 :     233735 :                     MARK_EXC_IP_SELECTIVE();
     479         [ -  + ]:     233735 :                     DECODE_QSTR;
     480                 :     233735 :                     mp_store_attr(sp[0], qst, sp[-1]);
     481                 :     233696 :                     sp -= 2;
     482                 :     233696 :                     DISPATCH();
     483                 :            :                 }
     484                 :            : 
     485                 :    7241291 :                 ENTRY(MP_BC_STORE_SUBSCR):
     486                 :    7241291 :                     MARK_EXC_IP_SELECTIVE();
     487                 :    7241291 :                     mp_obj_subscr(sp[-1], sp[0], sp[-2]);
     488                 :    7240663 :                     sp -= 3;
     489                 :    7240663 :                     DISPATCH();
     490                 :            : 
     491                 :        398 :                 ENTRY(MP_BC_DELETE_FAST): {
     492                 :        398 :                     MARK_EXC_IP_SELECTIVE();
     493         [ -  + ]:        398 :                     DECODE_UINT;
     494         [ +  + ]:        398 :                     if (fastn[-unum] == MP_OBJ_NULL) {
     495                 :          2 :                         goto local_name_error;
     496                 :            :                     }
     497                 :        396 :                     fastn[-unum] = MP_OBJ_NULL;
     498                 :        396 :                     DISPATCH();
     499                 :            :                 }
     500                 :            : 
     501                 :          4 :                 ENTRY(MP_BC_DELETE_DEREF): {
     502                 :          4 :                     MARK_EXC_IP_SELECTIVE();
     503         [ -  + ]:          4 :                     DECODE_UINT;
     504         [ +  + ]:          4 :                     if (mp_obj_cell_get(fastn[-unum]) == MP_OBJ_NULL) {
     505                 :          2 :                         goto local_name_error;
     506                 :            :                     }
     507                 :          2 :                     mp_obj_cell_set(fastn[-unum], MP_OBJ_NULL);
     508                 :          2 :                     DISPATCH();
     509                 :            :                 }
     510                 :            : 
     511                 :        235 :                 ENTRY(MP_BC_DELETE_NAME): {
     512                 :        235 :                     MARK_EXC_IP_SELECTIVE();
     513         [ -  + ]:        235 :                     DECODE_QSTR;
     514                 :        235 :                     mp_delete_name(qst);
     515                 :        233 :                     DISPATCH();
     516                 :            :                 }
     517                 :            : 
     518                 :          4 :                 ENTRY(MP_BC_DELETE_GLOBAL): {
     519                 :          4 :                     MARK_EXC_IP_SELECTIVE();
     520         [ -  + ]:          4 :                     DECODE_QSTR;
     521                 :          4 :                     mp_delete_global(qst);
     522                 :          2 :                     DISPATCH();
     523                 :            :                 }
     524                 :            : 
     525                 :    9968241 :                 ENTRY(MP_BC_DUP_TOP): {
     526                 :    9968241 :                     mp_obj_t top = TOP();
     527                 :    9968241 :                     PUSH(top);
     528                 :    9968241 :                     DISPATCH();
     529                 :            :                 }
     530                 :            : 
     531                 :    2408120 :                 ENTRY(MP_BC_DUP_TOP_TWO):
     532                 :    2408120 :                     sp += 2;
     533                 :    2408120 :                     sp[0] = sp[-2];
     534                 :    2408120 :                     sp[-1] = sp[-3];
     535                 :    2408120 :                     DISPATCH();
     536                 :            : 
     537                 :    1294431 :                 ENTRY(MP_BC_POP_TOP):
     538                 :    1294431 :                     sp -= 1;
     539                 :    1294431 :                     DISPATCH();
     540                 :            : 
     541                 :    2080771 :                 ENTRY(MP_BC_ROT_TWO): {
     542                 :    2080771 :                     mp_obj_t top = sp[0];
     543                 :    2080771 :                     sp[0] = sp[-1];
     544                 :    2080771 :                     sp[-1] = top;
     545                 :    2080771 :                     DISPATCH();
     546                 :            :                 }
     547                 :            : 
     548                 :     407140 :                 ENTRY(MP_BC_ROT_THREE): {
     549                 :     407140 :                     mp_obj_t top = sp[0];
     550                 :     407140 :                     sp[0] = sp[-1];
     551                 :     407140 :                     sp[-1] = sp[-2];
     552                 :     407140 :                     sp[-2] = top;
     553                 :     407140 :                     DISPATCH();
     554                 :            :                 }
     555                 :            : 
     556                 :     930966 :                 ENTRY(MP_BC_JUMP): {
     557         [ +  + ]:     930966 :                     DECODE_SLABEL;
     558                 :     930966 :                     ip += slab;
     559                 :     930966 :                     DISPATCH_WITH_PEND_EXC_CHECK();
     560                 :            :                 }
     561                 :            : 
     562                 :    6869282 :                 ENTRY(MP_BC_POP_JUMP_IF_TRUE): {
     563         [ +  + ]:    6869282 :                     DECODE_SLABEL;
     564         [ +  + ]:    6869282 :                     if (mp_obj_is_true(POP())) {
     565                 :    6321315 :                         ip += slab;
     566                 :            :                     }
     567                 :    6855472 :                     DISPATCH_WITH_PEND_EXC_CHECK();
     568                 :            :                 }
     569                 :            : 
     570                 :    5745814 :                 ENTRY(MP_BC_POP_JUMP_IF_FALSE): {
     571         [ +  + ]:    5745814 :                     DECODE_SLABEL;
     572         [ +  + ]:    5745814 :                     if (!mp_obj_is_true(POP())) {
     573                 :    3085681 :                         ip += slab;
     574                 :            :                     }
     575                 :    5744424 :                     DISPATCH_WITH_PEND_EXC_CHECK();
     576                 :            :                 }
     577                 :            : 
     578                 :        293 :                 ENTRY(MP_BC_JUMP_IF_TRUE_OR_POP): {
     579         [ -  + ]:        293 :                     DECODE_ULABEL;
     580         [ +  + ]:        293 :                     if (mp_obj_is_true(TOP())) {
     581                 :        212 :                         ip += ulab;
     582                 :            :                     } else {
     583                 :         81 :                         sp--;
     584                 :            :                     }
     585                 :        293 :                     DISPATCH_WITH_PEND_EXC_CHECK();
     586                 :            :                 }
     587                 :            : 
     588                 :        630 :                 ENTRY(MP_BC_JUMP_IF_FALSE_OR_POP): {
     589         [ -  + ]:        630 :                     DECODE_ULABEL;
     590         [ +  + ]:        630 :                     if (mp_obj_is_true(TOP())) {
     591                 :        594 :                         sp--;
     592                 :            :                     } else {
     593                 :         36 :                         ip += ulab;
     594                 :            :                     }
     595                 :        630 :                     DISPATCH_WITH_PEND_EXC_CHECK();
     596                 :            :                 }
     597                 :            : 
     598                 :      39245 :                 ENTRY(MP_BC_SETUP_WITH): {
     599                 :      39245 :                     MARK_EXC_IP_SELECTIVE();
     600                 :            :                     // stack: (..., ctx_mgr)
     601                 :      39245 :                     mp_obj_t obj = TOP();
     602                 :      39245 :                     mp_load_method(obj, MP_QSTR___exit__, sp);
     603                 :      39238 :                     mp_load_method(obj, MP_QSTR___enter__, sp + 2);
     604                 :      39235 :                     mp_obj_t ret = mp_call_method_n_kw(0, 0, sp + 2);
     605                 :      39272 :                     sp += 1;
     606         [ -  + ]:      39272 :                     PUSH_EXC_BLOCK(1);
     607                 :      39272 :                     PUSH(ret);
     608                 :            :                     // stack: (..., __exit__, ctx_mgr, as_value)
     609                 :      39272 :                     DISPATCH();
     610                 :            :                 }
     611                 :            : 
     612                 :      39272 :                 ENTRY(MP_BC_WITH_CLEANUP): {
     613                 :      39272 :                     MARK_EXC_IP_SELECTIVE();
     614                 :            :                     // Arriving here, there's "exception control block" on top of stack,
     615                 :            :                     // and __exit__ method (with self) underneath it. Bytecode calls __exit__,
     616                 :            :                     // and "deletes" it off stack, shifting "exception control block"
     617                 :            :                     // to its place.
     618                 :            :                     // The bytecode emitter ensures that there is enough space on the Python
     619                 :            :                     // value stack to hold the __exit__ method plus an additional 4 entries.
     620         [ +  + ]:      39272 :                     if (TOP() == mp_const_none) {
     621                 :            :                         // stack: (..., __exit__, ctx_mgr, None)
     622                 :      39230 :                         sp[1] = mp_const_none;
     623                 :      39230 :                         sp[2] = mp_const_none;
     624                 :      39230 :                         sp -= 2;
     625                 :      39230 :                         mp_call_method_n_kw(3, 0, sp);
     626                 :      39221 :                         SET_TOP(mp_const_none);
     627         [ +  + ]:         42 :                     } else if (mp_obj_is_small_int(TOP())) {
     628                 :            :                         // Getting here there are two distinct cases:
     629                 :            :                         //  - unwind return, stack: (..., __exit__, ctx_mgr, ret_val, SMALL_INT(-1))
     630                 :            :                         //  - unwind jump, stack:   (..., __exit__, ctx_mgr, dest_ip, SMALL_INT(num_exc))
     631                 :            :                         // For both cases we do exactly the same thing.
     632                 :         33 :                         mp_obj_t data = sp[-1];
     633                 :         33 :                         mp_obj_t cause = sp[0];
     634                 :         33 :                         sp[-1] = mp_const_none;
     635                 :         33 :                         sp[0] = mp_const_none;
     636                 :         33 :                         sp[1] = mp_const_none;
     637                 :         33 :                         mp_call_method_n_kw(3, 0, sp - 3);
     638                 :         33 :                         sp[-3] = data;
     639                 :         33 :                         sp[-2] = cause;
     640                 :         33 :                         sp -= 2; // we removed (__exit__, ctx_mgr)
     641                 :            :                     } else {
     642         [ -  + ]:          9 :                         assert(mp_obj_is_exception_instance(TOP()));
     643                 :            :                         // stack: (..., __exit__, ctx_mgr, exc_instance)
     644                 :            :                         // Need to pass (exc_type, exc_instance, None) as arguments to __exit__.
     645                 :          9 :                         sp[1] = sp[0];
     646                 :          9 :                         sp[0] = MP_OBJ_FROM_PTR(mp_obj_get_type(sp[0]));
     647                 :          9 :                         sp[2] = mp_const_none;
     648                 :          9 :                         sp -= 2;
     649                 :          9 :                         mp_obj_t ret_value = mp_call_method_n_kw(3, 0, sp);
     650         [ +  + ]:          9 :                         if (mp_obj_is_true(ret_value)) {
     651                 :            :                             // We need to silence/swallow the exception.  This is done
     652                 :            :                             // by popping the exception and the __exit__ handler and
     653                 :            :                             // replacing it with None, which signals END_FINALLY to just
     654                 :            :                             // execute the finally handler normally.
     655                 :          6 :                             SET_TOP(mp_const_none);
     656                 :            :                         } else {
     657                 :            :                             // We need to re-raise the exception.  We pop __exit__ handler
     658                 :            :                             // by copying the exception instance down to the new top-of-stack.
     659                 :          3 :                             sp[0] = sp[3];
     660                 :            :                         }
     661                 :            :                     }
     662                 :      39263 :                     DISPATCH();
     663                 :            :                 }
     664                 :            : 
     665                 :        136 :                 ENTRY(MP_BC_UNWIND_JUMP): {
     666                 :        136 :                     MARK_EXC_IP_SELECTIVE();
     667         [ +  + ]:        136 :                     DECODE_SLABEL;
     668                 :        136 :                     PUSH((mp_obj_t)(mp_uint_t)(uintptr_t)(ip + slab)); // push destination ip for jump
     669                 :        136 :                     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)
     670                 :        199 : unwind_jump:;
     671                 :        199 :                     mp_uint_t unum = (mp_uint_t)POP(); // get number of exception handlers to unwind
     672                 :        199 :                     while ((unum & 0x7f) > 0) {
     673                 :        234 :                         unum -= 1;
     674         [ -  + ]:        234 :                         assert(exc_sp >= exc_stack);
     675                 :            : 
     676         [ +  + ]:        234 :                         if (MP_TAGPTR_TAG1(exc_sp->val_sp)) {
     677         [ +  + ]:        145 :                             if (exc_sp->handler >= ip) {
     678                 :            :                                 // Found a finally handler that isn't active; run it.
     679                 :            :                                 // Getting here the stack looks like:
     680                 :            :                                 //     (..., X, dest_ip)
     681                 :            :                                 // where X is pointed to by exc_sp->val_sp and in the case
     682                 :            :                                 // of a "with" block contains the context manager info.
     683         [ -  + ]:         71 :                                 assert(&sp[-1] == MP_TAGPTR_PTR(exc_sp->val_sp));
     684                 :            :                                 // We're going to run "finally" code as a coroutine
     685                 :            :                                 // (not calling it recursively). Set up a sentinel
     686                 :            :                                 // on the stack so it can return back to us when it is
     687                 :            :                                 // done (when WITH_CLEANUP or END_FINALLY reached).
     688                 :            :                                 // The sentinel is the number of exception handlers left to
     689                 :            :                                 // unwind, which is a non-negative integer.
     690                 :         71 :                                 PUSH(MP_OBJ_NEW_SMALL_INT(unum));
     691                 :         71 :                                 ip = exc_sp->handler;
     692                 :         71 :                                 goto dispatch_loop;
     693                 :            :                             } else {
     694                 :            :                                 // Found a finally handler that is already active; cancel it.
     695   [ +  +  +  +  :         74 :                                 CANCEL_ACTIVE_FINALLY(sp);
                   -  + ]
     696                 :            :                             }
     697                 :            :                         }
     698         [ +  + ]:        362 :                         POP_EXC_BLOCK();
     699                 :            :                     }
     700                 :        128 :                     ip = (const byte*)MP_OBJ_TO_PTR(POP()); // pop destination ip for jump
     701         [ +  + ]:        128 :                     if (unum != 0) {
     702                 :            :                         // pop the exhausted iterator
     703                 :          8 :                         sp -= MP_OBJ_ITER_BUF_NSLOTS;
     704                 :            :                     }
     705                 :        128 :                     DISPATCH_WITH_PEND_EXC_CHECK();
     706                 :            :                 }
     707                 :            : 
     708                 :     154278 :                 ENTRY(MP_BC_SETUP_EXCEPT):
     709                 :     155246 :                 ENTRY(MP_BC_SETUP_FINALLY): {
     710                 :     155246 :                     MARK_EXC_IP_SELECTIVE();
     711                 :            :                     #if SELECTIVE_EXC_IP
     712                 :            :                     PUSH_EXC_BLOCK((code_state->ip[-1] == MP_BC_SETUP_FINALLY) ? 1 : 0);
     713                 :            :                     #else
     714   [ +  +  +  + ]:     155246 :                     PUSH_EXC_BLOCK((code_state->ip[0] == MP_BC_SETUP_FINALLY) ? 1 : 0);
     715                 :            :                     #endif
     716                 :     155246 :                     DISPATCH();
     717                 :            :                 }
     718                 :            : 
     719                 :      40087 :                 ENTRY(MP_BC_END_FINALLY):
     720                 :      40087 :                     MARK_EXC_IP_SELECTIVE();
     721                 :            :                     // if TOS is None, just pops it and continues
     722                 :            :                     // if TOS is an integer, finishes coroutine and returns control to caller
     723                 :            :                     // if TOS is an exception, reraises the exception
     724         [ -  + ]:      40087 :                     assert(exc_sp >= exc_stack);
     725                 :      40087 :                     POP_EXC_BLOCK();
     726         [ +  + ]:      40087 :                     if (TOP() == mp_const_none) {
     727                 :      39829 :                         sp--;
     728         [ +  + ]:        258 :                     } else if (mp_obj_is_small_int(TOP())) {
     729                 :            :                         // We finished "finally" coroutine and now dispatch back
     730                 :            :                         // to our caller, based on TOS value
     731                 :        173 :                         mp_int_t cause = MP_OBJ_SMALL_INT_VALUE(POP());
     732         [ +  + ]:        173 :                         if (cause < 0) {
     733                 :            :                             // A negative cause indicates unwind return
     734                 :        110 :                             goto unwind_return;
     735                 :            :                         } else {
     736                 :            :                             // Otherwise it's an unwind jump and we must push as a raw
     737                 :            :                             // number the number of exception handlers to unwind
     738                 :         63 :                             PUSH((mp_obj_t)cause);
     739                 :         63 :                             goto unwind_jump;
     740                 :            :                         }
     741                 :            :                     } else {
     742         [ -  + ]:         85 :                         assert(mp_obj_is_exception_instance(TOP()));
     743                 :         85 :                         RAISE(TOP());
     744                 :            :                     }
     745                 :      39829 :                     DISPATCH();
     746                 :            : 
     747                 :      69514 :                 ENTRY(MP_BC_GET_ITER):
     748                 :      69514 :                     MARK_EXC_IP_SELECTIVE();
     749                 :      69514 :                     SET_TOP(mp_getiter(TOP(), NULL));
     750                 :      69513 :                     DISPATCH();
     751                 :            : 
     752                 :            :                 // An iterator for a for-loop takes MP_OBJ_ITER_BUF_NSLOTS slots on
     753                 :            :                 // the Python value stack.  These slots are either used to store the
     754                 :            :                 // iterator object itself, or the first slot is MP_OBJ_NULL and
     755                 :            :                 // the second slot holds a reference to the iterator object.
     756                 :      74094 :                 ENTRY(MP_BC_GET_ITER_STACK): {
     757                 :      74094 :                     MARK_EXC_IP_SELECTIVE();
     758                 :      74094 :                     mp_obj_t obj = TOP();
     759                 :      74094 :                     mp_obj_iter_buf_t *iter_buf = (mp_obj_iter_buf_t*)sp;
     760                 :      74094 :                     sp += MP_OBJ_ITER_BUF_NSLOTS - 1;
     761                 :      74094 :                     obj = mp_getiter(obj, iter_buf);
     762         [ +  + ]:      74090 :                     if (obj != MP_OBJ_FROM_PTR(iter_buf)) {
     763                 :            :                         // Iterator didn't use the stack so indicate that with MP_OBJ_NULL.
     764                 :      71996 :                         *(sp - MP_OBJ_ITER_BUF_NSLOTS + 1) = MP_OBJ_NULL;
     765                 :      71996 :                         *(sp - MP_OBJ_ITER_BUF_NSLOTS + 2) = obj;
     766                 :            :                     }
     767                 :      74090 :                     DISPATCH();
     768                 :            :                 }
     769                 :            : 
     770                 :     120306 :                 ENTRY(MP_BC_FOR_ITER): {
     771                 :     120306 :                     FRAME_UPDATE();
     772                 :     120306 :                     MARK_EXC_IP_SELECTIVE();
     773         [ +  + ]:     120306 :                     DECODE_ULABEL; // the jump offset if iteration finishes; for labels are always forward
     774                 :     120306 :                     code_state->sp = sp;
     775                 :     120306 :                     mp_obj_t obj;
     776         [ +  + ]:     120306 :                     if (*(sp - MP_OBJ_ITER_BUF_NSLOTS + 1) == MP_OBJ_NULL) {
     777                 :     106134 :                         obj = *(sp - MP_OBJ_ITER_BUF_NSLOTS + 2);
     778                 :            :                     } else {
     779                 :            :                         obj = MP_OBJ_FROM_PTR(&sp[-MP_OBJ_ITER_BUF_NSLOTS + 1]);
     780                 :            :                     }
     781                 :     120306 :                     mp_obj_t value = mp_iternext_allow_raise(obj);
     782         [ +  + ]:     120106 :                     if (value == MP_OBJ_STOP_ITERATION) {
     783                 :      73957 :                         sp -= MP_OBJ_ITER_BUF_NSLOTS; // pop the exhausted iterator
     784                 :      73957 :                         ip += ulab; // jump to after for-block
     785                 :            :                     } else {
     786                 :      46149 :                         PUSH(value); // push the next iteration value
     787                 :            :                         #if MICROPY_PY_SYS_SETTRACE
     788                 :            :                         // LINE event should trigger for every iteration so invalidate last trigger
     789                 :            :                         if (code_state->frame) {
     790                 :            :                             code_state->frame->lineno = 0;
     791                 :            :                         }
     792                 :            :                         #endif
     793                 :            :                     }
     794                 :     120106 :                     DISPATCH();
     795                 :            :                 }
     796                 :            : 
     797                 :     153972 :                 ENTRY(MP_BC_POP_EXCEPT_JUMP): {
     798         [ -  + ]:     153972 :                     assert(exc_sp >= exc_stack);
     799                 :     153972 :                     POP_EXC_BLOCK();
     800         [ +  + ]:     153972 :                     DECODE_ULABEL;
     801                 :     153972 :                     ip += ulab;
     802                 :     153972 :                     DISPATCH_WITH_PEND_EXC_CHECK();
     803                 :            :                 }
     804                 :            : 
     805                 :      30570 :                 ENTRY(MP_BC_BUILD_TUPLE): {
     806                 :      30570 :                     MARK_EXC_IP_SELECTIVE();
     807         [ -  + ]:      30570 :                     DECODE_UINT;
     808                 :      30570 :                     sp -= unum - 1;
     809                 :      30570 :                     SET_TOP(mp_obj_new_tuple(unum, sp));
     810                 :      30568 :                     DISPATCH();
     811                 :            :                 }
     812                 :            : 
     813                 :     372823 :                 ENTRY(MP_BC_BUILD_LIST): {
     814                 :     372823 :                     MARK_EXC_IP_SELECTIVE();
     815         [ +  + ]:     372825 :                     DECODE_UINT;
     816                 :     372823 :                     sp -= unum - 1;
     817                 :     372823 :                     SET_TOP(mp_obj_new_list(unum, sp));
     818                 :     372773 :                     DISPATCH();
     819                 :            :                 }
     820                 :            : 
     821                 :        619 :                 ENTRY(MP_BC_BUILD_MAP): {
     822                 :        619 :                     MARK_EXC_IP_SELECTIVE();
     823         [ -  + ]:        619 :                     DECODE_UINT;
     824                 :        619 :                     PUSH(mp_obj_new_dict(unum));
     825                 :        617 :                     DISPATCH();
     826                 :            :                 }
     827                 :            : 
     828                 :        905 :                 ENTRY(MP_BC_STORE_MAP):
     829                 :        905 :                     MARK_EXC_IP_SELECTIVE();
     830                 :        905 :                     sp -= 2;
     831                 :        905 :                     mp_obj_dict_store(sp[0], sp[2], sp[1]);
     832                 :        903 :                     DISPATCH();
     833                 :            : 
     834                 :            :                 #if MICROPY_PY_BUILTINS_SET
     835                 :        152 :                 ENTRY(MP_BC_BUILD_SET): {
     836                 :        152 :                     MARK_EXC_IP_SELECTIVE();
     837         [ -  + ]:        152 :                     DECODE_UINT;
     838                 :        152 :                     sp -= unum - 1;
     839                 :        152 :                     SET_TOP(mp_obj_new_set(unum, sp));
     840                 :        150 :                     DISPATCH();
     841                 :            :                 }
     842                 :            :                 #endif
     843                 :            : 
     844                 :            :                 #if MICROPY_PY_BUILTINS_SLICE
     845                 :       4509 :                 ENTRY(MP_BC_BUILD_SLICE): {
     846                 :       4509 :                     MARK_EXC_IP_SELECTIVE();
     847                 :       4509 :                     mp_obj_t step = mp_const_none;
     848         [ +  + ]:       4509 :                     if (*ip++ == 3) {
     849                 :            :                         // 3-argument slice includes step
     850                 :        107 :                         step = POP();
     851                 :            :                     }
     852                 :       4509 :                     mp_obj_t stop = POP();
     853                 :       4509 :                     mp_obj_t start = TOP();
     854                 :       4509 :                     SET_TOP(mp_obj_new_slice(start, stop, step));
     855                 :       4507 :                     DISPATCH();
     856                 :            :                 }
     857                 :            :                 #endif
     858                 :            : 
     859                 :      15931 :                 ENTRY(MP_BC_STORE_COMP): {
     860                 :      15931 :                     MARK_EXC_IP_SELECTIVE();
     861         [ -  + ]:      15931 :                     DECODE_UINT;
     862                 :      15931 :                     mp_obj_t obj = sp[-(unum >> 2)];
     863         [ +  + ]:      15931 :                     if ((unum & 3) == 0) {
     864                 :      14499 :                         mp_obj_list_append(obj, sp[0]);
     865                 :      14499 :                         sp--;
     866         [ +  + ]:       1432 :                     } else if (!MICROPY_PY_BUILTINS_SET || (unum & 3) == 1) {
     867                 :       1422 :                         mp_obj_dict_store(obj, sp[0], sp[-1]);
     868                 :       1422 :                         sp -= 2;
     869                 :            :                     #if MICROPY_PY_BUILTINS_SET
     870                 :            :                     } else {
     871                 :         10 :                         mp_obj_set_store(obj, sp[0]);
     872                 :         10 :                         sp--;
     873                 :            :                     #endif
     874                 :            :                     }
     875                 :      15931 :                     DISPATCH();
     876                 :            :                 }
     877                 :            : 
     878                 :      21300 :                 ENTRY(MP_BC_UNPACK_SEQUENCE): {
     879                 :      21300 :                     MARK_EXC_IP_SELECTIVE();
     880         [ -  + ]:      21300 :                     DECODE_UINT;
     881                 :      21300 :                     mp_unpack_sequence(sp[0], unum, sp);
     882                 :      21292 :                     sp += unum - 1;
     883                 :      21292 :                     DISPATCH();
     884                 :            :                 }
     885                 :            : 
     886                 :         90 :                 ENTRY(MP_BC_UNPACK_EX): {
     887                 :         90 :                     MARK_EXC_IP_SELECTIVE();
     888         [ +  + ]:        124 :                     DECODE_UINT;
     889                 :         90 :                     mp_unpack_ex(sp[0], unum, sp);
     890                 :         84 :                     sp += (unum & 0xff) + ((unum >> 8) & 0xff);
     891                 :         84 :                     DISPATCH();
     892                 :            :                 }
     893                 :            : 
     894                 :       4056 :                 ENTRY(MP_BC_MAKE_FUNCTION): {
     895         [ -  + ]:       4056 :                     DECODE_PTR;
     896                 :       4056 :                     PUSH(mp_make_function_from_raw_code(ptr, code_state->fun_bc->context, NULL));
     897                 :       4056 :                     DISPATCH();
     898                 :            :                 }
     899                 :            : 
     900                 :        169 :                 ENTRY(MP_BC_MAKE_FUNCTION_DEFARGS): {
     901         [ -  + ]:        169 :                     DECODE_PTR;
     902                 :            :                     // Stack layout: def_tuple def_dict <- TOS
     903                 :        169 :                     sp -= 1;
     904                 :        169 :                     SET_TOP(mp_make_function_from_raw_code(ptr, code_state->fun_bc->context, sp));
     905                 :        169 :                     DISPATCH();
     906                 :            :                 }
     907                 :            : 
     908                 :       2416 :                 ENTRY(MP_BC_MAKE_CLOSURE): {
     909         [ -  + ]:       2416 :                     DECODE_PTR;
     910                 :       2416 :                     size_t n_closed_over = *ip++;
     911                 :            :                     // Stack layout: closed_overs <- TOS
     912                 :       2416 :                     sp -= n_closed_over - 1;
     913                 :       2416 :                     SET_TOP(mp_make_closure_from_raw_code(ptr, code_state->fun_bc->context, n_closed_over, sp));
     914                 :       2416 :                     DISPATCH();
     915                 :            :                 }
     916                 :            : 
     917                 :          2 :                 ENTRY(MP_BC_MAKE_CLOSURE_DEFARGS): {
     918         [ -  + ]:          2 :                     DECODE_PTR;
     919                 :          2 :                     size_t n_closed_over = *ip++;
     920                 :            :                     // Stack layout: def_tuple def_dict closed_overs <- TOS
     921                 :          2 :                     sp -= 2 + n_closed_over - 1;
     922                 :          2 :                     SET_TOP(mp_make_closure_from_raw_code(ptr, code_state->fun_bc->context, 0x100 | n_closed_over, sp));
     923                 :          2 :                     DISPATCH();
     924                 :            :                 }
     925                 :            : 
     926                 :    8406936 :                 ENTRY(MP_BC_CALL_FUNCTION): {
     927                 :    8406936 :                     FRAME_UPDATE();
     928                 :    8406936 :                     MARK_EXC_IP_SELECTIVE();
     929         [ +  + ]:    8427414 :                     DECODE_UINT;
     930                 :            :                     // unum & 0xff == n_positional
     931                 :            :                     // (unum >> 8) & 0xff == n_keyword
     932                 :    8406936 :                     sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe);
     933                 :            :                     #if MICROPY_STACKLESS
     934                 :            :                     if (mp_obj_get_type(*sp) == &mp_type_fun_bc) {
     935                 :            :                         code_state->ip = ip;
     936                 :            :                         code_state->sp = sp;
     937                 :            :                         code_state->exc_sp_idx = MP_CODE_STATE_EXC_SP_IDX_FROM_PTR(exc_stack, exc_sp);
     938                 :            :                         mp_code_state_t *new_state = mp_obj_fun_bc_prepare_codestate(*sp, unum & 0xff, (unum >> 8) & 0xff, sp + 1);
     939                 :            :                         #if !MICROPY_ENABLE_PYSTACK
     940                 :            :                         if (new_state == NULL) {
     941                 :            :                             // Couldn't allocate codestate on heap: in the strict case raise
     942                 :            :                             // an exception, otherwise just fall through to stack allocation.
     943                 :            :                             #if MICROPY_STACKLESS_STRICT
     944                 :            :                         deep_recursion_error:
     945                 :            :                             mp_raise_recursion_depth();
     946                 :            :                             #endif
     947                 :            :                         } else
     948                 :            :                         #endif
     949                 :            :                         {
     950                 :            :                             new_state->prev = code_state;
     951                 :            :                             code_state = new_state;
     952                 :            :                             nlr_pop();
     953                 :            :                             goto run_code_state;
     954                 :            :                         }
     955                 :            :                     }
     956                 :            :                     #endif
     957                 :    8406936 :                     SET_TOP(mp_call_function_n_kw(*sp, unum & 0xff, (unum >> 8) & 0xff, sp + 1));
     958                 :    8442177 :                     DISPATCH();
     959                 :            :                 }
     960                 :            : 
     961                 :       2323 :                 ENTRY(MP_BC_CALL_FUNCTION_VAR_KW): {
     962                 :       2323 :                     FRAME_UPDATE();
     963                 :       2323 :                     MARK_EXC_IP_SELECTIVE();
     964         [ +  + ]:       2453 :                     DECODE_UINT;
     965                 :            :                     // unum & 0xff == n_positional
     966                 :            :                     // (unum >> 8) & 0xff == n_keyword
     967                 :            :                     // We have following stack layout here:
     968                 :            :                     // fun arg0 arg1 ... kw0 val0 kw1 val1 ... bitmap <- TOS
     969                 :       2323 :                     sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe) + 1;
     970                 :            :                     #if MICROPY_STACKLESS
     971                 :            :                     if (mp_obj_get_type(*sp) == &mp_type_fun_bc) {
     972                 :            :                         code_state->ip = ip;
     973                 :            :                         code_state->sp = sp;
     974                 :            :                         code_state->exc_sp_idx = MP_CODE_STATE_EXC_SP_IDX_FROM_PTR(exc_stack, exc_sp);
     975                 :            : 
     976                 :            :                         mp_call_args_t out_args;
     977                 :            :                         mp_call_prepare_args_n_kw_var(false, unum, sp, &out_args);
     978                 :            : 
     979                 :            :                         mp_code_state_t *new_state = mp_obj_fun_bc_prepare_codestate(out_args.fun,
     980                 :            :                             out_args.n_args, out_args.n_kw, out_args.args);
     981                 :            :                         #if !MICROPY_ENABLE_PYSTACK
     982                 :            :                         // Freeing args at this point does not follow a LIFO order so only do it if
     983                 :            :                         // pystack is not enabled.  For pystack, they are freed when code_state is.
     984                 :            :                         mp_nonlocal_free(out_args.args, out_args.n_alloc * sizeof(mp_obj_t));
     985                 :            :                         #endif
     986                 :            :                         #if !MICROPY_ENABLE_PYSTACK
     987                 :            :                         if (new_state == NULL) {
     988                 :            :                             // Couldn't allocate codestate on heap: in the strict case raise
     989                 :            :                             // an exception, otherwise just fall through to stack allocation.
     990                 :            :                             #if MICROPY_STACKLESS_STRICT
     991                 :            :                             goto deep_recursion_error;
     992                 :            :                             #endif
     993                 :            :                         } else
     994                 :            :                         #endif
     995                 :            :                         {
     996                 :            :                             new_state->prev = code_state;
     997                 :            :                             code_state = new_state;
     998                 :            :                             nlr_pop();
     999                 :            :                             goto run_code_state;
    1000                 :            :                         }
    1001                 :            :                     }
    1002                 :            :                     #endif
    1003                 :       2323 :                     SET_TOP(mp_call_method_n_kw_var(false, unum, sp));
    1004                 :       2299 :                     DISPATCH();
    1005                 :            :                 }
    1006                 :            : 
    1007                 :     682087 :                 ENTRY(MP_BC_CALL_METHOD): {
    1008                 :     682087 :                     FRAME_UPDATE();
    1009                 :     682087 :                     MARK_EXC_IP_SELECTIVE();
    1010         [ +  + ]:     682351 :                     DECODE_UINT;
    1011                 :            :                     // unum & 0xff == n_positional
    1012                 :            :                     // (unum >> 8) & 0xff == n_keyword
    1013                 :     682087 :                     sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe) + 1;
    1014                 :            :                     #if MICROPY_STACKLESS
    1015                 :            :                     if (mp_obj_get_type(*sp) == &mp_type_fun_bc) {
    1016                 :            :                         code_state->ip = ip;
    1017                 :            :                         code_state->sp = sp;
    1018                 :            :                         code_state->exc_sp_idx = MP_CODE_STATE_EXC_SP_IDX_FROM_PTR(exc_stack, exc_sp);
    1019                 :            : 
    1020                 :            :                         size_t n_args = unum & 0xff;
    1021                 :            :                         size_t n_kw = (unum >> 8) & 0xff;
    1022                 :            :                         int adjust = (sp[1] == MP_OBJ_NULL) ? 0 : 1;
    1023                 :            : 
    1024                 :            :                         mp_code_state_t *new_state = mp_obj_fun_bc_prepare_codestate(*sp, n_args + adjust, n_kw, sp + 2 - adjust);
    1025                 :            :                         #if !MICROPY_ENABLE_PYSTACK
    1026                 :            :                         if (new_state == NULL) {
    1027                 :            :                             // Couldn't allocate codestate on heap: in the strict case raise
    1028                 :            :                             // an exception, otherwise just fall through to stack allocation.
    1029                 :            :                             #if MICROPY_STACKLESS_STRICT
    1030                 :            :                             goto deep_recursion_error;
    1031                 :            :                             #endif
    1032                 :            :                         } else
    1033                 :            :                         #endif
    1034                 :            :                         {
    1035                 :            :                             new_state->prev = code_state;
    1036                 :            :                             code_state = new_state;
    1037                 :            :                             nlr_pop();
    1038                 :            :                             goto run_code_state;
    1039                 :            :                         }
    1040                 :            :                     }
    1041                 :            :                     #endif
    1042                 :     682087 :                     SET_TOP(mp_call_method_n_kw(unum & 0xff, (unum >> 8) & 0xff, sp));
    1043                 :     681317 :                     DISPATCH();
    1044                 :            :                 }
    1045                 :            : 
    1046                 :       1887 :                 ENTRY(MP_BC_CALL_METHOD_VAR_KW): {
    1047                 :       1887 :                     FRAME_UPDATE();
    1048                 :       1887 :                     MARK_EXC_IP_SELECTIVE();
    1049         [ +  + ]:       1910 :                     DECODE_UINT;
    1050                 :            :                     // unum & 0xff == n_positional
    1051                 :            :                     // (unum >> 8) & 0xff == n_keyword
    1052                 :            :                     // We have following stack layout here:
    1053                 :            :                     // fun self arg0 arg1 ... kw0 val0 kw1 val1 ... bitmap <- TOS
    1054                 :       1887 :                     sp -= (unum & 0xff) + ((unum >> 7) & 0x1fe) + 2;
    1055                 :            :                     #if MICROPY_STACKLESS
    1056                 :            :                     if (mp_obj_get_type(*sp) == &mp_type_fun_bc) {
    1057                 :            :                         code_state->ip = ip;
    1058                 :            :                         code_state->sp = sp;
    1059                 :            :                         code_state->exc_sp_idx = MP_CODE_STATE_EXC_SP_IDX_FROM_PTR(exc_stack, exc_sp);
    1060                 :            : 
    1061                 :            :                         mp_call_args_t out_args;
    1062                 :            :                         mp_call_prepare_args_n_kw_var(true, unum, sp, &out_args);
    1063                 :            : 
    1064                 :            :                         mp_code_state_t *new_state = mp_obj_fun_bc_prepare_codestate(out_args.fun,
    1065                 :            :                             out_args.n_args, out_args.n_kw, out_args.args);
    1066                 :            :                         #if !MICROPY_ENABLE_PYSTACK
    1067                 :            :                         // Freeing args at this point does not follow a LIFO order so only do it if
    1068                 :            :                         // pystack is not enabled.  For pystack, they are freed when code_state is.
    1069                 :            :                         mp_nonlocal_free(out_args.args, out_args.n_alloc * sizeof(mp_obj_t));
    1070                 :            :                         #endif
    1071                 :            :                         #if !MICROPY_ENABLE_PYSTACK
    1072                 :            :                         if (new_state == NULL) {
    1073                 :            :                             // Couldn't allocate codestate on heap: in the strict case raise
    1074                 :            :                             // an exception, otherwise just fall through to stack allocation.
    1075                 :            :                             #if MICROPY_STACKLESS_STRICT
    1076                 :            :                             goto deep_recursion_error;
    1077                 :            :                             #endif
    1078                 :            :                         } else
    1079                 :            :                         #endif
    1080                 :            :                         {
    1081                 :            :                             new_state->prev = code_state;
    1082                 :            :                             code_state = new_state;
    1083                 :            :                             nlr_pop();
    1084                 :            :                             goto run_code_state;
    1085                 :            :                         }
    1086                 :            :                     }
    1087                 :            :                     #endif
    1088                 :       1887 :                     SET_TOP(mp_call_method_n_kw_var(true, unum, sp));
    1089                 :       1882 :                     DISPATCH();
    1090                 :            :                 }
    1091                 :            : 
    1092                 :    8089118 :                 ENTRY(MP_BC_RETURN_VALUE):
    1093                 :            :                     MARK_EXC_IP_SELECTIVE();
    1094                 :    8089118 : unwind_return:
    1095                 :            :                     // Search for and execute finally handlers that aren't already active
    1096                 :    8089118 :                     while (exc_sp >= exc_stack) {
    1097         [ +  + ]:        296 :                         if (MP_TAGPTR_TAG1(exc_sp->val_sp)) {
    1098         [ +  + ]:        200 :                             if (exc_sp->handler >= ip) {
    1099                 :            :                                 // Found a finally handler that isn't active; run it.
    1100                 :            :                                 // Getting here the stack looks like:
    1101                 :            :                                 //     (..., X, [iter0, iter1, ...,] ret_val)
    1102                 :            :                                 // where X is pointed to by exc_sp->val_sp and in the case
    1103                 :            :                                 // of a "with" block contains the context manager info.
    1104                 :            :                                 // There may be 0 or more for-iterators between X and the
    1105                 :            :                                 // return value, and these must be removed before control can
    1106                 :            :                                 // pass to the finally code.  We simply copy the ret_value down
    1107                 :            :                                 // over these iterators, if they exist.  If they don't then the
    1108                 :            :                                 // following is a null operation.
    1109                 :        126 :                                 mp_obj_t *finally_sp = MP_TAGPTR_PTR(exc_sp->val_sp);
    1110                 :        126 :                                 finally_sp[1] = sp[0];
    1111                 :        126 :                                 sp = &finally_sp[1];
    1112                 :            :                                 // We're going to run "finally" code as a coroutine
    1113                 :            :                                 // (not calling it recursively). Set up a sentinel
    1114                 :            :                                 // on a stack so it can return back to us when it is
    1115                 :            :                                 // done (when WITH_CLEANUP or END_FINALLY reached).
    1116                 :        126 :                                 PUSH(MP_OBJ_NEW_SMALL_INT(-1));
    1117                 :        126 :                                 ip = exc_sp->handler;
    1118                 :        126 :                                 goto dispatch_loop;
    1119                 :            :                             } else {
    1120                 :            :                                 // Found a finally handler that is already active; cancel it.
    1121   [ +  +  +  +  :         74 :                                 CANCEL_ACTIVE_FINALLY(sp);
                   -  + ]
    1122                 :            :                             }
    1123                 :            :                         }
    1124         [ +  + ]:    8089118 :                         POP_EXC_BLOCK();
    1125                 :            :                     }
    1126                 :    8088822 :                     nlr_pop();
    1127                 :    8108497 :                     code_state->sp = sp;
    1128         [ -  + ]:    8108497 :                     assert(exc_sp == exc_stack - 1);
    1129                 :            :                     MICROPY_VM_HOOK_RETURN
    1130                 :            :                     #if MICROPY_STACKLESS
    1131                 :            :                     if (code_state->prev != NULL) {
    1132                 :            :                         mp_obj_t res = *sp;
    1133                 :            :                         mp_globals_set(code_state->old_globals);
    1134                 :            :                         mp_code_state_t *new_code_state = code_state->prev;
    1135                 :            :                         #if MICROPY_ENABLE_PYSTACK
    1136                 :            :                         // Free code_state, and args allocated by mp_call_prepare_args_n_kw_var
    1137                 :            :                         // (The latter is implicitly freed when using pystack due to its LIFO nature.)
    1138                 :            :                         // The sizeof in the following statement does not include the size of the variable
    1139                 :            :                         // part of the struct.  This arg is anyway not used if pystack is enabled.
    1140                 :            :                         mp_nonlocal_free(code_state, sizeof(mp_code_state_t));
    1141                 :            :                         #endif
    1142                 :            :                         code_state = new_code_state;
    1143                 :            :                         *code_state->sp = res;
    1144                 :            :                         goto run_code_state_from_return;
    1145                 :            :                     }
    1146                 :            :                     #endif
    1147                 :            :                     FRAME_LEAVE();
    1148                 :    8263805 :                     return MP_VM_RETURN_NORMAL;
    1149                 :            : 
    1150                 :         20 :                 ENTRY(MP_BC_RAISE_LAST): {
    1151                 :         20 :                     MARK_EXC_IP_SELECTIVE();
    1152                 :            :                     // search for the inner-most previous exception, to reraise it
    1153                 :         20 :                     mp_obj_t obj = MP_OBJ_NULL;
    1154         [ +  + ]:         26 :                     for (mp_exc_stack_t *e = exc_sp; e >= exc_stack; --e) {
    1155         [ +  + ]:         23 :                         if (e->prev_exc != NULL) {
    1156                 :            :                             obj = MP_OBJ_FROM_PTR(e->prev_exc);
    1157                 :            :                             break;
    1158                 :            :                         }
    1159                 :            :                     }
    1160         [ +  + ]:         20 :                     if (obj == MP_OBJ_NULL) {
    1161                 :          3 :                         obj = mp_obj_new_exception_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("no active exception to reraise"));
    1162                 :            :                     }
    1163                 :         20 :                     RAISE(obj);
    1164                 :            :                 }
    1165                 :            : 
    1166                 :      69167 :                 ENTRY(MP_BC_RAISE_OBJ): {
    1167                 :      69167 :                     MARK_EXC_IP_SELECTIVE();
    1168                 :      69167 :                     mp_obj_t obj = mp_make_raise_obj(TOP());
    1169                 :      69167 :                     RAISE(obj);
    1170                 :            :                 }
    1171                 :            : 
    1172                 :          2 :                 ENTRY(MP_BC_RAISE_FROM): {
    1173                 :          2 :                     MARK_EXC_IP_SELECTIVE();
    1174                 :          2 :                     mp_warning(NULL, "exception chaining not supported");
    1175                 :          2 :                     sp--; // ignore (pop) "from" argument
    1176                 :          2 :                     mp_obj_t obj = mp_make_raise_obj(TOP());
    1177                 :          2 :                     RAISE(obj);
    1178                 :            :                 }
    1179                 :            : 
    1180                 :      85248 :                 ENTRY(MP_BC_YIELD_VALUE):
    1181                 :      85248 : yield:
    1182                 :      85248 :                     nlr_pop();
    1183                 :      85250 :                     code_state->ip = ip;
    1184                 :      85250 :                     code_state->sp = sp;
    1185                 :      85250 :                     code_state->exc_sp_idx = MP_CODE_STATE_EXC_SP_IDX_FROM_PTR(exc_stack, exc_sp);
    1186                 :      85250 :                     FRAME_LEAVE();
    1187                 :      85250 :                     return MP_VM_RETURN_YIELD;
    1188                 :            : 
    1189                 :     138405 :                 ENTRY(MP_BC_YIELD_FROM): {
    1190                 :     138405 :                     MARK_EXC_IP_SELECTIVE();
    1191                 :     138405 :                     mp_vm_return_kind_t ret_kind;
    1192                 :     138405 :                     mp_obj_t send_value = POP();
    1193                 :     138405 :                     mp_obj_t t_exc = MP_OBJ_NULL;
    1194                 :     138405 :                     mp_obj_t ret_value;
    1195                 :     138405 :                     code_state->sp = sp; // Save sp because it's needed if mp_resume raises StopIteration
    1196         [ +  + ]:     138405 :                     if (inject_exc != MP_OBJ_NULL) {
    1197                 :        105 :                         t_exc = inject_exc;
    1198                 :        105 :                         inject_exc = MP_OBJ_NULL;
    1199                 :        105 :                         ret_kind = mp_resume(TOP(), MP_OBJ_NULL, t_exc, &ret_value);
    1200                 :            :                     } else {
    1201                 :     138300 :                         ret_kind = mp_resume(TOP(), send_value, MP_OBJ_NULL, &ret_value);
    1202                 :            :                     }
    1203                 :            : 
    1204         [ +  + ]:      69639 :                     if (ret_kind == MP_VM_RETURN_YIELD) {
    1205                 :      69085 :                         ip--;
    1206                 :      69085 :                         PUSH(ret_value);
    1207                 :      69085 :                         goto yield;
    1208         [ +  + ]:        554 :                     } else if (ret_kind == MP_VM_RETURN_NORMAL) {
    1209                 :            :                         // The generator has finished, and returned a value via StopIteration
    1210                 :            :                         // Replace exhausted generator with the returned value
    1211                 :        247 :                         SET_TOP(ret_value);
    1212                 :            :                         // If we injected GeneratorExit downstream, then even
    1213                 :            :                         // if it was swallowed, we re-raise GeneratorExit
    1214   [ +  +  +  + ]:        247 :                         if (t_exc != MP_OBJ_NULL && mp_obj_exception_match(t_exc, MP_OBJ_FROM_PTR(&mp_type_GeneratorExit))) {
    1215                 :          8 :                             mp_obj_t raise_t = mp_make_raise_obj(t_exc);
    1216                 :        315 :                             RAISE(raise_t);
    1217                 :            :                         }
    1218                 :        239 :                         DISPATCH();
    1219                 :            :                     } else {
    1220         [ -  + ]:        307 :                         assert(ret_kind == MP_VM_RETURN_EXCEPTION);
    1221         [ -  + ]:        307 :                         assert(!mp_obj_exception_match(ret_value, MP_OBJ_FROM_PTR(&mp_type_StopIteration)));
    1222                 :            :                         // Pop exhausted gen
    1223                 :        307 :                         sp--;
    1224                 :      69392 :                         RAISE(ret_value);
    1225                 :            :                     }
    1226                 :            :                 }
    1227                 :            : 
    1228                 :        864 :                 ENTRY(MP_BC_IMPORT_NAME): {
    1229                 :        864 :                     FRAME_UPDATE();
    1230                 :        864 :                     MARK_EXC_IP_SELECTIVE();
    1231         [ -  + ]:        864 :                     DECODE_QSTR;
    1232                 :        864 :                     mp_obj_t obj = POP();
    1233                 :        864 :                     SET_TOP(mp_import_name(qst, obj, TOP()));
    1234                 :        853 :                     DISPATCH();
    1235                 :            :                 }
    1236                 :            : 
    1237                 :        282 :                 ENTRY(MP_BC_IMPORT_FROM): {
    1238                 :        282 :                     FRAME_UPDATE();
    1239                 :        282 :                     MARK_EXC_IP_SELECTIVE();
    1240         [ -  + ]:        282 :                     DECODE_QSTR;
    1241                 :        282 :                     mp_obj_t obj = mp_import_from(TOP(), qst);
    1242                 :        279 :                     PUSH(obj);
    1243                 :        279 :                     DISPATCH();
    1244                 :            :                 }
    1245                 :            : 
    1246                 :         42 :                 ENTRY(MP_BC_IMPORT_STAR):
    1247                 :         42 :                     MARK_EXC_IP_SELECTIVE();
    1248                 :         42 :                     mp_import_all(POP());
    1249                 :         42 :                     DISPATCH();
    1250                 :            : 
    1251                 :            :                 #if MICROPY_OPT_COMPUTED_GOTO
    1252                 :   31440342 :                 ENTRY(MP_BC_LOAD_CONST_SMALL_INT_MULTI):
    1253                 :   31440342 :                     PUSH(MP_OBJ_NEW_SMALL_INT((mp_int_t)ip[-1] - MP_BC_LOAD_CONST_SMALL_INT_MULTI - MP_BC_LOAD_CONST_SMALL_INT_MULTI_EXCESS));
    1254                 :   31440342 :                     DISPATCH();
    1255                 :            : 
    1256                 :   63958121 :                 ENTRY(MP_BC_LOAD_FAST_MULTI):
    1257                 :   63958121 :                     obj_shared = fastn[MP_BC_LOAD_FAST_MULTI - (mp_int_t)ip[-1]];
    1258                 :   63958121 :                     goto load_check;
    1259                 :            : 
    1260                 :   10952734 :                 ENTRY(MP_BC_STORE_FAST_MULTI):
    1261                 :   10952734 :                     fastn[MP_BC_STORE_FAST_MULTI - (mp_int_t)ip[-1]] = POP();
    1262                 :   10952734 :                     DISPATCH();
    1263                 :            : 
    1264                 :     140522 :                 ENTRY(MP_BC_UNARY_OP_MULTI):
    1265                 :     140522 :                     MARK_EXC_IP_SELECTIVE();
    1266                 :     140522 :                     SET_TOP(mp_unary_op(ip[-1] - MP_BC_UNARY_OP_MULTI, TOP()));
    1267                 :     140501 :                     DISPATCH();
    1268                 :            : 
    1269                 :   52936758 :                 ENTRY(MP_BC_BINARY_OP_MULTI): {
    1270                 :   52936758 :                     MARK_EXC_IP_SELECTIVE();
    1271                 :   52936758 :                     mp_obj_t rhs = POP();
    1272                 :   52936758 :                     mp_obj_t lhs = TOP();
    1273                 :   52936758 :                     SET_TOP(mp_binary_op(ip[-1] - MP_BC_BINARY_OP_MULTI, lhs, rhs));
    1274                 :   52813617 :                     DISPATCH();
    1275                 :            :                 }
    1276                 :            : 
    1277                 :          2 :                 ENTRY_DEFAULT:
    1278                 :          2 :                     MARK_EXC_IP_SELECTIVE();
    1279                 :            :                 #else
    1280                 :            :                 ENTRY_DEFAULT:
    1281                 :            :                     if (ip[-1] < MP_BC_LOAD_CONST_SMALL_INT_MULTI + MP_BC_LOAD_CONST_SMALL_INT_MULTI_NUM) {
    1282                 :            :                         PUSH(MP_OBJ_NEW_SMALL_INT((mp_int_t)ip[-1] - MP_BC_LOAD_CONST_SMALL_INT_MULTI - MP_BC_LOAD_CONST_SMALL_INT_MULTI_EXCESS));
    1283                 :            :                         DISPATCH();
    1284                 :            :                     } else if (ip[-1] < MP_BC_LOAD_FAST_MULTI + MP_BC_LOAD_FAST_MULTI_NUM) {
    1285                 :            :                         obj_shared = fastn[MP_BC_LOAD_FAST_MULTI - (mp_int_t)ip[-1]];
    1286                 :            :                         goto load_check;
    1287                 :            :                     } else if (ip[-1] < MP_BC_STORE_FAST_MULTI + MP_BC_STORE_FAST_MULTI_NUM) {
    1288                 :            :                         fastn[MP_BC_STORE_FAST_MULTI - (mp_int_t)ip[-1]] = POP();
    1289                 :            :                         DISPATCH();
    1290                 :            :                     } else if (ip[-1] < MP_BC_UNARY_OP_MULTI + MP_BC_UNARY_OP_MULTI_NUM) {
    1291                 :            :                         SET_TOP(mp_unary_op(ip[-1] - MP_BC_UNARY_OP_MULTI, TOP()));
    1292                 :            :                         DISPATCH();
    1293                 :            :                     } else if (ip[-1] < MP_BC_BINARY_OP_MULTI + MP_BC_BINARY_OP_MULTI_NUM) {
    1294                 :            :                         mp_obj_t rhs = POP();
    1295                 :            :                         mp_obj_t lhs = TOP();
    1296                 :            :                         SET_TOP(mp_binary_op(ip[-1] - MP_BC_BINARY_OP_MULTI, lhs, rhs));
    1297                 :            :                         DISPATCH();
    1298                 :            :                     } else
    1299                 :            :                 #endif // MICROPY_OPT_COMPUTED_GOTO
    1300                 :            :                 {
    1301                 :          2 :                     mp_obj_t obj = mp_obj_new_exception_msg(&mp_type_NotImplementedError, MP_ERROR_TEXT("opcode"));
    1302                 :          2 :                     nlr_pop();
    1303                 :          2 :                     code_state->state[0] = obj;
    1304                 :          2 :                     FRAME_LEAVE();
    1305                 :          2 :                     return MP_VM_RETURN_EXCEPTION;
    1306                 :            :                 }
    1307                 :            : 
    1308                 :            :                 #if !MICROPY_OPT_COMPUTED_GOTO
    1309                 :            :                 } // switch
    1310                 :            :                 #endif
    1311                 :            : 
    1312                 :   13685885 : pending_exception_check:
    1313                 :            :                 // We've just done a branch, use this as a convenient point to
    1314                 :            :                 // run periodic code/checks and/or bounce the GIL.. i.e.
    1315                 :            :                 // not _every_ instruction but on average a branch should
    1316                 :            :                 // occur every few instructions.
    1317                 :            :                 MICROPY_VM_HOOK_LOOP
    1318                 :            : 
    1319                 :            :                 // Check for pending exceptions or scheduled tasks to run.
    1320                 :            :                 // Note: it's safe to just call mp_handle_pending(true), but
    1321                 :            :                 // we can inline the check for the common case where there is
    1322                 :            :                 // neither.
    1323                 :   13685885 :                 if (
    1324                 :            :                 #if MICROPY_ENABLE_SCHEDULER
    1325                 :            :                 #if MICROPY_PY_THREAD
    1326                 :            :                     // Scheduler + threading: Scheduler and pending exceptions are independent, check both.
    1327   [ +  +  +  # ]:   13685885 :                     MP_STATE_VM(sched_state) == MP_SCHED_PENDING || MP_STATE_THREAD(mp_pending_exception) != MP_OBJ_NULL
    1328                 :            :                 #else
    1329                 :            :                     // Scheduler + non-threading: Optimisation: pending exception sets sched_state, only check sched_state.
    1330                 :            :                     MP_STATE_VM(sched_state) == MP_SCHED_PENDING
    1331                 :            :                 #endif
    1332                 :            :                 #else
    1333                 :            :                     // No scheduler: Just check pending exception.
    1334                 :            :                     MP_STATE_THREAD(mp_pending_exception) != MP_OBJ_NULL
    1335                 :            :                 #endif
    1336                 :            :                 ) {
    1337                 :      56485 :                     MARK_EXC_IP_SELECTIVE();
    1338                 :      56485 :                     mp_handle_pending(true);
    1339                 :            :                 }
    1340                 :            : 
    1341                 :            :                 #if MICROPY_PY_THREAD_GIL
    1342                 :            :                 #if MICROPY_PY_THREAD_GIL_VM_DIVISOR
    1343                 :            :                 // Don't bounce the GIL too frequently (default every 32 branches).
    1344                 :            :                 if (--gil_divisor == 0)
    1345                 :            :                 #endif
    1346                 :            :                 {
    1347                 :            :                     #if MICROPY_PY_THREAD_GIL_VM_DIVISOR
    1348                 :            :                     gil_divisor = MICROPY_PY_THREAD_GIL_VM_DIVISOR;
    1349                 :            :                     #endif
    1350                 :            :                     #if MICROPY_ENABLE_SCHEDULER
    1351                 :            :                     // can only switch threads if the scheduler is unlocked
    1352                 :            :                     if (MP_STATE_VM(sched_state) == MP_SCHED_IDLE)
    1353                 :            :                     #endif
    1354                 :            :                     {
    1355                 :            :                     MP_THREAD_GIL_EXIT();
    1356                 :            :                     MP_THREAD_GIL_ENTER();
    1357                 :            :                     }
    1358                 :            :                 }
    1359                 :            :                 #endif
    1360                 :            : 
    1361                 :            :             } // for loop
    1362                 :            : 
    1363                 :            :         } else {
    1364                 :      72060 : exception_handler:
    1365                 :            :             // exception occurred
    1366                 :            : 
    1367                 :            :             #if MICROPY_PY_SYS_EXC_INFO
    1368                 :     141750 :             MP_STATE_VM(cur_exception) = nlr.ret_val;
    1369                 :            :             #endif
    1370                 :            : 
    1371                 :            :             #if SELECTIVE_EXC_IP
    1372                 :            :             // with selective ip, we store the ip 1 byte past the opcode, so move ptr back
    1373                 :            :             code_state->ip -= 1;
    1374                 :            :             #endif
    1375                 :            : 
    1376         [ +  + ]:     141750 :             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))) {
    1377                 :            :                 // check if it's a StopIteration within a for block
    1378         [ +  + ]:     137787 :                 if (*code_state->ip == MP_BC_FOR_ITER) {
    1379                 :          6 :                     const byte *ip = code_state->ip + 1;
    1380         [ -  + ]:          6 :                     DECODE_ULABEL; // the jump offset if iteration finishes; for labels are always forward
    1381                 :          6 :                     code_state->ip = ip + ulab; // jump to after for-block
    1382                 :          6 :                     code_state->sp -= MP_OBJ_ITER_BUF_NSLOTS; // pop the exhausted iterator
    1383                 :          6 :                     goto outer_dispatch_loop; // continue with dispatch loop
    1384         [ +  + ]:     137781 :                 } else if (*code_state->ip == MP_BC_YIELD_FROM) {
    1385                 :            :                     // StopIteration inside yield from call means return a value of
    1386                 :            :                     // yield from, so inject exception's value as yield from's result
    1387                 :            :                     // (Instead of stack pop then push we just replace exhausted gen with value)
    1388                 :      68740 :                     *code_state->sp = mp_obj_exception_get_value(MP_OBJ_FROM_PTR(nlr.ret_val));
    1389                 :      68740 :                     code_state->ip++; // yield from is over, move to next instruction
    1390                 :      68740 :                     goto outer_dispatch_loop; // continue with dispatch loop
    1391                 :            :                 }
    1392                 :            :             }
    1393                 :            : 
    1394                 :            :             #if MICROPY_PY_SYS_SETTRACE
    1395                 :            :             // Exceptions are traced here
    1396                 :            :             if (mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(((mp_obj_base_t*)nlr.ret_val)->type), MP_OBJ_FROM_PTR(&mp_type_Exception))) {
    1397                 :            :                 TRACE_TICK(code_state->ip, code_state->sp, true /* yes, it's an exception */);
    1398                 :            :             }
    1399                 :            :             #endif
    1400                 :            : 
    1401                 :            : #if MICROPY_STACKLESS
    1402                 :            : unwind_loop:
    1403                 :            : #endif
    1404                 :            :             // Set traceback info (file and line number) where the exception occurred, but not for:
    1405                 :            :             // - constant GeneratorExit object, because it's const
    1406                 :            :             // - exceptions re-raised by END_FINALLY
    1407                 :            :             // - exceptions re-raised explicitly by "raise"
    1408         [ +  + ]:      73004 :             if (nlr.ret_val != &mp_const_GeneratorExit_obj
    1409         [ +  + ]:      72976 :                 && *code_state->ip != MP_BC_END_FINALLY
    1410         [ +  + ]:      72891 :                 && *code_state->ip != MP_BC_RAISE_LAST) {
    1411                 :      72873 :                 const byte *ip = code_state->fun_bc->bytecode;
    1412         [ +  + ]:      74854 :                 MP_BC_PRELUDE_SIG_DECODE(ip);
    1413         [ +  + ]:      73084 :                 MP_BC_PRELUDE_SIZE_DECODE(ip);
    1414                 :      72873 :                 const byte *line_info_top = ip + n_info;
    1415                 :      72873 :                 const byte *bytecode_start = ip + n_info + n_cell;
    1416                 :      72873 :                 size_t bc = code_state->ip - bytecode_start;
    1417                 :      72873 :                 qstr block_name = mp_decode_uint_value(ip);
    1418         [ +  + ]:     215923 :                 for (size_t i = 0; i < 1 + n_pos_args + n_kwonly_args; ++i) {
    1419                 :     143050 :                     ip = mp_decode_uint_skip(ip);
    1420                 :            :                 }
    1421                 :            :                 #if MICROPY_EMIT_BYTECODE_USES_QSTR_TABLE
    1422                 :      72873 :                 block_name = code_state->fun_bc->context->constants.qstr_table[block_name];
    1423                 :      72873 :                 qstr source_file = code_state->fun_bc->context->constants.qstr_table[0];
    1424                 :            :                 #else
    1425                 :            :                 qstr source_file = code_state->fun_bc->context->constants.source_file;
    1426                 :            :                 #endif
    1427                 :      72873 :                 size_t source_line = mp_bytecode_get_source_line(ip, line_info_top, bc);
    1428                 :      72873 :                 mp_obj_exception_add_traceback(MP_OBJ_FROM_PTR(nlr.ret_val), source_file, source_line, block_name);
    1429                 :            :             }
    1430                 :            : 
    1431         [ +  + ]:       3032 :             while (exc_sp >= exc_stack && exc_sp->handler <= code_state->ip) {
    1432                 :            : 
    1433                 :            :                 // nested exception
    1434                 :            : 
    1435         [ -  + ]:         84 :                 assert(exc_sp >= exc_stack);
    1436                 :            : 
    1437                 :            :                 // TODO make a proper message for nested exception
    1438                 :            :                 // at the moment we are just raising the very last exception (the one that caused the nested exception)
    1439                 :            : 
    1440                 :            :                 // move up to previous exception handler
    1441         [ +  + ]:      73088 :                 POP_EXC_BLOCK();
    1442                 :            :             }
    1443                 :            : 
    1444         [ +  + ]:      73004 :             if (exc_sp >= exc_stack) {
    1445                 :            :                 // catch exception and pass to byte code
    1446                 :       2948 :                 code_state->ip = exc_sp->handler;
    1447                 :       2948 :                 mp_obj_t *sp = MP_TAGPTR_PTR(exc_sp->val_sp);
    1448                 :            :                 // save this exception in the stack so it can be used in a reraise, if needed
    1449                 :       2948 :                 exc_sp->prev_exc = nlr.ret_val;
    1450                 :            :                 // push exception object so it can be handled by bytecode
    1451                 :       2948 :                 PUSH(MP_OBJ_FROM_PTR(nlr.ret_val));
    1452                 :       2948 :                 code_state->sp = sp;
    1453                 :            : 
    1454                 :            :             #if MICROPY_STACKLESS
    1455                 :            :             } else if (code_state->prev != NULL) {
    1456                 :            :                 mp_globals_set(code_state->old_globals);
    1457                 :            :                 mp_code_state_t *new_code_state = code_state->prev;
    1458                 :            :                 #if MICROPY_ENABLE_PYSTACK
    1459                 :            :                 // Free code_state, and args allocated by mp_call_prepare_args_n_kw_var
    1460                 :            :                 // (The latter is implicitly freed when using pystack due to its LIFO nature.)
    1461                 :            :                 // The sizeof in the following statement does not include the size of the variable
    1462                 :            :                 // part of the struct.  This arg is anyway not used if pystack is enabled.
    1463                 :            :                 mp_nonlocal_free(code_state, sizeof(mp_code_state_t));
    1464                 :            :                 #endif
    1465                 :            :                 code_state = new_code_state;
    1466                 :            :                 size_t n_state = code_state->n_state;
    1467                 :            :                 fastn = &code_state->state[n_state - 1];
    1468                 :            :                 exc_stack = (mp_exc_stack_t*)(code_state->state + n_state);
    1469                 :            :                 // variables that are visible to the exception handler (declared volatile)
    1470                 :            :                 exc_sp = MP_CODE_STATE_EXC_SP_IDX_TO_PTR(exc_stack, code_state->exc_sp_idx); // stack grows up, exc_sp points to top of stack
    1471                 :            :                 goto unwind_loop;
    1472                 :            : 
    1473                 :            :             #endif
    1474                 :            :             } else {
    1475                 :            :                 // propagate exception to higher level
    1476                 :            :                 // Note: ip and sp don't have usable values at this point
    1477                 :      70056 :                 code_state->state[0] = MP_OBJ_FROM_PTR(nlr.ret_val); // put exception here because sp is invalid
    1478                 :      70056 :                 FRAME_LEAVE();
    1479                 :      70056 :                 return MP_VM_RETURN_EXCEPTION;
    1480                 :            :             }
    1481                 :            :         }
    1482                 :            :     }
    1483                 :            : }

Generated by: LCOV version 1.15-5-g462f71d