Minor fixes to the FreeBSD contributions

On one code path, a reference to `af` should have been `self`.  There is
also a semantic change to handle odd uses of dependency-generation flags
that arises in libtool/autotools-based build systems.  These seem to
sometimes include dependency flags (-MT and friends) during
compilation (which probably has no effect).

The problem is that when these flags are really used for dependency
generation (and no code generation), we really should not invoke clang
to generate bitcode since it will fail.  On the other hand, we can't
just bail out when we see these -M* flags, since they might be misused
in a real compilation step.  This change tries to compromise: we only
skip bitcode generation when we see a -M* dependency flag and NO
accompanying `-c` flag.  This should work in the vast majority of cases,
since real makefile dependency generation should never use the -c flag.

Author: travitch

driver/utils.py

@@ -234,12 +234,12 @@ def __init__(self, inputList, exactMatches={}, patternMatches={}):
 
         #iam: parse the cmd line, bailing if we discover that there will be no second phase.
         while ( len(self._inputArgs) > 0   and
-                not (af.isAssembly or
-                     af.isAssembleOnly or
-                     af.isDependencyOnly or
-                     af.isPreprocessOnly  ) ):
+                not (self.isAssembly or
+                     self.isAssembleOnly or
+                     self.isPreprocessOnly  ) ):
             # Get the next argument
             currentItem = self._inputArgs.popleft()
+            _logger.debug('Trying to match item ' + 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
@@ -277,6 +277,7 @@ def abortUnaryCallback(self, flag):
         sys.exit(1)
 
     def inputFileCallback(self, infile):
+        _logger.debug('Input file: ' + infile)
         self.inputFiles.append(infile)
         if re.search('\\.(s|S)', infile):
             self.isAssembly = True
@@ -292,6 +293,7 @@ def preprocessOnlyCallback(self, flag):
 
     def dependencyOnlyCallback(self, flag):
         self.isDependencyOnly = True
+        self.compileArgs.append(flag)
 
     def assembleOnlyCallback(self, flag):
         self.isAssembleOnly = True
@@ -313,6 +315,8 @@ def defaultBinaryCallback(self, flag, arg):
 
     def dependencyBinaryCallback(self, flag, arg):
         self.isDependencyOnly = True
+        self.compileArgs.append(flag)
+        self.compileArgs.append(arg)
 
     def compileBinaryCallback(self, flag, arg):
         self.compileArgs.append(flag)
@@ -579,8 +583,10 @@ def buildAndAttachBitcode(builder):
     if ( len(af.inputFiles) == 0 or
          af.isAssembly or
          af.isAssembleOnly or
-         af.isDependencyOnly or
+         (af.isDependencyOnly and not af.isCompileOnly) or
          af.isPreprocessOnly  ):
+        _logger.debug('No work to do')
+        _logger.debug(af.__dict__)
         return
 
     #iam: when we have multiple input files we'll have to keep track of their object files.