Beispiel #1
0
    def actions_for_project(
            self, project: Project) -> tp.MutableSequence[actions.Step]:
        """Returns the specified steps to run the project(s) specified in the
        call in a fixed order."""

        # Add the required runtime extensions to the project(s).
        project.runtime_extension = run.RuntimeExtension(project, self) \
            << time.RunWithTime()

        # Add the required compiler extensions to the project(s).
        project.compiler_extension = compiler.RunCompiler(project, self) \
            << RunWLLVM() \
            << run.WithTimeout()

        # Add own error handler to compile step.
        project.compile = get_default_compile_error_wrapped(
            self.get_handle(), project, CR)

        # This c-flag is provided by VaRA and it suggests to use the git-blame
        # annotation.
        project.cflags = ["-fvara-GB"]

        analysis_actions = []

        analysis_actions += get_bc_cache_actions(
            project,
            extraction_error_handler=create_default_compiler_error_handler(
                self.get_handle(), project, self.REPORT_SPEC.main_report))

        analysis_actions.append(CRAnalysis(project, self.get_handle()))
        analysis_actions.append(actions.Clean(project))

        return analysis_actions
Beispiel #2
0
    def actions_for_project(self,
                            project: Project) -> tp.MutableSequence[Step]:
        """
        Defines the actions, which should be run on a project.

        Args:
            project: the project we run our `Experiment` on
        """
        project.compiler_extension = compiler.RunCompiler(
            project, self) << TraceBinaryCreator(project, self, "Print")

        project.cflags = ["-fvara-handleRM=High"]

        project_actions: tp.MutableSequence[
            Step] = self.default_compiletime_actions(project)

        return project_actions
    def actions_for_project(self,
                            project: Project) -> tp.MutableSequence[Step]:
        """
        Defines the actions, which should be run on a project.

        Args:
            project: the project we run our `Experiment` on
        """
        project.runtime_extension = run.RuntimeExtension(
            project, self) << time.RunWithTime()

        project.compiler_extension = compiler.RunCompiler(
            project, self) << RunWLLVM() << time.RunWithTime()

        project.ldflags = ["-lTrace"]
        project.cflags = ["-fvara-handleRM=High", "-mllvm", "-vara-tracer"]

        actns: tp.MutableSequence[Step] = self.default_runtime_actions(project)
        return actns