Import of the watch repository from Pebble

tools/generate_native_sdk/generate_app_shim.py

@@ -0,0 +1,121 @@
+# 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)
+