pebble/tools/generate_native_sdk/generate_app_shim.py

122 lines
4.7 KiB
Python
Raw Permalink Normal View History

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os.path
import subprocess
import tempfile
SHIM_PREAMBLE = """
.syntax unified
.thumb
"""
# We generate one of these trampolines for each function we export. This is a stub function
# that pretty much just sets us up to call 'jump_to_pbl_function', defined in the SHIM_FOOTER
# string.
SHIM_TEMPLATE = """
.section ".text.%(function_name)s"
.align 2
.thumb_func
.global %(function_name)s
.type %(function_name)s STT_FUNC
%(function_name)s:
push {r0, r1, r2, r3} @ Stack the original parameters. Remember that the caller
@ thinks they're calling a C function, not this shim function.
@ We don't want to touch these.
ldr r1, =%(offset)d @ Load up the index into the jump table array
b jump_to_pbl_function @ See below...
"""
# This section defines the second part of the trampoline function. We only jump to it from
# the functions we define in SHIM_TEMPLATE. The SHIM_TEMPLATE function jumps to us after
# setting up the offset in the jump table in r1.
SHIM_FOOTER = """
.section ".text"
.type jump_to_pbl_function function
jump_to_pbl_function:
adr r3, pbl_table_addr
ldr r0, [r3] @ r0 now holds the base address of the jump table
add r0, r0, r1 @ add the offset to address the function pointer to the exported function
ldr r2, [r0] @ r2 now holds the address of the exported function
mov r12, r2 @ r12 aka intra-procedure scratch register. We're allowed to
@ muck with this and not restore it
pop {r0, r1, r2, r3} @ Restore the original parameters to the exported C function
bx r12 @ And finally jump! Don't use branch and link, we want to
@ return to the original call site, not this shim
@ This pbl_table_addr variable will get compiled into our app binary. As part of our build process
@ the address of this variable will get poked into the PebbleProcessInfo meta data struct. Then, when
@ we load the app from flash we change the value of the variable to point the jump table exported
@ by the OS.
.align
pbl_table_addr:
.long 0xA8A8A8A8
"""
def gen_shim_asm(functions):
output = []
output.append(SHIM_PREAMBLE)
for idx, fun in enumerate(functions):
if not fun.removed:
output.append(SHIM_TEMPLATE % {'function_name': fun.name, 'offset': idx * 4})
output.append(SHIM_FOOTER)
return '\n'.join(output)
class CompilationFailedError(Exception):
pass
def build_shim(shim_s, dest_dir):
shim_a = os.path.join(dest_dir, 'libpebble.a')
# Delete any existing archive, otherwise `ar` will append/insert to it:
if os.path.exists(shim_a):
os.remove(shim_a)
shim_o = tempfile.NamedTemporaryFile(suffix='pebble.o').name
gcc_process = subprocess.Popen(['arm-none-eabi-gcc',
'-mcpu=cortex-m3',
'-mthumb',
'-fPIC',
'-c',
'-o',
shim_o,
shim_s],
stdout = subprocess.PIPE,
stderr = subprocess.PIPE)
output = gcc_process.communicate()
if (gcc_process.returncode != 0):
print(output[1])
raise CompilationFailedError()
ar_process = subprocess.Popen(['arm-none-eabi-ar',
'rcs',
shim_a,
shim_o],
stdout = subprocess.PIPE,
stderr = subprocess.PIPE)
output = ar_process.communicate()
if (ar_process.returncode != 0):
print(output[1])
raise CompilationFailedError()
def make_app_shim_lib(functions, sdk_lib_dir):
temp_asm_file = tempfile.NamedTemporaryFile(suffix='pbl_shim.s').name
with open(temp_asm_file, 'w') as shim_s:
shim_s.write(gen_shim_asm(functions))
build_shim(temp_asm_file, sdk_lib_dir)