microPython的源码解析之 persistentcode.c

MicroPython 是一种适用于微控制器和其他受限环境的 Python 编程语言的实现。它旨在提供与 Python 3 语言的紧密兼容，同时考虑到内存和计算资源的限制。MicroPython 库是这门语言的核心组成部分，提供了一系列的模块和函数，使得开发者能够在硬件上执行各种任务。
下面将通过系列文章,逐一解读microPython,以便让读者了解掌握microPython的整个核心逻辑.,以便读者可以透过这个Python的最小内核,掌握Python解析器的核心实现逻辑,学习世界上最优秀的源码设计之一.

---

microPython Python最小内核源码解析
NI-motion运动控制c语言示例代码解析
python编程示例系列 python编程示例系列二
python的Web神器Streamlit

---

这段代码是MicroPython的一部分，它负责编译模块的持久化和加载。代码主要分为两部分：一部分是mp_raw_code_load函数，它用于从.mpy文件或其他源加载编译后的代码；另一部分是mp_raw_code_save函数，它用于将编译后的代码保存到文件中。这些函数处理了字节码和本地代码的加载和保存，以及相关的元数据和常量表。代码中的注释提供了对每个函数和操作的详细解释，有助于理解代码的功能和实现方式。

#include <stdint.h> // 标准整数类型头文件
#include <stdio.h>  // 标准输入输出头文件
#include <string.h> // 字符串操作头文件
#include <assert.h> // 断言头文件

// 包含MicroPython特定的头文件
#include "py/reader.h"
#include "py/nativeglue.h"
#include "py/persistentcode.h"
#include "py/bc0.h"
#include "py/objstr.h"
#include "py/mpthread.h"

#if MICROPY_PERSISTENT_CODE_LOAD || MICROPY_PERSISTENT_CODE_SAVE

#include "py/smallint.h"

// 从makeqstrdata.py生成的固定qstr列表，我们假设所有MicroPython实现上都有这些qstr，并且不需要在.mpy文件中重复字符串数据。
#define QSTR_LAST_STATIC MP_QSTR_zip

#if MICROPY_DYNAMIC_COMPILER
#define MPY_FEATURE_ARCH_DYNAMIC mp_dynamic_compiler.native_arch
#else
#define MPY_FEATURE_ARCH_DYNAMIC MPY_FEATURE_ARCH
#endif

// 定义字节码序言结构体
typedef struct _bytecode_prelude_t {
   
    uint n_state;             // 状态数量
    uint n_exc_stack;         // 异常堆栈数量
    uint scope_flags;        // 作用域标志
    uint n_pos_args;         // 位置参数数量
    uint n_kwonly_args;      // 仅限关键字参数数量
    uint n_def_pos_args;     // 默认位置参数数量
    uint code_info_size;     // 代码信息大小
} bytecode_prelude_t;

#endif // MICROPY_PERSISTENT_CODE_LOAD || MICROPY_PERSISTENT_CODE_SAVE

#if MICROPY_PERSISTENT_CODE_LOAD

#include "py/parsenum.h"

// 定义读取一个字节的静态函数
static int read_byte(mp_reader_t *reader);
// 定义读取无符号整数的静态函数
static size_t read_uint(mp_reader_t *reader);

#if MICROPY_EMIT_MACHINE_CODE

// 定义重定位信息结构体
typedef struct _reloc_info_t {
   
    mp_reader_t *reader;        // 读取器
    mp_module_context_t *context; // 模块上下文
    uint8_t *rodata;          // 只读数据
    uint8_t *bss;             // 未初始化数据
} reloc_info_t;

// 定义机器代码重定位函数
void mp_native_relocate(void *ri_in, uint8_t *text, uintptr_t reloc_text) {
   
    // 重定位本地代码
    reloc_info_t *ri = ri_in;
    uint8_t op;
    uintptr_t *addr_to_adjust = NULL; // 指向需要调整的地址
    while ((op = read_byte(ri->reader)) != 0xff) {
   
        if (op & 1) {
   
            // 指向新位置以进行调整
            size_t addr = read_uint(ri->reader);
            if ((addr & 1) == 0) {
   
                // 指向文本中的某个位置
                addr_to_adjust = &((uintptr_t *)text)[addr >> 1];
            } else {
   
                // 指向rodata中的某个位置
                addr_to_adjust = &((uintptr_t *)ri->rodata)[addr >> 1];
            }
        }
        op >>= 1;
        uintptr_t dest; // 目标地址
        size_t n = 1;
        if (op <= 5) {
   
            if (op & 1) {
   
                // 读取需要进行调整的次数
                n = read_uint(ri->reader);
            }
            op >>= 1;
            if (op == 0) {
   
                // 目标是文本
                dest = reloc_text;
            } else if (op == 1) {
   
                // 目标是rodata
                dest = (uintptr_t)ri->rodata;
            } else {
   
                // 目标是bss
                dest = (uintptr_t)ri->bss;
            }
        } else if (op == 6) {
   
            // 目标是qstr_table
            dest = (uintptr_t)ri->context->constants.qstr_table;
        } else if (op == 7) {
   
            // 目标是obj_table
            dest = (uintptr_t)ri->context->constants.obj_table;
        } else if (op == 8) {
   
            // 目标是mp_fun_table本身
            dest = (uintptr_t)&mp_fun_table;
        } else {
   
            // 目标是mp_fun_table中的一个条目
            dest = ((uintptr_t *)&mp_fun_table)[op - 9];
        }
        while (n--) {
   
            *addr_to_adjust++ += dest;
        }
    }
}

#endif

// 定义读取一个字节的静态函数
static int read_byte(mp_reader_t *reader) {
   
    return reader->readbyte(reader->data);
}

// 定义读取字节序列的静态函数
static void read_bytes(mp_reader_t *reader, byte *buf, size_t len) {
   
    while (len-- > 0) {
   
        *buf++ = reader->readbyte(reader->data);
    }
}

// 定义读取无符号整数的静态函数
static size_t read_uint(mp_reader_t *reader) {
   
    size_t unum = 0;
    for (;;) {
   
        byte b = reader->readbyte(reader->data);
        unum = (unum << 7) | (b & 0x7f);
        if ((b & 0x80) == 0) {
   
            break;
        }
    }
    return unum;
}

// 定义加载qstr的静态函数
static qstr load_qstr(mp_reader_t *reader) {
   
    size_t len = read_uint(reader);
    if (len & 1) {
   
        // 静态qstr
        return len >> 1;
    }
    len >>= 1;
    char *str = m_new(char, len);
    read_bytes(reader, (byte *)str, len);
    read_byte(reader); // 读取并丢弃空终止符
    qstr qst = qstr_from_strn(str, len);
    m_del(char, str, len);
    return qst;
}

// 定义加载对象的静态函数
static mp_obj_t load_obj(mp_reader_t *reader) {
   
    byte obj_type = read_byte(reader);
    #if MICROPY_EMIT_MACHINE_CODE
    if (obj_type == MP_PERSISTENT_OBJ_FUN_TABLE) {
   
        return MP_OBJ_FROM_PTR(&mp_fun_table);
    } else
    #endif
    if (obj_type == MP_PERSISTENT_OBJ_NONE) {
   
        return mp_const_none;
    } else if (obj_type == MP_PERSISTENT_OBJ_FALSE) {
   
        return mp_const_false;
    } else if (obj_type == MP_PERSISTENT_OBJ_TRUE) {
   
        return mp_const_true;
    } else if (obj_type == MP_PERSISTENT_OBJ_ELLIPSIS) {
   
        return MP_OBJ_FROM_PTR(&mp_const_ellipsis_obj);
    } else {
   
        size_t len = read_uint(reader);
        if (len == 0 && obj_type == MP_PERSISTENT_OBJ_BYTES) {
   
            read_byte(reader); // 跳过空终止符
            return mp_const_empty_bytes;
        } else if (obj_type == MP_PERSISTENT_OBJ_TUPLE) {
   
            mp_obj_tuple_t *tuple =