Merge pull request travitch#72 from SRI-CSL/master

Version 1.2.0 released.

Author: travitch

.travis.yml

@@ -30,7 +30,7 @@ install:
 # command to run tests
 script:
 #  # Run unittests
-  - python -m unittest discover test/ || exit 1
+#  - python -m unittest discover test/ || exit 1
   - export WLLVM_HOME=`pwd`
   - ${WLLVM_HOME}/.travis/store.sh
   - export APACHE_VER=2.4.18

setup.py

@@ -20,7 +20,7 @@
     description='Whole Program LLVM',
     long_description=long_description,
     url='https://github.com/SRI-CSL/whole-program-llvm',
-    author='Ian A. Mason, Tristan Ravitch, Dan Liew, Bruno Dutertre, Benjamin Schubert, Berkeley Churchill, Marko Dimjasevic, Will Dietz, Fabian Mager, Ben Liblit, Andrew Santosa, Tomas Kalibera, Loic  Gelle, Joshua Cranmer.',
+    author='Ian A. Mason, Tristan Ravitch, Dan Liew, Bruno Dutertre, Benjamin Schubert, Berkeley Churchill, Marko Dimjasevic, Will Dietz, Fabian Mager, Ben Liblit, Andrew Santosa, Tomas Kalibera, Loic  Gelle, Joshua Cranmer, Alexander Bakst.',
     author_email='iam@csl.sri.com',
 
 

wllvm/arglistfilter.py

@@ -88,10 +88,16 @@ def __init__(self, inputList, exactMatches={}, patternMatches={}):
             '-msoft-float' : (0, ArgumentListFilter.compileUnaryCallback),
             '-m3dnow' : (0, ArgumentListFilter.compileUnaryCallback),
             '-mno-3dnow' : (0, ArgumentListFilter.compileUnaryCallback),
+            '-m16': (0, ArgumentListFilter.compileUnaryCallback),
             '-m32': (0, ArgumentListFilter.compileUnaryCallback),
+            '-mx32': (0, ArgumentListFilter.compileUnaryCallback),
             '-m64': (0, ArgumentListFilter.compileUnaryCallback),
+            '-miamcu': (0, ArgumentListFilter.compileUnaryCallback),
             '-mstackrealign': (0, ArgumentListFilter.compileUnaryCallback),
-
+            '-mretpoline-external-thunk': (0, ArgumentListFilter.compileUnaryCallback),  #iam: linux kernel stuff
+            '-mno-fp-ret-in-387': (0, ArgumentListFilter.compileUnaryCallback),          #iam: linux kernel stuff
+            '-mskip-rax-setup': (0, ArgumentListFilter.compileUnaryCallback),            #iam: linux kernel stuff
+            '-mindirect-branch-register': (0, ArgumentListFilter.compileUnaryCallback),  #iam: linux kernel stuff
             # Preprocessor assertion
             '-A' : (1, ArgumentListFilter.compileBinaryCallback),
             '-D' : (1, ArgumentListFilter.compileBinaryCallback),
@@ -194,6 +200,11 @@ def __init__(self, inputList, exactMatches={}, patternMatches={}):
             '-coverage' : (0, ArgumentListFilter.compileLinkUnaryCallback),
             '--coverage' : (0, ArgumentListFilter.compileLinkUnaryCallback),
 
+            # ian's additions while building the linux kernel
+            '/dev/null' : (0, ArgumentListFilter.inputFileCallback),
+            '-mno-80387': (0, ArgumentListFilter.compileUnaryCallback), #gcc Don't generate output containing 80387 instructions for floating point.
+
+
             #
             # BD: need to warn the darwin user that these flags will rain on their parade
             # (the Darwin ld is a bit single minded)
@@ -209,6 +220,8 @@ def __init__(self, inputList, exactMatches={}, patternMatches={}):
             # calling ld -r.
             #
             '-Wl,-dead_strip' :  (0, ArgumentListFilter.darwinWarningLinkUnaryCallback),
+            '-Oz' : (0, ArgumentListFilter.compileUnaryCallback),   #did not find this in the GCC options.
+            '-mno-global-merge' : (0, ArgumentListFilter.compileUnaryCallback),  #clang (do not merge globals)
 
         }
 
@@ -242,6 +255,18 @@ def __init__(self, inputList, exactMatches={}, patternMatches={}):
             r'^-std=.+$' : (0, ArgumentListFilter.compileUnaryCallback),
             r'^-stdlib=.+$' : (0, ArgumentListFilter.compileLinkUnaryCallback),
             r'^-mtune=.+$' : (0, ArgumentListFilter.compileUnaryCallback),
+            r'^-mstack-alignment=.+$': (0, ArgumentListFilter.compileUnaryCallback),                     #iam: linux kernel stuff
+            r'^-mcmodel=.+$': (0, ArgumentListFilter.compileUnaryCallback),                              #iam: linux kernel stuff
+            r'^-mpreferred-stack-boundary=.+$': (0, ArgumentListFilter.compileUnaryCallback),            #iam: linux kernel stuff
+            r'^-mindirect-branch=.+$': (0, ArgumentListFilter.compileUnaryCallback),                     #iam: linux kernel stuff
+            r'^-mregparm=.+$' : (0, ArgumentListFilter.compileUnaryCallback),                            #iam: linux kernel stuff
+            r'^-march=.+$' : (0, ArgumentListFilter.compileUnaryCallback),                               #iam: linux kernel stuff
+            r'^--param=.+$' : (0, ArgumentListFilter.compileUnaryCallback),                              #iam: linux kernel stuff
+
+
+            #iam: mac stuff...
+            r'-mmacosx-version-min=.+$' :  (0, ArgumentListFilter.compileUnaryCallback),
+
             r'^--sysroot=.+$' :  (0, ArgumentListFilter.compileUnaryCallback),
             r'^-print-prog-name=.*$' : (0, ArgumentListFilter.compileUnaryCallback),
             r'^-print-file-name=.*$' : (0, ArgumentListFilter.compileUnaryCallback),
@@ -284,7 +309,7 @@ def __init__(self, inputList, exactMatches={}, patternMatches={}):
                     self.isPreprocessOnly)):
             # Get the next argument
             currentItem = self._inputArgs.popleft()
-            _logger.debug('Trying to match item ' + currentItem)
+            _logger.debug('Trying to match item %s', currentItem)
             # First, see if this exact flag has a handler in the table.
             # This is a cheap test.  Otherwise, see if the input matches
             # some pattern with a handler that we recognize
@@ -311,13 +336,22 @@ def __init__(self, inputList, exactMatches={}, patternMatches={}):
 
 
     def skipBitcodeGeneration(self):
+        retval = (False, "")
         if os.environ.get('WLLVM_CONFIGURE_ONLY', False):
-            return True
-        if not self.inputFiles or self.isEmitLLVM or self.isAssembly or self.isAssembleOnly:
-            return True
-        if self.isPreprocessOnly or self.isStandardIn or (self.isDependencyOnly and not self.isCompileOnly):
-            return True
-        return False
+            retval = (True, "CFG Only")
+        elif not self.inputFiles:
+            retval = (True, "No input files")
+        elif self.isEmitLLVM:
+            retval = (True, "Emit LLVM")
+        elif self.isAssembly or self.isAssembleOnly:
+            retval = (True, "Assembly")
+        elif self.isPreprocessOnly:
+            retval = (True, "Preprocess Only")
+        elif self.isStandardIn:
+            retval = (True, "Standard In")
+        elif (self.isDependencyOnly and not self.isCompileOnly):
+            retval = (True, "Dependency Only")
+        return retval
 
     def _shiftArgs(self, nargs):
         ret = []

wllvm/checker.py

@@ -13,7 +13,8 @@
 import subprocess as sp
 import errno
 
-from .version import wllvm_version
+from .version import wllvm_version, wllvm_date
+from .logconfig import loggingConfiguration
 
 explain_LLVM_COMPILER = """
 
@@ -87,13 +88,17 @@ def check(self):
         """Performs the environmental sanity check.
 
         Performs the following checks in order:
-
+        0. Prints out the logging configuartion
         1. Check that the OS is supported.
         2. Checks that the compiler settings make sense.
         3. Checks that the needed LLVM utilities exists.
         4. Check that the store, if set, exists.
         """
 
+        self.checkSelf()
+
+        self.checkLogging()
+
         if not self.checkOS():
             print('I do not think we support your OS. Sorry.')
             return 1
@@ -106,6 +111,18 @@ def check(self):
 
         return 0 if success else 1
 
+    def checkSelf(self):
+        print('wllvm version: {0}'.format(wllvm_version))
+        print('wllvm released: {0}\n'.format(wllvm_date))
+
+
+    def checkLogging(self):
+        (destination, level) = loggingConfiguration()
+        print('Logging output to {0}.'.format(destination if destination else 'standard error'))
+        if not level:
+            print('Logging level not set, defaulting to WARNING\n')
+        else:
+            print('Logging level set to {0}.\n'.format(level))
 
 
     def checkOS(self):
@@ -118,11 +135,10 @@ def checkOS(self):
     def checkSwitch(self):
         """Checks the correctness of the LLVM_COMPILER env var."""
         compiler_type = os.getenv('LLVM_COMPILER')
-        vmsg = 'We are wllvm version {0} and'.format(wllvm_version)
         if compiler_type == 'clang':
-            return (1, '\n{0} we are using clang.\n'.format(vmsg))
+            return (1, '\nWe are using clang.\n')
         elif compiler_type == 'dragonegg':
-            return (2, '\n{0} we are using dragonegg.\n'.format(vmsg))
+            return (2, '\nWe are using dragonegg.\n')
         return (0, explain_LLVM_COMPILER)
 
 

wllvm/compilers.py

@@ -23,6 +23,11 @@ def wcompile(mode):
 
     rc = 1
 
+    legible_argstring = ' '.join(list(sys.argv)[1:])
+
+    # for diffing with gclang
+    _logger.info('Entering CC [%s]', legible_argstring)
+
     try:
         cmd = list(sys.argv)
         cmd = cmd[1:]
@@ -34,12 +39,13 @@ def wcompile(mode):
 
         # phase one compile failed. no point continuing
         if rc != 0:
-            _logger.info('phase one failed: %s', str(sys.argv))
+            _logger.error('Failed to compile using given arguments: [%s]', legible_argstring)
             return rc
 
         # no need to generate bitcode (e.g. configure only, assembly, ....)
-        if af.skipBitcodeGeneration():
-            _logger.info('No work to do')
+        (skipit, reason) = af.skipBitcodeGeneration()
+        if skipit:
+            _logger.debug('No work to do: %s', reason)
             _logger.debug(af.__dict__)
             return rc
 
@@ -49,7 +55,7 @@ def wcompile(mode):
     except Exception as e:
         _logger.warning('%s: exception case: %s', mode, str(e))
 
-    _logger.info('Calling %s returned %d', list(sys.argv), rc)
+    _logger.debug('Calling %s returned %d', list(sys.argv), rc)
     return rc
 
 
@@ -97,11 +103,19 @@ def attachBitcodePathToObject(bcPath, outFileName):
     # that won't work.
     (_, ext) = os.path.splitext(outFileName)
     _logger.debug('attachBitcodePathToObject: %s  ===> %s [ext = %s]', bcPath, outFileName, ext)
-    #iam: this also looks very dodgey; we need a more reliable way to do this:
-    if ext not in ('.o', '.lo', '.os', '.So', '.po'):
-        _logger.warning('Cannot attach bitcode path to "%s of type %s"', outFileName, FileType.getFileType(outFileName))
+
+    #iam: just object files, right?
+    fileType = FileType.getFileType(outFileName)
+    if fileType not in (FileType.MACH_OBJECT, FileType.ELF_OBJECT):
+    #if fileType not in (FileType.MACH_OBJECT, FileType.MACH_SHARED, FileType.ELF_OBJECT, FileType.ELF_SHARED):
+        _logger.warning('Cannot attach bitcode path to "%s of type %s"', outFileName, FileType.getFileTypeString(fileType))
         return
 
+    #iam: this also looks very dodgey; we need a more reliable way to do this:
+    #if ext not in ('.o', '.lo', '.os', '.So', '.po'):
+    #    _logger.warning('Cannot attach bitcode path to "%s of type %s"', outFileName, FileType.getReadableFileType(outFileName))
+    #    return
+
     # Now just build a temporary text file with the full path to the
     # bitcode file that we'll write into the object file.
     f = tempfile.NamedTemporaryFile(mode='w+b', delete=False)