Import of the watch repository from Pebble

tools/applib_malloc.py

@@ -0,0 +1,171 @@
+# 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 argparse
+import json
+import os
+import sh
+import string
+
+
+class ApplibType(object):
+    def __init__(self, type_dict):
+        self.name = type_dict['name']
+
+        self.check_size = 1  # C preproc bool: 1 = true, 0 = false
+        self.min_sdk = 0
+        self.size_2x = type_dict.get('size_2x', 0)
+        self.size_3x_direct_padding = type_dict.get('size_3x_padding', 0)
+        self.size_3x = type_dict.get('size_3x', 0)
+
+        self.dependencies = type_dict.get('dependencies', [])
+
+        self.total_3x_padding = None
+
+    def get_total_3x_padding(self, all_types):
+        """ Return the amount of padding to use for the 3x version of the struct including both
+            the direct padding we add for this struct in particular as well as all padding needed
+            for all dependenant structs.
+        """
+
+        if self.total_3x_padding is not None:
+            # We have it cached, just return the previously calculated value
+            return self.total_3x_padding
+
+        self.total_3x_padding = self.size_3x_direct_padding
+
+        for d in self.dependencies:
+            parent = filter(lambda t: d == t.name, all_types)[0]
+            self.total_3x_padding += parent.get_total_3x_padding(all_types)
+
+        return self.total_3x_padding
+
+    def __repr__(self):
+        return '<%s %s>' % (self.__class__.__name__, self.name)
+
+
+def get_types(data):
+    return [ApplibType(t) for t in data['types'] if 'name' in t]
+
+
+def writeline(f, str=''):
+    f.write(str + '\n')
+
+
+def write_template(f, filepath, replace):
+    with open(filepath, 'r') as template_file:
+        template = string.Template(template_file.read())
+        f.write(template.safe_substitute(**replace) + '\n')
+
+
+def generate_header(data, output_filename):
+    all_types = get_types(data)
+
+    with open(output_filename, 'w') as f:
+        write_template(f, 'tools/applib_malloc.template.h', {
+            'filename': output_filename,
+        })
+
+        for t in all_types:
+            write_template(f, 'tools/applib_malloc_type.template.h', t.__dict__)
+
+
+def generate_implementation(data, output_filename, min_sdk, disable_size_checks=False):
+    all_types = get_types(data)
+    with open(output_filename, 'w') as f:
+        includes = ['#include "%s"' % h for h in data['headers']]
+        applib_enum_types = ['ApplibType_%s' % t.name for t in all_types]
+        applib_malloc_types = ['{ sizeof(%s), %u, %u }' % (t.name, t.size_2x, t.size_3x)
+                               for t in all_types]
+
+        write_template(f, 'tools/applib_malloc.template.c', {
+            'filename': os.path.basename(output_filename),
+            'includes': '\n'.join(includes),
+            'applib_enum_types': ',\n  '.join(applib_enum_types),
+            'applib_malloc_types': ',\n  '.join(applib_malloc_types),
+        })
+
+        for t in all_types:
+            t.min_sdk = min_sdk
+            t.check_size = 0 if disable_size_checks else 1
+            t.get_total_3x_padding(all_types)  # Populate the value
+            write_template(f, 'tools/applib_malloc_type.template.c', t.__dict__)
+
+
+def generate_files(json_filename, header_filename, impl_filename, min_sdk,
+                   disable_size_checks=False):
+    with open(json_filename) as f:
+        data = json.load(f)
+
+    generate_header(data, header_filename)
+    generate_implementation(data, impl_filename, min_sdk, disable_size_checks)
+
+
+def _get_sizeof_type(elf_filename, typename):
+    def _run_gdb(cmd):
+        running_cmd = sh.arm_none_eabi_gdb(elf_filename, batch=True, nx=True, ex=cmd)
+        result = str(running_cmd)
+
+        # Strip escape sequences if present
+        if result[0] == '\x1b':
+            result = result[8:]
+
+        return result.strip()
+
+    gdb_output = _run_gdb('p sizeof(%s)' % typename)
+
+    if len(gdb_output) == 0:
+        # Sometimes gdb is dumb and fails at interpreting a typedef, try again with a struct prefix
+        gdb_output = _run_gdb('p sizeof(struct %s)' % typename)
+
+    if len(gdb_output) == 0:
+        raise Exception("Failed to get sizeof for type %s" % typename)
+
+    # Looks like "$1 = 44", we want the "44"
+    return int(gdb_output.split()[2])
+
+
+def dump_sizes(json_filename, elf_filename):
+    with open(json_filename) as f:
+        data = json.load(f)
+
+    all_types = get_types(data)
+    fmt_str = "%30s %10s %10s %10s %16s %16s %16s  %s"
+
+    print fmt_str % ("Type", "sizeof()", "Size 2.x", "Size 3.x",
+                     "direct padding", "total padding", "calculated size", "dependencies")
+
+    for t in all_types:
+        type_sizeof = _get_sizeof_type(elf_filename, t.name)
+
+        calculated_size = type_sizeof + t.get_total_3x_padding(all_types)
+        if not t.size_3x or calculated_size == t.size_3x:
+            calculated_size_str = str(calculated_size)
+        else:
+            calculated_size_str = "%u <%u>" % (calculated_size, (calculated_size - t.size_3x))
+
+        print fmt_str % (t.name, type_sizeof, t.size_2x, t.size_3x,
+                         t.size_3x_direct_padding, t.get_total_3x_padding(all_types),
+                         calculated_size_str, t.dependencies)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--json', type=str, default='src/fw/applib/applib_malloc.json',
+                        help="Specify the JSON file to use")
+    parser.add_argument('--elf', type=str, default='build/src/fw/tintin_fw.elf',
+                        help="Specify the ELF file to use")
+
+    args = parser.parse_args()
+    dump_sizes(args.json, args.elf)