2014-05-03 23:27:38 +01:00
|
|
|
/*
|
2017-06-30 08:22:17 +01:00
|
|
|
* This file is part of the MicroPython project, http://micropython.org/
|
2014-05-03 23:27:38 +01:00
|
|
|
*
|
|
|
|
* The MIT License (MIT)
|
|
|
|
*
|
|
|
|
* Copyright (c) 2013, 2014 Damien P. George
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
all: Unify header guard usage.
The code conventions suggest using header guards, but do not define how
those should look like and instead point to existing files. However, not
all existing files follow the same scheme, sometimes omitting header guards
altogether, sometimes using non-standard names, making it easy to
accidentally pick a "wrong" example.
This commit ensures that all header files of the MicroPython project (that
were not simply copied from somewhere else) follow the same pattern, that
was already present in the majority of files, especially in the py folder.
The rules are as follows.
Naming convention:
* start with the words MICROPY_INCLUDED
* contain the full path to the file
* replace special characters with _
In addition, there are no empty lines before #ifndef, between #ifndef and
one empty line before #endif. #endif is followed by a comment containing
the name of the guard macro.
py/grammar.h cannot use header guards by design, since it has to be
included multiple times in a single C file. Several other files also do not
need header guards as they are only used internally and guaranteed to be
included only once:
* MICROPY_MPHALPORT_H
* mpconfigboard.h
* mpconfigport.h
* mpthreadport.h
* pin_defs_*.h
* qstrdefs*.h
2017-06-29 22:14:58 +01:00
|
|
|
#ifndef MICROPY_INCLUDED_PY_EMIT_H
|
|
|
|
#define MICROPY_INCLUDED_PY_EMIT_H
|
2015-01-01 20:27:54 +00:00
|
|
|
|
|
|
|
#include "py/lexer.h"
|
|
|
|
#include "py/scope.h"
|
|
|
|
|
2013-10-04 19:53:11 +01:00
|
|
|
/* Notes on passes:
|
|
|
|
* We don't know exactly the opcodes in pass 1 because they depend on the
|
|
|
|
* closing over of variables (LOAD_CLOSURE, BUILD_TUPLE, MAKE_CLOSURE), which
|
|
|
|
* depends on determining the scope of variables in each function, and this
|
|
|
|
* is not known until the end of pass 1.
|
|
|
|
* As a consequence, we don't know the maximum stack size until the end of pass 2.
|
|
|
|
* This is problematic for some emitters (x64) since they need to know the maximum
|
2014-01-06 15:49:21 +00:00
|
|
|
* stack size to compile the entry to the function, and this affects code size.
|
2013-10-04 19:53:11 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
typedef enum {
|
2014-05-07 17:24:22 +01:00
|
|
|
MP_PASS_SCOPE = 1, // work out id's and their kind, and number of labels
|
|
|
|
MP_PASS_STACK_SIZE = 2, // work out maximum stack size
|
|
|
|
MP_PASS_CODE_SIZE = 3, // work out code size and label offsets
|
|
|
|
MP_PASS_EMIT = 4, // emit code
|
2013-10-04 19:53:11 +01:00
|
|
|
} pass_kind_t;
|
|
|
|
|
2014-04-09 12:43:17 +01:00
|
|
|
#define MP_EMIT_STAR_FLAG_SINGLE (0x01)
|
|
|
|
#define MP_EMIT_STAR_FLAG_DOUBLE (0x02)
|
|
|
|
|
2014-05-30 15:20:41 +01:00
|
|
|
#define MP_EMIT_BREAK_FROM_FOR (0x8000)
|
|
|
|
|
2014-08-15 16:45:41 +01:00
|
|
|
#define MP_EMIT_NATIVE_TYPE_ENABLE (0)
|
|
|
|
#define MP_EMIT_NATIVE_TYPE_RETURN (1)
|
|
|
|
#define MP_EMIT_NATIVE_TYPE_ARG (2)
|
|
|
|
|
2013-10-05 12:19:06 +01:00
|
|
|
typedef struct _emit_t emit_t;
|
|
|
|
|
2015-03-26 14:42:40 +00:00
|
|
|
typedef struct _mp_emit_method_table_id_ops_t {
|
|
|
|
void (*fast)(emit_t *emit, qstr qst, mp_uint_t local_num);
|
|
|
|
void (*deref)(emit_t *emit, qstr qst, mp_uint_t local_num);
|
|
|
|
void (*name)(emit_t *emit, qstr qst);
|
|
|
|
void (*global)(emit_t *emit, qstr qst);
|
|
|
|
} mp_emit_method_table_id_ops_t;
|
|
|
|
|
2013-10-05 12:19:06 +01:00
|
|
|
typedef struct _emit_method_table_t {
|
2014-08-15 16:45:41 +01:00
|
|
|
void (*set_native_type)(emit_t *emit, mp_uint_t op, mp_uint_t arg1, qstr arg2);
|
2013-10-05 12:19:06 +01:00
|
|
|
void (*start_pass)(emit_t *emit, pass_kind_t pass, scope_t *scope);
|
|
|
|
void (*end_pass)(emit_t *emit);
|
|
|
|
bool (*last_emit_was_return_value)(emit_t *emit);
|
2014-09-08 23:05:16 +01:00
|
|
|
void (*adjust_stack_size)(emit_t *emit, mp_int_t delta);
|
2015-03-26 16:44:14 +00:00
|
|
|
void (*set_source_line)(emit_t *emit, mp_uint_t line);
|
2013-10-05 12:19:06 +01:00
|
|
|
|
2015-03-26 14:42:40 +00:00
|
|
|
mp_emit_method_table_id_ops_t load_id;
|
|
|
|
mp_emit_method_table_id_ops_t store_id;
|
|
|
|
mp_emit_method_table_id_ops_t delete_id;
|
2013-10-05 14:17:09 +01:00
|
|
|
|
2014-09-08 23:05:16 +01:00
|
|
|
void (*label_assign)(emit_t *emit, mp_uint_t l);
|
|
|
|
void (*import_name)(emit_t *emit, qstr qst);
|
|
|
|
void (*import_from)(emit_t *emit, qstr qst);
|
2013-10-05 12:19:06 +01:00
|
|
|
void (*import_star)(emit_t *emit);
|
2013-12-21 18:17:45 +00:00
|
|
|
void (*load_const_tok)(emit_t *emit, mp_token_kind_t tok);
|
2014-07-03 13:25:24 +01:00
|
|
|
void (*load_const_small_int)(emit_t *emit, mp_int_t arg);
|
2015-06-25 15:42:13 +01:00
|
|
|
void (*load_const_str)(emit_t *emit, qstr qst);
|
2015-11-27 12:41:25 +00:00
|
|
|
void (*load_const_obj)(emit_t *emit, mp_obj_t obj);
|
2014-04-20 17:50:40 +01:00
|
|
|
void (*load_null)(emit_t *emit);
|
2014-09-08 23:05:16 +01:00
|
|
|
void (*load_attr)(emit_t *emit, qstr qst);
|
2017-04-19 00:45:59 +01:00
|
|
|
void (*load_method)(emit_t *emit, qstr qst, bool is_super);
|
2013-10-05 12:19:06 +01:00
|
|
|
void (*load_build_class)(emit_t *emit);
|
2014-04-17 22:10:53 +01:00
|
|
|
void (*load_subscr)(emit_t *emit);
|
2014-09-08 23:05:16 +01:00
|
|
|
void (*store_attr)(emit_t *emit, qstr qst);
|
2013-10-05 12:19:06 +01:00
|
|
|
void (*store_subscr)(emit_t *emit);
|
2014-09-08 23:05:16 +01:00
|
|
|
void (*delete_attr)(emit_t *emit, qstr qst);
|
2013-10-05 12:19:06 +01:00
|
|
|
void (*delete_subscr)(emit_t *emit);
|
|
|
|
void (*dup_top)(emit_t *emit);
|
|
|
|
void (*dup_top_two)(emit_t *emit);
|
|
|
|
void (*pop_top)(emit_t *emit);
|
|
|
|
void (*rot_two)(emit_t *emit);
|
|
|
|
void (*rot_three)(emit_t *emit);
|
2014-09-08 23:05:16 +01:00
|
|
|
void (*jump)(emit_t *emit, mp_uint_t label);
|
2015-02-28 15:04:06 +00:00
|
|
|
void (*pop_jump_if)(emit_t *emit, bool cond, mp_uint_t label);
|
|
|
|
void (*jump_if_or_pop)(emit_t *emit, bool cond, mp_uint_t label);
|
2014-09-08 23:05:16 +01:00
|
|
|
void (*break_loop)(emit_t *emit, mp_uint_t label, mp_uint_t except_depth);
|
|
|
|
void (*continue_loop)(emit_t *emit, mp_uint_t label, mp_uint_t except_depth);
|
|
|
|
void (*setup_with)(emit_t *emit, mp_uint_t label);
|
2016-04-07 08:50:38 +01:00
|
|
|
void (*with_cleanup)(emit_t *emit, mp_uint_t label);
|
2014-09-08 23:05:16 +01:00
|
|
|
void (*setup_except)(emit_t *emit, mp_uint_t label);
|
|
|
|
void (*setup_finally)(emit_t *emit, mp_uint_t label);
|
2013-10-05 12:19:06 +01:00
|
|
|
void (*end_finally)(emit_t *emit);
|
2016-01-09 23:59:52 +00:00
|
|
|
void (*get_iter)(emit_t *emit, bool use_stack);
|
2014-09-08 23:05:16 +01:00
|
|
|
void (*for_iter)(emit_t *emit, mp_uint_t label);
|
2017-01-17 04:30:18 +00:00
|
|
|
void (*for_iter_end)(emit_t *emit);
|
2013-10-05 12:19:06 +01:00
|
|
|
void (*pop_block)(emit_t *emit);
|
|
|
|
void (*pop_except)(emit_t *emit);
|
2014-03-30 13:35:08 +01:00
|
|
|
void (*unary_op)(emit_t *emit, mp_unary_op_t op);
|
|
|
|
void (*binary_op)(emit_t *emit, mp_binary_op_t op);
|
2014-09-08 23:05:16 +01:00
|
|
|
void (*build_tuple)(emit_t *emit, mp_uint_t n_args);
|
|
|
|
void (*build_list)(emit_t *emit, mp_uint_t n_args);
|
|
|
|
void (*build_map)(emit_t *emit, mp_uint_t n_args);
|
2013-10-05 12:19:06 +01:00
|
|
|
void (*store_map)(emit_t *emit);
|
2014-12-27 17:07:16 +00:00
|
|
|
#if MICROPY_PY_BUILTINS_SET
|
2014-09-08 23:05:16 +01:00
|
|
|
void (*build_set)(emit_t *emit, mp_uint_t n_args);
|
2014-12-27 17:07:16 +00:00
|
|
|
#endif
|
2014-12-27 17:20:41 +00:00
|
|
|
#if MICROPY_PY_BUILTINS_SLICE
|
2014-09-08 23:05:16 +01:00
|
|
|
void (*build_slice)(emit_t *emit, mp_uint_t n_args);
|
2014-12-27 17:20:41 +00:00
|
|
|
#endif
|
2016-09-18 14:59:47 +01:00
|
|
|
void (*store_comp)(emit_t *emit, scope_kind_t kind, mp_uint_t set_stack_index);
|
2014-09-08 23:05:16 +01:00
|
|
|
void (*unpack_sequence)(emit_t *emit, mp_uint_t n_args);
|
|
|
|
void (*unpack_ex)(emit_t *emit, mp_uint_t n_left, mp_uint_t n_right);
|
|
|
|
void (*make_function)(emit_t *emit, scope_t *scope, mp_uint_t n_pos_defaults, mp_uint_t n_kw_defaults);
|
|
|
|
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);
|
|
|
|
void (*call_function)(emit_t *emit, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags);
|
|
|
|
void (*call_method)(emit_t *emit, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags);
|
2013-10-05 12:19:06 +01:00
|
|
|
void (*return_value)(emit_t *emit);
|
2014-09-08 23:05:16 +01:00
|
|
|
void (*raise_varargs)(emit_t *emit, mp_uint_t n_args);
|
2013-10-05 12:19:06 +01:00
|
|
|
void (*yield_value)(emit_t *emit);
|
|
|
|
void (*yield_from)(emit_t *emit);
|
2014-04-20 18:02:27 +01:00
|
|
|
|
2014-06-30 05:17:25 +01:00
|
|
|
// these methods are used to control entry to/exit from an exception handler
|
|
|
|
// they may or may not emit code
|
|
|
|
void (*start_except_handler)(emit_t *emit);
|
|
|
|
void (*end_except_handler)(emit_t *emit);
|
2013-10-05 12:19:06 +01:00
|
|
|
} emit_method_table_t;
|
|
|
|
|
2015-03-26 14:42:40 +00:00
|
|
|
void mp_emit_common_get_id_for_load(scope_t *scope, qstr qst);
|
|
|
|
void mp_emit_common_get_id_for_modification(scope_t *scope, qstr qst);
|
|
|
|
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);
|
2013-10-05 13:37:10 +01:00
|
|
|
|
2013-10-05 18:08:26 +01:00
|
|
|
extern const emit_method_table_t emit_bc_method_table;
|
2013-10-08 09:05:10 +01:00
|
|
|
extern const emit_method_table_t emit_native_x64_method_table;
|
2014-09-06 23:06:36 +01:00
|
|
|
extern const emit_method_table_t emit_native_x86_method_table;
|
2013-10-08 09:05:10 +01:00
|
|
|
extern const emit_method_table_t emit_native_thumb_method_table;
|
2014-08-16 21:55:53 +01:00
|
|
|
extern const emit_method_table_t emit_native_arm_method_table;
|
2016-12-09 05:39:39 +00:00
|
|
|
extern const emit_method_table_t emit_native_xtensa_method_table;
|
2013-10-05 18:08:26 +01:00
|
|
|
|
2015-03-26 16:44:14 +00:00
|
|
|
extern const mp_emit_method_table_id_ops_t mp_emit_bc_method_table_load_id_ops;
|
|
|
|
extern const mp_emit_method_table_id_ops_t mp_emit_bc_method_table_store_id_ops;
|
|
|
|
extern const mp_emit_method_table_id_ops_t mp_emit_bc_method_table_delete_id_ops;
|
|
|
|
|
2015-03-26 15:49:53 +00:00
|
|
|
emit_t *emit_bc_new(void);
|
2015-04-20 14:29:31 +01:00
|
|
|
emit_t *emit_native_x64_new(mp_obj_t *error_slot, mp_uint_t max_num_labels);
|
|
|
|
emit_t *emit_native_x86_new(mp_obj_t *error_slot, mp_uint_t max_num_labels);
|
|
|
|
emit_t *emit_native_thumb_new(mp_obj_t *error_slot, mp_uint_t max_num_labels);
|
|
|
|
emit_t *emit_native_arm_new(mp_obj_t *error_slot, mp_uint_t max_num_labels);
|
2016-12-09 05:39:39 +00:00
|
|
|
emit_t *emit_native_xtensa_new(mp_obj_t *error_slot, mp_uint_t max_num_labels);
|
2013-10-05 23:17:28 +01:00
|
|
|
|
2015-03-26 15:49:53 +00:00
|
|
|
void emit_bc_set_max_num_labels(emit_t* emit, mp_uint_t max_num_labels);
|
|
|
|
|
2014-01-24 22:42:28 +00:00
|
|
|
void emit_bc_free(emit_t *emit);
|
|
|
|
void emit_native_x64_free(emit_t *emit);
|
2014-09-06 23:06:36 +01:00
|
|
|
void emit_native_x86_free(emit_t *emit);
|
2014-01-24 22:42:28 +00:00
|
|
|
void emit_native_thumb_free(emit_t *emit);
|
2014-08-16 21:55:53 +01:00
|
|
|
void emit_native_arm_free(emit_t *emit);
|
2016-12-09 05:39:39 +00:00
|
|
|
void emit_native_xtensa_free(emit_t *emit);
|
2014-01-24 22:42:28 +00:00
|
|
|
|
2015-03-26 16:44:14 +00:00
|
|
|
void mp_emit_bc_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope);
|
|
|
|
void mp_emit_bc_end_pass(emit_t *emit);
|
|
|
|
bool mp_emit_bc_last_emit_was_return_value(emit_t *emit);
|
|
|
|
void mp_emit_bc_adjust_stack_size(emit_t *emit, mp_int_t delta);
|
|
|
|
void mp_emit_bc_set_source_line(emit_t *emit, mp_uint_t line);
|
|
|
|
|
|
|
|
void mp_emit_bc_load_fast(emit_t *emit, qstr qst, mp_uint_t local_num);
|
|
|
|
void mp_emit_bc_load_deref(emit_t *emit, qstr qst, mp_uint_t local_num);
|
|
|
|
void mp_emit_bc_load_name(emit_t *emit, qstr qst);
|
|
|
|
void mp_emit_bc_load_global(emit_t *emit, qstr qst);
|
|
|
|
void mp_emit_bc_store_fast(emit_t *emit, qstr qst, mp_uint_t local_num);
|
|
|
|
void mp_emit_bc_store_deref(emit_t *emit, qstr qst, mp_uint_t local_num);
|
|
|
|
void mp_emit_bc_store_name(emit_t *emit, qstr qst);
|
|
|
|
void mp_emit_bc_store_global(emit_t *emit, qstr qst);
|
|
|
|
void mp_emit_bc_delete_fast(emit_t *emit, qstr qst, mp_uint_t local_num);
|
|
|
|
void mp_emit_bc_delete_deref(emit_t *emit, qstr qst, mp_uint_t local_num);
|
|
|
|
void mp_emit_bc_delete_name(emit_t *emit, qstr qst);
|
|
|
|
void mp_emit_bc_delete_global(emit_t *emit, qstr qst);
|
|
|
|
|
|
|
|
void mp_emit_bc_label_assign(emit_t *emit, mp_uint_t l);
|
|
|
|
void mp_emit_bc_import_name(emit_t *emit, qstr qst);
|
|
|
|
void mp_emit_bc_import_from(emit_t *emit, qstr qst);
|
|
|
|
void mp_emit_bc_import_star(emit_t *emit);
|
|
|
|
void mp_emit_bc_load_const_tok(emit_t *emit, mp_token_kind_t tok);
|
|
|
|
void mp_emit_bc_load_const_small_int(emit_t *emit, mp_int_t arg);
|
2015-06-25 15:42:13 +01:00
|
|
|
void mp_emit_bc_load_const_str(emit_t *emit, qstr qst);
|
2015-11-27 12:41:25 +00:00
|
|
|
void mp_emit_bc_load_const_obj(emit_t *emit, mp_obj_t obj);
|
2015-03-26 16:44:14 +00:00
|
|
|
void mp_emit_bc_load_null(emit_t *emit);
|
|
|
|
void mp_emit_bc_load_attr(emit_t *emit, qstr qst);
|
2017-04-19 00:45:59 +01:00
|
|
|
void mp_emit_bc_load_method(emit_t *emit, qstr qst, bool is_super);
|
2015-03-26 16:44:14 +00:00
|
|
|
void mp_emit_bc_load_build_class(emit_t *emit);
|
|
|
|
void mp_emit_bc_load_subscr(emit_t *emit);
|
|
|
|
void mp_emit_bc_store_attr(emit_t *emit, qstr qst);
|
|
|
|
void mp_emit_bc_store_subscr(emit_t *emit);
|
|
|
|
void mp_emit_bc_delete_attr(emit_t *emit, qstr qst);
|
|
|
|
void mp_emit_bc_delete_subscr(emit_t *emit);
|
|
|
|
void mp_emit_bc_dup_top(emit_t *emit);
|
|
|
|
void mp_emit_bc_dup_top_two(emit_t *emit);
|
|
|
|
void mp_emit_bc_pop_top(emit_t *emit);
|
|
|
|
void mp_emit_bc_rot_two(emit_t *emit);
|
|
|
|
void mp_emit_bc_rot_three(emit_t *emit);
|
|
|
|
void mp_emit_bc_jump(emit_t *emit, mp_uint_t label);
|
|
|
|
void mp_emit_bc_pop_jump_if(emit_t *emit, bool cond, mp_uint_t label);
|
|
|
|
void mp_emit_bc_jump_if_or_pop(emit_t *emit, bool cond, mp_uint_t label);
|
|
|
|
void mp_emit_bc_unwind_jump(emit_t *emit, mp_uint_t label, mp_uint_t except_depth);
|
|
|
|
#define mp_emit_bc_break_loop mp_emit_bc_unwind_jump
|
|
|
|
#define mp_emit_bc_continue_loop mp_emit_bc_unwind_jump
|
|
|
|
void mp_emit_bc_setup_with(emit_t *emit, mp_uint_t label);
|
2016-04-07 08:50:38 +01:00
|
|
|
void mp_emit_bc_with_cleanup(emit_t *emit, mp_uint_t label);
|
2015-03-26 16:44:14 +00:00
|
|
|
void mp_emit_bc_setup_except(emit_t *emit, mp_uint_t label);
|
|
|
|
void mp_emit_bc_setup_finally(emit_t *emit, mp_uint_t label);
|
|
|
|
void mp_emit_bc_end_finally(emit_t *emit);
|
2016-01-09 23:59:52 +00:00
|
|
|
void mp_emit_bc_get_iter(emit_t *emit, bool use_stack);
|
2015-03-26 16:44:14 +00:00
|
|
|
void mp_emit_bc_for_iter(emit_t *emit, mp_uint_t label);
|
2017-01-17 04:30:18 +00:00
|
|
|
void mp_emit_bc_for_iter_end(emit_t *emit);
|
2015-03-26 16:44:14 +00:00
|
|
|
void mp_emit_bc_pop_block(emit_t *emit);
|
|
|
|
void mp_emit_bc_pop_except(emit_t *emit);
|
|
|
|
void mp_emit_bc_unary_op(emit_t *emit, mp_unary_op_t op);
|
|
|
|
void mp_emit_bc_binary_op(emit_t *emit, mp_binary_op_t op);
|
|
|
|
void mp_emit_bc_build_tuple(emit_t *emit, mp_uint_t n_args);
|
|
|
|
void mp_emit_bc_build_list(emit_t *emit, mp_uint_t n_args);
|
|
|
|
void mp_emit_bc_build_map(emit_t *emit, mp_uint_t n_args);
|
|
|
|
void mp_emit_bc_store_map(emit_t *emit);
|
|
|
|
#if MICROPY_PY_BUILTINS_SET
|
|
|
|
void mp_emit_bc_build_set(emit_t *emit, mp_uint_t n_args);
|
|
|
|
#endif
|
|
|
|
#if MICROPY_PY_BUILTINS_SLICE
|
|
|
|
void mp_emit_bc_build_slice(emit_t *emit, mp_uint_t n_args);
|
|
|
|
#endif
|
2016-09-18 14:59:47 +01:00
|
|
|
void mp_emit_bc_store_comp(emit_t *emit, scope_kind_t kind, mp_uint_t list_stack_index);
|
2015-03-26 16:44:14 +00:00
|
|
|
void mp_emit_bc_unpack_sequence(emit_t *emit, mp_uint_t n_args);
|
|
|
|
void mp_emit_bc_unpack_ex(emit_t *emit, mp_uint_t n_left, mp_uint_t n_right);
|
|
|
|
void mp_emit_bc_make_function(emit_t *emit, scope_t *scope, mp_uint_t n_pos_defaults, mp_uint_t n_kw_defaults);
|
|
|
|
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);
|
|
|
|
void mp_emit_bc_call_function(emit_t *emit, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags);
|
|
|
|
void mp_emit_bc_call_method(emit_t *emit, mp_uint_t n_positional, mp_uint_t n_keyword, mp_uint_t star_flags);
|
|
|
|
void mp_emit_bc_return_value(emit_t *emit);
|
|
|
|
void mp_emit_bc_raise_varargs(emit_t *emit, mp_uint_t n_args);
|
|
|
|
void mp_emit_bc_yield_value(emit_t *emit);
|
|
|
|
void mp_emit_bc_yield_from(emit_t *emit);
|
|
|
|
void mp_emit_bc_start_except_handler(emit_t *emit);
|
|
|
|
void mp_emit_bc_end_except_handler(emit_t *emit);
|
|
|
|
|
2013-10-05 23:17:28 +01:00
|
|
|
typedef struct _emit_inline_asm_t emit_inline_asm_t;
|
|
|
|
|
|
|
|
typedef struct _emit_inline_asm_method_table_t {
|
2016-12-09 10:23:17 +00:00
|
|
|
void (*start_pass)(emit_inline_asm_t *emit, pass_kind_t pass, mp_obj_t *error_slot);
|
2016-01-15 15:20:43 +00:00
|
|
|
void (*end_pass)(emit_inline_asm_t *emit, mp_uint_t type_sig);
|
2014-09-08 23:05:16 +01:00
|
|
|
mp_uint_t (*count_params)(emit_inline_asm_t *emit, mp_uint_t n_params, mp_parse_node_t *pn_params);
|
2015-03-03 17:08:02 +00:00
|
|
|
bool (*label)(emit_inline_asm_t *emit, mp_uint_t label_num, qstr label_id);
|
2014-09-08 23:05:16 +01:00
|
|
|
void (*op)(emit_inline_asm_t *emit, qstr op, mp_uint_t n_args, mp_parse_node_t *pn_args);
|
2013-10-05 23:17:28 +01:00
|
|
|
} emit_inline_asm_method_table_t;
|
|
|
|
|
|
|
|
extern const emit_inline_asm_method_table_t emit_inline_thumb_method_table;
|
py: Add inline Xtensa assembler.
This patch adds the MICROPY_EMIT_INLINE_XTENSA option, which, when
enabled, allows the @micropython.asm_xtensa decorator to be used.
The following opcodes are currently supported (ax is a register, a0-a15):
ret_n()
callx0(ax)
j(label)
jx(ax)
beqz(ax, label)
bnez(ax, label)
mov(ax, ay)
movi(ax, imm) # imm can be full 32-bit, uses l32r if needed
and_(ax, ay, az)
or_(ax, ay, az)
xor(ax, ay, az)
add(ax, ay, az)
sub(ax, ay, az)
mull(ax, ay, az)
l8ui(ax, ay, imm)
l16ui(ax, ay, imm)
l32i(ax, ay, imm)
s8i(ax, ay, imm)
s16i(ax, ay, imm)
s32i(ax, ay, imm)
l16si(ax, ay, imm)
addi(ax, ay, imm)
ball(ax, ay, label)
bany(ax, ay, label)
bbc(ax, ay, label)
bbs(ax, ay, label)
beq(ax, ay, label)
bge(ax, ay, label)
bgeu(ax, ay, label)
blt(ax, ay, label)
bnall(ax, ay, label)
bne(ax, ay, label)
bnone(ax, ay, label)
Upon entry to the assembly function the registers a0, a12, a13, a14 are
pushed to the stack and the stack pointer (a1) decreased by 16. Upon
exit, these registers and the stack pointer are restored, and ret.n is
executed to return to the caller (caller address is in a0).
Note that the ABI for the Xtensa emitters is non-windowing.
2016-12-09 06:03:33 +00:00
|
|
|
extern const emit_inline_asm_method_table_t emit_inline_xtensa_method_table;
|
2013-10-05 23:17:28 +01:00
|
|
|
|
2014-09-08 23:05:16 +01:00
|
|
|
emit_inline_asm_t *emit_inline_thumb_new(mp_uint_t max_num_labels);
|
py: Add inline Xtensa assembler.
This patch adds the MICROPY_EMIT_INLINE_XTENSA option, which, when
enabled, allows the @micropython.asm_xtensa decorator to be used.
The following opcodes are currently supported (ax is a register, a0-a15):
ret_n()
callx0(ax)
j(label)
jx(ax)
beqz(ax, label)
bnez(ax, label)
mov(ax, ay)
movi(ax, imm) # imm can be full 32-bit, uses l32r if needed
and_(ax, ay, az)
or_(ax, ay, az)
xor(ax, ay, az)
add(ax, ay, az)
sub(ax, ay, az)
mull(ax, ay, az)
l8ui(ax, ay, imm)
l16ui(ax, ay, imm)
l32i(ax, ay, imm)
s8i(ax, ay, imm)
s16i(ax, ay, imm)
s32i(ax, ay, imm)
l16si(ax, ay, imm)
addi(ax, ay, imm)
ball(ax, ay, label)
bany(ax, ay, label)
bbc(ax, ay, label)
bbs(ax, ay, label)
beq(ax, ay, label)
bge(ax, ay, label)
bgeu(ax, ay, label)
blt(ax, ay, label)
bnall(ax, ay, label)
bne(ax, ay, label)
bnone(ax, ay, label)
Upon entry to the assembly function the registers a0, a12, a13, a14 are
pushed to the stack and the stack pointer (a1) decreased by 16. Upon
exit, these registers and the stack pointer are restored, and ret.n is
executed to return to the caller (caller address is in a0).
Note that the ABI for the Xtensa emitters is non-windowing.
2016-12-09 06:03:33 +00:00
|
|
|
emit_inline_asm_t *emit_inline_xtensa_new(mp_uint_t max_num_labels);
|
|
|
|
|
2014-01-24 22:42:28 +00:00
|
|
|
void emit_inline_thumb_free(emit_inline_asm_t *emit);
|
py: Add inline Xtensa assembler.
This patch adds the MICROPY_EMIT_INLINE_XTENSA option, which, when
enabled, allows the @micropython.asm_xtensa decorator to be used.
The following opcodes are currently supported (ax is a register, a0-a15):
ret_n()
callx0(ax)
j(label)
jx(ax)
beqz(ax, label)
bnez(ax, label)
mov(ax, ay)
movi(ax, imm) # imm can be full 32-bit, uses l32r if needed
and_(ax, ay, az)
or_(ax, ay, az)
xor(ax, ay, az)
add(ax, ay, az)
sub(ax, ay, az)
mull(ax, ay, az)
l8ui(ax, ay, imm)
l16ui(ax, ay, imm)
l32i(ax, ay, imm)
s8i(ax, ay, imm)
s16i(ax, ay, imm)
s32i(ax, ay, imm)
l16si(ax, ay, imm)
addi(ax, ay, imm)
ball(ax, ay, label)
bany(ax, ay, label)
bbc(ax, ay, label)
bbs(ax, ay, label)
beq(ax, ay, label)
bge(ax, ay, label)
bgeu(ax, ay, label)
blt(ax, ay, label)
bnall(ax, ay, label)
bne(ax, ay, label)
bnone(ax, ay, label)
Upon entry to the assembly function the registers a0, a12, a13, a14 are
pushed to the stack and the stack pointer (a1) decreased by 16. Upon
exit, these registers and the stack pointer are restored, and ret.n is
executed to return to the caller (caller address is in a0).
Note that the ABI for the Xtensa emitters is non-windowing.
2016-12-09 06:03:33 +00:00
|
|
|
void emit_inline_xtensa_free(emit_inline_asm_t *emit);
|
2014-12-25 21:29:19 +00:00
|
|
|
|
2015-01-01 07:29:28 +00:00
|
|
|
#if MICROPY_WARNINGS
|
|
|
|
void mp_emitter_warning(pass_kind_t pass, const char *msg);
|
|
|
|
#else
|
|
|
|
#define mp_emitter_warning(pass, msg)
|
|
|
|
#endif
|
|
|
|
|
all: Unify header guard usage.
The code conventions suggest using header guards, but do not define how
those should look like and instead point to existing files. However, not
all existing files follow the same scheme, sometimes omitting header guards
altogether, sometimes using non-standard names, making it easy to
accidentally pick a "wrong" example.
This commit ensures that all header files of the MicroPython project (that
were not simply copied from somewhere else) follow the same pattern, that
was already present in the majority of files, especially in the py folder.
The rules are as follows.
Naming convention:
* start with the words MICROPY_INCLUDED
* contain the full path to the file
* replace special characters with _
In addition, there are no empty lines before #ifndef, between #ifndef and
one empty line before #endif. #endif is followed by a comment containing
the name of the guard macro.
py/grammar.h cannot use header guards by design, since it has to be
included multiple times in a single C file. Several other files also do not
need header guards as they are only used internally and guaranteed to be
included only once:
* MICROPY_MPHALPORT_H
* mpconfigboard.h
* mpconfigport.h
* mpthreadport.h
* pin_defs_*.h
* qstrdefs*.h
2017-06-29 22:14:58 +01:00
|
|
|
#endif // MICROPY_INCLUDED_PY_EMIT_H
|