mirror of
https://github.com/google/pebble.git
synced 2025-03-15 16:51:21 +00:00
122 lines
4.7 KiB
Python
122 lines
4.7 KiB
Python
|
# 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)
|
||
|
|