tools/mpy_ld.py: Add new mpy_ld.py tool and associated build files.
This commit adds a new tool called mpy_ld.py which is essentially a linker that builds .mpy files directly from .o files. A new header file (dynruntime.h) and makefile fragment (dynruntime.mk) are also included which allow building .mpy files from C source code. Such .mpy files can then be dynamically imported as though they were a normal Python module, even though they are implemented in C. Converting .o files directly (rather than pre-linked .elf files) allows the resulting .mpy to be more efficient because it has more control over the relocations; for example it can skip PLT indirection. Doing it this way also allows supporting more architectures, such as Xtensa which has specific needs for position-independent code and the GOT. The tool supports targets of x86, x86-64, ARM Thumb and Xtensa (windowed and non-windowed). BSS, text and rodata sections are supported, with relocations to all internal sections and symbols, as well as relocations to some external symbols (defined by dynruntime.h), and linking of qstrs.
This commit is contained in:
Damien George
parent
27879844d2
commit
aad79adab7
193
py/dynruntime.h
Normal file
193
py/dynruntime.h
Normal file
@ -0,0 +1,193 @@
|
||||
/*
|
||||
* This file is part of the MicroPython project, http://micropython.org/
|
||||
*
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Copyright (c) 2019 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.
|
||||
*/
|
||||
#ifndef MICROPY_INCLUDED_PY_DYNRUNTIME_H
|
||||
#define MICROPY_INCLUDED_PY_DYNRUNTIME_H
|
||||
|
||||
// This header file contains definitions to dynamically implement the static
|
||||
// MicroPython runtime API defined in py/obj.h and py/runtime.h.
|
||||
|
||||
#include "py/nativeglue.h"
|
||||
#include "py/objstr.h"
|
||||
|
||||
#undef MP_ROM_QSTR
|
||||
#undef MP_OBJ_QSTR_VALUE
|
||||
#undef MP_OBJ_NEW_QSTR
|
||||
#undef mp_const_none
|
||||
#undef mp_const_false
|
||||
#undef mp_const_true
|
||||
#undef mp_const_empty_tuple
|
||||
#undef nlr_raise
|
||||
|
||||
/******************************************************************************/
|
||||
// Memory allocation
|
||||
|
||||
#define m_malloc(n) (m_malloc_dyn((n)))
|
||||
#define m_free(ptr) (m_free_dyn((ptr)))
|
||||
#define m_realloc(ptr, new_num_bytes) (m_realloc_dyn((ptr), (new_num_bytes)))
|
||||
|
||||
static inline void *m_malloc_dyn(size_t n) {
|
||||
// TODO won't raise on OOM
|
||||
return mp_fun_table.realloc_(NULL, n, false);
|
||||
}
|
||||
|
||||
static inline void m_free_dyn(void *ptr) {
|
||||
mp_fun_table.realloc_(ptr, 0, false);
|
||||
}
|
||||
|
||||
static inline void *m_realloc_dyn(void *ptr, size_t new_num_bytes) {
|
||||
// TODO won't raise on OOM
|
||||
return mp_fun_table.realloc_(ptr, new_num_bytes, true);
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
// Printing
|
||||
|
||||
#define mp_plat_print (*mp_fun_table.plat_print)
|
||||
#define mp_printf(p, ...) (mp_fun_table.printf_((p), __VA_ARGS__))
|
||||
#define mp_vprintf(p, fmt, args) (mp_fun_table.vprintf_((p), (fmt), (args)))
|
||||
|
||||
/******************************************************************************/
|
||||
// Types and objects
|
||||
|
||||
#define MP_OBJ_NEW_QSTR(x) MP_OBJ_NEW_QSTR_ ## x
|
||||
|
||||
#define mp_type_type (*mp_fun_table.type_type)
|
||||
#define mp_type_str (*mp_fun_table.type_str)
|
||||
#define mp_type_list (*mp_fun_table.type_list)
|
||||
#define mp_type_EOFError (*(mp_obj_type_t*)(mp_load_global(MP_QSTR_EOFError)))
|
||||
#define mp_type_IndexError (*(mp_obj_type_t*)(mp_load_global(MP_QSTR_IndexError)))
|
||||
#define mp_type_KeyError (*(mp_obj_type_t*)(mp_load_global(MP_QSTR_KeyError)))
|
||||
#define mp_type_NotImplementedError (*(mp_obj_type_t*)(mp_load_global(MP_QSTR_NotImplementedError)))
|
||||
#define mp_type_RuntimeError (*(mp_obj_type_t*)(mp_load_global(MP_QSTR_RuntimeError)))
|
||||
#define mp_type_TypeError (*(mp_obj_type_t*)(mp_load_global(MP_QSTR_TypeError)))
|
||||
#define mp_type_ValueError (*(mp_obj_type_t*)(mp_load_global(MP_QSTR_ValueError)))
|
||||
|
||||
#define mp_stream_read_obj (*mp_fun_table.stream_read_obj)
|
||||
#define mp_stream_readinto_obj (*mp_fun_table.stream_readinto_obj)
|
||||
#define mp_stream_unbuffered_readline_obj (*mp_fun_table.stream_unbuffered_readline_obj)
|
||||
#define mp_stream_write_obj (*mp_fun_table.stream_write_obj)
|
||||
|
||||
#define mp_const_none ((mp_obj_t)mp_fun_table.const_none)
|
||||
#define mp_const_false ((mp_obj_t)mp_fun_table.const_false)
|
||||
#define mp_const_true ((mp_obj_t)mp_fun_table.const_true)
|
||||
#define mp_const_empty_tuple (mp_fun_table.new_tuple(0, NULL))
|
||||
|
||||
#define mp_obj_new_bool(b) ((b) ? (mp_obj_t)mp_fun_table.const_true : (mp_obj_t)mp_fun_table.const_false)
|
||||
#define mp_obj_new_int(i) (mp_fun_table.native_to_obj(i, MP_NATIVE_TYPE_INT))
|
||||
#define mp_obj_new_str(data, len) (mp_fun_table.obj_new_str((data), (len)))
|
||||
#define mp_obj_new_str_of_type(t, d, l) (mp_obj_new_str_of_type_dyn((t), (d), (l)))
|
||||
#define mp_obj_new_bytes(data, len) (mp_fun_table.obj_new_bytes((data), (len)))
|
||||
#define mp_obj_new_bytearray_by_ref(n, i) (mp_fun_table.obj_new_bytearray_by_ref((n), (i)))
|
||||
#define mp_obj_new_tuple(n, items) (mp_fun_table.new_tuple((n), (items)))
|
||||
#define mp_obj_new_list(n, items) (mp_fun_table.new_list((n), (items)))
|
||||
|
||||
#define mp_obj_get_type(o) (mp_fun_table.obj_get_type((o)))
|
||||
#define mp_obj_get_int(o) (mp_fun_table.native_from_obj(o, MP_NATIVE_TYPE_INT))
|
||||
#define mp_obj_str_get_str(s) ((void*)mp_fun_table.native_from_obj(s, MP_NATIVE_TYPE_PTR))
|
||||
#define mp_obj_str_get_data(o, len) (mp_obj_str_get_data_dyn((o), (len)))
|
||||
#define mp_get_buffer_raise(o, bufinfo, fl) (mp_fun_table.get_buffer_raise((o), (bufinfo), (fl)))
|
||||
#define mp_get_stream_raise(s, flags) (mp_fun_table.get_stream_raise((s), (flags)))
|
||||
|
||||
#define mp_obj_list_append(list, item) (mp_fun_table.list_append((list), (item)))
|
||||
|
||||
static inline mp_obj_t mp_obj_new_str_of_type_dyn(const mp_obj_type_t *type, const byte* data, size_t len) {
|
||||
if (type == &mp_type_str) {
|
||||
return mp_obj_new_str((const char*)data, len);
|
||||
} else {
|
||||
return mp_obj_new_bytes(data, len);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void *mp_obj_str_get_data_dyn(mp_obj_t o, size_t *l) {
|
||||
mp_buffer_info_t bufinfo;
|
||||
mp_get_buffer_raise(o, &bufinfo, MP_BUFFER_READ);
|
||||
*l = bufinfo.len;
|
||||
return bufinfo.buf;
|
||||
}
|
||||
|
||||
/******************************************************************************/
|
||||
// General runtime functions
|
||||
|
||||
#define mp_load_name(qst) (mp_fun_table.load_name(qst))
|
||||
#define mp_load_global(qst) (mp_fun_table.load_global(qst))
|
||||
#define mp_store_global(qst, obj) (mp_fun_table.store_global((qst), (obj)))
|
||||
#define mp_unary_op(op, obj) (mp_fun_table.unary_op((op), (obj)))
|
||||
#define mp_binary_op(op, lhs, rhs) (mp_fun_table.binary_op((op), (lhs), (rhs)))
|
||||
|
||||
#define mp_make_function_from_raw_code(rc, def_args, def_kw_args) \
|
||||
(mp_fun_table.make_function_from_raw_code((rc), (def_args), (def_kw_args)))
|
||||
|
||||
#define mp_call_function_n_kw(fun, n_args, n_kw, args) \
|
||||
(mp_fun_table.call_function_n_kw((fun), (n_args) | ((n_kw) << 8), args))
|
||||
|
||||
#define mp_arg_check_num(n_args, n_kw, n_args_min, n_args_max, takes_kw) \
|
||||
(mp_fun_table.arg_check_num_sig((n_args), (n_kw), MP_OBJ_FUN_MAKE_SIG((n_args_min), (n_args_max), (takes_kw))))
|
||||
|
||||
#define MP_DYNRUNTIME_INIT_ENTRY \
|
||||
mp_obj_t old_globals = mp_fun_table.swap_globals(self->globals); \
|
||||
mp_raw_code_t rc; \
|
||||
rc.kind = MP_CODE_NATIVE_VIPER; \
|
||||
rc.scope_flags = 0; \
|
||||
rc.const_table = (void*)self->const_table; \
|
||||
(void)rc;
|
||||
|
||||
#define MP_DYNRUNTIME_INIT_EXIT \
|
||||
mp_fun_table.swap_globals(old_globals); \
|
||||
return mp_const_none;
|
||||
|
||||
#define MP_DYNRUNTIME_MAKE_FUNCTION(f) \
|
||||
(mp_make_function_from_raw_code((rc.fun_data = (f), &rc), MP_OBJ_NULL, MP_OBJ_NULL))
|
||||
|
||||
/******************************************************************************/
|
||||
// Exceptions
|
||||
|
||||
#define mp_obj_new_exception(o) ((mp_obj_t)(o)) // Assumes returned object will be raised, will create instance then
|
||||
#define mp_obj_new_exception_arg1(e_type, arg) (mp_obj_new_exception_arg1_dyn((e_type), (arg)))
|
||||
|
||||
#define nlr_raise(o) (mp_raise_dyn(o))
|
||||
#define mp_raise_msg(type, msg) (mp_fun_table.raise_msg((type), (msg)))
|
||||
#define mp_raise_OSError(er) (mp_raise_OSError_dyn(er))
|
||||
#define mp_raise_NotImplementedError(msg) (mp_raise_msg(&mp_type_NotImplementedError, (msg)))
|
||||
#define mp_raise_TypeError(msg) (mp_raise_msg(&mp_type_TypeError, (msg)))
|
||||
#define mp_raise_ValueError(msg) (mp_raise_msg(&mp_type_ValueError, (msg)))
|
||||
|
||||
static inline mp_obj_t mp_obj_new_exception_arg1_dyn(const mp_obj_type_t *exc_type, mp_obj_t arg) {
|
||||
mp_obj_t args[1] = { arg };
|
||||
return mp_call_function_n_kw(MP_OBJ_FROM_PTR(exc_type), 1, 0, &args[0]);
|
||||
}
|
||||
|
||||
static NORETURN inline void mp_raise_dyn(mp_obj_t o) {
|
||||
mp_fun_table.raise(o);
|
||||
for (;;) {
|
||||
}
|
||||
}
|
||||
|
||||
static inline void mp_raise_OSError_dyn(int er) {
|
||||
mp_obj_t args[1] = { MP_OBJ_NEW_SMALL_INT(er) };
|
||||
nlr_raise(mp_call_function_n_kw(mp_load_global(MP_QSTR_OSError), 1, 0, &args[0]));
|
||||
}
|
||||
|
||||
#endif // MICROPY_INCLUDED_PY_DYNRUNTIME_H
|
||||
134
py/dynruntime.mk
Normal file
134
py/dynruntime.mk
Normal file
@ -0,0 +1,134 @@
|
||||
# Makefile fragment for generating native .mpy files from C source
|
||||
# MPY_DIR must be set to the top of the MicroPython source tree
|
||||
|
||||
BUILD ?= build
|
||||
|
||||
ECHO = @echo
|
||||
RM = /bin/rm
|
||||
MKDIR = /bin/mkdir
|
||||
PYTHON = python3
|
||||
MPY_CROSS = $(MPY_DIR)/mpy-cross/mpy-cross
|
||||
MPY_TOOL = $(PYTHON) $(MPY_DIR)/tools/mpy-tool.py
|
||||
MPY_LD = $(PYTHON) $(MPY_DIR)/tools/mpy_ld.py
|
||||
|
||||
Q = @
|
||||
ifeq ("$(origin V)", "command line")
|
||||
ifeq ($(V),1)
|
||||
Q =
|
||||
MPY_LD += '-vvv'
|
||||
endif
|
||||
endif
|
||||
|
||||
ARCH_UPPER = $(shell echo $(ARCH) | tr '[:lower:]' '[:upper:]')
|
||||
CONFIG_H = $(BUILD)/$(MOD).config.h
|
||||
|
||||
CFLAGS += -I. -I$(MPY_DIR)
|
||||
CFLAGS += -std=c99
|
||||
CFLAGS += -Os
|
||||
CFLAGS += -Wall -Werror -DNDEBUG
|
||||
CFLAGS += -DNO_QSTR
|
||||
CFLAGS += -DMP_CONFIGFILE='<$(CONFIG_H)>'
|
||||
CFLAGS += -fpic -fno-common
|
||||
CFLAGS += -U _FORTIFY_SOURCE # prevent use of __*_chk libc functions
|
||||
#CFLAGS += -fdata-sections -ffunction-sections
|
||||
|
||||
MPY_CROSS_FLAGS += -march=$(ARCH)
|
||||
|
||||
SRC_O += $(addprefix $(BUILD)/, $(patsubst %.c,%.o,$(filter %.c,$(SRC))))
|
||||
SRC_MPY += $(addprefix $(BUILD)/, $(patsubst %.py,%.mpy,$(filter %.py,$(SRC))))
|
||||
|
||||
################################################################################
|
||||
# Architecture configuration
|
||||
|
||||
ifeq ($(ARCH),x86)
|
||||
|
||||
# x86
|
||||
CROSS =
|
||||
CFLAGS += -m32 -fno-stack-protector
|
||||
MPY_CROSS_FLAGS += -mcache-lookup-bc
|
||||
|
||||
else ifeq ($(ARCH),x64)
|
||||
|
||||
# x64
|
||||
CROSS =
|
||||
CFLAGS += -fno-stack-protector
|
||||
MPY_CROSS_FLAGS += -mcache-lookup-bc
|
||||
|
||||
else ifeq ($(ARCH),armv7m)
|
||||
|
||||
# thumb
|
||||
CROSS = arm-none-eabi-
|
||||
CFLAGS += -mthumb -mcpu=cortex-m3
|
||||
|
||||
else ifeq ($(ARCH),armv7emsp)
|
||||
|
||||
# thumb
|
||||
CROSS = arm-none-eabi-
|
||||
CFLAGS += -mthumb -mcpu=cortex-m4
|
||||
CFLAGS += -mfpu=fpv4-sp-d16 -mfloat-abi=hard
|
||||
|
||||
else ifeq ($(ARCH),armv7emdp)
|
||||
|
||||
# thumb
|
||||
CROSS = arm-none-eabi-
|
||||
CFLAGS += -mthumb -mcpu=cortex-m7
|
||||
CFLAGS += -mfpu=fpv5-d16 -mfloat-abi=hard
|
||||
|
||||
else ifeq ($(ARCH),xtensa)
|
||||
|
||||
# xtensa
|
||||
CROSS = xtensa-lx106-elf-
|
||||
CFLAGS += -mforce-l32
|
||||
|
||||
else ifeq ($(ARCH),xtensawin)
|
||||
|
||||
# xtensawin
|
||||
CROSS = xtensa-esp32-elf-
|
||||
CFLAGS +=
|
||||
|
||||
else
|
||||
$(error architecture '$(ARCH)' not supported)
|
||||
endif
|
||||
|
||||
CFLAGS += $(CFLAGS_EXTRA)
|
||||
|
||||
################################################################################
|
||||
# Build rules
|
||||
|
||||
.PHONY: all clean
|
||||
|
||||
all: $(MOD).mpy
|
||||
|
||||
clean:
|
||||
$(RM) -rf $(BUILD) $(CLEAN_EXTRA)
|
||||
|
||||
# Create build destination directories first
|
||||
BUILD_DIRS = $(sort $(dir $(CONFIG_H) $(SRC_O) $(SRC_MPY)))
|
||||
$(CONFIG_H) $(SRC_O) $(SRC_MPY): | $(BUILD_DIRS)
|
||||
$(BUILD_DIRS):
|
||||
$(Q)$(MKDIR) -p $@
|
||||
|
||||
# Preprocess all source files to generate $(CONFIG_H)
|
||||
$(CONFIG_H): $(SRC)
|
||||
$(ECHO) "GEN $@"
|
||||
$(Q)$(MPY_LD) --arch $(ARCH) --preprocess -o $@ $^
|
||||
|
||||
# Build .o from .c source files
|
||||
$(BUILD)/%.o: %.c $(CONFIG_H) Makefile
|
||||
$(ECHO) "CC $<"
|
||||
$(Q)$(CROSS)gcc $(CFLAGS) -o $@ -c $<
|
||||
|
||||
# Build .mpy from .py source files
|
||||
$(BUILD)/%.mpy: %.py
|
||||
$(ECHO) "MPY $<"
|
||||
$(Q)$(MPY_CROSS) $(MPY_CROSS_FLAGS) -o $@ $<
|
||||
|
||||
# Build native .mpy from object files
|
||||
$(BUILD)/$(MOD).native.mpy: $(SRC_O)
|
||||
$(ECHO) "LINK $<"
|
||||
$(Q)$(MPY_LD) --arch $(ARCH) --qstrs $(CONFIG_H) -o $@ $^
|
||||
|
||||
# Build final .mpy from all intermediate .mpy files
|
||||
$(MOD).mpy: $(BUILD)/$(MOD).native.mpy $(SRC_MPY)
|
||||
$(ECHO) "GEN $@"
|
||||
$(Q)$(MPY_TOOL) --merge -o $@ $^
|
||||
978
tools/mpy_ld.py
Executable file
978
tools/mpy_ld.py
Executable file
@ -0,0 +1,978 @@
|
||||
#!/usr/bin/env python3
|
||||
#
|
||||
# This file is part of the MicroPython project, http://micropython.org/
|
||||
#
|
||||
# The MIT License (MIT)
|
||||
#
|
||||
# Copyright (c) 2019 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.
|
||||
|
||||
"""
|
||||
Link .o files to .mpy
|
||||
"""
|
||||
|
||||
import sys, os, struct, re
|
||||
from elftools.elf import elffile
|
||||
|
||||
sys.path.append(os.path.dirname(__file__) + '/../py')
|
||||
import makeqstrdata as qstrutil
|
||||
|
||||
# MicroPython constants
|
||||
MPY_VERSION = 5
|
||||
MP_NATIVE_ARCH_X86 = 1
|
||||
MP_NATIVE_ARCH_X64 = 2
|
||||
MP_NATIVE_ARCH_ARMV7M = 5
|
||||
MP_NATIVE_ARCH_ARMV7EMSP = 7
|
||||
MP_NATIVE_ARCH_ARMV7EMDP = 8
|
||||
MP_NATIVE_ARCH_XTENSA = 9
|
||||
MP_NATIVE_ARCH_XTENSAWIN = 10
|
||||
MP_CODE_BYTECODE = 2
|
||||
MP_CODE_NATIVE_VIPER = 4
|
||||
MP_SCOPE_FLAG_VIPERRELOC = 0x10
|
||||
MP_SCOPE_FLAG_VIPERRODATA = 0x20
|
||||
MP_SCOPE_FLAG_VIPERBSS = 0x40
|
||||
MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE = 1
|
||||
MICROPY_PY_BUILTINS_STR_UNICODE = 2
|
||||
MP_SMALL_INT_BITS = 31
|
||||
QSTR_WINDOW_SIZE = 32
|
||||
|
||||
# ELF constants
|
||||
R_386_32 = 1
|
||||
R_X86_64_64 = 1
|
||||
R_XTENSA_32 = 1
|
||||
R_386_PC32 = 2
|
||||
R_X86_64_PC32 = 2
|
||||
R_ARM_ABS32 = 2
|
||||
R_386_GOT32 = 3
|
||||
R_ARM_REL32 = 3
|
||||
R_386_PLT32 = 4
|
||||
R_X86_64_PLT32 = 4
|
||||
R_XTENSA_PLT = 6
|
||||
R_386_GOTOFF = 9
|
||||
R_386_GOTPC = 10
|
||||
R_ARM_THM_CALL = 10
|
||||
R_XTENSA_DIFF32 = 19
|
||||
R_XTENSA_SLOT0_OP = 20
|
||||
R_ARM_BASE_PREL = 25 # aka R_ARM_GOTPC
|
||||
R_ARM_GOT_BREL = 26 # aka R_ARM_GOT32
|
||||
R_ARM_THM_JUMP24 = 30
|
||||
R_X86_64_REX_GOTPCRELX = 42
|
||||
R_386_GOT32X = 43
|
||||
|
||||
################################################################################
|
||||
# Architecture configuration
|
||||
|
||||
def asm_jump_x86(entry):
|
||||
return struct.pack('<BI', 0xe9, entry - 5)
|
||||
|
||||
def asm_jump_arm(entry):
|
||||
b_off = entry - 4
|
||||
if b_off >> 11 == 0 or b_off >> 11 == -1:
|
||||
# Signed value fits in 12 bits
|
||||
b0 = 0xe000 | (b_off >> 1 & 0x07ff)
|
||||
b1 = 0
|
||||
else:
|
||||
# Use large jump
|
||||
b0 = 0xf000 | (b_off >> 12 & 0x07ff)
|
||||
b1 = 0xb800 | (b_off >> 1 & 0x7ff)
|
||||
return struct.pack('<HH', b0, b1)
|
||||
|
||||
def asm_jump_xtensa(entry):
|
||||
jump_offset = entry - 4
|
||||
jump_op = jump_offset << 6 | 6
|
||||
return struct.pack('<BH', jump_op & 0xff, jump_op >> 8)
|
||||
|
||||
class ArchData:
|
||||
def __init__(self, name, mpy_feature, qstr_entry_size, word_size, arch_got, asm_jump):
|
||||
self.name = name
|
||||
self.mpy_feature = mpy_feature
|
||||
self.qstr_entry_size = qstr_entry_size
|
||||
self.word_size = word_size
|
||||
self.arch_got = arch_got
|
||||
self.asm_jump = asm_jump
|
||||
self.separate_rodata = name == 'EM_XTENSA' and qstr_entry_size == 4
|
||||
|
||||
ARCH_DATA = {
|
||||
'x86': ArchData(
|
||||
'EM_386',
|
||||
MP_NATIVE_ARCH_X86 << 2 | MICROPY_PY_BUILTINS_STR_UNICODE | MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE,
|
||||
2, 4, (R_386_PC32, R_386_GOT32, R_386_GOT32X), asm_jump_x86,
|
||||
),
|
||||
'x64': ArchData(
|
||||
'EM_X86_64',
|
||||
MP_NATIVE_ARCH_X64 << 2 | MICROPY_PY_BUILTINS_STR_UNICODE | MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE,
|
||||
2, 8, (R_X86_64_REX_GOTPCRELX,), asm_jump_x86,
|
||||
),
|
||||
'armv7m': ArchData(
|
||||
'EM_ARM',
|
||||
MP_NATIVE_ARCH_ARMV7M << 2 | MICROPY_PY_BUILTINS_STR_UNICODE,
|
||||
2, 4, (R_ARM_GOT_BREL,), asm_jump_arm,
|
||||
),
|
||||
'armv7emsp': ArchData(
|
||||
'EM_ARM',
|
||||
MP_NATIVE_ARCH_ARMV7EMSP << 2 | MICROPY_PY_BUILTINS_STR_UNICODE,
|
||||
2, 4, (R_ARM_GOT_BREL,), asm_jump_arm,
|
||||
),
|
||||
'armv7emdp': ArchData(
|
||||
'EM_ARM',
|
||||
MP_NATIVE_ARCH_ARMV7EMDP << 2 | MICROPY_PY_BUILTINS_STR_UNICODE,
|
||||
2, 4, (R_ARM_GOT_BREL,), asm_jump_arm,
|
||||
),
|
||||
'xtensa': ArchData(
|
||||
'EM_XTENSA',
|
||||
MP_NATIVE_ARCH_XTENSA << 2 | MICROPY_PY_BUILTINS_STR_UNICODE,
|
||||
2, 4, (R_XTENSA_32, R_XTENSA_PLT), asm_jump_xtensa,
|
||||
),
|
||||
'xtensawin': ArchData(
|
||||
'EM_XTENSA',
|
||||
MP_NATIVE_ARCH_XTENSAWIN << 2 | MICROPY_PY_BUILTINS_STR_UNICODE,
|
||||
4, 4, (R_XTENSA_32, R_XTENSA_PLT), asm_jump_xtensa,
|
||||
),
|
||||
}
|
||||
|
||||
################################################################################
|
||||
# Helper functions
|
||||
|
||||
def align_to(value, align):
|
||||
return (value + align - 1) & ~(align - 1)
|
||||
|
||||
def unpack_u24le(data, offset):
|
||||
return data[offset] | data[offset + 1] << 8 | data[offset + 2] << 16
|
||||
|
||||
def pack_u24le(data, offset, value):
|
||||
data[offset] = value & 0xff
|
||||
data[offset + 1] = value >> 8 & 0xff
|
||||
data[offset + 2] = value >> 16 & 0xff
|
||||
|
||||
def xxd(text):
|
||||
for i in range(0, len(text), 16):
|
||||
print('{:08x}:'.format(i), end='')
|
||||
for j in range(4):
|
||||
off = i + j * 4
|
||||
if off < len(text):
|
||||
d = int.from_bytes(text[off:off + 4], 'little')
|
||||
print(' {:08x}'.format(d), end='')
|
||||
print()
|
||||
|
||||
# Smaller numbers are enabled first
|
||||
LOG_LEVEL_1 = 1
|
||||
LOG_LEVEL_2 = 2
|
||||
LOG_LEVEL_3 = 3
|
||||
log_level = LOG_LEVEL_1
|
||||
|
||||
def log(level, msg):
|
||||
if level <= log_level:
|
||||
print(msg)
|
||||
|
||||
################################################################################
|
||||
# Qstr extraction
|
||||
|
||||
def extract_qstrs(source_files):
|
||||
def read_qstrs(f):
|
||||
with open(f) as f:
|
||||
vals = set()
|
||||
objs = set()
|
||||
for line in f:
|
||||
while line:
|
||||
m = re.search(r'MP_OBJ_NEW_QSTR\((MP_QSTR_[A-Za-z0-9_]*)\)', line)
|
||||
if m:
|
||||
objs.add(m.group(1))
|
||||
else:
|
||||
m = re.search(r'MP_QSTR_[A-Za-z0-9_]*', line)
|
||||
if m:
|
||||
vals.add(m.group())
|
||||
if m:
|
||||
s = m.span()
|
||||
line = line[:s[0]] + line[s[1]:]
|
||||
else:
|
||||
line = ''
|
||||
return vals, objs
|
||||
|
||||
static_qstrs = ['MP_QSTR_' + qstrutil.qstr_escape(q) for q in qstrutil.static_qstr_list]
|
||||
|
||||
qstr_vals = set()
|
||||
qstr_objs = set()
|
||||
for f in source_files:
|
||||
vals, objs = read_qstrs(f)
|
||||
qstr_vals.update(vals)
|
||||
qstr_objs.update(objs)
|
||||
qstr_vals.difference_update(static_qstrs)
|
||||
|
||||
return static_qstrs, qstr_vals, qstr_objs
|
||||
|
||||
################################################################################
|
||||
# Linker
|
||||
|
||||
class LinkError(Exception):
|
||||
pass
|
||||
|
||||
class Section:
|
||||
def __init__(self, name, data, alignment, filename=None):
|
||||
self.filename = filename
|
||||
self.name = name
|
||||
self.data = data
|
||||
self.alignment = alignment
|
||||
self.addr = 0
|
||||
self.reloc = []
|
||||
|
||||
@staticmethod
|
||||
def from_elfsec(elfsec, filename):
|
||||
assert elfsec.header.sh_addr == 0
|
||||
return Section(elfsec.name, elfsec.data(), elfsec.data_alignment, filename)
|
||||
|
||||
class GOTEntry:
|
||||
def __init__(self, name, sym, link_addr=0):
|
||||
self.name = name
|
||||
self.sym = sym
|
||||
self.offset = None
|
||||
self.link_addr = link_addr
|
||||
|
||||
def isexternal(self):
|
||||
return self.sec_name.startswith('.external')
|
||||
|
||||
def istext(self):
|
||||
return self.sec_name.startswith('.text')
|
||||
|
||||
def isrodata(self):
|
||||
return self.sec_name.startswith(('.rodata', '.data.rel.ro'))
|
||||
|
||||
def isbss(self):
|
||||
return self.sec_name.startswith('.bss')
|
||||
|
||||
class LiteralEntry:
|
||||
def __init__(self, value, offset):
|
||||
self.value = value
|
||||
self.offset = offset
|
||||
|
||||
class LinkEnv:
|
||||
def __init__(self, arch):
|
||||
self.arch = ARCH_DATA[arch]
|
||||
self.sections = [] # list of sections in order of output
|
||||
self.literal_sections = [] # list of literal sections (xtensa only)
|
||||
self.known_syms = {} # dict of symbols that are defined
|
||||
self.unresolved_syms = [] # list of unresolved symbols
|
||||
self.mpy_relocs = [] # list of relocations needed in the output .mpy file
|
||||
|
||||
def check_arch(self, arch_name):
|
||||
if arch_name != self.arch.name:
|
||||
raise LinkError('incompatible arch')
|
||||
|
||||
def print_sections(self):
|
||||
log(LOG_LEVEL_2, 'sections:')
|
||||
for sec in self.sections:
|
||||
log(LOG_LEVEL_2, ' {:08x} {} size={}'.format(sec.addr, sec.name, len(sec.data)))
|
||||
|
||||
def find_addr(self, name):
|
||||
if name in self.known_syms:
|
||||
s = self.known_syms[name]
|
||||
return s.section.addr + s['st_value']
|
||||
raise LinkError('unknown symbol: {}'.format(name))
|
||||
|
||||
def build_got_generic(env):
|
||||
env.got_entries = {}
|
||||
for sec in env.sections:
|
||||
for r in sec.reloc:
|
||||
s = r.sym
|
||||
if not (s.entry['st_info']['bind'] == 'STB_GLOBAL' and r['r_info_type'] in env.arch.arch_got):
|
||||
continue
|
||||
s_type = s.entry['st_info']['type']
|
||||
assert s_type in ('STT_NOTYPE', 'STT_FUNC', 'STT_OBJECT'), s_type
|
||||
assert s.name
|
||||
if s.name in env.got_entries:
|
||||
continue
|
||||
env.got_entries[s.name] = GOTEntry(s.name, s)
|
||||
|
||||
def build_got_xtensa(env):
|
||||
env.got_entries = {}
|
||||
env.lit_entries = {}
|
||||
env.xt_literals = {}
|
||||
|
||||
# Extract the values from the literal table
|
||||
for sec in env.literal_sections:
|
||||
assert len(sec.data) % env.arch.word_size == 0
|
||||
|
||||
# Look through literal relocations to find any global pointers that should be GOT entries
|
||||
for r in sec.reloc:
|
||||
s = r.sym
|
||||
s_type = s.entry['st_info']['type']
|
||||
assert s_type in ('STT_NOTYPE', 'STT_FUNC', 'STT_OBJECT', 'STT_SECTION'), s_type
|
||||
assert r['r_info_type'] in env.arch.arch_got
|
||||
assert r['r_offset'] % env.arch.word_size == 0
|
||||
# This entry is a global pointer
|
||||
existing = struct.unpack_from('<I', sec.data, r['r_offset'])[0]
|
||||
if s_type == 'STT_SECTION':
|
||||
assert r['r_addend'] == 0
|
||||
name = "{}+0x{:x}".format(s.section.name, existing)
|
||||
else:
|
||||
assert existing == 0
|
||||
name = s.name
|
||||
if r['r_addend'] != 0:
|
||||
name = "{}+0x{:x}".format(name, r['r_addend'])
|
||||
idx = '{}+0x{:x}'.format(sec.filename, r['r_offset'])
|
||||
env.xt_literals[idx] = name
|
||||
if name in env.got_entries:
|
||||
# Deduplicate GOT entries
|
||||
continue
|
||||
env.got_entries[name] = GOTEntry(name, s, existing)
|
||||
|
||||
# Go through all literal entries finding those that aren't global pointers so must be actual literals
|
||||
for i in range(0, len(sec.data), env.arch.word_size):
|
||||
idx = '{}+0x{:x}'.format(sec.filename, i)
|
||||
if idx not in env.xt_literals:
|
||||
# This entry is an actual literal
|
||||
value = struct.unpack_from('<I', sec.data, i)[0]
|
||||
env.xt_literals[idx] = value
|
||||
if value in env.lit_entries:
|
||||
# Deduplicate literals
|
||||
continue
|
||||
env.lit_entries[value] = LiteralEntry(value, len(env.lit_entries) * env.arch.word_size)
|
||||
|
||||
def populate_got(env):
|
||||
# Compute GOT destination addresses
|
||||
for got_entry in env.got_entries.values():
|
||||
sym = got_entry.sym
|
||||
if hasattr(sym, 'resolved'):
|
||||
sym = sym.resolved
|
||||
sec = sym.section
|
||||
addr = sym['st_value']
|
||||
got_entry.sec_name = sec.name
|
||||
got_entry.link_addr += sec.addr + addr
|
||||
|
||||
# Get sorted GOT, sorted by external, text, rodata, bss so relocations can be combined
|
||||
got_list = sorted(env.got_entries.values(),
|
||||
key=lambda g: g.isexternal() + 2 * g.istext() + 3 * g.isrodata() + 4 * g.isbss())
|
||||
|
||||
# Layout and populate the GOT
|
||||
offset = 0
|
||||
for got_entry in got_list:
|
||||
got_entry.offset = offset
|
||||
offset += env.arch.word_size
|
||||
o = env.got_section.addr + got_entry.offset
|
||||
env.full_text[o:o + env.arch.word_size] = got_entry.link_addr.to_bytes(env.arch.word_size, 'little')
|
||||
|
||||
# Create a relocation for each GOT entry
|
||||
for got_entry in got_list:
|
||||
if got_entry.name == 'mp_fun_table':
|
||||
dest = 'mp_fun_table'
|
||||
elif got_entry.name.startswith('mp_fun_table+0x'):
|
||||
dest = int(got_entry.name.split('+')[1], 16) // env.arch.word_size
|
||||
elif got_entry.sec_name.startswith('.text'):
|
||||
dest = '.text'
|
||||
elif got_entry.sec_name.startswith('.rodata'):
|
||||
dest = '.rodata'
|
||||
elif got_entry.sec_name.startswith('.data.rel.ro'):
|
||||
dest = '.data.rel.ro'
|
||||
elif got_entry.sec_name.startswith('.bss'):
|
||||
dest = '.bss'
|
||||
else:
|
||||
assert 0, (got_entry.name, got_entry.sec_name)
|
||||
env.mpy_relocs.append(('.text', env.got_section.addr + got_entry.offset, dest))
|
||||
|
||||
# Print out the final GOT
|
||||
log(LOG_LEVEL_2, 'GOT: {:08x}'.format(env.got_section.addr))
|
||||
for g in got_list:
|
||||
log(LOG_LEVEL_2, ' {:08x} {} -> {}+{:08x}'.format(g.offset, g.name, g.sec_name, g.link_addr))
|
||||
|
||||
def populate_lit(env):
|
||||
log(LOG_LEVEL_2, 'LIT: {:08x}'.format(env.lit_section.addr))
|
||||
for lit_entry in env.lit_entries.values():
|
||||
value = lit_entry.value
|
||||
log(LOG_LEVEL_2, ' {:08x} = {:08x}'.format(lit_entry.offset, value))
|
||||
o = env.lit_section.addr + lit_entry.offset
|
||||
env.full_text[o:o + env.arch.word_size] = value.to_bytes(env.arch.word_size, 'little')
|
||||
|
||||
def do_relocation_text(env, text_addr, r):
|
||||
# Extract relevant info about symbol that's being relocated
|
||||
s = r.sym
|
||||
s_bind = s.entry['st_info']['bind']
|
||||
s_shndx = s.entry['st_shndx']
|
||||
s_type = s.entry['st_info']['type']
|
||||
r_offset = r['r_offset'] + text_addr
|
||||
r_info_type = r['r_info_type']
|
||||
try:
|
||||
# only for RELA sections
|
||||
r_addend = r['r_addend']
|
||||
except KeyError:
|
||||
r_addend = 0
|
||||
|
||||
# Default relocation type and name for logging
|
||||
reloc_type = 'le32'
|
||||
log_name = None
|
||||
|
||||
if (env.arch.name == 'EM_386' and r_info_type in (R_386_PC32, R_386_PLT32)
|
||||
or env.arch.name == 'EM_X86_64' and r_info_type in (R_X86_64_PC32, R_X86_64_PLT32)
|
||||
or env.arch.name == 'EM_ARM' and r_info_type in (R_ARM_REL32, R_ARM_THM_CALL, R_ARM_THM_JUMP24)
|
||||
or s_bind == 'STB_LOCAL' and env.arch.name == 'EM_XTENSA' and r_info_type == R_XTENSA_32 # not GOT
|
||||
):
|
||||
# Standard relocation to fixed location within text/rodata
|
||||
if hasattr(s, 'resolved'):
|
||||
s = s.resolved
|
||||
|
||||
sec = s.section
|
||||
|
||||
if env.arch.separate_rodata and sec.name.startswith('.rodata'):
|
||||
raise LinkError('fixed relocation to rodata with rodata referenced via GOT')
|
||||
|
||||
if sec.name.startswith('.bss'):
|
||||
raise LinkError('{}: fixed relocation to bss (bss variables can\'t be static)'.format(s.filename))
|
||||
|
||||
if sec.name.startswith('.external'):
|
||||
raise LinkError('{}: fixed relocation to external symbol: {}'.format(s.filename, s.name))
|
||||
|
||||
addr = sec.addr + s['st_value']
|
||||
reloc = addr - r_offset + r_addend
|
||||
|
||||
if r_info_type in (R_ARM_THM_CALL, R_ARM_THM_JUMP24):
|
||||
# Both relocations have the same bit pattern to rewrite:
|
||||
# R_ARM_THM_CALL: bl
|
||||
# R_ARM_THM_JUMP24: b.w
|
||||
reloc_type = 'thumb_b'
|
||||
|
||||
elif (env.arch.name == 'EM_386' and r_info_type == R_386_GOTPC
|
||||
or env.arch.name == 'EM_ARM' and r_info_type == R_ARM_BASE_PREL
|
||||
):
|
||||
# Relocation to GOT address itself
|
||||
assert s.name == '_GLOBAL_OFFSET_TABLE_'
|
||||
addr = env.got_section.addr
|
||||
reloc = addr - r_offset + r_addend
|
||||
|
||||
elif (env.arch.name == 'EM_386' and r_info_type in (R_386_GOT32, R_386_GOT32X)
|
||||
or env.arch.name == 'EM_ARM' and r_info_type == R_ARM_GOT_BREL
|
||||
):
|
||||
# Relcation pointing to GOT
|
||||
reloc = addr = env.got_entries[s.name].offset
|
||||
|
||||
elif env.arch.name == 'EM_X86_64' and r_info_type == R_X86_64_REX_GOTPCRELX:
|
||||
# Relcation pointing to GOT
|
||||
got_entry = env.got_entries[s.name]
|
||||
addr = env.got_section.addr + got_entry.offset
|
||||
reloc = addr - r_offset + r_addend
|
||||
|
||||
elif env.arch.name == 'EM_386' and r_info_type == R_386_GOTOFF:
|
||||
# Relocation relative to GOT
|
||||
addr = s.section.addr + s['st_value']
|
||||
reloc = addr - env.got_section.addr + r_addend
|
||||
|
||||
elif env.arch.name == 'EM_XTENSA' and r_info_type == R_XTENSA_SLOT0_OP:
|
||||
# Relocation pointing to GOT, xtensa specific
|
||||
sec = s.section
|
||||
if sec.name.startswith('.text'):
|
||||
# it looks like R_XTENSA_SLOT0_OP into .text is already correctly relocated
|
||||
return
|
||||
assert sec.name.startswith('.literal'), sec.name
|
||||
lit_idx = '{}+0x{:x}'.format(sec.filename, r_addend)
|
||||
lit_ptr = env.xt_literals[lit_idx]
|
||||
if isinstance(lit_ptr, str):
|
||||
addr = env.got_section.addr + env.got_entries[lit_ptr].offset
|
||||
log_name = 'GOT {}'.format(lit_ptr)
|
||||
else:
|
||||
addr = env.lit_section.addr + env.lit_entries[lit_ptr].offset
|
||||
log_name = 'LIT'
|
||||
reloc = addr - r_offset
|
||||
reloc_type = 'xtensa_l32r'
|
||||
|
||||
elif env.arch.name == 'EM_XTENSA' and r_info_type == R_XTENSA_DIFF32:
|
||||
if s.section.name.startswith('.text'):
|
||||
# it looks like R_XTENSA_DIFF32 into .text is already correctly relocated
|
||||
return
|
||||
assert 0
|
||||
|
||||
else:
|
||||
# Unknown/unsupported relocation
|
||||
assert 0, r_info_type
|
||||
|
||||
# Write relocation
|
||||
if reloc_type == 'le32':
|
||||
existing, = struct.unpack_from('<I', env.full_text, r_offset)
|
||||
struct.pack_into('<I', env.full_text, r_offset, (existing + reloc) & 0xffffffff)
|
||||
elif reloc_type == 'thumb_b':
|
||||
b_h, b_l = struct.unpack_from('<HH', env.full_text, r_offset)
|
||||
existing = (b_h & 0x7ff) << 12 | (b_l & 0x7ff) << 1
|
||||
if existing >= 0x400000: # 2's complement
|
||||
existing -= 0x800000
|
||||
new = existing + reloc
|
||||
b_h = (b_h & 0xf800) | (new >> 12) & 0x7ff
|
||||
b_l = (b_l & 0xf800) | (new >> 1) & 0x7ff
|
||||
struct.pack_into('<HH', env.full_text, r_offset, b_h, b_l)
|
||||
elif reloc_type == 'xtensa_l32r':
|
||||
l32r = unpack_u24le(env.full_text, r_offset)
|
||||
assert l32r & 0xf == 1 # RI16 encoded l32r
|
||||
l32r_imm16 = l32r >> 8
|
||||
l32r_imm16 = (l32r_imm16 + reloc >> 2) & 0xffff
|
||||
l32r = l32r & 0xff | l32r_imm16 << 8
|
||||
pack_u24le(env.full_text, r_offset, l32r)
|
||||
else:
|
||||
assert 0, reloc_type
|
||||
|
||||
# Log information about relocation
|
||||
if log_name is None:
|
||||
if s_type == 'STT_SECTION':
|
||||
log_name = s.section.name
|
||||
else:
|
||||
log_name = s.name
|
||||
log(LOG_LEVEL_3, ' {:08x} {} -> {:08x}'.format(r_offset, log_name, addr))
|
||||
|
||||
def do_relocation_data(env, text_addr, r):
|
||||
s = r.sym
|
||||
s_type = s.entry['st_info']['type']
|
||||
r_offset = r['r_offset'] + text_addr
|
||||
r_info_type = r['r_info_type']
|
||||
try:
|
||||
# only for RELA sections
|
||||
r_addend = r['r_addend']
|
||||
except KeyError:
|
||||
r_addend = 0
|
||||
|
||||
if (env.arch.name == 'EM_386' and r_info_type == R_386_32
|
||||
or env.arch.name == 'EM_X86_64' and r_info_type == R_X86_64_64
|
||||
or env.arch.name == 'EM_ARM' and r_info_type == R_ARM_ABS32
|
||||
or env.arch.name == 'EM_XTENSA' and r_info_type == R_XTENSA_32):
|
||||
# Relocation in data.rel.ro to internal/external symbol
|
||||
if env.arch.word_size == 4:
|
||||
struct_type = '<I'
|
||||
elif env.arch.word_size == 8:
|
||||
struct_type = '<Q'
|
||||
sec = s.section
|
||||
assert r_offset % env.arch.word_size == 0
|
||||
addr = sec.addr + s['st_value'] + r_addend
|
||||
if s_type == 'STT_SECTION':
|
||||
log_name = sec.name
|
||||
else:
|
||||
log_name = s.name
|
||||
log(LOG_LEVEL_3, ' {:08x} -> {} {:08x}'.format(r_offset, log_name, addr))
|
||||
if env.arch.separate_rodata:
|
||||
data = env.full_rodata
|
||||
else:
|
||||
data = env.full_text
|
||||
existing, = struct.unpack_from(struct_type, data, r_offset)
|
||||
if sec.name.startswith(('.text', '.rodata', '.data.rel.ro', '.bss')):
|
||||
struct.pack_into(struct_type, data, r_offset, existing + addr)
|
||||
kind = sec.name
|
||||
elif sec.name == '.external.mp_fun_table':
|
||||
assert addr == 0
|
||||
kind = s.mp_fun_table_offset
|
||||
else:
|
||||
assert 0, sec.name
|
||||
if env.arch.separate_rodata:
|
||||
base = '.rodata'
|
||||
else:
|
||||
base = '.text'
|
||||
env.mpy_relocs.append((base, r_offset, kind))
|
||||
|
||||
else:
|
||||
# Unknown/unsupported relocation
|
||||
assert 0, r_info_type
|
||||
|
||||
def load_object_file(env, felf):
|
||||
with open(felf, 'rb') as f:
|
||||
elf = elffile.ELFFile(f)
|
||||
env.check_arch(elf['e_machine'])
|
||||
|
||||
# Get symbol table
|
||||
symtab = list(elf.get_section_by_name('.symtab').iter_symbols())
|
||||
|
||||
# Load needed sections from ELF file
|
||||
sections_shndx = {} # maps elf shndx to Section object
|
||||
for idx, s in enumerate(elf.iter_sections()):
|
||||
if s.header.sh_type in ('SHT_PROGBITS', 'SHT_NOBITS'):
|
||||
if s.data_size == 0:
|
||||
# Ignore empty sections
|
||||
pass
|
||||
elif s.name.startswith(('.literal', '.text', '.rodata', '.data.rel.ro', '.bss')):
|
||||
sec = Section.from_elfsec(s, felf)
|
||||
sections_shndx[idx] = sec
|
||||
if s.name.startswith('.literal'):
|
||||
env.literal_sections.append(sec)
|
||||
else:
|
||||
env.sections.append(sec)
|
||||
elif s.name.startswith('.data'):
|
||||
raise LinkError('{}: {} non-empty'.format(felf, s.name))
|
||||
else:
|
||||
# Ignore section
|
||||
pass
|
||||
elif s.header.sh_type in ('SHT_REL', 'SHT_RELA'):
|
||||
shndx = s.header.sh_info
|
||||
if shndx in sections_shndx:
|
||||
sec = sections_shndx[shndx]
|
||||
sec.reloc_name = s.name
|
||||
sec.reloc = list(s.iter_relocations())
|
||||
for r in sec.reloc:
|
||||
r.sym = symtab[r['r_info_sym']]
|
||||
|
||||
# Link symbols to their sections, and update known and unresolved symbols
|
||||
for sym in symtab:
|
||||
sym.filename = felf
|
||||
shndx = sym.entry['st_shndx']
|
||||
if shndx in sections_shndx:
|
||||
# Symbol with associated section
|
||||
sym.section = sections_shndx[shndx]
|
||||
if sym['st_info']['bind'] == 'STB_GLOBAL':
|
||||
# Defined global symbol
|
||||
if sym.name in env.known_syms and not sym.name.startswith('__x86.get_pc_thunk.'):
|
||||
raise LinkError('duplicate symbol: {}'.format(sym.name))
|
||||
env.known_syms[sym.name] = sym
|
||||
elif sym.entry['st_shndx'] == 'SHN_UNDEF' and sym['st_info']['bind'] == 'STB_GLOBAL':
|
||||
# Undefined global symbol, needs resolving
|
||||
env.unresolved_syms.append(sym)
|
||||
|
||||
def link_objects(env, native_qstr_vals_len, native_qstr_objs_len):
|
||||
# Build GOT information
|
||||
if env.arch.name == 'EM_XTENSA':
|
||||
build_got_xtensa(env)
|
||||
else:
|
||||
build_got_generic(env)
|
||||
|
||||
# Creat GOT section
|
||||
got_size = len(env.got_entries) * env.arch.word_size
|
||||
env.got_section = Section('GOT', bytearray(got_size), env.arch.word_size)
|
||||
if env.arch.name == 'EM_XTENSA':
|
||||
env.sections.insert(0, env.got_section)
|
||||
else:
|
||||
env.sections.append(env.got_section)
|
||||
|
||||
# Create optional literal section
|
||||
if env.arch.name == 'EM_XTENSA':
|
||||
lit_size = len(env.lit_entries) * env.arch.word_size
|
||||
env.lit_section = Section('LIT', bytearray(lit_size), env.arch.word_size)
|
||||
env.sections.insert(1, env.lit_section)
|
||||
|
||||
# Create section to contain mp_native_qstr_val_table
|
||||
env.qstr_val_section = Section('.text.QSTR_VAL', bytearray(native_qstr_vals_len * env.arch.qstr_entry_size), env.arch.qstr_entry_size)
|
||||
env.sections.append(env.qstr_val_section)
|
||||
|
||||
# Create section to contain mp_native_qstr_obj_table
|
||||
env.qstr_obj_section = Section('.text.QSTR_OBJ', bytearray(native_qstr_objs_len * env.arch.word_size), env.arch.word_size)
|
||||
env.sections.append(env.qstr_obj_section)
|
||||
|
||||
# Resolve unknown symbols
|
||||
mp_fun_table_sec = Section('.external.mp_fun_table', b'', 0)
|
||||
fun_table = {key: 63 + idx
|
||||
for idx, key in enumerate([
|
||||
'mp_type_type',
|
||||
'mp_type_str',
|
||||
'mp_type_list',
|
||||
'mp_type_dict',
|
||||
'mp_type_fun_builtin_0',
|
||||
'mp_type_fun_builtin_1',
|
||||
'mp_type_fun_builtin_2',
|
||||
'mp_type_fun_builtin_3',
|
||||
'mp_type_fun_builtin_var',
|
||||
'mp_stream_read_obj',
|
||||
'mp_stream_readinto_obj',
|
||||
'mp_stream_unbuffered_readline_obj',
|
||||
'mp_stream_write_obj',
|
||||
])
|
||||
}
|
||||
for sym in env.unresolved_syms:
|
||||
assert sym['st_value'] == 0
|
||||
if sym.name == '_GLOBAL_OFFSET_TABLE_':
|
||||
pass
|
||||
elif sym.name == 'mp_fun_table':
|
||||
sym.section = Section('.external', b'', 0)
|
||||
elif sym.name == 'mp_native_qstr_val_table':
|
||||
sym.section = env.qstr_val_section
|
||||
elif sym.name == 'mp_native_qstr_obj_table':
|
||||
sym.section = env.qstr_obj_section
|
||||
elif sym.name in env.known_syms:
|
||||
sym.resolved = env.known_syms[sym.name]
|
||||
else:
|
||||
if sym.name in fun_table:
|
||||
sym.section = mp_fun_table_sec
|
||||
sym.mp_fun_table_offset = fun_table[sym.name]
|
||||
else:
|
||||
raise LinkError('{}: undefined symbol: {}'.format(sym.filename, sym.name))
|
||||
|
||||
# Align sections, assign their addresses, and create full_text
|
||||
env.full_text = bytearray(env.arch.asm_jump(8)) # dummy, to be filled in later
|
||||
env.full_rodata = bytearray(0)
|
||||
env.full_bss = bytearray(0)
|
||||
for sec in env.sections:
|
||||
if env.arch.separate_rodata and sec.name.startswith(('.rodata', '.data.rel.ro')):
|
||||
data = env.full_rodata
|
||||
elif sec.name.startswith('.bss'):
|
||||
data = env.full_bss
|
||||
else:
|
||||
data = env.full_text
|
||||
sec.addr = align_to(len(data), sec.alignment)
|
||||
data.extend(b'\x00' * (sec.addr - len(data)))
|
||||
data.extend(sec.data)
|
||||
|
||||
env.print_sections()
|
||||
|
||||
populate_got(env)
|
||||
if env.arch.name == 'EM_XTENSA':
|
||||
populate_lit(env)
|
||||
|
||||
# Fill in relocations
|
||||
for sec in env.sections:
|
||||
if not sec.reloc:
|
||||
continue
|
||||
log(LOG_LEVEL_3, '{}: {} relocations via {}:'.format(sec.filename, sec.name, sec.reloc_name))
|
||||
for r in sec.reloc:
|
||||
if sec.name.startswith(('.text', '.rodata')):
|
||||
do_relocation_text(env, sec.addr, r)
|
||||
elif sec.name.startswith('.data.rel.ro'):
|
||||
do_relocation_data(env, sec.addr, r)
|
||||
else:
|
||||
assert 0, sec.name
|
||||
|
||||
################################################################################
|
||||
# .mpy output
|
||||
|
||||
class MPYOutput:
|
||||
def open(self, fname):
|
||||
self.f = open(fname, 'wb')
|
||||
self.prev_base = -1
|
||||
self.prev_offset = -1
|
||||
|
||||
def close(self):
|
||||
self.f.close()
|
||||
|
||||
def write_bytes(self, buf):
|
||||
self.f.write(buf)
|
||||
|
||||
def write_uint(self, val):
|
||||
b = bytearray()
|
||||
b.insert(0, val & 0x7f)
|
||||
val >>= 7
|
||||
while val:
|
||||
b.insert(0, 0x80 | (val & 0x7f))
|
||||
val >>= 7
|
||||
self.write_bytes(b)
|
||||
|
||||
def write_qstr(self, s):
|
||||
if s in qstrutil.static_qstr_list:
|
||||
self.write_bytes(bytes([0, qstrutil.static_qstr_list.index(s) + 1]))
|
||||
else:
|
||||
s = bytes(s, 'ascii')
|
||||
self.write_uint(len(s) << 1)
|
||||
self.write_bytes(s)
|
||||
|
||||
def write_obj(self, o):
|
||||
if o is Ellipsis:
|
||||
self.write_bytes(b'e')
|
||||
return
|
||||
else:
|
||||
# Other Python types not implemented
|
||||
assert 0
|
||||
|
||||
def write_reloc(self, base, offset, dest, n):
|
||||
need_offset = not (base == self.prev_base and offset == self.prev_offset + 1)
|
||||
self.prev_offset = offset + n - 1
|
||||
if dest <= 2:
|
||||
dest = (dest << 1) | (n > 1)
|
||||
else:
|
||||
assert 6 <= dest <= 127
|
||||
assert n == 1
|
||||
dest = dest << 1 | need_offset
|
||||
assert 0 <= dest <= 0xfe, dest
|
||||
self.write_bytes(bytes([dest]))
|
||||
if need_offset:
|
||||
if base == '.text':
|
||||
base = 0
|
||||
elif base == '.rodata':
|
||||
base = 1
|
||||
self.write_uint(offset << 1 | base)
|
||||
if n > 1:
|
||||
self.write_uint(n)
|
||||
|
||||
def build_mpy(env, entry_offset, fmpy, native_qstr_vals, native_qstr_objs):
|
||||
# Write jump instruction to start of text
|
||||
jump = env.arch.asm_jump(entry_offset)
|
||||
env.full_text[:len(jump)] = jump
|
||||
|
||||
log(LOG_LEVEL_1, 'arch: {}'.format(env.arch.name))
|
||||
log(LOG_LEVEL_1, 'text size: {}'.format(len(env.full_text)))
|
||||
if len(env.full_rodata):
|
||||
log(LOG_LEVEL_1, 'rodata size: {}'.format(len(env.full_rodata)))
|
||||
log(LOG_LEVEL_1, 'bss size: {}'.format(len(env.full_bss)))
|
||||
log(LOG_LEVEL_1, 'GOT entries: {}'.format(len(env.got_entries)))
|
||||
|
||||
#xxd(env.full_text)
|
||||
|
||||
out = MPYOutput()
|
||||
out.open(fmpy)
|
||||
|
||||
# MPY: header
|
||||
out.write_bytes(bytearray([
|
||||
ord('M'),
|
||||
MPY_VERSION,
|
||||
env.arch.mpy_feature,
|
||||
MP_SMALL_INT_BITS,
|
||||
QSTR_WINDOW_SIZE,
|
||||
]))
|
||||
|
||||
# MPY: kind/len
|
||||
out.write_uint(len(env.full_text) << 2 | (MP_CODE_NATIVE_VIPER - MP_CODE_BYTECODE))
|
||||
|
||||
# MPY: machine code
|
||||
out.write_bytes(env.full_text)
|
||||
|
||||
# MPY: n_qstr_link (assumes little endian)
|
||||
out.write_uint(len(native_qstr_vals) + len(native_qstr_objs))
|
||||
for q in range(len(native_qstr_vals)):
|
||||
off = env.qstr_val_section.addr + q * env.arch.qstr_entry_size
|
||||
out.write_uint(off << 2)
|
||||
out.write_qstr(native_qstr_vals[q])
|
||||
for q in range(len(native_qstr_objs)):
|
||||
off = env.qstr_obj_section.addr + q * env.arch.word_size
|
||||
out.write_uint(off << 2 | 3)
|
||||
out.write_qstr(native_qstr_objs[q])
|
||||
|
||||
# MPY: scope_flags
|
||||
scope_flags = MP_SCOPE_FLAG_VIPERRELOC
|
||||
if len(env.full_rodata):
|
||||
scope_flags |= MP_SCOPE_FLAG_VIPERRODATA
|
||||
if len(env.full_bss):
|
||||
scope_flags |= MP_SCOPE_FLAG_VIPERBSS
|
||||
out.write_uint(scope_flags)
|
||||
|
||||
# MPY: n_obj
|
||||
out.write_uint(bool(len(env.full_rodata)) + bool(len(env.full_bss)))
|
||||
|
||||
# MPY: n_raw_code
|
||||
out.write_uint(0)
|
||||
|
||||
# MPY: optional bytes object with rodata
|
||||
if len(env.full_rodata):
|
||||
out.write_obj(Ellipsis)
|
||||
if len(env.full_bss):
|
||||
out.write_obj(Ellipsis)
|
||||
|
||||
# MPY: rodata and/or bss
|
||||
if len(env.full_rodata):
|
||||
rodata_const_table_idx = 1
|
||||
out.write_uint(len(env.full_rodata))
|
||||
out.write_bytes(env.full_rodata)
|
||||
if len(env.full_bss):
|
||||
bss_const_table_idx = bool(env.full_rodata) + 1
|
||||
out.write_uint(len(env.full_bss))
|
||||
|
||||
# MPY: relocation information
|
||||
prev_kind = None
|
||||
for base, addr, kind in env.mpy_relocs:
|
||||
if isinstance(kind, str) and kind.startswith('.text'):
|
||||
kind = 0
|
||||
elif kind in ('.rodata', '.data.rel.ro'):
|
||||
if env.arch.separate_rodata:
|
||||
kind = rodata_const_table_idx
|
||||
else:
|
||||
kind = 0
|
||||
elif isinstance(kind, str) and kind.startswith('.bss'):
|
||||
kind = bss_const_table_idx
|
||||
elif kind == 'mp_fun_table':
|
||||
kind = 6
|
||||
else:
|
||||
kind = 7 + kind
|
||||
assert addr % env.arch.word_size == 0, addr
|
||||
offset = addr // env.arch.word_size
|
||||
if kind == prev_kind and base == prev_base and offset == prev_offset + 1:
|
||||
prev_n += 1
|
||||
prev_offset += 1
|
||||
else:
|
||||
if prev_kind is not None:
|
||||
out.write_reloc(prev_base, prev_offset - prev_n + 1, prev_kind, prev_n)
|
||||
prev_kind = kind
|
||||
prev_base = base
|
||||
prev_offset = offset
|
||||
prev_n = 1
|
||||
if prev_kind is not None:
|
||||
out.write_reloc(prev_base, prev_offset - prev_n + 1, prev_kind, prev_n)
|
||||
|
||||
# MPY: sentinel for end of relocations
|
||||
out.write_bytes(b'\xff')
|
||||
|
||||
out.close()
|
||||
|
||||
################################################################################
|
||||
# main
|
||||
|
||||
def do_preprocess(args):
|
||||
if args.output is None:
|
||||
assert args.files[0].endswith('.c')
|
||||
args.output = args.files[0][:-1] + 'config.h'
|
||||
static_qstrs, qstr_vals, qstr_objs = extract_qstrs(args.files)
|
||||
with open(args.output, 'w') as f:
|
||||
print('#include <stdint.h>\n'
|
||||
'typedef uintptr_t mp_uint_t;\n'
|
||||
'typedef intptr_t mp_int_t;\n'
|
||||
'typedef uintptr_t mp_off_t;', file=f)
|
||||
for i, q in enumerate(static_qstrs):
|
||||
print('#define %s (%u)' % (q, i + 1), file=f)
|
||||
for i, q in enumerate(sorted(qstr_vals)):
|
||||
print('#define %s (mp_native_qstr_val_table[%d])' % (q, i), file=f)
|
||||
for i, q in enumerate(sorted(qstr_objs)):
|
||||
print('#define MP_OBJ_NEW_QSTR_%s ((mp_obj_t)mp_native_qstr_obj_table[%d])' % (q, i), file=f)
|
||||
if args.arch == 'xtensawin':
|
||||
qstr_type = 'uint32_t' # esp32 can only read 32-bit values from IRAM
|
||||
else:
|
||||
qstr_type = 'uint16_t'
|
||||
print('extern const {} mp_native_qstr_val_table[];'.format(qstr_type), file=f)
|
||||
print('extern const mp_uint_t mp_native_qstr_obj_table[];', file=f)
|
||||
|
||||
def do_link(args):
|
||||
if args.output is None:
|
||||
assert args.files[0].endswith('.o')
|
||||
args.output = args.files[0][:-1] + 'mpy'
|
||||
native_qstr_vals = []
|
||||
native_qstr_objs = []
|
||||
if args.qstrs is not None:
|
||||
with open(args.qstrs) as f:
|
||||
for l in f:
|
||||
m = re.match(r'#define MP_QSTR_([A-Za-z0-9_]*) \(mp_native_', l)
|
||||
if m:
|
||||
native_qstr_vals.append(m.group(1))
|
||||
else:
|
||||
m = re.match(r'#define MP_OBJ_NEW_QSTR_MP_QSTR_([A-Za-z0-9_]*)', l)
|
||||
if m:
|
||||
native_qstr_objs.append(m.group(1))
|
||||
log(LOG_LEVEL_2, 'qstr vals: ' + ', '.join(native_qstr_vals))
|
||||
log(LOG_LEVEL_2, 'qstr objs: ' + ', '.join(native_qstr_objs))
|
||||
env = LinkEnv(args.arch)
|
||||
try:
|
||||
for file in args.files:
|
||||
load_object_file(env, file)
|
||||
link_objects(env, len(native_qstr_vals), len(native_qstr_objs))
|
||||
build_mpy(env, env.find_addr('mpy_init'), args.output, native_qstr_vals, native_qstr_objs)
|
||||
except LinkError as er:
|
||||
print('LinkError:', er.args[0])
|
||||
sys.exit(1)
|
||||
|
||||
def main():
|
||||
import argparse
|
||||
cmd_parser = argparse.ArgumentParser(description='Run scripts on the pyboard.')
|
||||
cmd_parser.add_argument('--verbose', '-v', action='count', default=1, help='increase verbosity')
|
||||
cmd_parser.add_argument('--arch', default='x64', help='architecture')
|
||||
cmd_parser.add_argument('--preprocess', action='store_true', help='preprocess source files')
|
||||
cmd_parser.add_argument('--qstrs', default=None, help='file defining additional qstrs')
|
||||
cmd_parser.add_argument('--output', '-o', default=None, help='output .mpy file (default to input with .o->.mpy)')
|
||||
cmd_parser.add_argument('files', nargs='+', help='input files')
|
||||
args = cmd_parser.parse_args()
|
||||
|
||||
global log_level
|
||||
log_level = args.verbose
|
||||
|
||||
if args.preprocess:
|
||||
do_preprocess(args)
|
||||
else:
|
||||
do_link(args)
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
Loading…
Reference in New Issue
Block a user