pebble/tools/generate_native_sdk/generate_app_shim.py

# 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)