src/starnix/lib/bindgen.py

#!/usr/bin/env fuchsia-vendored-python
# Copyright 2023 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import os
import re
import subprocess
import sys
import datetime

# All other paths are relative to here (main changes to this directory on startup).
ROOT_PATH = os.path.join(os.path.dirname(__file__), '..', '..', '..')

RUST_DIR = 'prebuilt/third_party/rust/linux-x64/bin'
BINDGEN_PATH = 'prebuilt/third_party/rust_bindgen/linux-x64/bindgen'
FX_PATH = 'scripts/fx'

GENERATED_FILE_HEADER = """// Copyright %d The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#![allow(dead_code)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
""" % datetime.datetime.now().year


class Bindgen:

    def __init__(self):
        self.clang_target = 'x86_64-pc-linux-gnu'
        self.c_types_prefix = ''
        self.raw_lines = ''
        self.opaque_types = []
        self.include_dirs = []
        self.auto_derive_traits = []
        self.replacements = []
        self.ignore_functions = False
        self.function_allowlist = []
        self.var_allowlist = []
        self.type_allowlist = []
        self.no_debug_types = []
        self.no_copy_types = []

    def set_auto_derive_traits(self, traits_map):
        self.auto_derive_traits = [(re.compile(x[0]), x[1]) for x in traits_map]

    def set_replacements(self, replacements):
        self.replacements = [(re.compile(x[0]), x[1]) for x in replacements]

    def run_bindgen(self, input_file, output_file):
        # Bindgen arguments.
        args = [
            BINDGEN_PATH,
            '--no-layout-tests',
            '--with-derive-default',
            '--explicit-padding',
            '--raw-line',
            GENERATED_FILE_HEADER + self.raw_lines,
            '-o',
            output_file,
        ]

        if self.ignore_functions:
            args.append('--ignore-functions')

        if self.c_types_prefix:
            args.append('--ctypes-prefix=' + self.c_types_prefix)

        args += ['--allowlist-function=' + x for x in self.function_allowlist]
        args += ['--allowlist-var=' + x for x in self.var_allowlist]
        args += ['--allowlist-type=' + x for x in self.type_allowlist]
        args += ['--opaque-type=' + x for x in self.opaque_types]
        args += ['--no-debug=' + x for x in self.no_debug_types]
        args += ['--no-copy=' + x for x in self.no_copy_types]

        args += [input_file]

        # Clang arguments (after the "--").
        args += [
            '--',
            '-target',
            self.clang_target,
            '-nostdlibinc',
            '-D__Fuchsia_API_level__=4294967295',
            '-DIS_BINDGEN=1',
        ]
        for i in self.include_dirs:
            args += ['-I', i]
        args += ['-I', '.']

        # Need to set the PATH to the prebuilt binary location for it to find rustfmt.
        env = os.environ.copy()
        env['PATH'] = '%s:%s' % (os.path.abspath(RUST_DIR), env['PATH'])
        subprocess.check_call(args, env=env)

    def get_auto_derive_traits(self, line):
        """Returns true if the given line defines a Rust structure with a name
        matching any of the types we need to add FromBytes."""
        if not (line.startswith("pub struct ") or
                line.startswith("pub union ")):
            return None

        # The third word (after the "pub struct") is the type name.
        split = re.split('[ <\(]', line)
        if len(split) < 3:
            return None
        type_name = split[2]

        for (t, traits) in self.auto_derive_traits:
            if t.match(type_name):
                return traits
        return None

    def post_process_rust_file(self, rust_file_name):
        with open(rust_file_name, 'r+') as source_file:
            input_lines = source_file.readlines()
            output_lines = []
            for line in input_lines:
                extra_traits = self.get_auto_derive_traits(line)
                if extra_traits:
                    # Parse existing traits, if any.
                    if len(output_lines) > 0 and output_lines[-1].startswith(
                            '#[derive('):
                        traits = output_lines[-1][9:-3].split(', ')
                        traits.extend(
                            x for x in extra_traits if x not in traits)
                        output_lines.pop()
                    else:
                        traits = extra_traits
                    output_lines.append(
                        '#[derive(' + ', '.join(traits) + ')]\n')
                output_lines.append(line)

            text = "".join(output_lines)
            for (regexp, replacement) in self.replacements:
                text = regexp.sub(replacement, text)

            source_file.seek(0)
            source_file.write(text)

    def run(self, input_file, rust_file):
        os.chdir(ROOT_PATH)

        self.run_bindgen(input_file, rust_file)
        self.post_process_rust_file(rust_file)

        subprocess.check_call([FX_PATH, 'format-code', '--files=' + rust_file])