4658 Commits

Author	SHA1	Message	Date
Jeff Epler	8abca6bacb	py/objexcept: Use mp_obj_get_type_str when printing exception name. ... Saves a few bytes of code. Signed-off-by: Jeff Epler <jepler@unpythonic.net>	2026-04-07 13:37:07 +10:00
Jeff Epler	4fe08ff16b	all: Avoid qstr_str calls when printing a qstr. ... The `%q` formatter of mp_printf can be used instead, and may save a small amount of code. Signed-off-by: Jeff Epler <jepler@unpythonic.net>	2026-04-07 13:36:34 +10:00
Damien George	367178fce7	all: Bump version to 1.29.0-preview. ... Signed-off-by: Damien George <damien@micropython.org>	2026-04-07 13:07:26 +10:00
Damien George	e0e9fbb17e	all: Bump version to 1.28.0. ... Signed-off-by: Damien George <damien@micropython.org>	2026-04-06 23:12:49 +10:00
Damien George	d41b8dc52e	py/emitglue: Fix macro logic that selects cache flushing code. ... This fixes a regression made by 9e9da6cb0d. There are two issues here: 1. `MPY_FEATURE_ARCH` and `MP_NATIVE_ARCH_xxx` are not visible in this file because `py/persistentcode.h` is not included. 2. Even if they were visible the macro logic will not work because `MP_NATIVE_ARCH_xxx` are enum values and cannot be used in #if logic. What this means is that the first #if is always true, so there is no cache flushing on ARM (non-Thumb) or RISC-V targets. This breaks native code on, eg, ESP32-P4. The fix here aims to simplify the logic by using built-in compiler defines to select the target: - On an ARM Thumb target with `__ICACHE_PRESENT` enabled, it will flush the cache. - On an ARM (non-Thumb) target, it will prefer `__builtin___clear_cache()` if possible, otherwise it will use inline assembler. - On a RISC-V target, it will use `MP_HAL_CLEAN_DCACHE()` if that macro is defined (that's only on ESP32-P4 at the moment). The logic should be the same as before, except for the cases where an emitter is enabled on a mismatching architecture. For example, if `MICROPY_EMIT_THUMB` and/or `MICROPY_EMIT_INLINE_THUMB` were enabled on a non-Thumb target, previously that will try to generate code to flush caches (which doesn't really make sense), but now it will not. This actually happened for `mpy-cross` which does enable all the emitters, and prior to this fix would follow the Thumb path, but not generate any code because `__ICACHE_PRESENT` is disabled (at least when building `mpy-cross` on x86). Signed-off-by: Damien George <damien@micropython.org>	2026-03-31 00:03:10 +11:00
Damien George	74e945752b	py/modweakref: Implement weakref module with ref and finalize classes. ... This adds support for the standard `weakref` module, to make weak references to Python objects and have callbacks for when an object is reclaimed by the GC. This feature was requested by PyScript, to allow control over the lifetime of external proxy objects (distinct from JS<->Python proxies). Addresses issue #646 (that's nearly a 12 year old issue!). Functionality added here: - `weakref.ref(object [, callback])` create a simple weak reference with optional callback to be called when the object is reclaimed by the GC - `weakref.finalize(object, callback, /, *args, **kwargs)` create a finalize object that holds a weak reference to an object and allows more convenient callback usage and state change The new module is enabled at the "everything" level. The implementation aims to be as efficient as possible, by adding another bit-per-block to the garbage collector, the WTB (weak table). Similar to the finalizer bit (FTB), if a GC block has its corresponding WTB bit set then a weak reference to that block is held. The details of that weak reference are stored in a global map, `mp_weakref_map`, which maps weak reference to ref/finalize objects, allowing the callbacks to be efficiently found when the object is reclaimed. With this feature enabled the overhead is: - 1/128th of the available memory is used for the new WTB table (eg a 128k heap now needs an extra 1k for the WTB). - Code size is increased. - At garbage collection time, there is a small overhead to check if the collected objects had weak references. This check is the same as the existing FTB finaliser scan, so shouldn't add much overhead. If there are weak reference objects alive (ref/finalize objects) then additional time is taken to call the callbacks and do some accounting to clean up the used weak reference. Signed-off-by: Damien George <damien@micropython.org>	2026-03-22 23:02:38 +11:00
Jeff Epler	803a4d7717	py/objtemplate: Correctly cast qstr literals when printing. ... qstr literals are of type qstr_short_t (aka uint16_t) for efficiency, but when the type is passed to `mp_printf` it must be cast explicitly to type `qstr`. These locations were found using an experimental gcc plugin for `mp_printf` error checking. Signed-off-by: Jeff Epler <jepler@unpythonic.net>	2026-03-22 22:59:15 +11:00
Angus Gratton	cda49bed27	py/objlist,stm32,esp32: Add helpers for creating/ensuring list args. ... Simplifies the pattern of an optional arg which can be a list of at least a certain length, otherwise one is lazily initialised. Modify pyb.CAN and ESP-NOW APIs to use the helper. Note this changes the return type of pyb.CAN.recv() from tuple to list. This work was funded through GitHub Sponsors. Signed-off-by: Angus Gratton <angus@redyak.com.au>	2026-03-19 15:37:19 +11:00
Damien George	d4751a164e	py: Add support for PEP 750's t-strings. ... This commit adds support for t-strings by leveraging the existing f-string parser in the lexer. It includes: - t-string parsing in `py/lexer.c` - new built-in `__template__()` function to construct t-string objects - new built-in `Template` and `Interpolation` classes which implement all the functionality from PEP 750 - new built-in `string` module with `templatelib` sub-module, which contains the classes `Template` and `Interpolation` The way the t-string parser works is that an input t-string like: t"hello {name:5}" is converted character-by-character by the lexer/tokenizer to: __template__(("hello ", "",), name, "name", None, "5") For reference, if it were an f-string it would be converted to: "hello {:5}".format(name) Some properties of this implementation: - it's enabled by default at the full feature level, MICROPY_CONFIG_ROM_LEVEL_AT_LEAST_FULL_FEATURES - when enabled on a Cortex-M bare-metal port it costs about +3000 bytes - there are no limits on the size or complexity of t-strings, and it allows arbitrary levels of nesting of f-strings and t-strings (up to the memory available to the compiler) - the 'a' (ascii) conversion specifier is not supported (MicroPython does not have the built-in `ascii` function) - space after conversion specifier, eg t"{x!r :10}", is not supported - arguments to `__template__` and `Interpolation` are not fully validated (it's not necessary, it won't crash if the wrong arguments are passed in) Otherwise the implementation here matches CPython. Signed-off-by: Damien George <damien@micropython.org>	2026-03-09 23:47:33 +11:00
Damien George	58436b2882	py/lexer: Fix parsing of f'{{'. ... Prior to this fix, f'{{' would raise a SyntaxError. Signed-off-by: Damien George <damien@micropython.org>	2026-03-09 23:14:42 +11:00
Damien George	06bfefeaee	py/objstr: Fix b"".hex() so it returns an empty str object. ... As per CPython behaviour, `b"".hex()` should return an empty str object (not an empty bytes object). Fixes issue #18807. Signed-off-by: Damien George <damien@micropython.org>	2026-03-04 12:06:33 +11:00
Damien George	65ddc2346c	py/objstr: Factor code with a helper function to create empty str/bytes. ... This reduces code duplication, and may help reduce code size. Signed-off-by: Damien George <damien@micropython.org>	2026-03-04 12:06:33 +11:00
Jeff Epler	c199ba9f71	py/objexcept: Check for incompletely constructed exceptions. ... This turns the reproducer into a sensible-ish crash: TypeError: exceptions must derive from BaseException Closes: #17117 Signed-off-by: Jeff Epler <jepler@unpythonic.net>	2026-02-26 16:15:54 +11:00
Jeff Epler	aaa30abbcd	py/objtype: Expose mp_native_base_init_wrapper_obj. ... Signed-off-by: Jeff Epler <jepler@unpythonic.net>	2026-02-26 16:15:54 +11:00
Alessandro Gatti	424ae08680	py/asmrv32: Do not clobber index register on viper load/store. ... This commit lets the native emitter preserve the value of the index register when performing register-indexed loads or stores for halfword or word values on RV32. The original code was optimised too aggressively to reduce the generated code's size, using compressed opcodes that alias the target register to one of the operands. In register-indexed load/store operations, the index register was assumed to be allocated somewhere safe, but it was not always the case. To solve this, now all halfword and word register-indexed operations will use REG_TEMP2 to store the scaled index register. The size penalty on generated code varies across operation sizes and enabled extensions: - byte operations stay the same size with or without Zba - halfword operations will be 2 bytes larger without Zba, and will stay the same size with Zba - word operations will be 4 bytes larger without Zba, and 2 bytes larger with Zba There is also a minor firmware footprint increase to hold the extra logic needed for conditional register clobbering, but it shouldn't be that large anyway. Signed-off-by: Alessandro Gatti <a.gatti@frob.it>	2026-02-24 18:42:53 +11:00
Alessandro Gatti	b46f9f503f	py/asmthumb: Do not clobber index register on viper load/store. ... This commit lets the native emitter preserve the value of the index register when performing register-indexed loads or stores of halfword or word values on Thumb. The original code was optimised too aggressively for a register-starved architecture like Thumb, and the index value in the sequence to generate was assumed to be allocated somewhere safe. This is valid on other architectures, but not on Thumb. To solve this, load operations do clobber a temporary register that should be safe to use, REG_TEMP2, to store the scaled register offset. REG_TEMP2's value is only used within the scope of a single ASM API instruction. Save operations unfortunately use a register that is aliased to REG_TEMP2, since they need to have three values in registers to perform the operation. This means the index register needs to be pushed to the stack before performing the scale + store operation, and then popped from the stack. That's a 4 bytes penalty on each store and a minor speed hit on generated code (plus a minor footprint increase of the firmware image). Signed-off-by: Alessandro Gatti <a.gatti@frob.it>	2026-02-24 18:42:53 +11:00
Alessandro Gatti	b7d7a26c8f	py/emitinlinextensa: Refactor handling of selected narrow opcodes. ... This commit migrates handling of certain narrow (ie. 16-bits) opcodes from a per-opcode dedicated code snippet to the existing table-driven opcode handler. The final ESP8266 firmware binary is 64 bytes shorter, without any change in the existing behaviour and with a reduced source code lines count too. Signed-off-by: Alessandro Gatti <a.gatti@frob.it>	2026-02-10 14:17:25 +11:00
Alessandro Gatti	9dcad25de6	py/emitinlinextensa: Add inline assembler support for windowed cores. ... This commit introduces support for writing inline assembler code snippets when targeting Xtensa cores that use register windows (eg. the whole ESP32 family). Opcodes support is still limited to what the ESP8266 supports (as in, LX3 cores opcodes), however each LX core version is guaranteed to support all previous versions' opcodes as well. The ESP32 does not have the inline assembler enabled by default, following the existing expectations when it comes to firmware footprint. Since now emitted functions may have one of two possible exit sequences, the L32I test had to be fixed. It would return the word containing the L32I opcode itself, but the upper 8 bits of the word came from the following opcode - which can change depending on the exit code sequence. Signed-off-by: Alessandro Gatti <a.gatti@frob.it>	2026-02-07 18:36:22 +11:00
stijn	dc91fa6548	py/misc: Fix truncating cast to char. ... Explicitly specify the wanted cast otherwise this results in warning C4244: '=': conversion from 'unichar' to 'char', possible loss of data when building with msvc with most warnings enabled. Signed-off-by: stijn <stijn@ignitron.net>	2026-02-07 18:16:54 +11:00
stijn	39d777cb86	py/gc: Differentiate between root and subtree pointers for debug log. ... This is more informative when debugging possible gc issues. Signed-off-by: stijn <stijn@ignitron.net>	2026-02-07 17:41:26 +11:00
stijn	eaf03bd68c	py/gc: Trace all marked heads in debug log. ... Otherwise only those in gc_mark_subtree get logged, which is incomplete and hence not very useful. Signed-off-by: stijn <stijn@ignitron.net>	2026-02-07 17:40:45 +11:00
Damien George	a2aad14506	py/objtuple: Remove unused mp_obj_tulpe_del function. ... Since the parent commit, this is now unused. Signed-off-by: Damien George <damien@micropython.org>	2026-02-07 17:09:22 +11:00
Damien George	3332e1ec0b	py/objzip: Adjust zip iter code to not use mp_obj_tuple_del. ... This is the only location in the code base that uses `mp_obj_tuple_del()`, so we can reduce code size by reworking the iter code not to use that function. The zip iter implementation should now have slightly better GC behaviour: it only allocates the return tuple if needed, instead of allocating it and then freeing it when the zip iterator is exhausted. Signed-off-by: Damien George <damien@micropython.org>	2026-02-07 17:08:18 +11:00
Daniël van de Giessen	71866edc13	py/stream: Use detailed error strings for TLS sockets. ... Both mbedTLS and axTLS have support for producing more detailed error strings. However, these are not used if the error is raised in stream protocol functions (read/write/ioctl). This commit adds support for more detailed error messages from streams. Under the hood it's using a new MP_STREAM_RAISE_ERROR ioctl request to pass the error code back to the stream implementation which can raise a more detailed error. If the ioctl is not implemented, we fall back to the old behaviour and raise an OSError with the error code. Currently the detailed messages are only implemented for TLS sockets since those already had helper functions for raising detailed exceptions, but can be easily implemented in any other stream. Signed-off-by: Daniël van de Giessen <daniel@dvdgiessen.nl>	2026-02-07 16:34:20 +11:00
Phil Howard	1095bbb3dc	py/objstr: Avoid double zero init on sized bytes. ... As per the implementation of m_malloc0, if MICROPY_GC_CONSERVATIVE_CLEAR is set then all RAM is guaranteed to be zero-init by gc_alloc. py/objstr.c: Guard the explicit zero init in bytes_make_new against being run, initialising the RAM to zero a second time, if this flag is set. Signed-off-by: Phil Howard <github@gadgetoid.com>	2026-02-06 00:19:48 +11:00
Phil Howard	53d900445b	py/objarray: Avoid double zero init on sized bytearrays. ... As per the implementation of m_malloc0, if MICROPY_GC_CONSERVATIVE_CLEAR is set then all RAM is guaranteed to be zero-init by gc_alloc. py/objarray.c: Guard the explicit zero init in bytearray_make_new against being run, initialising the RAM to zero a second time, if this flag is set. Note that MICROPY_GC_CONSERVATIVE_CLEAR is default enabled by MICROPY_ENABLE_GC, and no ports currently override this value. Co-authored-by: Mike Bell <mdb036@gmail.com> Signed-off-by: Phil Howard <github@gadgetoid.com>	2026-02-06 00:19:48 +11:00
Alessandro Gatti	b2073a09eb	py/emitinlinextensa: Refactor handling of selected opcodes. ... This commit refactors handling of opcodes whose composition can be easily defined as an entry in a table, so there's only one bit of code handling those opcodes rather than several small bits with overlapping functionalities. Two opcodes, RER and WER have been added to that table for completeness, although they're gated behind the uncommon opcodes configuration define. Still, despite two new opcodes, the final binary is smaller by about 160 bytes. Signed-off-by: Alessandro Gatti <a.gatti@frob.it>	2026-02-05 22:54:55 +11:00
Damien George	71b6a8595c	py/objtuple: Make mp_obj_tuple_get an inline function. ... This can be done now that it's declared in `py/objtuple.h`, where the `mp_obj_tuple` struct is defined. This allows much better code generation for users of `mp_obj_tuple_get()` where the caller uses len/items immediately (which is most uses), because the compiler no longer needs to allocate the return values on the stack. Changes code size by -36 bytes on bare-arm and -56 bytes on stm32. Signed-off-by: Damien George <damien@micropython.org>	2026-02-05 10:43:54 +11:00
Damien George	90f259f62b	py/objtuple: Move all tuple helper declarations to objtuple.h. ... These helper functions assume their argument is of type `mp_obj_tuple_t` so they have a better home in `py/objtuple.h`. Also remove `mp_obj_tuple_hash()` because it doesn't have a corresponding function defined anywhere (nor is it ever used). Signed-off-by: Damien George <damien@micropython.org>	2026-02-05 10:43:54 +11:00
Damien George	8c1462b454	py/objlist: Make three list helper functions inline. ... This can be done now these functions are declared in `py/objlist.h`, where the `mp_obj_list_t` struct is defined. This changes code size by -24 bytes on bare-arm, and by -56 bytes on stm32. Signed-off-by: Damien George <damien@micropython.org>	2026-02-05 10:43:54 +11:00
Damien George	1199015747	py/objlist: Move all list helper declarations to objlist.h. ... These helper functions assume their argument is of type `mp_obj_list_t` so they have a better home in `py/objlist.h`. Signed-off-by: Damien George <damien@micropython.org>	2026-02-05 10:43:54 +11:00
Damien George	512da03403	py/objfun: Rename mp_obj_fun_get_name to mp_obj_fun_bc_get_name. ... And change the argument to `const mp_obj_fun_bc_t *`. This makes it clear that it requires that specific type, rather than a general `mp_obj_t`. Signed-off-by: Damien George <damien@micropython.org>	2026-02-05 10:43:52 +11:00
Damien George	60fa4ab05d	py/objfun: Move decl of mp_obj_fun_get_name to objfun.h. ... This is an internal helper function that assumes the argument is of type `mp_obj_fun_bc_t`, so has a better home in `py/objfun.h`. Signed-off-by: Damien George <damien@micropython.org>	2026-02-05 10:42:50 +11:00
Damien George	cf90c8d88b	py/objmodule: Move decl of mp_obj_module_get_globals to objmodule.h. ... This inline helper function has two specific uses so doesn't need to be generally available in `py/obj.h`. Signed-off-by: Damien George <damien@micropython.org>	2026-02-05 10:42:50 +11:00
Damien George	e07bad9866	py/misc: Remove unused CHECKBUF macros. ... These macros were added in e11b17c25f for use with `sys.path` and building import path names, as well as being used by the unix port in 625d08a93e. But the macro usage for importing was promptly replaced with vstrs in e09ffa1400, and eventually for the unix port in 520f35632d, over 9.5 years ago. So, remove these unused macros. Signed-off-by: Damien George <damien@micropython.org>	2026-02-05 10:42:50 +11:00
Damien George	0c7726a89c	all: Use enum instead of bool argument to mp_handle_pending. ... This should be a no-op because the enum and bool have the same numeric value. Signed-off-by: Damien George <damien@micropython.org>	2026-02-05 00:29:36 +11:00
Damien George	74845981bb	py/runtime: Rename mp_handle_pending_internal to mp_handle_pending. ... This commit removes the static-inline `mp_handle_pending()` wrapper function, which was originally added for backwards compatibility. It replaces it with `mp_handle_pending_internal()` which is renamed to `mp_handle_pending()`, which has the same arguments. Signed-off-by: Damien George <damien@micropython.org>	2026-02-05 00:29:05 +11:00
Damien George	2984574d71	py/runtime: Reorder mp_handle_pending_behaviour_t enum. ... This is functionally a no-op, although will change compiled code due to the numerical values of the enums changing. This is needed for a follow-up commit, to remove the static-inline `mp_handle_pending(bool)` helper function. Signed-off-by: Damien George <damien@micropython.org>	2026-02-05 00:29:05 +11:00
Damien George	570744d06c	py/runtime: Make import-all support non-modules via __dict__/__all__. ... Prior to this fix, `mp_import_all()` assumed that its argument was exactly a native module instance. That would lead to a crash if something else was passed in, eg a user class via a custom `__import__` implementation or by writing to `sys.modules`. MicroPython already supports injecting non-module objects into the import machinery, so it makes sense to round out that implementation by supporting `from x import *` where `x` is a non-module object. Fixes issue #18639. Signed-off-by: Damien George <damien@micropython.org>	2026-02-05 00:24:14 +11:00
Damien George	c9f747cccf	py/lexer: Move f-string completion code to more logical location. ... This way, the use of `lex->fstring_args` is fully self contained within the string literal parsing section of `mp_lexer_to_next()`. Signed-off-by: Damien George <damien@micropython.org>	2026-02-04 23:19:09 +11:00
Damien George	7ea88f7da2	py/lexer: Add support for nested f-strings within f-strings. ... It turns out that it's relatively simple to support nested f-strings, which is what this commit implements. The way the MicroPython f-string parser works at the moment is: 1. it extracts the f-string arguments (things in curly braces) into a temporary buffer (a vstr) 2. once the f-string ends (reaches its closing quote) the lexer switches to tokenizing the temporary buffer 3. once the buffer is empty it switches back to the stream. The temporary buffer can easily hold f-strings itself (ie nested f-strings) and they can be re-parsed by the lexer using the same algorithm. The only thing stopping that from working is that the temporary buffer can't be reused for the nested f-string because it's currently being parsed. This commit fixes that by adding a second temporary buffer, which is the "injection" buffer. That allows arbitrary number of nestings with a simple modification to the original algorithm: 1. when an f-string is encountered the string is parsed and its arguments are extracted into `fstring_args` 2. when the f-string finishes, `fstring_args` is inserted into the current position in `inject_chrs` (which is the start of that buffer if no injection is ongoing) 3. `fstring_args` is now cleared and ready for any further f-strings (nested or not) 4. the lexer switches to `inject_chrs` if it's not already reading from it 5. if an f-string appeared inside the f-string then it is in `inject_chrs` and can be processed as before, extracting its arguments into `fstring_args`, which can then be inserted again into `inject_chrs` 6. once `inject_chrs` is exhausted (meaning that all levels of f-strings have been fully processed) the lexer switched back to tokenizing the stream. Amazingly, this scheme supports arbitrary numbers of nestings of f-strings using the same quote style. This adds some code size and a bit more memory usage for the lexer. In particular for a single (non-nested) f-string it now makes an extra copy of the `fstring_args` data, when copying it across to `inject_chrs`. Otherwise, memory use only goes up with the complexity of nested f-strings. Signed-off-by: Damien George <damien@micropython.org>	2026-02-04 23:19:09 +11:00
Damien George	617c7dba3b	py/lexer: Use null char as lexer EOF sentinel. ... The null byte cannot exist in source code (per CPython), so use it to indicate the end of the input stream (instead of `(mp_uint_t)-1`). This allows the cache chars (chr0/1/2 and their saved versions) to be 8-bit bytes, making it clear that they are not `unichar` values. It also saves a bit of memory in the `mp_lexer_t` data structure. (And in a future commit allows the saved cache chars to be eliminated entirely by storing them in a vstr instead.) In order to keep code size down, the frequently used `chr0` is still of type `uint32_t`. Having it 32-bit means that machine instructions to load it are smaller (it adds about +80 bytes to Thumb code if `chr0` is changed to `uint8_t`). Also add tests for invalid bytes in the input stream to make sure there are no regressions in this regard. Signed-off-by: Damien George <damien@micropython.org>	2026-02-04 23:19:09 +11:00
Damien George	bfb5e772f1	py/vstr: Don't check for byte_len>0 in vstr_ins_blank_bytes. ... Having this check takes code size and execution time, and it's not necessary: all callers of this function pass a non-zero value for `byte_len` already. And even if `byte_len` was zero, the code would still perform correctly. Signed-off-by: Damien George <damien@micropython.org>	2026-02-04 23:19:09 +11:00
Damien George	5f59f399b7	py/vstr: Add vstr_ins_strn helper function. ... This is now an easy function to define as inline, so it does not impact code size unless it's used. Signed-off-by: Damien George <damien@micropython.org>	2026-02-04 23:19:09 +11:00
Damien George	60c37a22d6	py/vstr: Make vstr_ins_byte/char functions inline to reduce code size. ... This saves about 4 bytes on ARM Cortex-M, and about 50-60 bytes on x86-64. It also allows the upcoming `vstr_ins_strn()` function to be inline as well, and have less of a code-size impact when used. Signed-off-by: Damien George <damien@micropython.org>	2026-02-04 23:19:09 +11:00
Damien George	878f8004fd	py/objfun: Support __code__ on functions with children. ... If a function has children then the code object returned from __code__ must contain an `mp_raw_code_t` (actually `mp_raw_code_truncated_t` is enough) that points to the child table. Signed-off-by: Damien George <damien@micropython.org>	2026-01-27 01:20:36 +11:00
Damien George	384cc627bc	py/persistentcode: Support saving functions with children. ... This adds support to `mp_raw_code_save_fun_to_bytes()` so that it can handle saving functions that have children. It does this by inspecting the MP_BC_MAKE_FUNCTION/etc opcodes to work out how many children there are, and creating a tree of simplified raw code information. Signed-off-by: Damien George <damien@micropython.org>	2026-01-27 01:20:36 +11:00
Damien George	03f50d39da	py/mpconfig: Enable MICROPY_PY_FUNCTION_ATTRS_CODE when marshal enabled. ... In case `MICROPY_PY_MARSHAL` is enabled manually. Otherwise the marshal module is not very usable. Signed-off-by: Damien George <damien@micropython.org>	2026-01-27 01:20:36 +11:00
Damien George	a5bda23aaa	py/emitglue: Check for bytecode with MICROPY_PY_FUNCTION_ATTRS_CODE. ... When `MICROPY_PY_FUNCTION_ATTRS_CODE` is enabled, constructing a function instance through `fun_bc_make_new()` can call `mp_make_function_from_proto_fun()` with pure bytecode as the proto-fun. Signed-off-by: Damien George <damien@micropython.org>	2026-01-27 01:20:36 +11:00
Alessandro Gatti	b87d73f2e9	tools/mpy_ld.py: Write architecture flags to output natmod if needed. ... This commit lets "tools/mpy_ld.py" store architecture flags in generated MPY files if explicitly requested, like "mpy-cross" does. To achieve this, a new command-line option ("--arch-flags") was added to receive the architecture flags value, accepting the same arguments' format as "mpy-cross", and performing the same input validation. The rest of the MPY toolchain was also modified to let the user pass the arch flags to standard native module makefiles. Given that there's already a well-established "ARCH" argument, "ARCH_FLAGS" was chosen to pass the optional flags to "mpy_ld.py". Finally, documentation was updated to mention the new variable. Signed-off-by: Alessandro Gatti <a.gatti@frob.it>	2026-01-11 09:22:13 +01:00