djsundog
/
circuitpython
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
circuitpython/py/runtime0.h

211 lines
6.5 KiB
C
Raw Normal View History

Add license header to (almost) all files. Blanket wide to all .c and .h files. Some files originating from ST are difficult to deal with (license wise) so it was left out of those. Also merged modpyb.h, modos.h, modstm.h and modtime.h in stmhal/.
2014-05-03 18:27:38 -04:00
/*
all: Use the name MicroPython consistently in comments There were several different spellings of MicroPython present in comments, when there should be only one.
2017-06-30 03:22:17 -04:00
* This file is part of the MicroPython project, http://micropython.org/
Add license header to (almost) all files. Blanket wide to all .c and .h files. Some files originating from ST are difficult to deal with (license wise) so it was left out of those. Also merged modpyb.h, modos.h, modstm.h and modtime.h in stmhal/.
2014-05-03 18:27:38 -04: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 17:14:58 -04:00
#ifndef MICROPY_INCLUDED_PY_RUNTIME0_H
#define MICROPY_INCLUDED_PY_RUNTIME0_H
Add license header to (almost) all files. Blanket wide to all .c and .h files. Some files originating from ST are difficult to deal with (license wise) so it was left out of those. Also merged modpyb.h, modos.h, modstm.h and modtime.h in stmhal/.
2014-05-03 18:27:38 -04:00
py/emitnative: Place const objs for native code in separate const table. This commit changes native code to handle constant objects like bytecode: instead of storing the pointers inside the native code they are now stored in a separate constant table (such pointers include objects like bignum, bytes, and raw code for nested functions). This removes the need for the GC to scan native code for root pointers, and takes a step towards making native code independent of the runtime (eg so it can be compiled offline by mpy-cross). Note that the changes to the struct scope_t did not increase its size: on a 32-bit architecture it is still 48 bytes, and on a 64-bit architecture it decreased from 80 to 72 bytes.
2018-09-27 09:27:53 -04:00
// The first four must fit in 8 bits, see emitbc.c
// The remaining must fit in 16 bits, see scope.h
py: Remove unused compile scope flags, and irrelevant flag compute code.
2015-08-17 17:39:03 -04:00
#define MP_SCOPE_FLAG_VARARGS (0x01)
#define MP_SCOPE_FLAG_VARKEYWORDS (0x02)
#define MP_SCOPE_FLAG_GENERATOR (0x04)
py: Put all bytecode state (arg count, etc) in bytecode.
2015-10-22 18:45:37 -04:00
#define MP_SCOPE_FLAG_DEFKWARGS (0x08)
py: Fix native functions so they run with their correct globals context. Prior to this commit a function compiled with the native decorator @micropython.native would not work correctly when accessing global variables, because the globals dict was not being set upon function entry. This commit fixes this problem by, upon function entry, setting as the current globals dict the globals dict context the function was defined within, as per normal Python semantics, and as bytecode does. Upon function exit the original globals dict is restored. In order to restore the globals dict when an exception is raised the native function must guard its internals with an nlr_push/nlr_pop pair. Because this push/pop is relatively expensive, in both C stack usage for the nlr_buf_t and CPU execution time, the implementation here optimises things as much as possible. First, the compiler keeps track of whether a function even needs to access global variables. Using this information the native emitter then generates three different kinds of code: 1. no globals used, no exception handlers: no nlr handling code and no setting of the globals dict. 2. globals used, no exception handlers: an nlr_buf_t is allocated on the C stack but it is not used if the globals dict is unchanged, saving execution time because nlr_push/nlr_pop don't need to run. 3. function has exception handlers, may use globals: an nlr_buf_t is allocated and nlr_push/nlr_pop are always called. In the end, native functions that don't access globals and don't have exception handlers will run more efficiently than those that do. Fixes issue #1573.
2018-09-13 08:03:48 -04:00
#define MP_SCOPE_FLAG_REFGLOBALS (0x10) // used only if native emitter enabled
py/emitnative: Place const objs for native code in separate const table. This commit changes native code to handle constant objects like bytecode: instead of storing the pointers inside the native code they are now stored in a separate constant table (such pointers include objects like bignum, bytes, and raw code for nested functions). This removes the need for the GC to scan native code for root pointers, and takes a step towards making native code independent of the runtime (eg so it can be compiled offline by mpy-cross). Note that the changes to the struct scope_t did not increase its size: on a 32-bit architecture it is still 48 bytes, and on a 64-bit architecture it decreased from 80 to 72 bytes.
2018-09-27 09:27:53 -04:00
#define MP_SCOPE_FLAG_HASCONSTS (0x20) // used only if native emitter enabled
#define MP_SCOPE_FLAG_VIPERRET_POS (6) // 3 bits used for viper return type
py: Pass all scope flags through to runtime.
2014-02-15 14:33:11 -05:00
py: Allow viper to have type annotations. Viper functions can now be annotated with the type of their arguments and return value. Eg: @micropython.viper def f(x:int) -> int: return x + 1
2014-08-15 11:45:41 -04:00
// types for native (viper) function signature
#define MP_NATIVE_TYPE_OBJ (0x00)
#define MP_NATIVE_TYPE_BOOL (0x01)
#define MP_NATIVE_TYPE_INT (0x02)
#define MP_NATIVE_TYPE_UINT (0x03)
py: Extend native type-sig to use 4 bits, so uint is separate to ptr. Before this patch, the native types for uint and ptr/ptr8/ptr16/ptr32 all overlapped and it was possible to make a mistake in casting. Now, these types are all separate and any coding mistakes will be raised as runtime errors.
2016-02-02 18:16:05 -05:00
#define MP_NATIVE_TYPE_PTR (0x04)
#define MP_NATIVE_TYPE_PTR8 (0x05)
#define MP_NATIVE_TYPE_PTR16 (0x06)
#define MP_NATIVE_TYPE_PTR32 (0x07)
py: Allow viper to have type annotations. Viper functions can now be annotated with the type of their arguments and return value. Eg: @micropython.viper def f(x:int) -> int: return x + 1
2014-08-15 11:45:41 -04:00
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
typedef enum {
py: Clarify which mp_unary_op_t's may appear in the bytecode. Not all can, so we don't need to reserve bytecodes for them, and can use free slots for something else later.
2017-09-25 19:35:19 -04:00
// These ops may appear in the bytecode. Changing this group
// in any way requires changing the bytecode version.
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
MP_UNARY_OP_POSITIVE,
MP_UNARY_OP_NEGATIVE,
MP_UNARY_OP_INVERT,
MP_UNARY_OP_NOT,
py: Clarify which mp_unary_op_t's may appear in the bytecode. Not all can, so we don't need to reserve bytecodes for them, and can use free slots for something else later.
2017-09-25 19:35:19 -04:00
// Following ops cannot appear in the bytecode
py: Clean up unary and binary enum list to keep groups together. 2 non-bytecode binary ops (NOT_IN and IN_NOT) are moved out of the bytecode group, so this change will change the bytecode format.
2017-10-03 08:34:28 -04:00
MP_UNARY_OP_NUM_BYTECODE,
py: Clarify which mp_unary_op_t's may appear in the bytecode. Not all can, so we don't need to reserve bytecodes for them, and can use free slots for something else later.
2017-09-25 19:35:19 -04:00
py: Clean up unary and binary enum list to keep groups together. 2 non-bytecode binary ops (NOT_IN and IN_NOT) are moved out of the bytecode group, so this change will change the bytecode format.
2017-10-03 08:34:28 -04:00
MP_UNARY_OP_BOOL = MP_UNARY_OP_NUM_BYTECODE, // __bool__
py: Clarify which mp_unary_op_t's may appear in the bytecode. Not all can, so we don't need to reserve bytecodes for them, and can use free slots for something else later.
2017-09-25 19:35:19 -04:00
MP_UNARY_OP_LEN, // __len__
MP_UNARY_OP_HASH, // __hash__; must return a small int
py/modbuiltins: Implement abs() by dispatching to MP_UNARY_OP_ABS. This allows user classes to implement __abs__ special method, and saves code size (104 bytes for x86_64), even though during refactor, an issue was fixed and few optimizations were made: * abs() of minimum (negative) small int value is calculated properly. * objint_longlong and objint_mpz avoid allocating new object is the argument is already non-negative.
2017-09-17 17:06:43 -04:00
MP_UNARY_OP_ABS, // __abs__
py/obj: Add support for __int__ special method. Based on the discussion, this special method is available unconditionally, as converting to int is a common operation.
2018-08-29 10:59:36 -04:00
MP_UNARY_OP_INT, // __int__
py/modsys: Initial implementation of sys.getsizeof(). Implemented as a new MP_UNARY_OP. This patch adds support lists, dicts and instances.
2017-08-11 02:42:39 -04:00
MP_UNARY_OP_SIZEOF, // for sys.getsizeof()
py: Clean up unary and binary enum list to keep groups together. 2 non-bytecode binary ops (NOT_IN and IN_NOT) are moved out of the bytecode group, so this change will change the bytecode format.
2017-10-03 08:34:28 -04:00
MP_UNARY_OP_NUM_RUNTIME,
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
} mp_unary_op_t;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
py: Clean up unary and binary enum list to keep groups together. 2 non-bytecode binary ops (NOT_IN and IN_NOT) are moved out of the bytecode group, so this change will change the bytecode format.
2017-10-03 08:34:28 -04:00
// Note: the first 9+12+12 of these are used in bytecode and changing
py/runtime0: Add comments about unary/binary-op enums used in bytecode.
2017-09-21 21:54:08 -04:00
// them requires changing the bytecode version.
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
typedef enum {
py: Clean up unary and binary enum list to keep groups together. 2 non-bytecode binary ops (NOT_IN and IN_NOT) are moved out of the bytecode group, so this change will change the bytecode format.
2017-10-03 08:34:28 -04:00
// 9 relational operations, should return a bool
py/runtime0.h: Move relational ops to the beginning of mp_binary_op_t. This is to allow to encode arithmetic operations more efficiently, in preparation to introduction of __rOP__ method support.
2017-09-07 03:55:43 -04:00
MP_BINARY_OP_LESS,
MP_BINARY_OP_MORE,
MP_BINARY_OP_EQUAL,
MP_BINARY_OP_LESS_EQUAL,
MP_BINARY_OP_MORE_EQUAL,
MP_BINARY_OP_NOT_EQUAL,
MP_BINARY_OP_IN,
MP_BINARY_OP_IS,
MP_BINARY_OP_EXCEPTION_MATCH,
py: Clean up unary and binary enum list to keep groups together. 2 non-bytecode binary ops (NOT_IN and IN_NOT) are moved out of the bytecode group, so this change will change the bytecode format.
2017-10-03 08:34:28 -04:00
// 12 inplace arithmetic operations
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
MP_BINARY_OP_INPLACE_OR,
MP_BINARY_OP_INPLACE_XOR,
py: Add MP_BINARY_OP_DIVMOD to simplify and consolidate divmod builtin.
2015-06-13 17:00:10 -04:00
MP_BINARY_OP_INPLACE_AND,
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
MP_BINARY_OP_INPLACE_LSHIFT,
MP_BINARY_OP_INPLACE_RSHIFT,
MP_BINARY_OP_INPLACE_ADD,
py/runtime0.h: Regroup operations a bit. Originally, there were grouped in blocks of 5, to make it easier e.g. to assess and numeric code of each. But now it makes more sense to group it by semantics/properties, and then split in chunks still, which usually leads to chunks of ~6 ops.
2017-09-07 06:37:33 -04:00
MP_BINARY_OP_INPLACE_SUBTRACT,
py: Add MP_BINARY_OP_DIVMOD to simplify and consolidate divmod builtin.
2015-06-13 17:00:10 -04:00
MP_BINARY_OP_INPLACE_MULTIPLY,
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
MP_BINARY_OP_INPLACE_FLOOR_DIVIDE,
MP_BINARY_OP_INPLACE_TRUE_DIVIDE,
MP_BINARY_OP_INPLACE_MODULO,
MP_BINARY_OP_INPLACE_POWER,
py/runtime0.h: Move MP_BINARY_OP_DIVMOD to the end of mp_binary_op_t. It starts a dichotomy of mp_binary_op_t values which can't appear in the bytecode. Another reason to move it is to VALUES of OP_* and OP_INPLACE_* nicely adjacent. This also will be needed for OP_REVERSE_*, to be soon introduced.
2017-09-07 04:26:42 -04:00
py: Clean up unary and binary enum list to keep groups together. 2 non-bytecode binary ops (NOT_IN and IN_NOT) are moved out of the bytecode group, so this change will change the bytecode format.
2017-10-03 08:34:28 -04:00
// 12 normal arithmetic operations
py/runtime0.h: Put inplace arith ops in front of normal operations. This is to allow to place reverse ops immediately after normal ops, so they can be tested as one range (which is optimization for reverse ops introduction in the next patch).
2017-09-07 17:10:10 -04:00
MP_BINARY_OP_OR,
MP_BINARY_OP_XOR,
MP_BINARY_OP_AND,
MP_BINARY_OP_LSHIFT,
MP_BINARY_OP_RSHIFT,
MP_BINARY_OP_ADD,
MP_BINARY_OP_SUBTRACT,
MP_BINARY_OP_MULTIPLY,
MP_BINARY_OP_FLOOR_DIVIDE,
MP_BINARY_OP_TRUE_DIVIDE,
MP_BINARY_OP_MODULO,
MP_BINARY_OP_POWER,
py/runtime0.h: Move MP_BINARY_OP_DIVMOD to the end of mp_binary_op_t. It starts a dichotomy of mp_binary_op_t values which can't appear in the bytecode. Another reason to move it is to VALUES of OP_* and OP_INPLACE_* nicely adjacent. This also will be needed for OP_REVERSE_*, to be soon introduced.
2017-09-07 04:26:42 -04:00
// Operations below this line don't appear in bytecode, they
// just identify special methods.
py: Clean up unary and binary enum list to keep groups together. 2 non-bytecode binary ops (NOT_IN and IN_NOT) are moved out of the bytecode group, so this change will change the bytecode format.
2017-10-03 08:34:28 -04:00
MP_BINARY_OP_NUM_BYTECODE,
py/runtime0.h: Move MP_BINARY_OP_DIVMOD to the end of mp_binary_op_t. It starts a dichotomy of mp_binary_op_t values which can't appear in the bytecode. Another reason to move it is to VALUES of OP_* and OP_INPLACE_* nicely adjacent. This also will be needed for OP_REVERSE_*, to be soon introduced.
2017-09-07 04:26:42 -04:00
py/runtime: Implement dispatch for "reverse op" special methods. If, for class X, X.__add__(Y) doesn't exist (or returns NotImplemented), try Y.__radd__(X) instead. This patch could be simpler, but requires undoing operand swap and operation switch to get non-confusing error message in case __radd__ doesn't exist.
2017-09-10 10:05:20 -04:00
// MP_BINARY_OP_REVERSE_* must follow immediately after MP_BINARY_OP_*
#if MICROPY_PY_REVERSE_SPECIAL_METHODS
py: Clean up unary and binary enum list to keep groups together. 2 non-bytecode binary ops (NOT_IN and IN_NOT) are moved out of the bytecode group, so this change will change the bytecode format.
2017-10-03 08:34:28 -04:00
MP_BINARY_OP_REVERSE_OR = MP_BINARY_OP_NUM_BYTECODE,
py/runtime: Implement dispatch for "reverse op" special methods. If, for class X, X.__add__(Y) doesn't exist (or returns NotImplemented), try Y.__radd__(X) instead. This patch could be simpler, but requires undoing operand swap and operation switch to get non-confusing error message in case __radd__ doesn't exist.
2017-09-10 10:05:20 -04:00
MP_BINARY_OP_REVERSE_XOR,
MP_BINARY_OP_REVERSE_AND,
MP_BINARY_OP_REVERSE_LSHIFT,
MP_BINARY_OP_REVERSE_RSHIFT,
MP_BINARY_OP_REVERSE_ADD,
MP_BINARY_OP_REVERSE_SUBTRACT,
MP_BINARY_OP_REVERSE_MULTIPLY,
MP_BINARY_OP_REVERSE_FLOOR_DIVIDE,
MP_BINARY_OP_REVERSE_TRUE_DIVIDE,
MP_BINARY_OP_REVERSE_MODULO,
MP_BINARY_OP_REVERSE_POWER,
#endif
py: Clean up unary and binary enum list to keep groups together. 2 non-bytecode binary ops (NOT_IN and IN_NOT) are moved out of the bytecode group, so this change will change the bytecode format.
2017-10-03 08:34:28 -04:00
// This is not emitted by the compiler but is supported by the runtime
MP_BINARY_OP_DIVMOD
#if !MICROPY_PY_REVERSE_SPECIAL_METHODS
= MP_BINARY_OP_NUM_BYTECODE
#endif
,
py/runtime: Add MP_BINARY_OP_CONTAINS as reverse of MP_BINARY_OP_IN. Before this patch MP_BINARY_OP_IN had two meanings: coming from bytecode it meant that the args needed to be swapped, but coming from within the runtime meant that the args were already in the correct order. This lead to some confusion in the code and comments stating how args were reversed. It also lead to 2 bugs: 1) containment for a subclass of a native type didn't work; 2) the expression "{True} in True" would illegally succeed and return True. In both of these cases it was because the args to MP_BINARY_OP_IN ended up being reversed twice. To fix these things this patch introduces MP_BINARY_OP_CONTAINS which corresponds exactly to the __contains__ special method, and this is the operator that built-in types should implement. MP_BINARY_OP_IN is now only emitted by the compiler and is converted to MP_BINARY_OP_CONTAINS by swapping the arguments.
2017-11-23 21:04:24 -05:00
// The runtime will convert MP_BINARY_OP_IN to this operator with swapped args.
// A type should implement this containment operator instead of MP_BINARY_OP_IN.
MP_BINARY_OP_CONTAINS,
py: Clean up unary and binary enum list to keep groups together. 2 non-bytecode binary ops (NOT_IN and IN_NOT) are moved out of the bytecode group, so this change will change the bytecode format.
2017-10-03 08:34:28 -04:00
MP_BINARY_OP_NUM_RUNTIME,
py/objtype: Make sure mp_binary_op_method_name has full size again. After recent refactorings to mp_binary_op_t, and make it future refactoring proof for now, at the cost of extra element in the array.
2017-09-07 05:54:58 -04:00
py: Clean up unary and binary enum list to keep groups together. 2 non-bytecode binary ops (NOT_IN and IN_NOT) are moved out of the bytecode group, so this change will change the bytecode format.
2017-10-03 08:34:28 -04:00
// These 2 are not supported by the runtime and must be synthesised by the emitter
MP_BINARY_OP_NOT_IN,
MP_BINARY_OP_IS_NOT,
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
} mp_binary_op_t;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
typedef enum {
py/emitnative: Put None/False/True in global native const table. So these constant objects can be loaded by dereferencing the REG_FUN_TABLE pointer instead of loading immediate values. This reduces the size of generated native code (when such constants are used), and means that pointers to these constants are no longer stored in the assembly code.
2018-10-14 08:56:46 -04:00
MP_F_CONST_NONE_OBJ = 0,
MP_F_CONST_FALSE_OBJ,
MP_F_CONST_TRUE_OBJ,
MP_F_CONVERT_OBJ_TO_NATIVE,
py: Viper can now store to global.
2014-08-15 18:47:59 -04:00
MP_F_CONVERT_NATIVE_TO_OBJ,
py: Fix native functions so they run with their correct globals context. Prior to this commit a function compiled with the native decorator @micropython.native would not work correctly when accessing global variables, because the globals dict was not being set upon function entry. This commit fixes this problem by, upon function entry, setting as the current globals dict the globals dict context the function was defined within, as per normal Python semantics, and as bytecode does. Upon function exit the original globals dict is restored. In order to restore the globals dict when an exception is raised the native function must guard its internals with an nlr_push/nlr_pop pair. Because this push/pop is relatively expensive, in both C stack usage for the nlr_buf_t and CPU execution time, the implementation here optimises things as much as possible. First, the compiler keeps track of whether a function even needs to access global variables. Using this information the native emitter then generates three different kinds of code: 1. no globals used, no exception handlers: no nlr handling code and no setting of the globals dict. 2. globals used, no exception handlers: an nlr_buf_t is allocated on the C stack but it is not used if the globals dict is unchanged, saving execution time because nlr_push/nlr_pop don't need to run. 3. function has exception handlers, may use globals: an nlr_buf_t is allocated and nlr_push/nlr_pop are always called. In the end, native functions that don't access globals and don't have exception handlers will run more efficiently than those that do. Fixes issue #1573.
2018-09-13 08:03:48 -04:00
MP_F_NATIVE_SWAP_GLOBALS,
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
MP_F_LOAD_NAME,
MP_F_LOAD_GLOBAL,
MP_F_LOAD_BUILD_CLASS,
MP_F_LOAD_ATTR,
MP_F_LOAD_METHOD,
py: Add LOAD_SUPER_METHOD bytecode to allow heap-free super meth calls. This patch allows the following code to run without allocating on the heap: super().foo(...) Before this patch such a call would allocate a super object on the heap and then load the foo method and call it right away. The super object is only needed to perform the lookup of the method and not needed after that. This patch makes an optimisation to allocate the super object on the C stack and discard it right after use. Changes in code size due to this patch are: bare-arm: +128 minimal: +232 unix x64: +416 unix nanbox: +364 stmhal: +184 esp8266: +340 cc3200: +128
2017-04-18 19:45:59 -04:00
MP_F_LOAD_SUPER_METHOD,
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
MP_F_STORE_NAME,
py: Viper can now store to global.
2014-08-15 18:47:59 -04:00
MP_F_STORE_GLOBAL,
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
MP_F_STORE_ATTR,
py: Merge BINARY_OP_SUBSCR and store_subscr (w/ delete) into subscr. mp_obj_t->subscr now does load/store/delete.
2014-04-17 17:10:53 -04:00
MP_F_OBJ_SUBSCR,
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
MP_F_OBJ_IS_TRUE,
MP_F_UNARY_OP,
MP_F_BINARY_OP,
MP_F_BUILD_TUPLE,
MP_F_BUILD_LIST,
MP_F_LIST_APPEND,
MP_F_BUILD_MAP,
MP_F_STORE_MAP,
py: Add option to disable set() object (enabled by default).
2014-06-01 08:46:47 -04:00
#if MICROPY_PY_BUILTINS_SET
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
MP_F_STORE_SET,
py/emit: Merge build set/slice into existing build emit function. Reduces code size by: bare-arm: +0 minimal x86: +0 unix x64: -368 unix nanbox: -248 stm32: -128 cc3200: -48 esp8266: -184 esp32: -40
2018-05-22 08:18:42 -04:00
MP_F_BUILD_SET,
py: Add option to disable set() object (enabled by default).
2014-06-01 08:46:47 -04:00
#endif
py: Remove unique_codes from emitglue.c. Replace with pointers. Attempt to address issue #386. unique_code_id's have been removed and replaced with a pointer to the "raw code" information. This pointer is stored in the actual byte code (aligned, so the GC can trace it), so that raw code (ie byte code, native code and inline assembler) is kept only for as long as it is needed. In memory it's now like a tree: the outer module's byte code points directly to its children's raw code. So when the outer code gets freed, if there are no remaining functions that need the raw code, then the children's code gets freed as well. This is pretty much like CPython does it, except that CPython stores indexes in the byte code rather than machine pointers. These indices index the per-function constant table in order to find the relevant code.
2014-04-13 06:04:33 -04:00
MP_F_MAKE_FUNCTION_FROM_RAW_CODE,
py: Viper can call functions with native types, and raise exceptions.
2014-08-16 17:06:11 -04:00
MP_F_NATIVE_CALL_FUNCTION_N_KW,
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
MP_F_CALL_METHOD_N_KW,
py: Implement calling functions with *args in native emitter.
2015-04-06 17:48:21 -04:00
MP_F_CALL_METHOD_N_KW_VAR,
py: Optimise storage of iterator so it takes only 4 slots on Py stack.
2017-01-16 23:27:37 -05:00
MP_F_NATIVE_GETITER,
MP_F_NATIVE_ITERNEXT,
py: Code clean-up in native emitter; improve thumb native calls.
2014-08-16 17:31:57 -04:00
MP_F_NLR_PUSH,
MP_F_NLR_POP,
py: Viper can call functions with native types, and raise exceptions.
2014-08-16 17:06:11 -04:00
MP_F_NATIVE_RAISE,
py: Implement more features in native emitter. On x64, native emitter now passes 70 of the tests.
2014-04-06 07:58:40 -04:00
MP_F_IMPORT_NAME,
py: Code clean-up in native emitter; improve thumb native calls.
2014-08-16 17:31:57 -04:00
MP_F_IMPORT_FROM,
py: Implement more features in native emitter. On x64, native emitter now passes 70 of the tests.
2014-04-06 07:58:40 -04:00
MP_F_IMPORT_ALL,
py: Fix configurability of builtin slice.
2014-06-01 08:49:35 -04:00
#if MICROPY_PY_BUILTINS_SLICE
py: Implement more features in native emitter. On x64, native emitter now passes 70 of the tests.
2014-04-06 07:58:40 -04:00
MP_F_NEW_SLICE,
py: Fix configurability of builtin slice.
2014-06-01 08:49:35 -04:00
#endif
py: Implement more features in native emitter. On x64, native emitter now passes 70 of the tests.
2014-04-06 07:58:40 -04:00
MP_F_UNPACK_SEQUENCE,
py: Improve native emitter; now supports more opcodes.
2014-05-07 13:30:52 -04:00
MP_F_UNPACK_EX,
py: Native emitter now supports delete name & global, and end finally.
2014-09-06 13:38:20 -04:00
MP_F_DELETE_NAME,
MP_F_DELETE_GLOBAL,
py: Implement closures in native code generator. Currently supports only x64 and Thumb2 archs.
2015-01-15 09:41:41 -05:00
MP_F_NEW_CELL,
MP_F_MAKE_CLOSURE_FROM_RAW_CODE,
py: Make viper functions have the same entry signature as native. This commit makes viper functions have the same signature as native functions, at the level of the emitter/assembler. This means that viper functions can now be wrapped in the same uPy object as native functions. Viper functions are now responsible for parsing their arguments (before it was done by the runtime), and this makes calling them more efficient (in most cases) because the viper entry code can be custom generated to suit the signature of the function. This change also opens the way forward for viper functions to take arbitrary numbers of arguments, and for them to handle globals correctly, among other things.
2018-09-14 03:40:59 -04:00
MP_F_ARG_CHECK_NUM_SIG,
py: Implement full func arg passing for native emitter. This patch gets full function argument passing working with native emitter. Includes named args, keyword args, default args, var args and var keyword args. Fully Python compliant. It reuses the bytecode mp_setup_code_state function to do all the hard work. This function is slightly adjusted to accommodate native calls, and the native emitter is forced a bit to emit similar prelude and code-info as bytecode.
2015-04-06 17:38:53 -04:00
MP_F_SETUP_CODE_STATE,
py/emitnative: Implement floor-division and modulo for viper emitter.
2017-10-11 03:54:34 -04:00
MP_F_SMALL_INT_FLOOR_DIVIDE,
MP_F_SMALL_INT_MODULO,
py/emitnative: Implement yield and yield-from in native emitter. This commit adds first class support for yield and yield-from in the native emitter, including send and throw support, and yields enclosed in exception handlers (which requires pulling down the NLR stack before yielding, then rebuilding it when resuming). This has been fully tested and is working on unix x86 and x86-64, and stm32. Also basic tests have been done with the esp8266 port. Performance of existing native code is unchanged.
2018-09-30 23:07:04 -04:00
MP_F_NATIVE_YIELD_FROM,
Rename rt_* to mp_*. Mostly just a global search and replace. Except rt_is_true which becomes mp_obj_is_true. Still would like to tidy up some of the names, but this will do for now.
2014-03-30 08:35:08 -04:00
MP_F_NUMBER_OF,
} mp_fun_kind_t;
Change object representation from 1 big union to individual structs. A big change. Micro Python objects are allocated as individual structs with the first element being a pointer to the type information (which is itself an object). This scheme follows CPython. Much more flexible, not necessarily slower, uses same heap memory, and can allocate objects statically. Also change name prefix, from py_ to mp_ (mp for Micro Python).
2013-12-21 13:17:45 -05:00
py/emitnative: Put None/False/True in global native const table. So these constant objects can be loaded by dereferencing the REG_FUN_TABLE pointer instead of loading immediate values. This reduces the size of generated native code (when such constants are used), and means that pointers to these constants are no longer stored in the assembly code.
2018-10-14 08:56:46 -04:00
extern const void *const mp_fun_table[MP_F_NUMBER_OF];
py: Move to guarded includes for compile.h and related headers.
2014-12-25 16:29:19 -05:00
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 17:14:58 -04:00
#endif // MICROPY_INCLUDED_PY_RUNTIME0_H