[lit] Add a basic implementation of build for GccBuilder

[stella.stamenova]

Summary

This adds an implementation for compile as well as compile-and-link, but not link. For compile-and-link we rely on clang to orchestrate both similarly to how the tests use it today.

[labath]

Btw, I also wrote something like this in D55430. (Zachary asked me to do it, but it looks like he missed the review request. :P)

I think my version is more complete, though I am missing lto support, because I couldn't be bothered to figure out how it works. But if all that's needed is to add -flto=thin, then I can easily integrate that.

[zturner]

@labath: Sorry, I didn't miss it, I just forgot about it (that's not much better, I know). I'll look today. If Pavel's is more complete let's use that as a starting point, although TBH I'm fine going with either one.

[stella.stamenova]

Let's use @labath's change instead.

lit/BuildScript/modes-nonwin.test

+UNSUPPORTED: system-windows
+
+RUN: %build -n --verbose --arch=32 --mode=compile --compiler=any -o %t/foo.out foobar.c \
+RUN:    | FileCheck --check-prefix=COMPILE %s
+
+RUN: %build -n --verbose --arch=32 --mode=compile --compiler=any --outdir %t foo.c bar.c \
+RUN:    | FileCheck --check-prefix=COMPILE-MULTI %s
+
+RUN: %build -n --verbose --arch=32 --mode=link --compiler=any -o %t/foo.out foobar.o \
+RUN:    | FileCheck --check-prefix=LINK %s
+
+RUN: %build -n --verbose --arch=32 --mode=link --compiler=any -o %t/foobar.out foo.o bar.o \
+RUN:    | FileCheck --check-prefix=LINK-MULTI %s
+
+RUN: %build -n --verbose --arch=32 --mode=compile-and-link --compiler=any -o %t/foobar.out foobar.c \
+RUN:    | FileCheck --check-prefix=BOTH %s
+
+RUN: %build -n --verbose --arch=32 --mode=compile-and-link --compiler=any -o %t/foobar.out foo.c bar.c \
+RUN:    | FileCheck --check-prefix=BOTH-MULTI %s
+
+
+COMPILE: compiling foobar.c -> foo.out
+
+COMPILE-MULTI: compiling foo.c -> foo.o
+COMPILE-MULTI: compiling bar.c -> bar.o
+
+
+LINK: linking only not supported
+
+LINK-MULTI: linking only not supported
+
+BOTH: compiling and linking foobar.c -> foobar.out
+
+BOTH-MULTI: compiling and linking foo.c+bar.c -> foobar.out

lit/BuildScript/script-args.test

-REQUIRES: system-windows
-
 RUN: %build -n --verbose --arch=32 --mode=compile --compiler=any -o %t/foo.out foobar.c \
 RUN:    | FileCheck %s
 RUN: %build -n --verbose --arch=32 --mode=compile --compiler=any --outdir %t foo.c bar.c \
 RUN:    | FileCheck --check-prefix=MULTI-INPUT %s
 
 
 CHECK:      Script Arguments:
 CHECK-NEXT:   Arch: 32

 MULTI-INPUT-NEXT:   Nodefaultlib: False
 MULTI-INPUT-NEXT:   Opt: none
 MULTI-INPUT-NEXT:   Mode: compile
 MULTI-INPUT-NEXT:   Clean: True
 MULTI-INPUT-NEXT:   Verbose: True
 MULTI-INPUT-NEXT:   Dryrun: True
 MULTI-INPUT-NEXT:   Inputs: foo.c
 MULTI-INPUT-NEXT:           bar.c
 No newline at end of file

lit/helper/build.py

 
 def format_text(lines, indent_0, indent_n):
     result = ' ' * indent_0 + lines[0]
     for next in lines[1:]:
         result = result + '\n{0}{1}'.format(' ' * indent_n, next)
     return result
 
 def print_environment(env):
+    if env:
         for e in env:
             value = env[e]
             lines = value.split(os.pathsep)
             formatted_value = format_text(lines, 0, 7 + len(e))
             print('    {0} = {1}'.format(e, formatted_value))
+    else:
+        print('    No environment specified')
 
 def find_executable(binary_name, search_paths):
     if sys.platform == 'win32':
         binary_name = binary_name + '.exe'
 
     search_paths = os.pathsep.join(search_paths)
     paths = search_paths + os.pathsep + os.environ.get('PATH', '')
     for path in paths.split(os.pathsep):
def output_files(self):
             outputs.append(self._exe_file_name())
 
         return [x for x in outputs if x is not None]
 
 class GccBuilder(Builder):
     def __init__(self, toolchain_type, args):
         Builder.__init__(self, toolchain_type, args)
 
+    def _output_name(self, input, extension, with_executable=False):
+        basename = os.path.splitext(os.path.basename(input))[0] + extension
+        if with_executable:
+            exe_basename = os.path.basename(self._exe_file_name())
+            basename = exe_basename + '-' + basename
+
+        output = os.path.join(self.outdir, basename)
+        return os.path.normpath(output)
+
+    def _obj_file_names(self):
+        if self.mode == 'link':
+            return self.inputs
+
+        if self.mode == 'compile-and-link':
+            # Object file names should factor in both the input file (source)
+            # name and output file (executable) name, to ensure that two tests
+            # which share a common source file don't race to write the same
+            # object file.
+            return [self._output_name(x, '.o', True) for x in self.inputs]
+
+        if self.mode == 'compile' and self.output:
+            return [self.output]
+
+        return [self._output_name(x, '.o') for x in self.inputs]
+
+    def _exe_file_name(self):
+        if self.mode == 'compile':
+            return None
+        return self.output
+
+    def _get_compilation_command(self, source, obj):
+        args = []
+
+        args.append(self.compiler)
+
+        if self.opt == 'none':
+            args.append('-O0')
+        elif self.opt == 'basic':
+            args.append('-O2')
+        elif self.opt == 'lto':
+            args.append('-flto=thin')
+
+        args.append('-c')
+        args.append('-g')
+        args.append('-o' + obj)
+        args.append(source)
+
+        return ('compiling', [source], obj,
+                None,
+                args)
+
+    def _get_compile_and_link_command(self):
+        args = []
+
+        args.append(self.compiler)
+
+        if self.opt == 'none':
+            args.append('-O0')
+        elif self.opt == 'basic':
+            args.append('-O2')
+        elif self.opt == 'lto':
+            args.append('-flto=thin')
+
+        args.append('-g')
+        args.append('-o' + self._exe_file_name())
+        args.extend(self.inputs)
+
+        return ('compiling and linking', self.inputs, self._exe_file_name(),
+                None,
+                args)
+
+    def _get_link_command(self):
+        args = []
+        args.append('echo linking only not supported')
+
+        return ('linking', self._obj_file_names(), self._exe_file_name(),
+                None,
+                args)
+
     def build_commands(self):
-        pass
+        commands = []
+        if self.mode == 'compile':
+            for input, output in zip(self.inputs, self._obj_file_names()):
+                commands.append(self._get_compilation_command(input, output))
+        if self.mode == 'compile-and-link':
+            commands.append(self._get_compile_and_link_command())
+        if self.mode == 'link':
+            commands.append(self._get_link_command())
+        return commands
 
     def output_files(self):
-        pass
+        outdir = os.path.dirname(self.output)
+        file = os.path.basename(self.output)
+        name, ext = os.path.splitext(file)
+
+        outputs = []
+        if self.mode == 'compile' or self.mode == 'compile-and-link':
+            outputs.extend(self._obj_file_names())
+        if self.mode == 'link' or self.mode == 'compile-and-link':
+            outputs.append(self._exe_file_name())
+
+        return [x for x in outputs if x is not None]
 
 def indent(text, spaces):
     def prefixed_lines():
         prefix = ' ' * spaces
         for line in text.splitlines(True):
             yield prefix + line
     return ''.join(prefixed_lines())