Add explicit MIT license and copyright

[deliverable/exatracer.git] / scripts / gen-hip-wrappers

#!/usr/bin/env python3
#
# SPDX-FileCopyrightText: 2023 EfficiOS, Inc.
#
# SPDX-License-Identifier: MIT
#
# Author: Olivier Dion <odion@efficios.com>
#
# Auto-generate lttng-ust wrappers for HIP.
#
# Require: python-clang (libclang)

import argparse
import re
import subprocess

from string import Template

import clang.cindex

def list_function_declarations(root):
    """Return all function declarations under ROOT."""
    return [
        child
        for child in root.get_children()
        if child.kind == clang.cindex.CursorKind.FUNCTION_DECL
    ]

def get_system_include_paths():
    """Get default system include paths from Clang."""
    clang_args = ["clang", "-v", "-c", "-xc", "-o", "/dev/null", "/dev/null"]
    paths = []

    with subprocess.Popen(clang_args, stderr=subprocess.PIPE, text=True) as proc:
        start_sys_search = False
        for line in proc.stderr:
            if start_sys_search:
                if line == "End of search list.\n":
                    break
                paths.append("-isystem")
                paths.append(line.strip())
            elif line == "#include <...> search starts here:\n":
                start_sys_search = True

    return paths

def parse_header(header_file, includes, defines):
    """
    Parse HEADER_FILE with Clang with INCLUDES (-I) and DEFINES (-D).
    Return a cursor to root.
    """

    # For some reason, python-clang does not use all system include paths.
    # Thus, compiler dependant headers, like stddef.h can not be found without
    # this.
    args = get_system_include_paths()

    if includes:
        for inc in includes:
            args.append("-I")
            args.append(inc)

    if defines:
        for d in defines:
            args.append("-D")
            args.append(d)

    tu = clang.cindex.Index.create().parse(header_file, args=args)

    for d in tu.diagnostics:
        print(f"WARNING: {d}")

    return tu.cursor

def list_functions(root):
    """Return the list of function declarations with `hip' prefix from ROOT."""
    return [
        fn
        for fn in list_function_declarations(root)
        if fn.spelling.startswith("hip") and fn.spelling
    ]

def exact_definition(arg):
    """Given a cursor ARG that is a function argument, return its exact definition."""
    ct = arg.type.get_canonical()
    if ct.kind == clang.cindex.TypeKind.POINTER:
        pt = ct.get_pointee()
        if pt.kind == clang.cindex.TypeKind.FUNCTIONPROTO:
            ret_type = pt.get_result().spelling
            argument_types = ", ".join([a.spelling for a in pt.argument_types()])
            return f"{ret_type} (*{arg.spelling})({argument_types})"
    m = re.search(r'(\[[0-9]*\])+', arg.type.spelling)
    if m:
        return f"{arg.type.spelling[:m.start(0)]} {arg.spelling}{m.group(0)}"
    else:
        return f"{arg.type.spelling} {arg.spelling}"

def cast(arg):
    """
    Cast argument ARG to something that LTTng-UST can consume.  Typically,
    this is used to cast any pointer to void * because pointers are not
    dereferenced anyway.  Furthermore, array are also cast void *.
    """
    canon = arg.type.get_canonical()
    if canon.kind == clang.cindex.TypeKind.POINTER:
        return "void *"
    return re.sub(r'\[[0-9]*\]', '*', canon.spelling)

def main():

    # Extra works to do for functions.
    #
    # Format:
    #   key = str: function name ; e.g. hipMalloc
    #   value = str: C code ; e.g. printf("hello\n");
    extra_works = {
    }

    parser = argparse.ArgumentParser(prog="gen-hip-wrappers")

    parser.add_argument("api",
                        help="HIP API header")

    parser.add_argument("wrappers",
                        help="Path to HIP wrappers")

    parser.add_argument("--ignores",
                        dest="ignores",
                        metavar="FILE",
                        default=None,
                        help="Ignore list")

    parser.add_argument("-I",
                        action="append",
                        metavar="DIR",
                        dest="includes",
                        help="Add DIR to list of directories to include")

    parser.add_argument("-D",
                        action="append",
                        metavar="DEFINITION",
                        dest="defines",
                        help="Add DEFINITION to list of definitions")

    args = parser.parse_args()

    # The set of function to not instrument.
    forbiden_list = set()

    if args.ignores:
        with open(args.ignores, "r") as f:
            for ignore in f.read().splitlines():
                forbiden_list.add(ignore)

    prologue_tpl = Template("""/* Auto-generated */
#include "lttng-ust-hip-states.h"
""")

    ret_fn_tpl = Template("""
static ${ret_type} lttng_${fn_name}(${fn_arguments})
{
	${ret_type} ret;
	{
		lttng_hip::api_object_${fn_name} lttng_api_object {${fn_rest_argument_names}};
		ret = next_hip_table.${fn_name}_fn(${fn_pass_argument_names});
		lttng_api_object.mark_return(ret);
	}
$extra_work
	return ret;
}
""")

    # Void function are special because they do not return anything ..
    void_fn_tpl = Template("""
static void lttng_${fn_name}(${fn_arguments})
{
	{
		lttng_hip::api_object_${fn_name} lttng_api_object {${fn_rest_argument_names}};
		next_hip_table.${fn_name}_fn(${fn_pass_argument_names});
		lttng_api_object.mark_return();
	}
$extra_work
}
""")

    # Because C++ does not support designated initializer.
    epilogue_tpl = Template("""
static void lttng_hip_install_wrappers(void)
{
	${wrappers}
}
""")

    functions = list_functions(parse_header(args.api,
                                            args.includes,
                                            args.defines))

    with open(args.wrappers, "w") as output:

        output.write(prologue_tpl.substitute())

        for fn in functions:

            if fn.spelling in forbiden_list:
                continue

            args = list(fn.get_arguments())
            fn_pass_argument_names = ", ".join([
                f"{arg.spelling}"
                for arg in args
            ])

            if args:
                fn_rest_argument_names = ", ".join([
                    "(%s)%s" % (cast(arg), arg.spelling)
                    for arg in args
                ])
            else:
                fn_rest_argument_names=""

            if fn.spelling in extra_works:
                extra_work = extra_works[fn.spelling]
            else:
                extra_work = ""

            if "void"== fn.type.get_result().spelling:
                fn_tpl = void_fn_tpl
            else:
                fn_tpl = ret_fn_tpl

            output.write(fn_tpl.substitute(fn_name=fn.spelling,
                                           fn_arguments=", ".join([
                                               exact_definition(arg)
                                               for arg in fn.get_arguments()
                                           ]),
                                           fn_pass_argument_names=fn_pass_argument_names,
                                           fn_rest_argument_names=fn_rest_argument_names,
                                           ret_type=fn.type.get_result().spelling,
                                           extra_work=extra_work))

        output.write(epilogue_tpl.substitute(wrappers="\n	".join([
            f"lttng_hip_table.{fn.spelling}_fn = &lttng_{fn.spelling};"
            for fn in functions if fn.spelling not in forbiden_list
        ])))


if __name__ == "__main__":
    main()