ccc: Recognize -emit-llvm [-S].

- Unlike llvm-gcc, this doesn't yet treat -emit-llvm output as a
   linker input.

llvm-svn: 63014

clang/tools/ccc/ccclib/Arguments.py

@@ -689,7 +689,7 @@ class OptionParser:
 
         self.addOption(JoinedOption('-i', self.iGroup))
 
-        # Where are these coming from? I can't find them...
+        self.emitLLVMOption = self.addOption(FlagOption('-emit-llvm'))
         self.eOption = self.addOption(JoinedOrSeparateOption('-e'))
         self.rOption = self.addOption(JoinedOrSeparateOption('-r'))
 

clang/tools/ccc/ccclib/Driver.py

@@ -336,6 +336,7 @@ class Driver(object):
     def buildNormalPipeline(self, args):
         hasAnalyze = args.getLastArg(self.parser.analyzeOption)
         hasCombine = args.getLastArg(self.parser.combineOption)
+        hasEmitLLVM = args.getLastArg(self.parser.emitLLVMOption)
         hasSyntaxOnly = args.getLastArg(self.parser.syntaxOnlyOption)
         hasDashC = args.getLastArg(self.parser.cOption)
         hasDashE = args.getLastArg(self.parser.EOption)
@@ -368,7 +369,7 @@ class Driver(object):
                 # worth doing, since the tool presumably does this
                 # anyway, and this just adds an extra stat to the
                 # equation, but this is gcc compatible.
-                if not os.path.exists(inputValue):
+                if inputValue != '-' and not os.path.exists(inputValue):
                     self.warning("%s: No such file or directory" % inputValue)
                 else:
                     inputs.append((klass, a))
@@ -408,15 +409,11 @@ class Driver(object):
         if hasDashE or hasDashM or hasDashMM:
             finalPhase = Phases.Phase.eOrderPreprocess
             finalPhaseOpt = hasDashE
-        elif hasAnalyze:
+        elif (hasAnalyze or hasSyntaxOnly or 
+              hasEmitLLVM or hasDashS):
             finalPhase = Phases.Phase.eOrderCompile
-            finalPhaseOpt = hasAnalyze
+            finalPhaseOpt = (hasAnalyze or hasSyntaxOnly or 
-        elif hasSyntaxOnly:
+                             hasEmitLLVM or hasDashS)
-            finalPhase = Phases.Phase.eOrderCompile
-            finalPhaseOpt = hasSyntaxOnly
-        elif hasDashS:
-            finalPhase = Phases.Phase.eOrderCompile
-            finalPhaseOpt = hasDashS
         elif hasDashC:
             finalPhase = Phases.Phase.eOrderAssemble
             finalPhaseOpt = hasDashC    
@@ -464,6 +461,8 @@ class Driver(object):
                 sequence.append(Phases.AnalyzePhase())
             elif hasSyntaxOnly:
                 sequence.append(Phases.SyntaxOnlyPhase())
+            elif hasEmitLLVM:
+                sequence.append(Phases.EmitLLVMPhase())
             else:
                 sequence.extend([Phases.CompilePhase(),
                                  Phases.AssemblePhase(),
@@ -506,6 +505,14 @@ class Driver(object):
                             current = Phases.JobAction(transition,
                                                        [current],
                                                        output)
+                        elif isinstance(transition, Phases.EmitLLVMPhase):
+                            if hasDashS:
+                                output = Types.LLVMAsmType
+                            else:
+                                output = Types.LLVMBCType
+                            current = Phases.JobAction(transition,
+                                                       [current],
+                                                       output)
                         elif isinstance(transition, Phases.CompilePhase):
                             output = Types.AsmTypeNoPP
                             current = Phases.JobAction(transition,

clang/tools/ccc/ccclib/Phases.py

@@ -76,6 +76,10 @@ class SyntaxOnlyPhase(Phase):
     def __init__(self):
         super(SyntaxOnlyPhase, self).__init__("syntax-only", Phase.eOrderCompile)
 
+class EmitLLVMPhase(Phase):
+    def __init__(self):
+        super(EmitLLVMPhase, self).__init__("emit-llvm", Phase.eOrderCompile)
+
 class CompilePhase(Phase):
     def __init__(self):
         super(CompilePhase, self).__init__("compiler", Phase.eOrderCompile)

clang/tools/ccc/ccclib/ToolChain.py

@@ -64,12 +64,14 @@ class Darwin_X86_ToolChain(ToolChain):
         self.archName = archName
 
         self.clangTool = Tools.Clang_CompileTool(self)
+        cc = Tools.Darwin_X86_CompileTool(self)
         self.toolMap = {
             Phases.PreprocessPhase : Tools.Darwin_X86_PreprocessTool(self),
             Phases.AnalyzePhase : self.clangTool,
-            Phases.SyntaxOnlyPhase : Tools.Darwin_X86_CompileTool(self),
+            Phases.SyntaxOnlyPhase : cc,
-            Phases.CompilePhase : Tools.Darwin_X86_CompileTool(self),
+            Phases.EmitLLVMPhase : cc,
-            Phases.PrecompilePhase : Tools.Darwin_X86_CompileTool(self),
+            Phases.CompilePhase : cc,
+            Phases.PrecompilePhase : cc,
             Phases.AssemblePhase : Tools.Darwin_AssembleTool(self),
             Phases.LinkPhase : Tools.Darwin_X86_LinkTool(self),
             Phases.LipoPhase : Tools.LipoTool(),
@@ -110,7 +112,9 @@ class Darwin_X86_ToolChain(ToolChain):
         if self.driver.cccClang and self.archName == 'i386':
             if (action.inputs[0].type in (Types.CType, Types.CTypeNoPP,
                                           Types.ObjCType, Types.ObjCTypeNoPP) and
-                isinstance(action.phase, Phases.CompilePhase)):
+                (isinstance(action.phase, Phases.CompilePhase) or
+                 isinstance(action.phase, Phases.SyntaxOnlyPhase) or
+                 isinstance(action.phase, Phases.EmitLLVMPhase))):
                 return self.clangTool
             elif (action.inputs[0].type in (Types.CHeaderType, Types.CHeaderNoPPType,
                                             Types.ObjCHeaderType, Types.ObjCHeaderNoPPType) and
@@ -200,11 +204,13 @@ class Generic_GCC_ToolChain(ToolChain):
 
     def __init__(self, driver):
         super(Generic_GCC_ToolChain, self).__init__(driver)
+        cc = Tools.GCC_CompileTool()
         self.toolMap = {
             Phases.PreprocessPhase : Tools.GCC_PreprocessTool(),
             Phases.AnalyzePhase : Tools.Clang_CompileTool(self),
-            Phases.SyntaxOnlyPhase : Tools.GCC_CompileTool(),
+            Phases.SyntaxOnlyPhase : cc,
-            Phases.CompilePhase : Tools.GCC_CompileTool(),
+            Phases.EmitLLVMPhase : cc,
+            Phases.CompilePhase : cc,
             Phases.PrecompilePhase : Tools.GCC_PrecompileTool(),
             Phases.AssemblePhase : Tools.GCC_AssembleTool(),
             Phases.LinkPhase : Tools.GCC_LinkTool(),

clang/tools/ccc/ccclib/Tools.py

@@ -179,9 +179,15 @@ class Clang_CompileTool(Tool):
         patchOutputNameForPTH = False
 
         if isinstance(phase.phase, Phases.AnalyzePhase):
+            assert outputType is Types.PlistType
             cmd_args.append('-analyze')
         elif isinstance(phase.phase, Phases.SyntaxOnlyPhase):
+            assert outputType is Types.NothingType
             cmd_args.append('-fsyntax-only')
+        elif outputType is Types.LLVMAsmType:
+            cmd_args.append('-emit-llvm')
+        elif outputType is Types.LLVMBCType:
+            cmd_args.append('-emit-llvm-bc')
         elif outputType is Types.AsmTypeNoPP:
             cmd_args.append('-S')
         elif outputType is Types.PCHType:
@@ -687,6 +693,15 @@ class Darwin_X86_CompileTool(Darwin_X86_CC1Tool):
             arglist.getLastArg(arglist.parser.f_traditionalOption)):
             raise Arguments.InvalidArgumentsError("-traditional is not supported without -E")
 
+        if outputType is Types.PCHType:
+            pass
+        elif outputType is Types.AsmTypeNoPP:
+            pass
+        elif outputType is Types.LLVMAsmType:
+            cmd_args.append('-emit-llvm')
+        elif outputType is Types.LLVMBCType:
+            cmd_args.append('-emit-llvm-bc')
+
         if outputType is Types.PCHType:
             output_args = []
         else:

clang/tools/ccc/ccclib/Types.py

@@ -69,6 +69,8 @@ FortranType = InputType('f95-cpp-input', FortranTypeNoPP, canBeUserSpecified=Tru
 JavaType = InputType('java', canBeUserSpecified=True)
 
 # Misc.
+LLVMAsmType = InputType('llvm-asm', tempSuffix='ll')
+LLVMBCType = InputType('llvm-bc', tempSuffix='bc')
 PlistType = InputType('plist', tempSuffix='plist')
 PCHType = InputType('precompiled-header', tempSuffix='gch')
 ObjectType = InputType('object', tempSuffix='o')