Merge branch 'master' of https://github.com/SRI-CSL/whole-program-llvm into SRI-CSL-master

Author: travitch

.travis/apache_clang.sh

@@ -12,6 +12,7 @@ wget https://archive.apache.org/dist/httpd/httpd-${APACHE_VER}.tar.gz
 
 tar xfz httpd-${APACHE_VER}.tar.gz
 mv httpd-${APACHE_VER} apache_clang
+
 cd apache_clang
 CC=wllvm ./configure
 make

.travis/apache_dragonegg.sh

@@ -11,10 +11,10 @@ export LLVM_DRAGONEGG_PLUGIN=/usr/lib/gcc/x86_64-linux-gnu/4.6/plugin/dragonegg.
 
 export WLLVM_OUTPUT=WARNING
 
-
 APACHE_VER=2.4.18
 wget https://archive.apache.org/dist/httpd/httpd-${APACHE_VER}.tar.gz
 
+
 tar xfz httpd-${APACHE_VER}.tar.gz
 mv httpd-${APACHE_VER} apache_dragonegg
 cd apache_dragonegg

README.md

@@ -22,15 +22,14 @@ utility to read the contents of the dedicated section and link all of
 the bitcode into a single whole-program bitcode file. This utility
 works for both executable and native libraries.
 
-Currently, WLLVM works with either clang or the gcc dragonegg plugin.
-
 This two-phase build process is necessary to be a drop-in replacement
 for gcc or g++ in any build system.  Using the LTO framework in gcc
 and the gold linker plugin works in many cases, but fails in the
 presence of static libraries in builds.  WLLVM's approach has the
 distinct advantage of generating working binaries, in case some part
 of a build process requires that.
 
+WLLVM works with either clang or the gcc dragonegg plugin.
 
 Usage
 =====
@@ -40,7 +39,7 @@ and `wllvm++` for C++, and an auxiliary tool `extract-bc`.
 
 Three environment variables must be set to use these wrappers:
 
- * `LLVM_COMPILER` should be set to either 'dragonegg' or 'clang'.
+ * `LLVM_COMPILER` should be set to either `dragonegg` or `clang`.
  * `LLVM_GCC_PREFIX` should be set to the prefix for the version of gcc that should
    be used with dragonegg.  This can be empty if there is no prefix.  This variable is
    not used if `$LLVM_COMPILER == clang`.
@@ -50,8 +49,16 @@ Three environment variables must be set to use these wrappers:
 Once the environment is set up, just use `wllvm` and `wllvm++` as your C
 and C++ compilers, respectively.
 
+
 In addition to the above environment variables the following can be optionally used:
 
+ * `LLVM_CC_NAME` can be set if your clang compiler is not called `clang` but
+    something like `clang-3.7`. Similarly `LLVM_CXX_NAME` can be used to describe
+    what the C++ compiler is called. Note that in these sorts of cases, the environment
+    variable `LLVM_COMPILER` should still be set to `clang` not `clang-3.7` etc.
+    We also pay attention to the environment variables `LLVM_LINK_NAME` and `LLVM_AR_NAME` in an
+    analagous way,  since they too get adorned with suffixes in various Linux distributions.
+
  * `LLVM_COMPILER_PATH` can be set to the absolute path to the folder that
    contains the compiler and other LLVM tools such as `llvm-link` to be used.
    This prevents searching for the compiler in your PATH environment variable.
@@ -62,7 +69,7 @@ In addition to the above environment variables the following can be optionally u
 
 * `WLLVM_CONFIGURE_ONLY` can be set to anything. If it is set, `wllvm`
    and `wllvm++` behave like a normal C or C++ compiler. They do not
-   the produce bitcode.  Setting `WLLVM_CONFIGURE_ONLY` may prevent
+   produce bitcode.  Setting `WLLVM_CONFIGURE_ONLY` may prevent
    configuration errors caused by the unexpected production of hidden
    bitcode files.
 
@@ -80,6 +87,9 @@ Building a bitcode module with clang
     # Produces pkg-config.bc
     extract-bc pkg-config
 
+A gentler set of instructions on building apache can be found
+[here.](https://github.com/SRI-CSL/whole-program-llvm/blob/master/tutorial.md)
+
 Building a bitcode module with dragonegg
 ========================================
 
@@ -125,6 +135,23 @@ Configuring without building bitcode
     CC=wllvm make
 
 
+Building a bitcode archive then extracting the bitcode
+========================
+
+    export LLVM_COMPILER=clang
+    tar xvfz jansson-2.7.tar.gz
+    cd jansson-2.7
+    CC=wllvm ./configure
+    make
+    mkdir bitcode
+    cp src/.libs/libjansson.a bitcode
+    cd bitcode
+    extract-bc libjansson.a
+    llvm-ar x libjansson.bca
+    ls -la
+   
+    
+
 Debugging
 =========
 
@@ -141,6 +168,18 @@ For example
 
     export WLLVM_OUTPUT=DEBUG
 
+
+Sanity Checking
+=========
+
+Too many environment variables? Try doing a sanity check:
+
+```
+wllvm-sanity-checker
+```
+it might point out what is wrong.
+
+
 License
 =======
 

driver/utils.py

@@ -25,7 +25,9 @@
 elfSectionName='.llvm_bc'
 
 # These are the MACH_O segment and section name
-darwinSegmentName='__LLVM'
+# The SegmentName was __LLVM. Changed to __WLLVM to avoid clashing
+# with a segment that ld now uses (since MacOS X 10.11.3?)
+darwinSegmentName='__WLLVM'
 darwinSectionName='__llvm_bc'
 
 
@@ -167,7 +169,7 @@ def __init__(self, inputList, exactMatches={}, patternMatches={}):
             '-Ofast' : (0, ArgumentListFilter.compileUnaryCallback),
             '-Og' : (0, ArgumentListFilter.compileUnaryCallback),
             # Component-specifiers
-            '-Xclang' : (1, ArgumentListFilter.defaultBinaryCallback),
+            '-Xclang' : (1, ArgumentListFilter.compileBinaryCallback),
             '-Xpreprocessor' : (1, ArgumentListFilter.defaultBinaryCallback),
             '-Xassembler' : (1, ArgumentListFilter.defaultBinaryCallback),
             '-Xlinker' : (1, ArgumentListFilter.defaultBinaryCallback),
@@ -194,6 +196,12 @@ def __init__(self, inputList, exactMatches={}, patternMatches={}):
             # dragonegg mystery argument
             '--64' : (0, ArgumentListFilter.compileUnaryCallback),
 
+            # binutils nonsense
+            '-print-multi-directory' : (0, ArgumentListFilter.compileUnaryCallback),
+            '-print-multi-lib' : (0, ArgumentListFilter.compileUnaryCallback),
+            '-print-libgcc-file-name' : (0, ArgumentListFilter.compileUnaryCallback),
+
+
             #
             # BD: need to warn the darwin user that these flags will rain on their parade
             # (the Darwin ld is a bit single minded)
@@ -215,7 +223,7 @@ def __init__(self, inputList, exactMatches={}, patternMatches={}):
         #
         # Patterns for other command-line arguments:
         # - inputFiles
-        # - objecFiles (suffix .o)
+        # - objectFiles (suffix .o)
         # - libraries + linker options as in -lxxx -Lpath or -Wl,xxxx
         # - preprocessor options as in -DXXX -Ipath
         # - compiler warning options: -W....
@@ -225,7 +233,7 @@ def __init__(self, inputList, exactMatches={}, patternMatches={}):
             r'^.+\.(c|cc|cpp|C|cxx|i|s|S)$' : (0, ArgumentListFilter.inputFileCallback),
             #iam: the object file recogition is not really very robust, object files
             # should be determined by their existance and contents...
-            r'^.+\.(o|lo|So|so|po|a)$' : (0, ArgumentListFilter.objectFileCallback),
+            r'^.+\.(o|lo|So|so|po|a|dylib)$' : (0, ArgumentListFilter.objectFileCallback),
             #iam: library.so.4.5.6 probably need a similar pattern for .dylib too.
             r'^.+\.dylib(\.\d)+$' : (0, ArgumentListFilter.objectFileCallback),
             r'^.+\.(So|so)(\.\d)+$' : (0, ArgumentListFilter.objectFileCallback),
@@ -237,15 +245,17 @@ def __init__(self, inputList, exactMatches={}, patternMatches={}):
             r'^-W(?!l,).*$' : (0, ArgumentListFilter.compileUnaryCallback),
             r'^-f.+$' : (0, ArgumentListFilter.compileUnaryCallback),
             r'^-std=.+$' : (0, ArgumentListFilter.compileUnaryCallback),
+            r'^-print-prog-name=.*$' : (0, ArgumentListFilter.compileUnaryCallback),
+            r'^-print-file-name=.*$' : (0, ArgumentListFilter.compileUnaryCallback),
+            
         }
 
-        self.inputList = inputList
-
         #iam: try and keep track of the files, input object, and output
+        self.inputList = inputList
         self.inputFiles = []
         self.objectFiles = []
         self.outputFilename = None
-
+        
         #iam: try and split the args into linker and compiler switches
         self.compileArgs = []
         self.linkArgs = []
@@ -546,16 +556,24 @@ def getBitcodeFileName(self, argFilter):
 class ClangBuilder(BuilderBase):
     def __init__(self, cmd, isCxx, prefixPath=None):
         super(ClangBuilder, self).__init__(cmd, isCxx, prefixPath)
-
+        
     def getBitcodeCompiler(self):
         cc = self.getCompiler()
         return cc + ['-emit-llvm']
 
     def getCompiler(self):
         if self.isCxx:
-            return ['{0}clang++'.format(self.prefixPath)]
+            cxx =  os.getenv('LLVM_CXX_NAME')
+            if cxx:
+                return ['{0}{1}'.format(self.prefixPath, cxx)]
+            else:
+                return ['{0}clang++'.format(self.prefixPath)]
         else:
-            return ['{0}clang'.format(self.prefixPath)]
+            cc =  os.getenv('LLVM_CC_NAME')
+            if cc:
+                return ['{0}{1}'.format(self.prefixPath, cc)]
+            else:
+                return ['{0}clang'.format(self.prefixPath)]
 
     def getBitcodeArglistFilter(self):
         return ClangBitcodeArgumentListFilter(self.cmd)
@@ -569,7 +587,6 @@ def attachBitcode(self, argFilter):
         outFile = argFilter.getOutputFilename()
         attachBitcodePathToObject(bcname, outFile)
 
-#iam: this should join the dodo soon, yes?
 class DragoneggBuilder(BuilderBase):
     def __init__(self, cmd, isCxx, prefixPath=None):
         super(DragoneggBuilder, self).__init__(cmd, isCxx, prefixPath)