llvm-project/clang/tools/scan-build-py/lib/libear/__init__.py

# -*- coding: utf-8 -*-
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
""" This module compiles the intercept library. """

import sys
import os
import os.path
import re
import tempfile
import shutil
import contextlib
import logging

__all__ = ["build_libear"]


def build_libear(compiler, dst_dir):
    """Returns the full path to the 'libear' library."""

    try:
        src_dir = os.path.dirname(os.path.realpath(__file__))
        toolset = make_toolset(src_dir)
        toolset.set_compiler(compiler)
        toolset.set_language_standard("c99")
        toolset.add_definitions(["-D_GNU_SOURCE"])

        configure = do_configure(toolset)
        configure.check_function_exists("execve", "HAVE_EXECVE")
        configure.check_function_exists("execv", "HAVE_EXECV")
        configure.check_function_exists("execvpe", "HAVE_EXECVPE")
        configure.check_function_exists("execvp", "HAVE_EXECVP")
        configure.check_function_exists("execvP", "HAVE_EXECVP2")
        configure.check_function_exists("exect", "HAVE_EXECT")
        configure.check_function_exists("execl", "HAVE_EXECL")
        configure.check_function_exists("execlp", "HAVE_EXECLP")
        configure.check_function_exists("execle", "HAVE_EXECLE")
        configure.check_function_exists("posix_spawn", "HAVE_POSIX_SPAWN")
        configure.check_function_exists("posix_spawnp", "HAVE_POSIX_SPAWNP")
        configure.check_symbol_exists(
            "_NSGetEnviron", "crt_externs.h", "HAVE_NSGETENVIRON"
        )
        configure.write_by_template(
            os.path.join(src_dir, "config.h.in"), os.path.join(dst_dir, "config.h")
        )

        target = create_shared_library("ear", toolset)
        target.add_include(dst_dir)
        target.add_sources("ear.c")
        target.link_against(toolset.dl_libraries())
        target.link_against(["pthread"])
        target.build_release(dst_dir)

        return os.path.join(dst_dir, target.name)

    except Exception:
        logging.info("Could not build interception library.", exc_info=True)
        return None


def execute(cmd, *args, **kwargs):
    """Make subprocess execution silent."""

    import subprocess

    kwargs.update({"stdout": subprocess.PIPE, "stderr": subprocess.STDOUT})
    return subprocess.check_call(cmd, *args, **kwargs)


@contextlib.contextmanager
def TemporaryDirectory(**kwargs):
    name = tempfile.mkdtemp(**kwargs)
    try:
        yield name
    finally:
        shutil.rmtree(name)


class Toolset(object):
    """Abstract class to represent different toolset."""

    def __init__(self, src_dir):
        self.src_dir = src_dir
        self.compiler = None
        self.c_flags = []

    def set_compiler(self, compiler):
        """part of public interface"""
        self.compiler = compiler

    def set_language_standard(self, standard):
        """part of public interface"""
        self.c_flags.append("-std=" + standard)

    def add_definitions(self, defines):
        """part of public interface"""
        self.c_flags.extend(defines)

    def dl_libraries(self):
        raise NotImplementedError()

    def shared_library_name(self, name):
        raise NotImplementedError()

    def shared_library_c_flags(self, release):
        extra = ["-DNDEBUG", "-O3"] if release else []
        return extra + ["-fPIC"] + self.c_flags

    def shared_library_ld_flags(self, release, name):
        raise NotImplementedError()


class DarwinToolset(Toolset):
    def __init__(self, src_dir):
        Toolset.__init__(self, src_dir)

    def dl_libraries(self):
        return []

    def shared_library_name(self, name):
        return "lib" + name + ".dylib"

    def shared_library_ld_flags(self, release, name):
        extra = ["-dead_strip"] if release else []
        return extra + ["-dynamiclib", "-install_name", "@rpath/" + name]


class UnixToolset(Toolset):
    def __init__(self, src_dir):
        Toolset.__init__(self, src_dir)

    def dl_libraries(self):
        return []

    def shared_library_name(self, name):
        return "lib" + name + ".so"

    def shared_library_ld_flags(self, release, name):
        extra = [] if release else []
        return extra + ["-shared", "-Wl,-soname," + name]


class LinuxToolset(UnixToolset):
    def __init__(self, src_dir):
        UnixToolset.__init__(self, src_dir)

    def dl_libraries(self):
        return ["dl"]


def make_toolset(src_dir):
    platform = sys.platform
    if platform in {"win32", "cygwin"}:
        raise RuntimeError("not implemented on this platform")
    elif platform == "darwin":
        return DarwinToolset(src_dir)
    elif platform in {"linux", "linux2"}:
        return LinuxToolset(src_dir)
    else:
        return UnixToolset(src_dir)


class Configure(object):
    def __init__(self, toolset):
        self.ctx = toolset
        self.results = {"APPLE": sys.platform == "darwin"}

    def _try_to_compile_and_link(self, source):
        try:
            with TemporaryDirectory() as work_dir:
                src_file = "check.c"
                with open(os.path.join(work_dir, src_file), "w") as handle:
                    handle.write(source)

                execute([self.ctx.compiler, src_file] + self.ctx.c_flags, cwd=work_dir)
                return True
        except Exception:
            return False

    def check_function_exists(self, function, name):
        template = "int FUNCTION(); int main() { return FUNCTION(); }"
        source = template.replace("FUNCTION", function)

        logging.debug("Checking function %s", function)
        found = self._try_to_compile_and_link(source)
        logging.debug(
            "Checking function %s -- %s", function, "found" if found else "not found"
        )
        self.results.update({name: found})

    def check_symbol_exists(self, symbol, include, name):
        template = """#include <INCLUDE>
                      int main() { return ((int*)(&SYMBOL))[0]; }"""
        source = template.replace("INCLUDE", include).replace("SYMBOL", symbol)

        logging.debug("Checking symbol %s", symbol)
        found = self._try_to_compile_and_link(source)
        logging.debug(
            "Checking symbol %s -- %s", symbol, "found" if found else "not found"
        )
        self.results.update({name: found})

    def write_by_template(self, template, output):
        def transform(line, definitions):

            pattern = re.compile(r"^#cmakedefine\s+(\S+)")
            m = pattern.match(line)
            if m:
                key = m.group(1)
                if key not in definitions or not definitions[key]:
                    return "/* #undef {0} */{1}".format(key, os.linesep)
                else:
                    return "#define {0}{1}".format(key, os.linesep)
            return line

        with open(template, "r") as src_handle:
            logging.debug("Writing config to %s", output)
            with open(output, "w") as dst_handle:
                for line in src_handle:
                    dst_handle.write(transform(line, self.results))


def do_configure(toolset):
    return Configure(toolset)


class SharedLibrary(object):
    def __init__(self, name, toolset):
        self.name = toolset.shared_library_name(name)
        self.ctx = toolset
        self.inc = []
        self.src = []
        self.lib = []

    def add_include(self, directory):
        self.inc.extend(["-I", directory])

    def add_sources(self, source):
        self.src.append(source)

    def link_against(self, libraries):
        self.lib.extend(["-l" + lib for lib in libraries])

    def build_release(self, directory):
        for src in self.src:
            logging.debug("Compiling %s", src)
            execute(
                [
                    self.ctx.compiler,
                    "-c",
                    os.path.join(self.ctx.src_dir, src),
                    "-o",
                    src + ".o",
                ]
                + self.inc
                + self.ctx.shared_library_c_flags(True),
                cwd=directory,
            )
        logging.debug("Linking %s", self.name)
        execute(
            [self.ctx.compiler]
            + [src + ".o" for src in self.src]
            + ["-o", self.name]
            + self.lib
            + self.ctx.shared_library_ld_flags(True, self.name),
            cwd=directory,
        )


def create_shared_library(name, toolset):
    return SharedLibrary(name, toolset)