scons: Use the new error() and warning() methods.

Also clean up some error messages which were missing capitalization,
etc.

Change-Id: Iaef6b4343a693d30b579e72218cbb7723ebf7d48
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/22886
Reviewed-by: Jason Lowe-Power <jason@lowepower.com>
Maintainer: Jason Lowe-Power <jason@lowepower.com>
Tested-by: kokoro <noreply+kokoro@google.com>

1 files changed, 80 insertions, 135 deletions

diff --git a/SConstruct b/SConstruct
index 3951a8e51..9a382102c 100755
--- a/SConstruct
+++ b/SConstruct
@@ -169,9 +169,10 @@ AddLocalOption('--with-ubsan', dest='with_ubsan', action='store_true',
 AddLocalOption('--with-asan', dest='with_asan', action='store_true',
                help='Build with Address Sanitizer if available')
 
+from gem5_scons import Transform, error, warning
+
 if GetOption('no_lto') and GetOption('force_lto'):
-    print('--no-lto and --force-lto are mutually exclusive')
-    Exit(1)
+    error('--no-lto and --force-lto are mutually exclusive')
 
 ########################################################################
 #
@@ -181,7 +182,6 @@ if GetOption('no_lto') and GetOption('force_lto'):
 
 main = Environment()
 
-from gem5_scons import Transform
 from gem5_scons.util import get_termcap
 termcap = get_termcap()
 
@@ -189,8 +189,7 @@ main_dict_keys = main.Dictionary().keys()
 
 # Check that we have a C/C++ compiler
 if not ('CC' in main_dict_keys and 'CXX' in main_dict_keys):
-    print("No C++ compiler installed (package g++ on Ubuntu and RedHat)")
-    Exit(1)
+    error("No C++ compiler installed (package g++ on Ubuntu and RedHat)")
 
 ###################################################
 #
@@ -249,16 +248,14 @@ for t in BUILD_TARGETS:
     try:
         build_top = rfind(path_dirs, 'build', -2)
     except:
-        print("Error: no non-leaf 'build' dir found on target path", t)
-        Exit(1)
+        error("No non-leaf 'build' dir found on target path.", t)
     this_build_root = joinpath('/',*path_dirs[:build_top+1])
     if not build_root:
         build_root = this_build_root
     else:
         if this_build_root != build_root:
-            print("Error: build targets not under same build root\n"
+            error("build targets not under same build root\n"
                   "  %s\n  %s" % (build_root, this_build_root))
-            Exit(1)
     variant_path = joinpath('/',*path_dirs[:build_top+2])
     if variant_path not in variant_paths:
         variant_paths.append(variant_path)
@@ -358,8 +355,7 @@ CXX_V = readCommand([main['CXX'],'-V'], exception=False)
 main['GCC'] = CXX_version and CXX_version.find('g++') >= 0
 main['CLANG'] = CXX_version and CXX_version.find('clang') >= 0
 if main['GCC'] + main['CLANG'] > 1:
-    print('Error: How can we have two at the same time?')
-    Exit(1)
+    error('Two compilers enabled at once?')
 
 # Set up default C++ compiler flags
 if main['GCC'] or main['CLANG']:
@@ -392,23 +388,18 @@ if main['GCC'] or main['CLANG']:
                          '-Wno-error=deprecated',
                         ])
 else:
-    print(termcap.Yellow + termcap.Bold + 'Error' + termcap.Normal, end=' ')
-    print("Don't know what compiler options to use for your compiler.")
-    print(termcap.Yellow + '       compiler:' + termcap.Normal, main['CXX'])
-    print(termcap.Yellow + '       version:' + termcap.Normal, end = ' ')
-    if not CXX_version:
-        print(termcap.Yellow + termcap.Bold + "COMMAND NOT FOUND!" +
-              termcap.Normal)
-    else:
-        print(CXX_version.replace('\n', '<nl>'))
-    print("       If you're trying to use a compiler other than GCC")
-    print("       or clang, there appears to be something wrong with your")
-    print("       environment.")
-    print("       ")
-    print("       If you are trying to use a compiler other than those listed")
-    print("       above you will need to ease fix SConstruct and ")
-    print("       src/SConscript to support that compiler.")
-    Exit(1)
+    error('\n'.join(
+          "Don't know what compiler options to use for your compiler.",
+          "compiler: " + main['CXX'],
+          "version: " + CXX_version.replace('\n', '<nl>') if
+                CXX_version else 'COMMAND NOT FOUND!',
+          "If you're trying to use a compiler other than GCC",
+          "or clang, there appears to be something wrong with your",
+          "environment.",
+          "",
+          "If you are trying to use a compiler other than those listed",
+          "above you will need to ease fix SConstruct and ",
+          "src/SConscript to support that compiler."))
 
 if main['GCC']:
     # Check for a supported version of gcc. >= 4.8 is chosen for its
@@ -416,8 +407,8 @@ if main['GCC']:
     # http://gcc.gnu.org/projects/cxx0x.html for details.
     gcc_version = readCommand([main['CXX'], '-dumpversion'], exception=False)
     if compareVersions(gcc_version, "4.8") < 0:
-        print('Error: gcc version 4.8 or newer required.')
-        print('       Installed version: ', gcc_version)
+        error('gcc version 4.8 or newer required.\n'
+              'Installed version:', gcc_version)
         Exit(1)
 
     main['GCC_VERSION'] = gcc_version
@@ -447,21 +438,16 @@ if main['GCC']:
     # Make sure we warn if the user has requested to compile with the
     # Undefined Benahvior Sanitizer and this version of gcc does not
     # support it.
-    if GetOption('with_ubsan') and \
-            compareVersions(gcc_version, '4.9') < 0:
-        print(termcap.Yellow + termcap.Bold +
-            'Warning: UBSan is only supported using gcc 4.9 and later.' +
-            termcap.Normal)
+    if GetOption('with_ubsan') and compareVersions(gcc_version, '4.9') < 0:
+        warning('UBSan is only supported using gcc 4.9 and later.')
 
     disable_lto = GetOption('no_lto')
     if not disable_lto and main.get('BROKEN_INCREMENTAL_LTO', False) and \
             not GetOption('force_lto'):
-        print(termcap.Yellow + termcap.Bold +
-            'Warning: Your compiler doesn\'t support incremental linking' +
-            ' and lto at the same time, so lto is being disabled. To force' +
-            ' lto on anyway, use the --force-lto option. That will disable' +
-            ' partial linking.' +
-            termcap.Normal)
+        warning('Warning: Your compiler doesn\'t support incremental linking '
+                'and lto at the same time, so lto is being disabled. To force '
+                'lto on anyway, use the --force-lto option. That will disable '
+                'partial linking.')
         disable_lto = True
 
     # Add the appropriate Link-Time Optimization (LTO) flags
@@ -508,12 +494,10 @@ elif main['CLANG']:
     if (clang_version_match):
         clang_version = clang_version_match.groups()[0]
         if compareVersions(clang_version, "3.1") < 0:
-            print('Error: clang version 3.1 or newer required.')
-            print('       Installed version:', clang_version)
-            Exit(1)
+            error('clang version 3.1 or newer required.\n'
+                  'Installed version:', clang_version)
     else:
-        print('Error: Unable to determine clang version.')
-        Exit(1)
+        error('Unable to determine clang version.')
 
     # clang has a few additional warnings that we disable, extraneous
     # parantheses are allowed due to Ruby's printing of the AST,
@@ -555,25 +539,6 @@ elif main['CLANG']:
                              '-fno-omit-frame-pointer'],
                    LINKFLAGS='-fsanitize=address')
 
-else:
-    print(termcap.Yellow + termcap.Bold + 'Error' + termcap.Normal, end=' ')
-    print("Don't know what compiler options to use for your compiler.")
-    print(termcap.Yellow + '       compiler:' + termcap.Normal, main['CXX'])
-    print(termcap.Yellow + '       version:' + termcap.Normal, end=' ')
-    if not CXX_version:
-        print(termcap.Yellow + termcap.Bold + "COMMAND NOT FOUND!" +
-              termcap.Normal)
-    else:
-        print(CXX_version.replace('\n', '<nl>'))
-    print("       If you're trying to use a compiler other than GCC")
-    print("       or clang, there appears to be something wrong with your")
-    print("       environment.")
-    print("       ")
-    print("       If you are trying to use a compiler other than those listed")
-    print("       above you will need to ease fix SConstruct and ")
-    print("       src/SConscript to support that compiler.")
-    Exit(1)
-
 # Set up common yacc/bison flags (needed for Ruby)
 main['YACCFLAGS'] = '-d'
 main['YACCHXXFILESUFFIX'] = '.hh'
@@ -601,21 +566,17 @@ try:
 
     # First two words should be "libprotoc x.y.z"
     if len(protoc_version) < 2 or protoc_version[0] != 'libprotoc':
-        print(termcap.Yellow + termcap.Bold +
-            'Warning: Protocol buffer compiler (protoc) not found.\n' +
-            '         Please install protobuf-compiler for tracing support.' +
-            termcap.Normal)
+        warning('Protocol buffer compiler (protoc) not found.\n'
+                'Please install protobuf-compiler for tracing support.')
         main['HAVE_PROTOC'] = False
     else:
         # Based on the availability of the compress stream wrappers,
         # require 2.1.0
         min_protoc_version = '2.1.0'
         if compareVersions(protoc_version[1], min_protoc_version) < 0:
-            print(termcap.Yellow + termcap.Bold +
-                'Warning: protoc version', min_protoc_version,
-                'or newer required.\n' +
-                '         Installed version:', protoc_version[1],
-                termcap.Normal)
+            warning('protoc version', min_protoc_version,
+                    'or newer required.\n'
+                    'Installed version:', protoc_version[1])
             main['HAVE_PROTOC'] = False
         else:
             # Attempt to determine the appropriate include path and
@@ -632,11 +593,9 @@ try:
                     main.ParseConfig(
                             'pkg-config --cflags --libs-only-L protobuf')
                 except:
-                    print(termcap.Yellow + termcap.Bold +
-                        'Warning: pkg-config could not get protobuf flags.' +
-                        termcap.Normal)
+                    warning('pkg-config could not get protobuf flags.')
 except Exception as e:
-    print(termcap.Yellow + termcap.Bold + str(e) + termcap.Normal)
+    warning('While checking protoc version:', str(e))
     main['HAVE_PROTOC'] = False
 
 # Check for 'timeout' from GNU coreutils. If present, regressions will
@@ -731,9 +690,8 @@ if main['USE_PYTHON']:
 
     python_config = find_first_prog(main['PYTHON_CONFIG'])
     if python_config is None:
-        print("Error: can't find a suitable python-config, tried %s" % \
+        error("Can't find a suitable python-config, tried %s" % \
               main['PYTHON_CONFIG'])
-        Exit(1)
 
     print("Info: Using Python config: %s" % (python_config, ))
     py_includes = readCommand([python_config, '--includes'],
@@ -759,33 +717,30 @@ if main['USE_PYTHON']:
 
     # verify that this stuff works
     if not conf.CheckHeader('Python.h', '<>'):
-        print("Error: Check failed for Python.h header in", py_includes)
-        print("Two possible reasons:")
-        print("1. Python headers are not installed (You can install the "
-              "package python-dev on Ubuntu and RedHat)")
-        print("2. SCons is using a wrong C compiler. This can happen if "
-              "CC has the wrong value.")
-        print("CC = %s" % main['CC'])
-        Exit(1)
+        error("Check failed for Python.h header in", py_includes, "\n"
+              "Two possible reasons:\n"
+              "1. Python headers are not installed (You can install the "
+              "package python-dev on Ubuntu and RedHat)\n"
+              "2. SCons is using a wrong C compiler. This can happen if "
+              "CC has the wrong value.\n"
+              "CC = %s" % main['CC'])
 
     for lib in py_libs:
         if not conf.CheckLib(lib):
-            print("Error: can't find library %s required by python" % lib)
-            Exit(1)
+            error("Can't find library %s required by python." % lib)
 
 # On Solaris you need to use libsocket for socket ops
 if not conf.CheckLibWithHeader(None, 'sys/socket.h', 'C++', 'accept(0,0,0);'):
-   if not conf.CheckLibWithHeader('socket', 'sys/socket.h', 'C++', 'accept(0,0,0);'):
-       print("Can't find library with socket calls (e.g. accept())")
-       Exit(1)
+   if not conf.CheckLibWithHeader('socket', 'sys/socket.h',
+                                  'C++', 'accept(0,0,0);'):
+       error("Can't find library with socket calls (e.g. accept()).")
 
 # Check for zlib.  If the check passes, libz will be automatically
 # added to the LIBS environment variable.
 if not conf.CheckLibWithHeader('z', 'zlib.h', 'C++','zlibVersion();'):
-    print('Error: did not find needed zlib compression library '
-          'and/or zlib.h header file.')
-    print('       Please install zlib and try again.')
-    Exit(1)
+    error('Did not find needed zlib compression library '
+          'and/or zlib.h header file.\n'
+          'Please install zlib and try again.')
 
 # If we have the protobuf compiler, also make sure we have the
 # development libraries. If the check passes, libprotobuf will be
@@ -802,10 +757,8 @@ main['HAVE_VALGRIND'] = conf.CheckCHeader('valgrind/valgrind.h')
 
 # If we have the compiler but not the library, print another warning.
 if main['HAVE_PROTOC'] and not main['HAVE_PROTOBUF']:
-    print(termcap.Yellow + termcap.Bold +
-        'Warning: did not find protocol buffer library and/or headers.\n' +
-    '       Please install libprotobuf-dev for tracing support.' +
-    termcap.Normal)
+    warning('Did not find protocol buffer library and/or headers.\n'
+            'Please install libprotobuf-dev for tracing support.')
 
 # Check for librt.
 have_posix_clock = \
@@ -824,10 +777,9 @@ if not GetOption('without_tcmalloc'):
     elif conf.CheckLib('tcmalloc_minimal'):
         main.Append(CCFLAGS=main['TCMALLOC_CCFLAGS'])
     else:
-        print(termcap.Yellow + termcap.Bold +
-              "You can get a 12% performance improvement by "
-              "installing tcmalloc (libgoogle-perftools-dev package "
-              "on Ubuntu or RedHat)." + termcap.Normal)
+        warning("You can get a 12% performance improvement by "
+                "installing tcmalloc (libgoogle-perftools-dev package "
+                "on Ubuntu or RedHat).")
 
 
 # Detect back trace implementations. The last implementation in the
@@ -846,26 +798,24 @@ elif conf.CheckLibWithHeader('execinfo', 'execinfo.h', 'C',
 
 if backtrace_impls[-1] == "none":
     default_backtrace_impl = "none"
-    print(termcap.Yellow + termcap.Bold +
-        "No suitable back trace implementation found." +
-        termcap.Normal)
+    warning("No suitable back trace implementation found.")
 
 if not have_posix_clock:
-    print("Can't find library for POSIX clocks.")
+    warning("Can't find library for POSIX clocks.")
 
 # Check for <fenv.h> (C99 FP environment control)
 have_fenv = conf.CheckHeader('fenv.h', '<>')
 if not have_fenv:
-    print("Warning: Header file <fenv.h> not found.")
-    print("         This host has no IEEE FP rounding mode control.")
+    warning("Header file <fenv.h> not found.\n"
+            "This host has no IEEE FP rounding mode control.")
 
 # Check for <png.h> (libpng library needed if wanting to dump
 # frame buffer image in png format)
 have_png = conf.CheckHeader('png.h', '<>')
 if not have_png:
-    print("Warning: Header file <png.h> not found.")
-    print("         This host has no libpng library.")
-    print("         Disabling support for PNG framebuffers.")
+    warning("Header file <png.h> not found.\n"
+            "This host has no libpng library.\n"
+            "Disabling support for PNG framebuffers.")
 
 # Check if we should enable KVM-based hardware virtualization. The API
 # we rely on exists since version 2.6.36 of the kernel, but somehow
@@ -893,12 +843,12 @@ def is_isa_kvm_compatible(isa):
         import platform
         host_isa = platform.machine()
     except:
-        print("Warning: Failed to determine host ISA.")
+        warning("Failed to determine host ISA.")
         return False
 
     if not have_posix_timers:
-        print("Warning: Can not enable KVM, host seems to lack support "
-              "for POSIX timers")
+        warning("Can not enable KVM, host seems to lack support "
+                "for POSIX timers")
         return False
 
     if isa == "arm":
@@ -908,7 +858,7 @@ def is_isa_kvm_compatible(isa):
             return False
 
         if not have_kvm_xsave:
-            print("KVM on x86 requires xsave support in kernel headers.")
+            warning("KVM on x86 requires xsave support in kernel headers.")
             return False
 
         return True
@@ -1020,8 +970,7 @@ if GetOption('verbose'):
     print("Reading SConsopts")
 for bdir in [ base_dir ] + extras_dir_list:
     if not isdir(bdir):
-        print("Error: directory '%s' does not exist" % bdir)
-        Exit(1)
+        error("Directory '%s' does not exist." % bdir)
     for root, dirs, files in os.walk(bdir):
         if 'SConsopts' in files:
             if GetOption('verbose'):
@@ -1266,8 +1215,7 @@ for variant_path in variant_paths:
             print("Variables file %s not found,\n  using defaults in %s"
                   % (current_vars_file, default_vars_file))
         else:
-            print("Error: cannot find variables file %s or "
-                  "default file(s) %s"
+            error("Cannot find variables file %s or default file(s) %s"
                   % (current_vars_file, ' or '.join(default_vars_files)))
             Exit(1)
 
@@ -1281,18 +1229,17 @@ for variant_path in variant_paths:
     # Process variable settings.
 
     if not have_fenv and env['USE_FENV']:
-        print("Warning: <fenv.h> not available; "
-              "forcing USE_FENV to False in", variant_dir + ".")
+        warning("<fenv.h> not available; forcing USE_FENV to False in",
+                variant_dir + ".")
         env['USE_FENV'] = False
 
     if not env['USE_FENV']:
-        print("Warning: No IEEE FP rounding mode control in",
-              variant_dir + ".")
-        print("         FP results may deviate slightly from other platforms.")
+        warning("No IEEE FP rounding mode control in", variant_dir + ".\n"
+                "FP results may deviate slightly from other platforms.")
 
     if not have_png and env['USE_PNG']:
-        print("Warning: <png.h> not available; "
-              "forcing USE_PNG to False in", variant_dir + ".")
+        warning("<png.h> not available; forcing USE_PNG to False in",
+                variant_dir + ".")
         env['USE_PNG'] = False
 
     if env['USE_PNG']:
@@ -1303,8 +1250,7 @@ for variant_path in variant_paths:
 
     if env['USE_KVM']:
         if not have_kvm:
-            print("Warning: Can not enable KVM, host seems to "
-                  "lack KVM support")
+            warning("Can not enable KVM, host seems to lack KVM support")
             env['USE_KVM'] = False
         elif not is_isa_kvm_compatible(env['TARGET_ISA']):
             print("Info: KVM support disabled due to unsupported host and "
@@ -1313,7 +1259,7 @@ for variant_path in variant_paths:
 
     if env['USE_TUNTAP']:
         if not have_tuntap:
-            print("Warning: Can't connect EtherTap with a tap device.")
+            warning("Can't connect EtherTap with a tap device.")
             env['USE_TUNTAP'] = False
 
     if env['BUILD_GPU']:
@@ -1322,9 +1268,8 @@ for variant_path in variant_paths:
     # Warn about missing optional functionality
     if env['USE_KVM']:
         if not main['HAVE_PERF_ATTR_EXCLUDE_HOST']:
-            print("Warning: perf_event headers lack support for the "
-                  "exclude_host attribute. KVM instruction counts will "
-                  "be inaccurate.")
+            warning("perf_event headers lack support for the exclude_host "
+                    "attribute. KVM instruction counts will be inaccurate.")
 
     # Save sticky variable settings back to current variables file
     sticky_vars.Save(current_vars_file, env)