LCOV - code coverage report
Current view: top level - py - emit.h (source / functions) Hit Total Coverage
Test: unix_coverage_v1.19.1-724-gfb7d21153.info Lines: 7 7 100.0 %
Date: 2022-12-01 09:37:31 Functions: 0 0 -
Branches: 2 2 100.0 %

           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, 2014 Damien P. George
       7                 :            :  *
       8                 :            :  * Permission is hereby granted, free of charge, to any person obtaining a copy
       9                 :            :  * of this software and associated documentation files (the "Software"), to deal
      10                 :            :  * in the Software without restriction, including without limitation the rights
      11                 :            :  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
      12                 :            :  * copies of the Software, and to permit persons to whom the Software is
      13                 :            :  * furnished to do so, subject to the following conditions:
      14                 :            :  *
      15                 :            :  * The above copyright notice and this permission notice shall be included in
      16                 :            :  * all copies or substantial portions of the Software.
      17                 :            :  *
      18                 :            :  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
      19                 :            :  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      20                 :            :  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
      21                 :            :  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
      22                 :            :  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
      23                 :            :  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
      24                 :            :  * THE SOFTWARE.
      25                 :            :  */
      26                 :            : #ifndef MICROPY_INCLUDED_PY_EMIT_H
      27                 :            : #define MICROPY_INCLUDED_PY_EMIT_H
      28                 :            : 
      29                 :            : #include "py/lexer.h"
      30                 :            : #include "py/scope.h"
      31                 :            : 
      32                 :            : /* Notes on passes:
      33                 :            :  * We don't know exactly the opcodes in pass 1 because they depend on the
      34                 :            :  * closing over of variables (LOAD_CLOSURE, BUILD_TUPLE, MAKE_CLOSURE), which
      35                 :            :  * depends on determining the scope of variables in each function, and this
      36                 :            :  * is not known until the end of pass 1.
      37                 :            :  * As a consequence, we don't know the maximum stack size until the end of pass 2.
      38                 :            :  * This is problematic for some emitters (x64) since they need to know the maximum
      39                 :            :  * stack size to compile the entry to the function, and this affects code size.
      40                 :            :  */
      41                 :            : 
      42                 :            : typedef enum {
      43                 :            :     MP_PASS_SCOPE = 1,      // work out id's and their kind, and number of labels
      44                 :            :     MP_PASS_STACK_SIZE = 2, // work out maximum stack size
      45                 :            :     MP_PASS_CODE_SIZE = 3,  // work out code size and label offsets
      46                 :            :     MP_PASS_EMIT = 4,       // emit code (may be run multiple times if the emitter requests it)
      47                 :            : } pass_kind_t;
      48                 :            : 
      49                 :            : #define MP_EMIT_STAR_FLAG_SINGLE (0x01)
      50                 :            : #define MP_EMIT_STAR_FLAG_DOUBLE (0x02)
      51                 :            : 
      52                 :            : #define MP_EMIT_BREAK_FROM_FOR (0x8000)
      53                 :            : 
      54                 :            : // Kind for emit_id_ops->local()
      55                 :            : #define MP_EMIT_IDOP_LOCAL_FAST (0)
      56                 :            : #define MP_EMIT_IDOP_LOCAL_DEREF (1)
      57                 :            : 
      58                 :            : // Kind for emit_id_ops->global()
      59                 :            : #define MP_EMIT_IDOP_GLOBAL_NAME (0)
      60                 :            : #define MP_EMIT_IDOP_GLOBAL_GLOBAL (1)
      61                 :            : 
      62                 :            : // Kind for emit->import()
      63                 :            : #define MP_EMIT_IMPORT_NAME (0)
      64                 :            : #define MP_EMIT_IMPORT_FROM (1)
      65                 :            : #define MP_EMIT_IMPORT_STAR (2)
      66                 :            : 
      67                 :            : // Kind for emit->subscr()
      68                 :            : #define MP_EMIT_SUBSCR_LOAD (0)
      69                 :            : #define MP_EMIT_SUBSCR_STORE (1)
      70                 :            : #define MP_EMIT_SUBSCR_DELETE (2)
      71                 :            : 
      72                 :            : // Kind for emit->attr()
      73                 :            : #define MP_EMIT_ATTR_LOAD (0)
      74                 :            : #define MP_EMIT_ATTR_STORE (1)
      75                 :            : #define MP_EMIT_ATTR_DELETE (2)
      76                 :            : 
      77                 :            : // Kind for emit->setup_block()
      78                 :            : #define MP_EMIT_SETUP_BLOCK_WITH (0)
      79                 :            : #define MP_EMIT_SETUP_BLOCK_EXCEPT (1)
      80                 :            : #define MP_EMIT_SETUP_BLOCK_FINALLY (2)
      81                 :            : 
      82                 :            : // Kind for emit->build()
      83                 :            : #define MP_EMIT_BUILD_TUPLE (0)
      84                 :            : #define MP_EMIT_BUILD_LIST (1)
      85                 :            : #define MP_EMIT_BUILD_MAP (2)
      86                 :            : #define MP_EMIT_BUILD_SET (3)
      87                 :            : #define MP_EMIT_BUILD_SLICE (4)
      88                 :            : 
      89                 :            : // Kind for emit->yield()
      90                 :            : #define MP_EMIT_YIELD_VALUE (0)
      91                 :            : #define MP_EMIT_YIELD_FROM (1)
      92                 :            : 
      93                 :            : typedef struct _emit_t emit_t;
      94                 :            : 
      95                 :            : typedef struct _mp_emit_common_t {
      96                 :            :     pass_kind_t pass;
      97                 :            :     uint16_t ct_cur_child;
      98                 :            :     mp_raw_code_t **children;
      99                 :            :     #if MICROPY_EMIT_BYTECODE_USES_QSTR_TABLE
     100                 :            :     mp_map_t qstr_map;
     101                 :            :     #endif
     102                 :            :     mp_obj_list_t const_obj_list;
     103                 :            : } mp_emit_common_t;
     104                 :            : 
     105                 :            : typedef struct _mp_emit_method_table_id_ops_t {
     106                 :            :     void (*local)(emit_t *emit, qstr qst, mp_uint_t local_num, int kind);
     107                 :            :     void (*global)(emit_t *emit, qstr qst, int kind);
     108                 :            : } mp_emit_method_table_id_ops_t;
     109                 :            : 
     110                 :            : typedef struct _emit_method_table_t {
     111                 :            :     #if MICROPY_DYNAMIC_COMPILER
     112                 :            :     emit_t *(*emit_new)(mp_emit_common_t * emit_common, mp_obj_t *error_slot, uint *label_slot, mp_uint_t max_num_labels);
     113                 :            :     void (*emit_free)(emit_t *emit);
     114                 :            :     #endif
     115                 :            : 
     116                 :            :     void (*start_pass)(emit_t *emit, pass_kind_t pass, scope_t *scope);
     117                 :            :     bool (*end_pass)(emit_t *emit);
     118                 :            :     void (*adjust_stack_size)(emit_t *emit, mp_int_t delta);
     119                 :            :     void (*set_source_line)(emit_t *emit, mp_uint_t line);
     120                 :            : 
     121                 :            :     mp_emit_method_table_id_ops_t load_id;
     122                 :            :     mp_emit_method_table_id_ops_t store_id;
     123                 :            :     mp_emit_method_table_id_ops_t delete_id;
     124                 :            : 
     125                 :            :     void (*label_assign)(emit_t *emit, mp_uint_t l);
     126                 :            :     void (*import)(emit_t *emit, qstr qst, int kind);
     127                 :            :     void (*load_const_tok)(emit_t *emit, mp_token_kind_t tok);
     128                 :            :     void (*load_const_small_int)(emit_t *emit, mp_int_t arg);
     129                 :            :     void (*load_const_str)(emit_t *emit, qstr qst);
     130                 :            :     void (*load_const_obj)(emit_t *emit, mp_obj_t obj);
     131                 :            :     void (*load_null)(emit_t *emit);
     132                 :            :     void (*load_method)(emit_t *emit, qstr qst, bool is_super);
     133                 :            :     void (*load_build_class)(emit_t *emit);
     134                 :            :     void (*subscr)(emit_t *emit, int kind);
     135                 :            :     void (*attr)(emit_t *emit, qstr qst, int kind);
     136                 :            :     void (*dup_top)(emit_t *emit);
     137                 :            :     void (*dup_top_two)(emit_t *emit);
     138                 :            :     void (*pop_top)(emit_t *emit);
     139                 :            :     void (*rot_two)(emit_t *emit);
     140                 :            :     void (*rot_three)(emit_t *emit);
     141                 :            :     void (*jump)(emit_t *emit, mp_uint_t label);
     142                 :            :     void (*pop_jump_if)(emit_t *emit, bool cond, mp_uint_t label);
     143                 :            :     void (*jump_if_or_pop)(emit_t *emit, bool cond, mp_uint_t label);
     144                 :            :     void (*unwind_jump)(emit_t *emit, mp_uint_t label, mp_uint_t except_depth);
     145                 :            :     void (*setup_block)(emit_t *emit, mp_uint_t label, int kind);
     146                 :            :     void (*with_cleanup)(emit_t *emit, mp_uint_t label);
     147                 :            :     void (*end_finally)(emit_t *emit);
     148                 :            :     void (*get_iter)(emit_t *emit, bool use_stack);
     149                 :            :     void (*for_iter)(emit_t *emit, mp_uint_t label);
     150                 :            :     void (*for_iter_end)(emit_t *emit);
     151                 :            :     void (*pop_except_jump)(emit_t *emit, mp_uint_t label, bool within_exc_handler);
     152                 :            :     void (*unary_op)(emit_t *emit, mp_unary_op_t op);
     153                 :            :     void (*binary_op)(emit_t *emit, mp_binary_op_t op);
     154                 :            :     void (*build)(emit_t *emit, mp_uint_t n_args, int kind);
     155                 :            :     void (*store_map)(emit_t *emit);
     156                 :            :     void (*store_comp)(emit_t *emit, scope_kind_t kind, mp_uint_t set_stack_index);
     157                 :            :     void (*unpack_sequence)(emit_t *emit, mp_uint_t n_args);
     158                 :            :     void (*unpack_ex)(emit_t *emit, mp_uint_t n_left, mp_uint_t n_right);
     159                 :            :     void (*make_function)(emit_t *emit, scope_t *scope, mp_uint_t n_pos_defaults, mp_uint_t n_kw_defaults);
     160                 :            :     void (*make_closure)(emit_t *emit, scope_t *scope, mp_uint_t n_closed_over, mp_uint_t n_pos_defaults, mp_uint_t n_kw_defaults);
     161                 :            :     void (*call_function)(emit_t *emit, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags);
     162                 :            :     void (*call_method)(emit_t *emit, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags);
     163                 :            :     void (*return_value)(emit_t *emit);
     164                 :            :     void (*raise_varargs)(emit_t *emit, mp_uint_t n_args);
     165                 :            :     void (*yield)(emit_t *emit, int kind);
     166                 :            : 
     167                 :            :     // these methods are used to control entry to/exit from an exception handler
     168                 :            :     // they may or may not emit code
     169                 :            :     void (*start_except_handler)(emit_t *emit);
     170                 :            :     void (*end_except_handler)(emit_t *emit);
     171                 :            : } emit_method_table_t;
     172                 :            : 
     173                 :            : #if MICROPY_EMIT_BYTECODE_USES_QSTR_TABLE
     174                 :            : qstr_short_t mp_emit_common_use_qstr(mp_emit_common_t *emit, qstr qst);
     175                 :            : #else
     176                 :            : static inline qstr_short_t mp_emit_common_use_qstr(mp_emit_common_t *emit, qstr qst) {
     177                 :            :     return qst;
     178                 :            : }
     179                 :            : #endif
     180                 :            : 
     181                 :            : size_t mp_emit_common_use_const_obj(mp_emit_common_t *emit, mp_obj_t const_obj);
     182                 :            : 
     183                 :      22042 : static inline size_t mp_emit_common_alloc_const_child(mp_emit_common_t *emit, mp_raw_code_t *rc) {
     184         [ +  + ]:      22042 :     if (emit->pass == MP_PASS_EMIT) {
     185                 :       5532 :         emit->children[emit->ct_cur_child] = rc;
     186                 :            :     }
     187                 :      22042 :     return emit->ct_cur_child++;
     188                 :            : }
     189                 :            : 
     190                 :      71116 : static inline void mp_emit_common_get_id_for_load(scope_t *scope, qstr qst) {
     191                 :      71116 :     scope_find_or_add_id(scope, qst, ID_INFO_KIND_GLOBAL_IMPLICIT);
     192                 :      71116 : }
     193                 :            : 
     194                 :            : void mp_emit_common_get_id_for_modification(scope_t *scope, qstr qst);
     195                 :            : void mp_emit_common_id_op(emit_t *emit, const mp_emit_method_table_id_ops_t *emit_method_table, scope_t *scope, qstr qst);
     196                 :            : 
     197                 :            : extern const emit_method_table_t emit_bc_method_table;
     198                 :            : extern const emit_method_table_t emit_native_x64_method_table;
     199                 :            : extern const emit_method_table_t emit_native_x86_method_table;
     200                 :            : extern const emit_method_table_t emit_native_thumb_method_table;
     201                 :            : extern const emit_method_table_t emit_native_arm_method_table;
     202                 :            : extern const emit_method_table_t emit_native_xtensa_method_table;
     203                 :            : extern const emit_method_table_t emit_native_xtensawin_method_table;
     204                 :            : 
     205                 :            : extern const mp_emit_method_table_id_ops_t mp_emit_bc_method_table_load_id_ops;
     206                 :            : extern const mp_emit_method_table_id_ops_t mp_emit_bc_method_table_store_id_ops;
     207                 :            : extern const mp_emit_method_table_id_ops_t mp_emit_bc_method_table_delete_id_ops;
     208                 :            : 
     209                 :            : emit_t *emit_bc_new(mp_emit_common_t *emit_common);
     210                 :            : emit_t *emit_native_x64_new(mp_emit_common_t *emit_common, mp_obj_t *error_slot, uint *label_slot, mp_uint_t max_num_labels);
     211                 :            : emit_t *emit_native_x86_new(mp_emit_common_t *emit_common, mp_obj_t *error_slot, uint *label_slot, mp_uint_t max_num_labels);
     212                 :            : emit_t *emit_native_thumb_new(mp_emit_common_t *emit_common, mp_obj_t *error_slot, uint *label_slot, mp_uint_t max_num_labels);
     213                 :            : emit_t *emit_native_arm_new(mp_emit_common_t *emit_common, mp_obj_t *error_slot, uint *label_slot, mp_uint_t max_num_labels);
     214                 :            : emit_t *emit_native_xtensa_new(mp_emit_common_t *emit_common, mp_obj_t *error_slot, uint *label_slot, mp_uint_t max_num_labels);
     215                 :            : emit_t *emit_native_xtensawin_new(mp_emit_common_t *emit_common, mp_obj_t *error_slot, uint *label_slot, mp_uint_t max_num_labels);
     216                 :            : 
     217                 :            : void emit_bc_set_max_num_labels(emit_t *emit, mp_uint_t max_num_labels);
     218                 :            : 
     219                 :            : void emit_bc_free(emit_t *emit);
     220                 :            : void emit_native_x64_free(emit_t *emit);
     221                 :            : void emit_native_x86_free(emit_t *emit);
     222                 :            : void emit_native_thumb_free(emit_t *emit);
     223                 :            : void emit_native_arm_free(emit_t *emit);
     224                 :            : void emit_native_xtensa_free(emit_t *emit);
     225                 :            : void emit_native_xtensawin_free(emit_t *emit);
     226                 :            : 
     227                 :            : void mp_emit_bc_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope);
     228                 :            : bool mp_emit_bc_end_pass(emit_t *emit);
     229                 :            : void mp_emit_bc_adjust_stack_size(emit_t *emit, mp_int_t delta);
     230                 :            : void mp_emit_bc_set_source_line(emit_t *emit, mp_uint_t line);
     231                 :            : 
     232                 :            : void mp_emit_bc_load_local(emit_t *emit, qstr qst, mp_uint_t local_num, int kind);
     233                 :            : void mp_emit_bc_load_global(emit_t *emit, qstr qst, int kind);
     234                 :            : void mp_emit_bc_store_local(emit_t *emit, qstr qst, mp_uint_t local_num, int kind);
     235                 :            : void mp_emit_bc_store_global(emit_t *emit, qstr qst, int kind);
     236                 :            : void mp_emit_bc_delete_local(emit_t *emit, qstr qst, mp_uint_t local_num, int kind);
     237                 :            : void mp_emit_bc_delete_global(emit_t *emit, qstr qst, int kind);
     238                 :            : 
     239                 :            : void mp_emit_bc_label_assign(emit_t *emit, mp_uint_t l);
     240                 :            : void mp_emit_bc_import(emit_t *emit, qstr qst, int kind);
     241                 :            : void mp_emit_bc_load_const_tok(emit_t *emit, mp_token_kind_t tok);
     242                 :            : void mp_emit_bc_load_const_small_int(emit_t *emit, mp_int_t arg);
     243                 :            : void mp_emit_bc_load_const_str(emit_t *emit, qstr qst);
     244                 :            : void mp_emit_bc_load_const_obj(emit_t *emit, mp_obj_t obj);
     245                 :            : void mp_emit_bc_load_null(emit_t *emit);
     246                 :            : void mp_emit_bc_load_method(emit_t *emit, qstr qst, bool is_super);
     247                 :            : void mp_emit_bc_load_build_class(emit_t *emit);
     248                 :            : void mp_emit_bc_subscr(emit_t *emit, int kind);
     249                 :            : void mp_emit_bc_attr(emit_t *emit, qstr qst, int kind);
     250                 :            : void mp_emit_bc_dup_top(emit_t *emit);
     251                 :            : void mp_emit_bc_dup_top_two(emit_t *emit);
     252                 :            : void mp_emit_bc_pop_top(emit_t *emit);
     253                 :            : void mp_emit_bc_rot_two(emit_t *emit);
     254                 :            : void mp_emit_bc_rot_three(emit_t *emit);
     255                 :            : void mp_emit_bc_jump(emit_t *emit, mp_uint_t label);
     256                 :            : void mp_emit_bc_pop_jump_if(emit_t *emit, bool cond, mp_uint_t label);
     257                 :            : void mp_emit_bc_jump_if_or_pop(emit_t *emit, bool cond, mp_uint_t label);
     258                 :            : void mp_emit_bc_unwind_jump(emit_t *emit, mp_uint_t label, mp_uint_t except_depth);
     259                 :            : void mp_emit_bc_setup_block(emit_t *emit, mp_uint_t label, int kind);
     260                 :            : void mp_emit_bc_with_cleanup(emit_t *emit, mp_uint_t label);
     261                 :            : void mp_emit_bc_end_finally(emit_t *emit);
     262                 :            : void mp_emit_bc_get_iter(emit_t *emit, bool use_stack);
     263                 :            : void mp_emit_bc_for_iter(emit_t *emit, mp_uint_t label);
     264                 :            : void mp_emit_bc_for_iter_end(emit_t *emit);
     265                 :            : void mp_emit_bc_pop_except_jump(emit_t *emit, mp_uint_t label, bool within_exc_handler);
     266                 :            : void mp_emit_bc_unary_op(emit_t *emit, mp_unary_op_t op);
     267                 :            : void mp_emit_bc_binary_op(emit_t *emit, mp_binary_op_t op);
     268                 :            : void mp_emit_bc_build(emit_t *emit, mp_uint_t n_args, int kind);
     269                 :            : void mp_emit_bc_store_map(emit_t *emit);
     270                 :            : void mp_emit_bc_store_comp(emit_t *emit, scope_kind_t kind, mp_uint_t list_stack_index);
     271                 :            : void mp_emit_bc_unpack_sequence(emit_t *emit, mp_uint_t n_args);
     272                 :            : void mp_emit_bc_unpack_ex(emit_t *emit, mp_uint_t n_left, mp_uint_t n_right);
     273                 :            : void mp_emit_bc_make_function(emit_t *emit, scope_t *scope, mp_uint_t n_pos_defaults, mp_uint_t n_kw_defaults);
     274                 :            : void mp_emit_bc_make_closure(emit_t *emit, scope_t *scope, mp_uint_t n_closed_over, mp_uint_t n_pos_defaults, mp_uint_t n_kw_defaults);
     275                 :            : void mp_emit_bc_call_function(emit_t *emit, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags);
     276                 :            : void mp_emit_bc_call_method(emit_t *emit, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags);
     277                 :            : void mp_emit_bc_return_value(emit_t *emit);
     278                 :            : void mp_emit_bc_raise_varargs(emit_t *emit, mp_uint_t n_args);
     279                 :            : void mp_emit_bc_yield(emit_t *emit, int kind);
     280                 :            : void mp_emit_bc_start_except_handler(emit_t *emit);
     281                 :            : void mp_emit_bc_end_except_handler(emit_t *emit);
     282                 :            : 
     283                 :            : typedef struct _emit_inline_asm_t emit_inline_asm_t;
     284                 :            : 
     285                 :            : typedef struct _emit_inline_asm_method_table_t {
     286                 :            :     #if MICROPY_DYNAMIC_COMPILER
     287                 :            :     emit_inline_asm_t *(*asm_new)(mp_uint_t max_num_labels);
     288                 :            :     void (*asm_free)(emit_inline_asm_t *emit);
     289                 :            :     #endif
     290                 :            : 
     291                 :            :     void (*start_pass)(emit_inline_asm_t *emit, pass_kind_t pass, mp_obj_t *error_slot);
     292                 :            :     void (*end_pass)(emit_inline_asm_t *emit, mp_uint_t type_sig);
     293                 :            :     mp_uint_t (*count_params)(emit_inline_asm_t *emit, mp_uint_t n_params, mp_parse_node_t *pn_params);
     294                 :            :     bool (*label)(emit_inline_asm_t *emit, mp_uint_t label_num, qstr label_id);
     295                 :            :     void (*op)(emit_inline_asm_t *emit, qstr op, mp_uint_t n_args, mp_parse_node_t *pn_args);
     296                 :            : } emit_inline_asm_method_table_t;
     297                 :            : 
     298                 :            : extern const emit_inline_asm_method_table_t emit_inline_thumb_method_table;
     299                 :            : extern const emit_inline_asm_method_table_t emit_inline_xtensa_method_table;
     300                 :            : 
     301                 :            : emit_inline_asm_t *emit_inline_thumb_new(mp_uint_t max_num_labels);
     302                 :            : emit_inline_asm_t *emit_inline_xtensa_new(mp_uint_t max_num_labels);
     303                 :            : 
     304                 :            : void emit_inline_thumb_free(emit_inline_asm_t *emit);
     305                 :            : void emit_inline_xtensa_free(emit_inline_asm_t *emit);
     306                 :            : 
     307                 :            : #if MICROPY_WARNINGS
     308                 :            : void mp_emitter_warning(pass_kind_t pass, const char *msg);
     309                 :            : #else
     310                 :            : #define mp_emitter_warning(pass, msg)
     311                 :            : #endif
     312                 :            : 
     313                 :            : #endif // MICROPY_INCLUDED_PY_EMIT_H

Generated by: LCOV version 1.15-5-g462f71d