ccc is dead.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@70649 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/tools/ccc/Makefile b/tools/ccc/Makefile
deleted file mode 100644
index 139c5d8..0000000
--- a/tools/ccc/Makefile
+++ /dev/null
@@ -1,28 +0,0 @@
-##===- tools/ccc/Makefile ----------------------------------*- Makefile -*-===##
-#
-# The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
-#
-##===----------------------------------------------------------------------===##
-
-LEVEL = ../../../..
-
-include $(LEVEL)/Makefile.common
-
-install-local:: $(PROJ_bindir)/ccc $(PROJ_bindir)/ccclib
-
-Extra := $(wildcard $(PROJ_SRC_ROOT)/tools/clang/tools/ccc/ccclib/*.py)
-
-$(PROJ_bindir)/ccclib : $(Extra)
- $(Echo) Installing ccclib.
- $(Verb) mkdir -p "$(PROJ_bindir)/ccclib"
- $(Verb) cp -p $? "$(PROJ_bindir)/ccclib"
- $(Verb) python -m compileall -d "$(PROJ_prefix)/bin/ccclib" "$(PROJ_bindir)/ccclib"
- $(Verb) touch "$(PROJ_bindir)/ccclib"
-
-$(PROJ_bindir)/ccc : ccc
- $(Echo) Installing $< shell script.
- $(Verb) cat $< > "$@"
- $(Verb) chmod 0755 "$@"
diff --git a/tools/ccc/ccc b/tools/ccc/ccc
deleted file mode 100755
index 4043150..0000000
--- a/tools/ccc/ccc
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/usr/bin/env python
-
-import os
-import sys
-from ccclib import Arguments
-from ccclib import Driver
-
-def main():
- progDir = os.path.dirname(sys.argv[0])
- progName = os.path.basename(sys.argv[0])
-
- d = Driver.Driver(progName, progDir)
- try:
- d.run(sys.argv[1:])
- except Arguments.InvalidArgumentsError,e:
- print >>sys.stderr, "%s: %s" % (progName, e.args[0])
- sys.exit(1)
- except Arguments.MissingArgumentError,e:
- print >>sys.stderr, "%s: argument to '%s' missing" % (progName, e.args[0].name)
- sys.exit(1)
- except NotImplementedError,e:
- print >>sys.stderr, "%s: not implemented: %s" % (progName, e.args[0])
-
-if __name__=='__main__':
- main()
diff --git a/tools/ccc/ccclib/Arguments.py b/tools/ccc/ccclib/Arguments.py
deleted file mode 100644
index 958dd38..0000000
--- a/tools/ccc/ccclib/Arguments.py
+++ /dev/null
@@ -1,1194 +0,0 @@
-import os
-
-###
-
-class InvalidArgumentsError(ValueError):
- """InvalidArgumentsError - The driver arguments are invalid or
- inconsistent."""
-
-class MissingArgumentError(ValueError):
- """MissingArgumentError - An option required an argument but none
- was given."""
-
-###
-
-class Option(object):
- """Option - Root option class."""
-
- def __init__(self, name, group=None, alias=None,
- isLinkerInput=False, noOptAsInput=False,
- forceSeparateRender=False,
- forceJoinedRender=False,
- unsupported=False):
- assert group is None or isinstance(group, OptionGroup)
- # Multi-level aliases are not supported, and alias options
- # cannot have groups. This just simplifies option tracking, it
- # is not an inherent limitation.
- assert alias is None or (alias.alias is None and
- group is None)
-
- self.name = name
- self.group = group
- self.alias = alias
- self.isLinkerInput = isLinkerInput
- self.noOptAsInput = noOptAsInput
- self.forceSeparateRender = forceSeparateRender
- self.forceJoinedRender = forceJoinedRender
- self.unsupported = unsupported
-
- def getUnaliasedOption(self):
- if self.alias:
- return self.alias.getUnaliasedOption()
- return self
-
- def getRenderName(self):
- return self.getUnaliasedOption().name
-
- def matches(self, opt):
- """matches(opt) -> bool
-
- Predicate for whether this option is part of the given option
- (which may be a group)."""
-
- if self.alias:
- return self.alias.matches(opt)
- if self is opt:
- return True
- elif self.group:
- return self.group.matches(opt)
- else:
- return False
-
- def accept(self, index, arg, it):
- """accept(index, arg, iterator) -> Arg or None
-
- Accept the argument at the given index, returning an Arg, or
- return None if the option does not accept this argument.
-
- May raise MissingArgumentError.
- """
- abstract
-
- def __repr__(self):
- return '<%s name=%r>' % (self.__class__.__name__,
- self.name)
-
- def forwardToGCC(self):
- # FIXME: Get rid of this hack.
- if self.name == '<input>':
- return False
-
- if self.isLinkerInput:
- return False
-
- return self.name not in ('-E', '-S', '-c',
- '-arch', '-fsyntax-only', '-combine', '-x',
- '-###', '-o')
-
-class OptionGroup(Option):
- """OptionGroup - A fake option class used to group options so that
- the driver can efficiently refer to an entire set of options."""
-
- def __init__(self, name, group=None):
- super(OptionGroup, self).__init__(name, group)
-
- def accept(self, index, arg, it):
- raise RuntimeError,"accept() should never be called on an OptionGroup"
-
-# Dummy options
-
-class InputOption(Option):
- def __init__(self):
- super(InputOption, self).__init__('<input>')
-
- def accept(self):
- raise RuntimeError,"accept() should never be used on InputOption instance."
-
-class UnknownOption(Option):
- def __init__(self):
- super(UnknownOption, self).__init__('<unknown>')
-
- def accept(self):
- raise RuntimeError,"accept() should never be used on UnknownOption instance."
-
-# Normal options
-
-class FlagOption(Option):
- """An option which takes no arguments."""
-
- def accept(self, index, arg, it):
- if arg == self.name:
- return Arg(index, self)
-
-class JoinedOption(Option):
- """An option which literally prefixes its argument."""
-
- def accept(self, index, arg, it):
- if arg.startswith(self.name):
- return JoinedValueArg(index, self)
-
-class CommaJoinedOption(Option):
- """An option which literally prefixs its argument, but which
- conceptually may have an arbitrary number of arguments which are
- separated by commas."""
-
- def accept(self, index, arg, it):
- if arg.startswith(self.name):
- return CommaJoinedValuesArg(index, self)
-
-class SeparateOption(Option):
- """An option which is followed by its value."""
-
- def accept(self, index, arg, it):
- if arg == self.name:
- try:
- _,value = it.next()
- except StopIteration:
- raise MissingArgumentError,self
- return SeparateValueArg(index, self)
-
-class MultiArgOption(Option):
- """An option which takes multiple arguments."""
-
- def __init__(self, name, numArgs):
- assert numArgs > 1
- super(MultiArgOption, self).__init__(name)
- self.numArgs = numArgs
-
- def accept(self, index, arg, it):
- if arg == self.name:
- try:
- values = [it.next()[1] for i in range(self.numArgs)]
- except StopIteration:
- raise MissingArgumentError,self
- return MultipleValuesArg(index, self)
-
-class JoinedOrSeparateOption(Option):
- """An option which either literally prefixes its value or is
- followed by an value."""
-
- def accept(self, index, arg, it):
- if arg.startswith(self.name):
- if len(arg) != len(self.name): # Joined case
- return JoinedValueArg(index, self)
- else:
- try:
- _,value = it.next()
- except StopIteration:
- raise MissingArgumentError,self
- return SeparateValueArg(index, self)
-
-class JoinedAndSeparateOption(Option):
- """An option which literally prefixes its value and is followed by
- an value."""
-
- def accept(self, index, arg, it):
- if arg.startswith(self.name):
- try:
- _,value = it.next()
- except StopIteration:
- raise MissingArgumentError,self
- return JoinedAndSeparateValuesArg(index, self)
-
-###
-
-class Arg(object):
- """Arg - Base class for actual driver arguments."""
- def __init__(self, index, opt):
- assert opt is not None
- self.index = index
- self.opt = opt
-
- def __repr__(self):
- return '<%s index=%r opt=%r>' % (self.__class__.__name__,
- self.index,
- self.opt)
-
- def render(self, args):
- """render(args) -> [str]
-
- Map the argument into a list of actual program arguments,
- given the source argument array."""
- return [self.opt.getRenderName()]
-
- def renderAsInput(self, args):
- return self.render(args)
-
-class ValueArg(Arg):
- """ValueArg - An instance of an option which has an argument."""
-
- def getValue(self, args):
- abstract
-
- def getValues(self, args):
- return [self.getValue(args)]
-
-class PositionalArg(ValueArg):
- """PositionalArg - A simple positional argument."""
-
- def getValue(self, args):
- return args.getInputString(self.index)
-
- def render(self, args):
- return [args.getInputString(self.index)]
-
-class JoinedValueArg(ValueArg):
- """JoinedValueArg - A single value argument where the value is
- joined (suffixed) to the option."""
-
- def getValue(self, args):
- return args.getInputString(self.index)[len(self.opt.name):]
-
- def render(self, args):
- if self.opt.forceSeparateRender:
- return [self.opt.getRenderName(),
- self.getValue(args)]
- return [self.opt.getRenderName() + self.getValue(args)]
-
- def renderAsInput(self, args):
- if self.opt.noOptAsInput:
- return [self.getValue(args)]
- return self.render(args)
-
-class SeparateValueArg(ValueArg):
- """SeparateValueArg - A single value argument where the value
- follows the option in the argument vector."""
-
- def getValue(self, args):
- return args.getInputString(self.index, offset=1)
-
- def render(self, args):
- if self.opt.forceJoinedRender:
- return [self.opt.getRenderName() + self.getValue(args)]
- return [self.opt.getRenderName(), self.getValue(args)]
-
- def renderAsInput(self, args):
- if self.opt.noOptAsInput:
- return [self.getValue(args)]
- return self.render(args)
-
-class MultipleValuesArg(Arg):
- """MultipleValuesArg - An argument with multiple values which
- follow the option in the argument vector."""
-
- # FIXME: Should we unify this with SeparateValueArg?
-
- def getValues(self, args):
- return [args.getInputString(self.index, offset=1+i)
- for i in range(self.opt.numArgs)]
-
- def render(self, args):
- return [self.opt.getRenderName()] + self.getValues(args)
-
-class CommaJoinedValuesArg(Arg):
- """CommaJoinedValuesArg - An argument with multiple values joined
- by commas and joined (suffixed) to the option.
-
- The key point of this arg is that it renders its values into
- separate arguments, which allows it to be used as a generic
- mechanism for passing arguments through to tools."""
-
- def getValues(self, args):
- return args.getInputString(self.index)[len(self.opt.name):].split(',')
-
- def render(self, args):
- return [self.opt.getRenderName() + ','.join(self.getValues(args))]
-
- def renderAsInput(self, args):
- return self.getValues(args)
-
-# FIXME: Man, this is lame. It is only used by -Xarch. Maybe easier to
-# just special case?
-class JoinedAndSeparateValuesArg(Arg):
- """JoinedAndSeparateValuesArg - An argument with both joined and
- separate values."""
-
- def getJoinedValue(self, args):
- return args.getInputString(self.index)[len(self.opt.name):]
-
- def getSeparateValue(self, args):
- return args.getInputString(self.index, offset=1)
-
- def render(self, args):
- return ([self.opt.getRenderName() + self.getJoinedValue(args)] +
- [self.getSeparateValue(args)])
-
-###
-
-class InputIndex:
- def __init__(self, sourceId, pos):
- self.sourceId = sourceId
- self.pos = pos
-
- def __repr__(self):
- return 'InputIndex(%d, %d)' % (self.sourceId, self.pos)
-
-class ArgList(object):
- """ArgList - Collect an input argument vector along with a set of
- parsed Args and supporting information."""
-
- def __init__(self, parser, argv):
- self.parser = parser
- self.argv = list(argv)
- self.syntheticArgv = []
- self.lastArgs = {}
- self.args = []
-
- def getArgs(self, option):
- # FIXME: How efficient do we want to make this. One reasonable
- # solution would be to embed a linked list inside each arg and
- # automatically chain them (with pointers to head and
- # tail). This gives us efficient access to the (first, last,
- # all) arg(s) with little overhead.
- for arg in self.args:
- if arg.opt.matches(option):
- yield arg
-
- def getArgs2(self, optionA, optionB):
- """getArgs2 - Iterate over all arguments for two options, in
- the order they were specified."""
- # As long as getArgs is efficient, we can easily make this
- # efficient by iterating both at once and always taking the
- # earlier arg.
- for arg in self.args:
- if (arg.opt.matches(optionA) or
- arg.opt.matches(optionB)):
- yield arg
-
- def getArgs3(self, optionA, optionB, optionC):
- """getArgs3 - Iterate over all arguments for three options, in
- the order they were specified."""
- for arg in self.args:
- if (arg.opt.matches(optionA) or
- arg.opt.matches(optionB) or
- arg.opt.matches(optionC)):
- yield arg
-
- def getLastArgAndPosition(self, option):
- return self.lastArgs.get(option, (None,-1))
-
- def getLastArg(self, option):
- return self.getLastArgAndPosition(option)[0]
-
- def hasFFlag(self, option, negativeOption, default):
- """hasFFlag - Given an option and its corresponding negative
- option, return True if the option is present, False if the
- negation is present, and default if neither option is
- given. If both the option and its negation are present, the
- last one wins.
- """
- arg,argPos = self.getLastArgAndPosition(option)
- neg,negPos = self.getLastArgAndPosition(negativeOption)
- if arg and neg:
- return negPos < argPos
- elif arg:
- return True
- elif neg:
- return False
- else:
- return default
-
- def getInputString(self, index, offset=0):
- # Source 0 is argv.
- if index.sourceId == 0:
- return self.argv[index.pos + offset]
-
- # Source 1 is synthetic argv.
- if index.sourceId == 1:
- return self.syntheticArgv[index.pos + offset]
-
- raise RuntimeError,'Unknown source ID for index.'
-
- def addLastArg(self, output, option):
- """addLastArgs - Extend the given output vector with the last
- instance of a given option."""
- arg = self.getLastArg(option)
- if arg:
- output.extend(self.render(arg))
-
- def addAllArgs(self, output, option):
- """addAllArgs - Extend the given output vector with all
- instances of a given option."""
- for arg in self.getArgs(option):
- output.extend(self.render(arg))
-
- def addAllArgs2(self, output, optionA, optionB):
- """addAllArgs2 - Extend the given output vector with all
- instances of two given option, with relative order preserved."""
- for arg in self.getArgs2(optionA, optionB):
- output.extend(self.render(arg))
-
- def addAllArgs3(self, output, optionA, optionB, optionC):
- """addAllArgs3 - Extend the given output vector with all
- instances of three given option, with relative order preserved."""
- for arg in self.getArgs3(optionA, optionB, optionC):
- output.extend(self.render(arg))
-
- def addAllArgsTranslated(self, output, option, translation):
- """addAllArgsTranslated - Extend the given output vector with
- all instances of a given option, rendered as separate
- arguments with the actual option name translated to a user
- specified string. For example, '-foox' will be render as
- ['-bar', 'x'] if '-foo' was the option and '-bar' was the
- translation.
-
- This routine expects that the option can only yield ValueArg
- instances."""
- for arg in self.getArgs(option):
- assert isinstance(arg, ValueArg)
- output.append(translation)
- output.append(self.getValue(arg))
-
- def makeIndex(self, *strings):
- pos = len(self.syntheticArgv)
- self.syntheticArgv.extend(strings)
- return InputIndex(1, pos)
-
- def makeFlagArg(self, option):
- return Arg(self.makeIndex(option.name),
- option)
-
- def makeInputArg(self, string):
- return PositionalArg(self.makeIndex(string),
- self.parser.inputOption)
-
- def makeUnknownArg(self, string):
- return PositionalArg(self.makeIndex(string),
- self.parser.unknownOption)
-
- def makeSeparateArg(self, string, option):
- return SeparateValueArg(self.makeIndex(option.name, string),
- option)
-
- def makeJoinedArg(self, string, option):
- return JoinedValueArg(self.makeIndex(option.name + string),
- option)
-
- # Support use as a simple arg list.
-
- def __iter__(self):
- return iter(self.args)
-
- def append(self, arg):
- if arg.opt.unsupported:
- raise InvalidArgumentsError('option %r is unsupported' % arg.opt.name)
-
- self.args.append(arg)
-
- opt = arg.opt
- if opt.alias:
- opt = opt.alias
- self.lastArgs[opt] = (arg, len(self.args) - 1)
- if opt.group is not None:
- self.lastArgs[opt.group] = (arg, len(self.args) - 1)
-
- # Forwarding methods.
- #
- # FIXME: Clean this up once restructuring is done.
-
- def render(self, arg):
- return arg.render(self)
-
- def renderAsInput(self, arg):
- return arg.renderAsInput(self)
-
- def getValue(self, arg):
- return arg.getValue(self)
-
- def getValues(self, arg):
- return arg.getValues(self)
-
- def getSeparateValue(self, arg):
- return arg.getSeparateValue(self)
-
- def getJoinedValue(self, arg):
- return arg.getJoinedValue(self)
-
-class DerivedArgList(ArgList):
- def __init__(self, args):
- super(DerivedArgList, self).__init__(args.parser, args.argv)
- self.parser = args.parser
- self.argv = args.argv
- self.syntheticArgv = args.syntheticArgv
- self.lastArgs = {}
- self.args = []
-
-###
-
-class OptionParser:
- def __init__(self):
- self.options = []
- self.inputOption = InputOption()
- self.unknownOption = UnknownOption()
-
- # Driver driver options
- self.archOption = self.addOption(SeparateOption('-arch'))
-
- # Misc driver options
- self.passExitCodesOption = self.addOption(FlagOption('-pass-exit-codes'))
- self.dumpspecsOption = self.addOption(FlagOption('-dumpspecs', unsupported=True))
- self.dumpversionOption = self.addOption(FlagOption('-dumpversion', unsupported=True))
- self.dumpmachineOption = self.addOption(FlagOption('-dumpmachine', unsupported=True))
- self.printSearchDirsOption = self.addOption(FlagOption('-print-search-dirs', unsupported=True))
- self.printLibgccFileNameOption = self.addOption(FlagOption('-print-libgcc-file-name'))
- self.printFileNameOption = self.addOption(JoinedOption('-print-file-name='))
- self.printProgNameOption = self.addOption(JoinedOption('-print-prog-name='))
- self.printMultiDirectoryOption = self.addOption(FlagOption('-print-multi-directory', unsupported=True))
- self.printMultiOsDirectoryOption = self.addOption(FlagOption('-print-multi-os-directory', unsupported=True))
- self.printMultiLibOption = self.addOption(FlagOption('-print-multi-lib', unsupported=True))
- self.addOption(SeparateOption('-specs', unsupported=True))
-
- # Pipeline control
- self.hashHashHashOption = self.addOption(FlagOption('-###'))
- self.EOption = self.addOption(FlagOption('-E'))
- self.SOption = self.addOption(FlagOption('-S'))
- self.cOption = self.addOption(FlagOption('-c'))
- self.combineOption = self.addOption(FlagOption('-combine', unsupported=True))
- self.noIntegratedCPPOption = self.addOption(FlagOption('-no-integrated-cpp'))
- self.pipeOption = self.addOption(FlagOption('-pipe'))
- self.saveTempsOption = self.addOption(FlagOption('-save-temps'))
-
- # FIXME: Error out if this is used.
- self.specsOption = self.addOption(JoinedOption('-specs='))
- # FIXME: Implement.
- self.addOption(FlagOption('-time'))
- # FIXME: Implement.
- self.vOption = self.addOption(FlagOption('-v'))
-
- # Input/output stuff
- self.oOption = self.addOption(JoinedOrSeparateOption('-o', noOptAsInput=True))
- self.xOption = self.addOption(JoinedOrSeparateOption('-x'))
-
- self.ObjCOption = self.addOption(FlagOption('-ObjC'))
- self.ObjCXXOption = self.addOption(FlagOption('-ObjC++'))
-
- # FIXME: Weird, gcc claims this here in help but I'm not sure why;
- # perhaps interaction with preprocessor? Investigate.
-
- # FIXME: This is broken in Darwin cc1, it wants std* and this
- # is std=. May need an option group for this as well.
- self.stdOption = self.addOption(JoinedOption('-std='))
-
- # Blanket pass-through options.
-
- self.XanalyzerOption = self.addOption(SeparateOption('-Xanalyzer'))
- self.XclangOption = self.addOption(SeparateOption('-Xclang'))
-
- self.WaOption = self.addOption(CommaJoinedOption('-Wa,'))
- self.XassemblerOption = self.addOption(SeparateOption('-Xassembler'))
-
- self.WpOption = self.addOption(CommaJoinedOption('-Wp,'))
- self.XpreprocessorOption = self.addOption(SeparateOption('-Xpreprocessor'))
-
- self.addOption(CommaJoinedOption('-Wl,', isLinkerInput=True))
- self.XlinkerOption = self.addOption(SeparateOption('-Xlinker',
- isLinkerInput=True,
- noOptAsInput=True))
-
- ####
- # Bring on the random garbage.
-
- self.sOption = self.addOption(FlagOption('-s'))
-
- self.MGroup = OptionGroup('-M')
- self.MOption = self.addOption(FlagOption('-M', self.MGroup))
- self.MDOption = self.addOption(FlagOption('-MD', self.MGroup))
- self.MGOption = self.addOption(FlagOption('-MG', self.MGroup))
- self.MMDOption = self.addOption(FlagOption('-MMD', self.MGroup))
- self.MPOption = self.addOption(FlagOption('-MP', self.MGroup))
- self.MMOption = self.addOption(FlagOption('-MM', self.MGroup))
- self.MFOption = self.addOption(JoinedOrSeparateOption('-MF', self.MGroup))
- self.MTOption = self.addOption(JoinedOrSeparateOption('-MT', self.MGroup))
- self.MQOption = self.addOption(JoinedOrSeparateOption('-MQ', self.MGroup))
- self.MachOption = self.addOption(FlagOption('-Mach'))
- self.uGroup = OptionGroup('-u')
- self.undefOption = self.addOption(FlagOption('-undef', self.uGroup))
-
- self.wOption = self.addOption(FlagOption('-w'))
- self.bundle_loaderOption = self.addOption(SeparateOption('-bundle_loader'))
- self.bundleOption = self.addOption(FlagOption('-bundle'))
- self.client_nameOption = self.addOption(JoinedOrSeparateOption('-client_name'))
- self.compatibility_versionOption = self.addOption(JoinedOrSeparateOption('-compatibility_version'))
- self.current_versionOption = self.addOption(JoinedOrSeparateOption('-current_version'))
- self.dependencyFileOption = self.addOption(SeparateOption('-dependency-file'))
- self.dynamiclibOption = self.addOption(FlagOption('-dynamiclib'))
- self.dynamicOption = self.addOption(FlagOption('-dynamic'))
- self.dylinker_install_nameOption = self.addOption(JoinedOrSeparateOption('-dylinker_install_name'))
- self.dylinkerOption = self.addOption(FlagOption('-dylinker'))
-
- self.iGroup = OptionGroup('-i')
- self.idirafterOption = self.addOption(JoinedOrSeparateOption('-idirafter', self.iGroup))
- self.imacrosOption = self.addOption(JoinedOrSeparateOption('-imacros', self.iGroup))
- self.iprefixOption = self.addOption(JoinedOrSeparateOption('-iprefix', self.iGroup))
- self.isystem = self.addOption(JoinedOrSeparateOption('-isystem', self.iGroup))
- self.iwithprefixOption = self.addOption(JoinedOrSeparateOption('-iwithprefix', self.iGroup))
- self.iwithprefixbeforeOption = self.addOption(JoinedOrSeparateOption('-iwithprefixbefore', self.iGroup))
- self.addOption(JoinedOrSeparateOption('-iquote', self.iGroup))
- self.isysrootOption = self.addOption(JoinedOrSeparateOption('-isysroot', self.iGroup))
- self.iwithsysrootOption = self.addOption(JoinedOrSeparateOption('-iwithsysroot', self.iGroup))
- self.includeOption = self.addOption(JoinedOrSeparateOption('-include', self.iGroup))
-
- self.keep_private_externsOption = self.addOption(JoinedOrSeparateOption('-keep_private_externs'))
- self.private_bundleOption = self.addOption(FlagOption('-private_bundle'))
- self.seg1addrOption = self.addOption(JoinedOrSeparateOption('-seg1addr'))
- self.segprotOption = self.addOption(JoinedOrSeparateOption('-segprot'))
- self.sub_libraryOption = self.addOption(JoinedOrSeparateOption('-sub_library'))
- self.sub_umbrellaOption = self.addOption(JoinedOrSeparateOption('-sub_umbrella'))
- self.umbrellaOption = self.addOption(SeparateOption('-umbrella', self.uGroup))
- self.undefinedOption = self.addOption(JoinedOrSeparateOption('-undefined', self.uGroup))
- self.headerpad_max_install_namesOption = self.addOption(JoinedOption('-headerpad_max_install_names'))
- self.twolevel_namespaceOption = self.addOption(FlagOption('-twolevel_namespace'))
- self.twolevel_namespace_hintsOption = self.addOption(FlagOption('-twolevel_namespace_hints'))
- self.prebindOption = self.addOption(FlagOption('-prebind'))
- self.noprebindOption = self.addOption(FlagOption('-noprebind'))
- self.nofixprebindingOption = self.addOption(FlagOption('-nofixprebinding'))
- self.prebind_all_twolevel_modulesOption = self.addOption(FlagOption('-prebind_all_twolevel_modules'))
- self.remapOption = self.addOption(FlagOption('-remap'))
- self.read_only_relocsOption = self.addOption(SeparateOption('-read_only_relocs'))
- self.nomultidefsOption = self.addOption(FlagOption('-nomultidefs'))
- self.nostartfilesOption = self.addOption(FlagOption('-nostartfiles'))
- self.nodefaultlibsOption = self.addOption(FlagOption('-nodefaultlibs'))
- self.nostdlibOption = self.addOption(FlagOption('-nostdlib'))
- self.nostdincOption = self.addOption(FlagOption('-nostdinc'))
- self.objectOption = self.addOption(FlagOption('-object'))
- self.preloadOption = self.addOption(FlagOption('-preload'))
- self.staticOption = self.addOption(FlagOption('-static'))
- self.pagezero_sizeOption = self.addOption(FlagOption('-pagezero_size'))
- self.sharedOption = self.addOption(FlagOption('-shared'))
- self.staticLibgccOption = self.addOption(FlagOption('-static-libgcc'))
- self.sharedLibgccOption = self.addOption(FlagOption('-shared-libgcc'))
- self.COption = self.addOption(FlagOption('-C'))
- self.CCOption = self.addOption(FlagOption('-CC'))
- self.HOption = self.addOption(FlagOption('-H'))
- self.addOption(FlagOption('-R'))
- self.POption = self.addOption(FlagOption('-P'))
- self.QOption = self.addOption(FlagOption('-Q'))
- self.QnOption = self.addOption(FlagOption('-Qn'))
- self.addOption(FlagOption('--constant-cfstrings'))
- self.traditionalOption = self.addOption(FlagOption('-traditional'))
- self.traditionalCPPOption = self.addOption(FlagOption('-traditional-cpp'))
- self.no_dead_strip_inits_and_termsOption = self.addOption(FlagOption('-no_dead_strip_inits_and_terms'))
- self.addOption(JoinedOption('-weak-l', isLinkerInput=True))
- self.addOption(SeparateOption('-weak_framework', isLinkerInput=True))
- self.addOption(SeparateOption('-weak_library', isLinkerInput=True))
- self.whyloadOption = self.addOption(FlagOption('-whyload'))
- self.whatsloadedOption = self.addOption(FlagOption('-whatsloaded'))
- self.sectalignOption = self.addOption(MultiArgOption('-sectalign', numArgs=3))
- self.sectobjectsymbolsOption = self.addOption(MultiArgOption('-sectobjectsymbols', numArgs=2))
- self.segcreateOption = self.addOption(MultiArgOption('-segcreate', numArgs=3))
- self.seglinkeditOption = self.addOption(FlagOption('-seglinkedit'))
- self.noseglinkeditOption = self.addOption(FlagOption('-noseglinkedit'))
- self.sectcreateOption = self.addOption(MultiArgOption('-sectcreate', numArgs=3))
- self.sectorderOption = self.addOption(MultiArgOption('-sectorder', numArgs=3))
-
- self.all_loadOption = self.addOption(FlagOption('-all_load'))
- self.allowable_clientOption = self.addOption(SeparateOption('-allowable_client'))
- self.bind_at_loadOption = self.addOption(FlagOption('-bind_at_load'))
- self.dead_stripOption = self.addOption(FlagOption('-dead_strip'))
- self.dylib_fileOption = self.addOption(SeparateOption('-dylib_file'))
- self.exported_symbols_listOption = self.addOption(SeparateOption('-exported_symbols_list'))
- self.flat_namespaceOption = self.addOption(FlagOption('-flat_namespace'))
- self.force_cpusubtype_ALLOption = self.addOption(FlagOption('-force_cpusubtype_ALL'))
- self.force_flat_namespaceOption = self.addOption(FlagOption('-force_flat_namespace'))
- self.image_baseOption = self.addOption(FlagOption('-image_base'))
- self.initOption = self.addOption(SeparateOption('-init'))
- self.install_nameOption = self.addOption(SeparateOption('-install_name'))
- self.multi_moduleOption = self.addOption(FlagOption('-multi_module'))
- self.multiply_definedOption = self.addOption(SeparateOption('-multiply_defined'))
- self.multiply_defined_unusedOption = self.addOption(SeparateOption('-multiply_defined_unused'))
- self.seg_addr_table_filenameOption = self.addOption(SeparateOption('-seg_addr_table_filename'))
- self.seg_addr_tableOption = self.addOption(SeparateOption('-seg_addr_table'))
- self.segaddrOption = self.addOption(SeparateOption('-segaddr'))
- self.segs_read_only_addrOption = self.addOption(SeparateOption('-segs_read_only_addr'))
- self.segs_read_write_addrOption = self.addOption(SeparateOption('-segs_read_write_addr'))
- # FIXME: This probably isn't necessary.
- self.segs_read_Option = self.addOption(JoinedOption('-segs_read_'))
- self.single_moduleOption = self.addOption(FlagOption('-single_module'))
- self.unexported_symbols_listOption = self.addOption(SeparateOption('-unexported_symbols_list', self.uGroup))
- self.weak_reference_mismatchesOption = self.addOption(SeparateOption('-weak_reference_mismatches'))
-
- self.addOption(SeparateOption('-filelist', isLinkerInput=True))
- self.addOption(SeparateOption('-framework', isLinkerInput=True))
-
- self.addOption(JoinedOption('-i', self.iGroup))
-
- self.emitLLVMOption = self.addOption(FlagOption('-emit-llvm'))
- self.eOption = self.addOption(JoinedOrSeparateOption('-e'))
- self.rOption = self.addOption(FlagOption('-r'))
-
- self.pgOption = self.addOption(FlagOption('-pg'))
- self.pOption = self.addOption(FlagOption('-p'))
-
- doNotReallySupport = 1
- if doNotReallySupport:
- # Archaic gcc option.
- self.addOption(FlagOption('-cpp-precomp'))
- self.addOption(FlagOption('-no-cpp-precomp'))
-
- # C options for testing
-
- self.trigraphsOption = self.addOption(FlagOption('-trigraphs'))
-
- # FIXME: This is broken, we need -A as a single option to send
- # stuff to cc1, but the way the ld spec is constructed it
- # wants to see -A options but only as a separate arg.
- self.AOption = self.addOption(JoinedOrSeparateOption('-A'))
- self.DOption = self.addOption(JoinedOrSeparateOption('-D'))
- self.FOption = self.addOption(JoinedOrSeparateOption('-F'))
-
- self.IGroup = OptionGroup('-I')
- self.I_Option = self.addOption(FlagOption('-I-', self.IGroup))
- self.IOption = self.addOption(JoinedOrSeparateOption('-I', self.IGroup))
-
- self.LOption = self.addOption(JoinedOrSeparateOption('-L'))
-
- self.TGroup = OptionGroup('-T')
- self.addOption(JoinedOrSeparateOption('-Tbss', self.TGroup))
- self.addOption(JoinedOrSeparateOption('-Tdata', self.TGroup))
- self.addOption(JoinedOrSeparateOption('-Ttext', self.TGroup))
- self.addOption(JoinedOrSeparateOption('-T', self.TGroup))
-
- self.UOption = self.addOption(JoinedOrSeparateOption('-U'))
- self.ZOption = self.addOption(JoinedOrSeparateOption('-Z'))
-
- self.addOption(JoinedOrSeparateOption('-l', isLinkerInput=True))
- self.uOption = self.addOption(JoinedOrSeparateOption('-u', self.uGroup))
- self.tOption = self.addOption(JoinedOrSeparateOption('-t'))
- self.yOption = self.addOption(JoinedOption('-y'))
-
- # FIXME: What is going on here? '-X' goes to linker, and -X ... goes nowhere?
- self.XOption = self.addOption(FlagOption('-X'))
- # Not exactly sure how to decompose this. I split out -Xarch_
- # because we need to recognize that in the driver driver part.
- # FIXME: Man, this is lame it needs its own option.
- self.XarchOption = self.addOption(JoinedAndSeparateOption('-Xarch_'))
- self.addOption(JoinedOption('-X'))
-
- # The driver needs to know about this flag.
- self.syntaxOnlyOption = self.addOption(FlagOption('-fsyntax-only'))
-
- # FIXME: Wrong?
- # FIXME: What to do about the ambiguity of options like
- # -dumpspecs? How is this handled in gcc?
- # FIXME: Naming convention.
- self.dGroup = OptionGroup('-d')
- self.dAOption = self.addOption(FlagOption('-dA', self.dGroup))
- self.dMOption = self.addOption(FlagOption('-dM', self.dGroup))
- self.dOption = self.addOption(FlagOption('-d', self.dGroup))
- self.addOption(JoinedOption('-d', group=self.dGroup))
-
- self.gGroup = OptionGroup('-g')
- self.gfullOption = self.addOption(JoinedOption('-gfull', self.gGroup))
- self.gusedOption = self.addOption(JoinedOption('-gused', self.gGroup))
- self.gstabsOption = self.addOption(JoinedOption('-gstabs', self.gGroup))
- self.g0Option = self.addOption(JoinedOption('-g0', self.gGroup))
- self.g3Option = self.addOption(JoinedOption('-g3', self.gGroup))
- # FIXME: Naming.
- self.gOption = self.addOption(FlagOption('-g', self.gGroup))
- self.addOption(JoinedOption('-g', self.gGroup))
-
- # FIXME: How should we handle clang specific options? Do we
- # want to avoid passing them to gcc/cc1 (which will generally
- # not eat them), or should we let the user sort it out.
-
- self.fGroup = OptionGroup('-f')
- self.Clang_fGroup = OptionGroup('-clang-f', self.fGroup)
- self.fastOption = self.addOption(FlagOption('-fast', self.fGroup))
- self.fastfOption = self.addOption(FlagOption('-fastf', self.fGroup))
- self.fastcpOption = self.addOption(FlagOption('-fastcp', self.fGroup))
-
- self.f_appleKextOption = self.addOption(FlagOption('-fapple-kext', self.fGroup))
- self.f_blocksOption = self.addOption(FlagOption('-fblocks', self.Clang_fGroup))
- self.f_noBlocksOption = self.addOption(FlagOption('-fno-blocks', self.Clang_fGroup))
- self.f_bootclasspathOption = self.addOption(JoinedOption('-fbootclasspath=', self.fGroup))
- self.f_builtinOption = self.addOption(FlagOption('-fbuiltin', self.Clang_fGroup))
- self.f_noBuiltinOption = self.addOption(FlagOption('-fno-builtin', self.Clang_fGroup))
- self.f_classpathOption = self.addOption(JoinedOption('-fclasspath=', self.fGroup))
- self.f_compileResourceOption = self.addOption(JoinedOption('-fcompile-resource=', self.fGroup))
- self.f_constantCfstringsOption = self.addOption(FlagOption('-fconstant-cfstrings', self.fGroup))
- self.f_createProfileOption = self.addOption(FlagOption('-fcreate-profile', self.fGroup))
- self.f_debugPassArgumentsOption = self.addOption(FlagOption('-fdebug-pass-arguments', self.fGroup))
- self.f_debugPassStructureOption = self.addOption(FlagOption('-fdebug-pass-structure', self.fGroup))
- self.f_eliminateUnusedDebugSymbolsOption = self.addOption(FlagOption('-feliminate-unused-debug-symbols', self.fGroup))
- self.addOption(FlagOption('-femit-all-decls', self.Clang_fGroup))
- self.f_encodingOption = self.addOption(JoinedOption('-fencoding=', self.fGroup))
- self.f_exceptionsOption = self.addOption(FlagOption('-fexceptions', self.Clang_fGroup))
- self.f_extdirsOption = self.addOption(JoinedOption('-fextdirs=', self.fGroup))
- self.f_freestandingOption = self.addOption(FlagOption('-ffreestanding', self.Clang_fGroup))
- self.f_gnuRuntimeOption = self.addOption(FlagOption('-fgnu-runtime', self.Clang_fGroup))
- self.addOption(FlagOption('-fheinous-gnu-extensions', self.Clang_fGroup))
- self.f_indirectVirtualCallsOption = self.addOption(FlagOption('-findirect-virtual-calls', self.fGroup))
- self.f_laxVectorConversionsOption = self.addOption(FlagOption('-flax-vector-conversions', self.Clang_fGroup))
- self.f_limitedPrecisionOption = self.addOption(JoinedOption('-flimited-precision=', self.fGroup))
- self.f_mathErrnoOption = self.addOption(FlagOption('-fmath-errno', self.fGroup))
- self.f_noMathErrnoOption = self.addOption(FlagOption('-fno-math-errno', self.fGroup))
- self.f_msExtensionsOption = self.addOption(FlagOption('-fms-extensions', self.Clang_fGroup))
- self.f_mudflapOption = self.addOption(FlagOption('-fmudflap', self.fGroup))
- self.f_mudflapthOption = self.addOption(FlagOption('-fmudflapth', self.fGroup))
- self.f_nestedFunctionsOption = self.addOption(FlagOption('-fnested-functions', self.fGroup))
- self.f_nextRuntimeOption = self.addOption(FlagOption('-fnext-runtime', self.Clang_fGroup))
- self.f_noCaretDiagnosticsOption = self.addOption(FlagOption('-fno-caret-diagnostics', self.Clang_fGroup))
- self.f_noConstantCfstringsOption = self.addOption(FlagOption('-fno-constant-cfstrings', self.fGroup))
- self.f_noEliminateUnusedDebugSymbolsOption = self.addOption(FlagOption('-fno-eliminate-unused-debug-symbols', self.fGroup))
- self.f_noPascalStringsOption = self.addOption(FlagOption('-fno-pascal-strings', self.fGroup))
- self.f_noShowColumnOption = self.addOption(FlagOption('-fno-show-column', self.Clang_fGroup))
- self.f_noWorkingDirectoryOption = self.addOption(FlagOption('-fno-working-directory', self.fGroup))
- self.f_objcGcOnlyOption = self.addOption(FlagOption('-fobjc-gc-only', self.Clang_fGroup))
- self.f_objcGcOption = self.addOption(FlagOption('-fobjc-gc', self.Clang_fGroup))
- self.f_objcNonfragileAbiOption = self.addOption(FlagOption('-fobjc-nonfragile-abi', self.Clang_fGroup))
- self.f_objcOption = self.addOption(FlagOption('-fobjc', self.fGroup))
- self.f_omitFramePointerOption = self.addOption(FlagOption('-fomit-frame-pointer', self.fGroup))
- self.f_openmpOption = self.addOption(FlagOption('-fopenmp', self.fGroup))
- self.f_outputClassDirOption = self.addOption(JoinedOption('-foutput-class-dir=', self.fGroup))
- self.f_pascalStringsOption = self.addOption(FlagOption('-fpascal-strings', self.Clang_fGroup))
- self.f_pieOption = self.addOption(FlagOption('-fpie', self.fGroup))
- self.f_PIEOption = self.addOption(FlagOption('-fPIE', self.fGroup))
- self.f_picOption = self.addOption(FlagOption('-fpic', self.fGroup))
- self.f_PICOption = self.addOption(FlagOption('-fPIC', self.fGroup))
- self.addOption(FlagOption('-fprint-source-range-info', self.Clang_fGroup))
- self.f_profileArcsOption = self.addOption(FlagOption('-fprofile-arcs', self.fGroup))
- self.f_profileGenerateOption = self.addOption(FlagOption('-fprofile-generate', self.fGroup))
- self.f_terminatedVtablesOption = self.addOption(FlagOption('-fterminated-vtables', self.fGroup))
- self.f_templateDepthOption = self.addOption(JoinedOption('-ftemplate-depth-', self.fGroup))
- self.f_timeReportOption = self.addOption(FlagOption('-ftime-report', self.Clang_fGroup))
- self.f_traditionalOption = self.addOption(FlagOption('-ftraditional', self.fGroup))
- self.f_unwindTablesOption = self.addOption(FlagOption('-funwind-tables', self.fGroup))
- self.f_noUnwindTablesOption = self.addOption(FlagOption('-fno-unwind-tables', self.fGroup))
- self.f_writableStringsOption = self.addOption(FlagOption('-fwritable-strings', self.Clang_fGroup))
- self.f_zeroInitializedInBssOption = self.addOption(FlagOption('-fzero-initialized-in-bss', self.fGroup))
- self.f_noZeroInitializedInBssOption = self.addOption(FlagOption('-fno-zero-initialized-in-bss', self.fGroup))
- self.fOption = self.addOption(JoinedOption('-f', self.fGroup))
-
- self.coverageOption = self.addOption(FlagOption('-coverage'))
-
- self.mGroup = OptionGroup('-m')
- self.m_32Option = self.addOption(FlagOption('-m32', self.mGroup))
- self.m_64Option = self.addOption(FlagOption('-m64', self.mGroup))
- self.m_dynamicNoPicOption = self.addOption(JoinedOption('-mdynamic-no-pic', self.mGroup))
- self.m_iphoneosVersionMinOption = self.addOption(JoinedOption('-miphoneos-version-min=', self.mGroup))
- self.m_kernelOption = self.addOption(FlagOption('-mkernel', self.mGroup))
- self.m_macosxVersionMinOption = self.addOption(JoinedOption('-mmacosx-version-min=', self.mGroup))
- self.m_constantCfstringsOption = self.addOption(FlagOption('-mconstant-cfstrings', self.mGroup))
- self.m_noConstantCfstringsOption = self.addOption(FlagOption('-mno-constant-cfstrings', self.mGroup))
- self.m_warnNonportableCfstringsOption = self.addOption(FlagOption('-mwarn-nonportable-cfstrings', self.mGroup))
- self.m_noWarnNonportableCfstringsOption = self.addOption(FlagOption('-mno-warn-nonportable-cfstrings', self.mGroup))
- self.m_pascalStringsOption = self.addOption(FlagOption('-mpascal-strings', self.mGroup))
- self.m_noPascalStringsOption = self.addOption(FlagOption('-mno-pascal-strings', self.mGroup))
- self.m_tuneOption = self.addOption(JoinedOption('-mtune=', self.mGroup))
-
- self.m_mmxOption = self.addOption(FlagOption('-mmmx', self.mGroup))
- self.m_noMmxOption = self.addOption(FlagOption('-mno-mmx', self.mGroup))
- self.m_sseOption = self.addOption(FlagOption('-msse', self.mGroup))
- self.m_noSseOption = self.addOption(FlagOption('-mno-sse', self.mGroup))
- self.m_sse2Option = self.addOption(FlagOption('-msse2', self.mGroup))
- self.m_noSse2Option = self.addOption(FlagOption('-mno-sse2', self.mGroup))
- self.m_sse3Option = self.addOption(FlagOption('-msse3', self.mGroup))
- self.m_noSse3Option = self.addOption(FlagOption('-mno-sse3', self.mGroup))
- self.m_ssse3Option = self.addOption(FlagOption('-mssse3', self.mGroup))
- self.m_noSsse3Option = self.addOption(FlagOption('-mno-ssse3', self.mGroup))
- self.m_sse41Option = self.addOption(FlagOption('-msse41', self.mGroup))
- self.m_noSse41Option = self.addOption(FlagOption('-mno-sse41', self.mGroup))
- self.m_sse42Option = self.addOption(FlagOption('-msse42', self.mGroup))
- self.m_noSse42Option = self.addOption(FlagOption('-mno-sse42', self.mGroup))
- self.m_sse4aOption = self.addOption(FlagOption('-msse4a', self.mGroup))
- self.m_noSse4aOption = self.addOption(FlagOption('-mno-sse4a', self.mGroup))
- self.m_3dnowOption = self.addOption(FlagOption('-m3dnow', self.mGroup))
- self.m_no3dnowOption = self.addOption(FlagOption('-mno-3dnow', self.mGroup))
- self.m_3dnowaOption = self.addOption(FlagOption('-m3dnowa', self.mGroup))
- self.m_no3dnowaOption = self.addOption(FlagOption('-mno-3dnowa', self.mGroup))
- self.m_redZoneOption = self.addOption(FlagOption('-mred-zone', self.mGroup))
- self.m_noRedZoneOption = self.addOption(FlagOption('-mno-red-zone', self.mGroup))
- self.m_softFloatOption = self.addOption(FlagOption('-msoft-float', self.mGroup))
- self.m_noSoftFloatOption = self.addOption(FlagOption('-mno-soft-float', self.mGroup))
-
- # Ugh. Need to disambiguate our naming convetion. -m x goes to
- # the linker sometimes, wheres -mxxxx is used for a variety of
- # other things.
- self.mSeparate = self.addOption(SeparateOption('-m', self.mGroup))
- self.mJoined = self.addOption(JoinedOption('-m', self.mGroup))
-
- # FIXME: Why does Darwin send -a* to cc1?
- self.aGroup = OptionGroup('-a')
- self.ansiOption = self.addOption(FlagOption('-ansi', self.aGroup))
-
- self.aOption = self.addOption(JoinedOption('-a', self.aGroup))
-
- self.pedanticGroup = OptionGroup('-pedantic')
- self.pedanticOption = self.addOption(FlagOption('-pedantic', self.pedanticGroup))
- self.pedanticErrorsOption = self.addOption(FlagOption('-pedantic-errors', self.pedanticGroup))
- self.OOption = self.addOption(JoinedOption('-O'))
-
- self.WGroup = OptionGroup('-W')
- self.ClangWGroup = OptionGroup('-clang-W', self.WGroup)
-
- self.WallOption = self.addOption(FlagOption('-Wall', self.WGroup))
- self.addOption(FlagOption('-Wunused-macros', self.ClangWGroup))
- self.addOption(FlagOption('-Wfloat-equal', self.ClangWGroup))
- self.addOption(FlagOption('-Wreadonly-setter-attrs', self.ClangWGroup))
- self.addOption(FlagOption('-Wno-format-nonliteral', self.ClangWGroup))
- self.addOption(FlagOption('-Wundef', self.ClangWGroup))
- self.addOption(FlagOption('-Wimplicit-function-declaration', self.ClangWGroup))
- self.addOption(FlagOption('-Wno-strict-selector-match', self.ClangWGroup))
-
- self.WnonportableCfstringsOption = self.addOption(JoinedOption('-Wnonportable-cfstrings', self.WGroup))
- self.WnoNonportableCfstringsOption = self.addOption(JoinedOption('-Wno-nonportable-cfstrings', self.WGroup))
- self.WOption = self.addOption(JoinedOption('-W', self.WGroup))
-
- # FIXME: Weird. This option isn't really separate, --param=a=b
- # works. There is something else going on which interprets the
- # '='.
- self._paramOption = self.addOption(SeparateOption('--param'))
-
- # FIXME: What is this? I think only one is valid, but have a
- # log that uses both.
- self.pthreadOption = self.addOption(FlagOption('-pthread'))
- self.addOption(FlagOption('-pthreads'))
-
- # Version control.
- # FIXME: Figure out what to do about these.
- self.BOption = self.addOption(JoinedOrSeparateOption('-B', unsupported=True))
- self.addOption(JoinedOrSeparateOption('-V', unsupported=True))
- self.addOption(JoinedOrSeparateOption('-b', unsupported=True))
-
- # Clang static analyzer options (also see -WA,).
- self.analyzeOption = self.addOption(FlagOption('--analyze'))
-
- # Long option handling (aliases).
- self.addOption(FlagOption('--help'))
- self.addOption(FlagOption('--target-help'))
- # FIXME: Who handles this?
- self.addOption(FlagOption('--version'))
-
- self.addOption(FlagOption('--all-warnings', alias=self.WallOption))
- self.addOption(FlagOption('--ansi', alias=self.ansiOption))
- self.addOption(FlagOption('--assemble', alias=self.SOption))
- self.addOption(FlagOption('--combine', alias=self.combineOption))
- self.addOption(FlagOption('--comments', alias=self.COption))
- self.addOption(FlagOption('--comments-in-macros', alias=self.CCOption))
- self.addOption(FlagOption('--compile', alias=self.cOption))
- self.addOption(FlagOption('--coverage', alias=self.coverageOption))
- self.addOption(FlagOption('--dependencies', alias=self.MOption))
- self.addOption(FlagOption('--entry', alias=self.eOption))
- self.addOption(FlagOption('--extra-warnings', alias=self.WOption))
- self.addOption(FlagOption('--include-barrier', alias=self.I_Option))
- self.addOption(FlagOption('--no-integrated-cpp', alias=self.noIntegratedCPPOption))
- self.addOption(FlagOption('--no-line-commands', alias=self.POption))
-# self.addOption(FlagOption('--no-precompiled-includes', alias=self.noprecompOption))
- self.addOption(FlagOption('--no-standard-includes', alias=self.nostdincOption))
- self.addOption(FlagOption('--no-standard-libraries', alias=self.nostdlibOption))
- self.addOption(FlagOption('--no-warnings', alias=self.wOption))
- self.addOption(FlagOption('--pass-exit-codes', alias=self.passExitCodesOption))
- self.addOption(FlagOption('--pedantic', alias=self.pedanticOption))
- self.addOption(FlagOption('--pedantic-errors', alias=self.pedanticErrorsOption))
-# self.addOption(FlagOption('--pie', alias=self.pieOption))
- self.addOption(FlagOption('--pipe', alias=self.pipeOption))
- self.addOption(FlagOption('--preprocess', alias=self.EOption))
- self.addOption(JoinedOption('--param=', alias=self._paramOption,
- forceSeparateRender=True))
- self.addOption(JoinedOption('--print-file-name=', alias=self.printFileNameOption))
- self.addOption(SeparateOption('--print-file-name', alias=self.printFileNameOption))
- self.addOption(FlagOption('--print-libgcc-file-name',
- alias=self.printLibgccFileNameOption))
- self.addOption(FlagOption('--print-missing-file-dependencies', alias=self.MGOption))
- self.addOption(FlagOption('--print-multi-lib', alias=self.printMultiLibOption))
- self.addOption(FlagOption('--print-multi-directory', alias=self.printMultiDirectoryOption))
- self.addOption(FlagOption('--print-multi-os-directory', alias=self.printMultiOsDirectoryOption))
- self.addOption(JoinedOption('--print-prog-name=', alias=self.printProgNameOption))
- self.addOption(SeparateOption('--print-prog-name', alias=self.printProgNameOption))
- self.addOption(FlagOption('--print-search-dirs', alias=self.printSearchDirsOption))
- self.addOption(FlagOption('--profile', alias=self.pOption))
- self.addOption(FlagOption('--profile-blocks', alias=self.aOption))
-# self.addOption(FlagOption('--quiet', alias=self.qOption))
-# self.addOption(FlagOption('--shared', alias=self.sharedOption))
-# self.addOption(FlagOption('--silent', alias=self.qOption))
- self.addOption(FlagOption('--static', alias=self.staticOption))
-# self.addOption(FlagOption('--symbolic', alias=self.symbolicOption))
-# self.addOption(FlagOption('--time', alias=self.timeOption))
- self.addOption(FlagOption('--trace-includes', alias=self.HOption))
- self.addOption(FlagOption('--traditional', alias=self.traditionalOption))
- self.addOption(FlagOption('--traditional-cpp', alias=self.traditionalCPPOption))
- self.addOption(FlagOption('--trigraphs', alias=self.trigraphsOption))
- self.addOption(FlagOption('--user-dependencies', alias=self.MMOption))
- self.addOption(FlagOption('--verbose', alias=self.vOption))
- self.addOption(FlagOption('--save-temps', alias=self.saveTempsOption))
- self.addOption(FlagOption('--write-dependencies', alias=self.MDOption))
- self.addOption(FlagOption('--write-user-dependencies', alias=self.MMDOption))
-
- # Long options with joined & separate forms (coercing to
- # joined form).
-
- self.addOption(SeparateOption('--assert', alias=self.AOption))
- self.addOption(JoinedOption('--assert=', alias=self.AOption,
- forceSeparateRender=True))
- self.addOption(JoinedOption('--bootclasspath=', alias=self.f_bootclasspathOption))
- self.addOption(SeparateOption('--bootclasspath', alias=self.f_bootclasspathOption,
- forceJoinedRender=True))
- self.addOption(JoinedOption('--CLASSPATH=', alias=self.f_classpathOption))
- self.addOption(SeparateOption('--CLASSPATH', alias=self.f_classpathOption,
- forceJoinedRender=True))
- self.addOption(JoinedOption('--classpath=', alias=self.f_classpathOption))
- self.addOption(SeparateOption('--classpath', alias=self.f_classpathOption,
- forceJoinedRender=True))
- self.addOption(JoinedOption('--define-macro=', alias=self.DOption))
- self.addOption(SeparateOption('--define-macro', alias=self.DOption,
- forceJoinedRender=True))
- self.addOption(JoinedOption('--encoding=', alias=self.f_encodingOption))
- self.addOption(SeparateOption('--encoding', alias=self.f_encodingOption,
- forceJoinedRender=True))
- self.addOption(JoinedOption('--extdirs=', alias=self.f_extdirsOption))
- self.addOption(SeparateOption('--extdirs', alias=self.f_extdirsOption,
- forceJoinedRender=True))
- self.addOption(JoinedOption('--include-directory=', alias=self.IOption))
- self.addOption(SeparateOption('--include-directory', alias=self.IOption,
- forceJoinedRender=True))
- self.addOption(JoinedOption('--machine=', alias=self.mJoined))
- self.addOption(SeparateOption('--machine', alias=self.mJoined,
- forceJoinedRender=True))
- self.addOption(JoinedOption('--output-class-directory=', alias=self.f_outputClassDirOption))
- self.addOption(SeparateOption('--output-class-directory', alias=self.f_outputClassDirOption,
- forceJoinedRender=True))
- self.addOption(JoinedOption('--resource=', alias=self.f_compileResourceOption))
- self.addOption(SeparateOption('--resource', alias=self.f_compileResourceOption,
- forceJoinedRender=True))
- self.addOption(JoinedOption('--specs=', alias=self.specsOption,
- unsupported=True))
- self.addOption(SeparateOption('--specs', alias=self.specsOption,
- forceJoinedRender=True, unsupported=True))
- self.addOption(JoinedOption('--std=', alias=self.stdOption))
- self.addOption(SeparateOption('--std', alias=self.stdOption,
- forceJoinedRender=True))
- self.sysrootOption = self.addOption(JoinedOption('--sysroot='))
- self.addOption(SeparateOption('--sysroot', alias=self.sysrootOption,
- forceJoinedRender=True))
- self.addOption(JoinedOption('--undefine-macro=', alias=self.UOption))
- self.addOption(SeparateOption('--undefine-macro', alias=self.UOption,
- forceJoinedRender=True))
-
- # Long options with joined & separate forms (coercing to
- # separate form).
-
-# self.addOption(JoinedOption('--dump=', alias=self.dOption,
-# forceSeparateRender=True))
-# self.addOption(SeparateOption('--dump', alias=self.dOption))
-# self.addOption(JoinedOption('--dumpbase=', alias=self.dumpbaseOption,
-# forceSeparateRender=True))
-# self.addOption(SeparateOption('--dumpbase', alias=self.dumpbaseOption))
-# self.addOption(JoinedOption('--for-assembler=', alias=self.WaOption,
-# forceSeparateRender=True))
-# self.addOption(SeparateOption('--for-assembler', alias=self.WaOption))
- self.addOption(JoinedOption('--for-linker=', alias=self.XlinkerOption,
- forceSeparateRender=True,
- isLinkerInput=True,
- noOptAsInput=True))
- self.addOption(SeparateOption('--for-linker', alias=self.XlinkerOption,
- isLinkerInput=True,
- noOptAsInput=True))
- self.addOption(JoinedOption('--force-link=', alias=self.uOption,
- forceSeparateRender=True))
- self.addOption(SeparateOption('--force-link', alias=self.uOption))
- self.addOption(JoinedOption('--imacros=', alias=self.imacrosOption,
- forceSeparateRender=True))
- self.addOption(SeparateOption('--imacros', alias=self.imacrosOption))
- self.addOption(JoinedOption('--include=', alias=self.includeOption,
- forceSeparateRender=True))
- self.addOption(SeparateOption('--include', alias=self.includeOption))
- self.addOption(JoinedOption('--include-directory-after=', alias=self.idirafterOption,
- forceSeparateRender=True))
- self.addOption(SeparateOption('--include-directory-after', alias=self.idirafterOption))
- self.addOption(JoinedOption('--include-prefix=', alias=self.iprefixOption,
- forceSeparateRender=True))
- self.addOption(SeparateOption('--include-prefix', alias=self.iprefixOption))
- self.addOption(JoinedOption('--include-with-prefix=', alias=self.iwithprefixOption,
- forceSeparateRender=True))
- self.addOption(SeparateOption('--include-with-prefix', alias=self.iwithprefixOption))
- self.addOption(JoinedOption('--include-with-prefix-before=', alias=self.iwithprefixbeforeOption,
- forceSeparateRender=True))
- self.addOption(SeparateOption('--include-with-prefix-before', alias=self.iwithprefixbeforeOption))
- self.addOption(JoinedOption('--include-with-prefix-after=', alias=self.iwithprefixOption,
- forceSeparateRender=True))
- self.addOption(SeparateOption('--include-with-prefix-after', alias=self.iwithprefixOption))
- self.addOption(JoinedOption('--language=', alias=self.xOption,
- forceSeparateRender=True))
- self.addOption(SeparateOption('--language', alias=self.xOption))
- self.addOption(JoinedOption('--library-directory=', alias=self.LOption,
- forceSeparateRender=True))
- self.addOption(SeparateOption('--library-directory', alias=self.LOption))
- self.addOption(JoinedOption('--output=', alias=self.oOption,
- forceSeparateRender=True))
- self.addOption(SeparateOption('--output', alias=self.oOption))
- self.addOption(JoinedOption('--prefix=', alias=self.BOption,
- forceSeparateRender=True))
- self.addOption(SeparateOption('--prefix', alias=self.BOption))
-
- # Long options with joined forms. gcc's handling of '=' for
- # long forms makes these a bit odd.
- #
- # FIXME: We do not currently support these options. The
- # problem is that they need to be reparsed in their translated
- # form; they need to map to the correct option and we have to
- # find a way to do so without replicating all the declared
- # names.
- self.addOption(JoinedOption('--debug=', alias=self.gOption,
- unsupported=True))
- self.addOption(FlagOption('--debug', alias=self.gOption,
- unsupported=True))
- self.addOption(JoinedOption('--machine-=', alias=self.mJoined,
- unsupported=True))
- self.addOption(JoinedOption('--machine-', alias=self.mJoined,
- unsupported=True))
- self.addOption(JoinedOption('--optimize=', alias=self.OOption,
- unsupported=True))
- self.addOption(FlagOption('--optimize', alias=self.OOption,
- unsupported=True))
- self.addOption(JoinedOption('--warn-=', alias=self.WOption,
- unsupported=True))
- self.addOption(JoinedOption('--warn-', alias=self.WOption,
- unsupported=True))
-
- # Ugh.
- self.addOption(JoinedOption('--', alias=self.fOption,
- unsupported=True))
-
- def addOption(self, opt):
- self.options.append(opt)
- return opt
-
- def parseArgs(self, argv):
- """
- parseArgs([str]) -> ArgList
-
- Parse command line into individual option instances.
- """
-
- iargs = enumerate(argv)
- it = iter(iargs)
- args = ArgList(self, argv)
- for pos,a in it:
- i = InputIndex(0, pos)
- if not a:
- # gcc's handling of empty arguments doesn't make
- # sense, but this is not a common use case. :)
- #
- # We just ignore them here (note that other things may
- # still take them as arguments).
- pass
- elif a[0] == '@':
- # @<filename> is only an argument list if it actually
- # exists, otherwise it is treated like an input.
- if os.path.exists(a[1:]):
- # FIXME: Handle '@'
- raise InvalidArgumentsError('@ style argument lists are unsupported')
- else:
- args.append(PositionalArg(i, self.inputOption))
- elif a[0] == '-' and a != '-':
- args.append(self.lookupOptForArg(i, a, it))
- else:
- args.append(PositionalArg(i, self.inputOption))
- return args
-
- def lookupOptForArg(self, i, string, it):
- for o in self.options:
- arg = o.accept(i, string, it)
- if arg is not None:
- return arg
- return PositionalArg(i, self.unknownOption)
diff --git a/tools/ccc/ccclib/Driver.py b/tools/ccc/ccclib/Driver.py
deleted file mode 100644
index 92f7c87..0000000
--- a/tools/ccc/ccclib/Driver.py
+++ /dev/null
@@ -1,873 +0,0 @@
-import os
-import platform
-import subprocess
-import sys
-import tempfile
-from pprint import pprint
-
-###
-
-import Arguments
-import Jobs
-import HostInfo
-import Phases
-import Tools
-import Types
-import Util
-
-# FIXME: Clean up naming of options and arguments. Decide whether to
-# rename Option and be consistent about use of Option/Arg.
-
-####
-
-class Driver(object):
- def __init__(self, driverName, driverDir):
- self.driverName = driverName
- self.driverDir = driverDir
- self.hostInfo = None
- self.parser = Arguments.OptionParser()
- self.cccHostBits = self.cccHostMachine = None
- self.cccHostSystem = self.cccHostRelease = None
- self.cccCXX = False
- self.cccEcho = False
- self.cccNoClang = self.cccNoClangCXX = self.cccNoClangPreprocessor = False
- self.cccClangArchs = None
-
- # Certain options suppress the 'no input files' warning.
- self.suppressMissingInputWarning = False
-
- # Temporary files used in compilation, removed on exit.
- self.tempFiles = []
- # Result files produced by compilation, removed on error.
- self.resultFiles = []
-
- # Host queries which can be forcibly over-riden by the user for
- # testing purposes.
- #
- # FIXME: We should make sure these are drawn from a fixed set so
- # that nothing downstream ever plays a guessing game.
-
- def getHostBits(self):
- if self.cccHostBits:
- return self.cccHostBits
-
- return platform.architecture()[0].replace('bit','')
-
- def getHostMachine(self):
- if self.cccHostMachine:
- return self.cccHostMachine
-
- machine = platform.machine()
- # Normalize names.
- if machine == 'Power Macintosh':
- return 'ppc'
- if machine == 'x86_64':
- return 'i386'
- return machine
-
- def getHostSystemName(self):
- if self.cccHostSystem:
- return self.cccHostSystem
-
- return platform.system().lower()
-
- def getHostReleaseName(self):
- if self.cccHostRelease:
- return self.cccHostRelease
-
- return platform.release()
-
- def getenvBool(self, name):
- var = os.getenv(name)
- if not var:
- return False
-
- try:
- return bool(int(var))
- except:
- return False
-
- ###
-
- def getFilePath(self, name, toolChain=None):
- tc = toolChain or self.toolChain
- for p in tc.filePathPrefixes:
- path = os.path.join(p, name)
- if os.path.exists(path):
- return path
- return name
-
- def getProgramPath(self, name, toolChain=None):
- tc = toolChain or self.toolChain
- for p in tc.programPathPrefixes:
- path = os.path.join(p, name)
- if os.path.exists(path):
- return path
- return name
-
- ###
-
- def run(self, argv):
- # FIXME: Things to support from environment: GCC_EXEC_PREFIX,
- # COMPILER_PATH, LIBRARY_PATH, LPATH, CC_PRINT_OPTIONS,
- # QA_OVERRIDE_GCC3_OPTIONS, ...?
-
- # FIXME: -V and -b processing
-
- # Handle some special -ccc- options used for testing which are
- # only allowed at the beginning of the command line.
- cccPrintOptions = False
- cccPrintPhases = False
-
- # FIXME: How to handle override of host? ccc specific options?
- # Abuse -b?
- arg = os.getenv('CCC_ADD_ARGS')
- if arg:
- args = filter(None, map(str.strip, arg.split(',')))
- argv = args + argv
-
- while argv and argv[0].startswith('-ccc-'):
- fullOpt,argv = argv[0],argv[1:]
- opt = fullOpt[5:]
-
- if opt == 'print-options':
- cccPrintOptions = True
- elif opt == 'print-phases':
- cccPrintPhases = True
- elif opt == 'cxx':
- self.cccCXX = True
- elif opt == 'echo':
- self.cccEcho = True
-
- elif opt == 'no-clang':
- self.cccNoClang = True
- elif opt == 'no-clang-cxx':
- self.cccNoClangCXX = True
- elif opt == 'no-clang-cpp':
- self.cccNoClangPreprocessor = True
- elif opt == 'clang-archs':
- self.cccClangArchs,argv = argv[0].split(','),argv[1:]
-
- elif opt == 'host-bits':
- self.cccHostBits,argv = argv[0],argv[1:]
- elif opt == 'host-machine':
- self.cccHostMachine,argv = argv[0],argv[1:]
- elif opt == 'host-system':
- self.cccHostSystem,argv = argv[0],argv[1:]
- elif opt == 'host-release':
- self.cccHostRelease,argv = argv[0],argv[1:]
- elif opt == 'host-triple':
- # This is a complete hack, but only exists for testing
- # compatibility with the new driver. We will be six
- # feet under soon enough.
- triple,argv = argv[0],argv[1:]
- self.cccHostMachine,_,self.cccHostSystem = triple.split('-', 2)
- if self.cccHostSystem.startswith('darwin'):
- self.cccHostSystem = 'darwin'
- self.cccHostRelease = '10.5.0'
- if self.cccHostMachine == 'x86_64':
- self.cccHostMachine = 'i386'
- self.cccHostBits = '64'
- elif self.cccHostMachine == 'i386':
- self.cccHostBits = '32'
- else:
- raise Arguments.InvalidArgumentsError("invalid option: %r" % fullOpt)
-
- self.hostInfo = HostInfo.getHostInfo(self)
- self.toolChain = self.hostInfo.getToolChain()
-
- args = self.parser.parseArgs(argv)
-
- # FIXME: Ho hum I have just realized -Xarch_ is broken. We really
- # need to reparse the Arguments after they have been expanded by
- # -Xarch. How is this going to work?
- #
- # Scratch that, we aren't going to do that; it really disrupts the
- # organization, doesn't consistently work with gcc-dd, and is
- # confusing. Instead we are going to enforce that -Xarch_ is only
- # used with options which do not alter the driver behavior. Let's
- # hope this is ok, because the current architecture is a little
- # tied to it.
-
- if cccPrintOptions:
- self.printOptions(args)
- sys.exit(0)
-
- self.handleImmediateOptions(args)
-
- if self.hostInfo.useDriverDriver():
- phases = self.buildPipeline(args)
- else:
- phases = self.buildNormalPipeline(args)
-
- if cccPrintPhases:
- self.printPhases(phases, args)
- sys.exit(0)
-
- if 0:
- print Util.pprint(phases)
-
- jobs = self.bindPhases(phases, args)
-
- # FIXME: We should provide some basic sanity checking of the
- # pipeline as a "verification" sort of stage. For example, the
- # pipeline should never end up writing to an output file in two
- # places (I think). The pipeline should also never end up writing
- # to an output file that is an input.
- #
- # This is intended to just be a "verify" step, not a functionality
- # step. It should catch things like the driver driver not
- # preventing -save-temps, but it shouldn't change behavior (so we
- # can turn it off in Release-Asserts builds).
-
- # Print in -### syntax.
- hasHashHashHash = args.getLastArg(self.parser.hashHashHashOption)
- if hasHashHashHash:
- self.claim(hasHashHashHash)
- for j in jobs.iterjobs():
- if isinstance(j, Jobs.Command):
- print >>sys.stderr, ' "%s"' % '" "'.join(j.getArgv())
- elif isinstance(j, Jobs.PipedJob):
- for c in j.commands:
- print >>sys.stderr, ' "%s" %c' % ('" "'.join(c.getArgv()),
- "| "[c is j.commands[-1]])
- elif not isinstance(j, JobList):
- raise ValueError,'Encountered unknown job.'
- sys.exit(0)
-
- try:
- try:
- self.executeJobs(args, jobs)
- except:
- if not args.getLastArg(self.parser.saveTempsOption):
- # Fail if removing a result fails.
- self.removeFiles(self.resultFiles, failOnError=True)
- raise
- finally:
- # Ignore failures in removing temporary files
- self.removeFiles(self.tempFiles, failOnError=False)
-
- def removeFiles(self, fileList, failOnError=False):
- for f in fileList:
- try:
- os.remove(f)
- except OSError,e:
- if failOnError:
- import errno
- if e.errno != errno.ENOENT:
- raise
- except:
- if failOnError:
- raise
-
- def executeJobs(self, args, jobs):
- vArg = args.getLastArg(self.parser.vOption)
- for j in jobs.iterjobs():
- if isinstance(j, Jobs.Command):
- if vArg or self.cccEcho:
- print >>sys.stderr, ' '.join(map(str,j.getArgv()))
- sys.stderr.flush()
- p = self.startSubprocess(j.getArgv(), j.executable)
- res = p.wait()
- if res:
- sys.exit(res)
-
- elif isinstance(j, Jobs.PipedJob):
- procs = []
- for sj in j.commands:
- if vArg or self.cccEcho:
- print >> sys.stderr, ' '.join(map(str,sj.getArgv()))
- sys.stdout.flush()
-
- if not procs:
- stdin = None
- else:
- stdin = procs[-1].stdout
- if sj is j.commands[-1]:
- stdout = None
- else:
- stdout = subprocess.PIPE
-
- procs.append(self.startSubprocess(sj.getArgv(), sj.executable,
- stdin=stdin,
- stdout=stdout))
-
- for proc in procs:
- res = proc.wait()
- if res:
- sys.exit(res)
- else:
- raise ValueError,'Encountered unknown job.'
-
- def startSubprocess(self, argv, executable, **kwargs):
- try:
- return subprocess.Popen(argv, executable=executable, **kwargs)
- except OSError, e:
- self.warning("error trying to exec '%s': %s" %
- (executable, e.args[1]))
- sys.exit(1)
-
- def claim(self, option):
- # FIXME: Move to OptionList once introduced and implement.
- pass
-
- def warning(self, message):
- print >>sys.stderr,'%s: %s' % (self.driverName, message)
-
- def printOptions(self, args):
- for i,arg in enumerate(args):
- if isinstance(arg, Arguments.MultipleValuesArg):
- values = list(args.getValues(arg))
- elif isinstance(arg, Arguments.ValueArg):
- values = [args.getValue(arg)]
- elif isinstance(arg, Arguments.JoinedAndSeparateValuesArg):
- values = [args.getJoinedValue(arg), args.getSeparateValue(arg)]
- else:
- values = []
- print 'Option %d - Name: "%s", Values: {%s}' % (i, arg.opt.name,
- ', '.join(['"%s"' % v
- for v in values]))
-
- def printPhases(self, phases, args):
- def printPhase(p, f, steps):
- if p in steps:
- return steps[p]
-
- if isinstance(p, Phases.InputAction):
- phaseName = 'input'
- inputStr = '"%s"' % args.getValue(p.filename)
- elif isinstance(p, Phases.BindArchAction):
- phaseName = 'bind-arch'
- inputs = [printPhase(i, f, steps)
- for i in p.inputs]
- inputStr = '"%s", {%s}' % (args.getValue(p.arch),
- ', '.join(map(str, inputs)))
- else:
- phaseName = p.phase.name
- inputs = [printPhase(i, f, steps)
- for i in p.inputs]
- inputStr = '{%s}' % ', '.join(map(str, inputs))
- steps[p] = index = len(steps)
- print "%d: %s, %s, %s" % (index,phaseName,inputStr,p.type.name)
- return index
- steps = {}
- for phase in phases:
- printPhase(phase, sys.stdout, steps)
-
- def printVersion(self):
- # FIXME: Print default target triple.
- vers = '$HeadURL$'
- vers = vers.split('/tools/ccc')[0]
- vers = vers.split('/clang/tools/clang')[0]
- vers = ' (' + vers[10:] + ')'
- print >>sys.stderr,'ccc version 1.0' + vers
-
- def handleImmediateOptions(self, args):
- # FIXME: Some driver Arguments are consumed right off the bat,
- # like -dumpversion. Currently the gcc-dd handles these
- # poorly, so we should be ok handling them upfront instead of
- # after driver-driver level dispatching.
- #
- # FIXME: The actual order of these options in gcc is all over the
- # place. The -dump ones seem to be first and in specification
- # order, but there are other levels of precedence. For example,
- # -print-search-dirs is evaluated before -print-prog-name=,
- # regardless of order (and the last instance of -print-prog-name=
- # wins verse itself).
- #
- # FIXME: Do we want to report "argument unused" type errors in the
- # presence of things like -dumpmachine and -print-search-dirs?
- # Probably not.
- if (args.getLastArg(self.parser.vOption) or
- args.getLastArg(self.parser.hashHashHashOption)):
- self.printVersion()
- self.suppressMissingInputWarning = True
-
- arg = args.getLastArg(self.parser.printFileNameOption)
- if arg:
- print self.getFilePath(args.getValue(arg))
- sys.exit(0)
-
- arg = args.getLastArg(self.parser.printProgNameOption)
- if arg:
- print self.getProgramPath(args.getValue(arg))
- sys.exit(0)
-
- arg = args.getLastArg(self.parser.printLibgccFileNameOption)
- if arg:
- print self.getFilePath('libgcc.a')
- sys.exit(0)
-
- 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)
- hasDashS = args.getLastArg(self.parser.SOption)
- hasDashM = args.getLastArg(self.parser.MOption)
- hasDashMM = args.getLastArg(self.parser.MMOption)
-
- inputType = None
- inputTypeOpt = None
- inputs = []
- for a in args:
- if a.opt is self.parser.inputOption:
- inputValue = args.getValue(a)
- if inputType is None:
- base,ext = os.path.splitext(inputValue)
- # stdin is handled specially.
- if inputValue == '-':
- if args.getLastArg(self.parser.EOption):
- # Treat as a C input needing preprocessing
- # (or Obj-C if over-ridden below).
- klass = Types.CType
- else:
- raise Arguments.InvalidArgumentsError("-E or -x required when input is from standard input")
- elif ext and ext in Types.kTypeSuffixMap:
- klass = self.hostInfo.lookupTypeForExtension(ext)
- else:
- # FIXME: Its not clear why we shouldn't just
- # revert to unknown. I think this is more likely a
- # bug / unintended behavior in gcc. Not very
- # important though.
- klass = Types.ObjectType
-
- # -ObjC and -ObjC++ over-ride the default
- # language, but only for "source files". We
- # just treat everything that isn't a linker
- # input as a source file.
- #
- # FIXME: Clean this up if we move the phase
- # sequence into the type.
- if klass is not Types.ObjectType:
- if args.getLastArg(self.parser.ObjCOption):
- klass = Types.ObjCType
- elif args.getLastArg(self.parser.ObjCXXOption):
- klass = Types.ObjCType
- else:
- assert inputTypeOpt is not None
- self.claim(inputTypeOpt)
- klass = inputType
-
- # Check that the file exists. It isn't clear this is
- # 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 inputValue != '-' and not os.path.exists(inputValue):
- self.warning("%s: No such file or directory" % inputValue)
- else:
- inputs.append((klass, a))
- elif a.opt.isLinkerInput:
- # Treat as a linker input.
- #
- # FIXME: This might not be good enough. We may
- # need to introduce another type for this case, so
- # that other code which needs to know the inputs
- # handles this properly. Best not to try and lipo
- # this, for example.
- inputs.append((Types.ObjectType, a))
- elif a.opt is self.parser.xOption:
- inputTypeOpt = a
- value = args.getValue(a)
- if value in Types.kTypeSpecifierMap:
- inputType = Types.kTypeSpecifierMap[value]
- else:
- # FIXME: How are we going to handle diagnostics.
- self.warning("language %s not recognized" % value)
-
- # FIXME: Its not clear why we shouldn't just
- # revert to unknown. I think this is more likely a
- # bug / unintended behavior in gcc. Not very
- # important though.
- inputType = Types.ObjectType
-
- # We claim things here so that options for which we silently allow
- # override only ever claim the used option.
- if hasCombine:
- self.claim(hasCombine)
-
- finalPhase = Phases.Phase.eOrderPostAssemble
- finalPhaseOpt = None
-
- # Determine what compilation mode we are in.
- if hasDashE or hasDashM or hasDashMM:
- finalPhase = Phases.Phase.eOrderPreprocess
- finalPhaseOpt = hasDashE
- elif (hasAnalyze or hasSyntaxOnly or
- hasEmitLLVM or hasDashS):
- finalPhase = Phases.Phase.eOrderCompile
- finalPhaseOpt = (hasAnalyze or hasSyntaxOnly or
- hasEmitLLVM or hasDashS)
- elif hasDashC:
- finalPhase = Phases.Phase.eOrderAssemble
- finalPhaseOpt = hasDashC
-
- if finalPhaseOpt:
- self.claim(finalPhaseOpt)
-
- # Reject -Z* at the top level for now.
- arg = args.getLastArg(self.parser.ZOption)
- if arg:
- raise Arguments.InvalidArgumentsError("%s: unsupported use of internal gcc option" % ' '.join(args.render(arg)))
-
- if not inputs and not self.suppressMissingInputWarning:
- raise Arguments.InvalidArgumentsError("no input files")
-
- actions = []
- linkerInputs = []
- # FIXME: This is gross.
- linkPhase = Phases.LinkPhase()
- for klass,input in inputs:
- # Figure out what step to start at.
-
- # FIXME: This should be part of the input class probably?
- # Altough it doesn't quite fit there either, things like
- # asm-with-preprocess don't easily fit into a linear scheme.
-
- # FIXME: I think we are going to end up wanting to just build
- # a simple FSA which we run the inputs down.
- sequence = []
- if klass.preprocess:
- sequence.append(Phases.PreprocessPhase())
- if klass == Types.ObjectType:
- sequence.append(linkPhase)
- elif klass.onlyAssemble:
- sequence.extend([Phases.AssemblePhase(),
- linkPhase])
- elif klass.onlyPrecompile:
- sequence.append(Phases.PrecompilePhase())
- elif hasAnalyze:
- sequence.append(Phases.AnalyzePhase())
- elif hasSyntaxOnly:
- sequence.append(Phases.SyntaxOnlyPhase())
- elif hasEmitLLVM:
- sequence.append(Phases.EmitLLVMPhase())
- else:
- sequence.extend([Phases.CompilePhase(),
- Phases.AssemblePhase(),
- linkPhase])
-
- if sequence[0].order > finalPhase:
- assert finalPhaseOpt and finalPhaseOpt.opt
- # FIXME: Explain what type of input file is. Or just match
- # gcc warning.
- self.warning("%s: %s input file unused when %s is present" % (args.getValue(input),
- sequence[0].name,
- finalPhaseOpt.opt.name))
- else:
- # Build the pipeline for this file.
-
- current = Phases.InputAction(input, klass)
- for transition in sequence:
- # If the current action produces no output, or we are
- # past what the user requested, we are done.
- if (current.type is Types.NothingType or
- transition.order > finalPhase):
- break
- else:
- if isinstance(transition, Phases.PreprocessPhase):
- assert isinstance(klass.preprocess, Types.InputType)
- current = Phases.JobAction(transition,
- [current],
- klass.preprocess)
- elif isinstance(transition, Phases.PrecompilePhase):
- current = Phases.JobAction(transition,
- [current],
- Types.PCHType)
- elif isinstance(transition, Phases.AnalyzePhase):
- output = Types.PlistType
- current = Phases.JobAction(transition,
- [current],
- output)
- elif isinstance(transition, Phases.SyntaxOnlyPhase):
- output = Types.NothingType
- 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,
- [current],
- output)
- elif isinstance(transition, Phases.AssemblePhase):
- current = Phases.JobAction(transition,
- [current],
- Types.ObjectType)
- elif transition is linkPhase:
- linkerInputs.append(current)
- current = None
- break
- else:
- raise RuntimeError,'Unrecognized transition: %s.' % transition
- pass
-
- if current is not None:
- assert not isinstance(current, Phases.InputAction)
- actions.append(current)
-
- if linkerInputs:
- actions.append(Phases.JobAction(linkPhase,
- linkerInputs,
- Types.ImageType))
-
- return actions
-
- def buildPipeline(self, args):
- # FIXME: We need to handle canonicalization of the specified arch.
-
- archs = {}
- hasDashM = args.getLastArg(self.parser.MGroup)
- hasSaveTemps = args.getLastArg(self.parser.saveTempsOption)
- for arg in args:
- if arg.opt is self.parser.archOption:
- # FIXME: Canonicalize this.
- archName = args.getValue(arg)
- archs[archName] = arg
-
- archs = archs.values()
- if not archs:
- archs.append(args.makeSeparateArg(self.hostInfo.getArchName(args),
- self.parser.archOption))
-
- actions = self.buildNormalPipeline(args)
-
- # FIXME: Use custom exception for this.
- #
- # FIXME: We killed off some others but these aren't yet detected in
- # a functional manner. If we added information to jobs about which
- # "auxiliary" files they wrote then we could detect the conflict
- # these cause downstream.
- if len(archs) > 1:
- if hasDashM:
- raise Arguments.InvalidArgumentsError("Cannot use -M options with multiple arch flags.")
- elif hasSaveTemps:
- raise Arguments.InvalidArgumentsError("Cannot use -save-temps with multiple arch flags.")
-
- # Execute once per arch.
- finalActions = []
- for p in actions:
- # Make sure we can lipo this kind of output. If not (and it
- # is an actual output) then we disallow, since we can't
- # create an output file with the right name without
- # overwriting it. We could remove this oddity by just
- # changing the output names to include the arch, which would
- # also fix -save-temps. Compatibility wins for now.
- #
- # FIXME: Is this error substantially less useful than
- # gcc-dd's? The main problem is that "Cannot use compiler
- # output with multiple arch flags" won't make sense to most
- # developers.
- if (len(archs) > 1 and
- p.type not in (Types.NothingType,Types.ObjectType,Types.ImageType)):
- raise Arguments.InvalidArgumentsError('Cannot use %s output with multiple arch flags.' % p.type.name)
-
- inputs = []
- for arch in archs:
- inputs.append(Phases.BindArchAction(p, arch))
-
- # Lipo if necessary. We do it this way because we need to set
- # the arch flag so that -Xarch_ gets rewritten.
- if len(inputs) == 1 or p.type == Types.NothingType:
- finalActions.extend(inputs)
- else:
- finalActions.append(Phases.JobAction(Phases.LipoPhase(),
- inputs,
- p.type))
-
- return finalActions
-
- def bindPhases(self, phases, args):
- jobs = Jobs.JobList()
-
- finalOutput = args.getLastArg(self.parser.oOption)
- hasSaveTemps = args.getLastArg(self.parser.saveTempsOption)
- hasNoIntegratedCPP = args.getLastArg(self.parser.noIntegratedCPPOption)
- hasTraditionalCPP = args.getLastArg(self.parser.traditionalCPPOption)
- hasPipe = args.getLastArg(self.parser.pipeOption)
-
- # We claim things here so that options for which we silently allow
- # override only ever claim the used option.
- if hasPipe:
- self.claim(hasPipe)
- # FIXME: Hack, override -pipe till we support it.
- if hasSaveTemps:
- self.warning('-pipe ignored because -save-temps specified')
- hasPipe = None
- # Claim these here. Its not completely accurate but any warnings
- # about these being unused are likely to be noise anyway.
- if hasSaveTemps:
- self.claim(hasSaveTemps)
-
- if hasTraditionalCPP:
- self.claim(hasTraditionalCPP)
- elif hasNoIntegratedCPP:
- self.claim(hasNoIntegratedCPP)
-
- # FIXME: Move to... somewhere else.
- class InputInfo:
- def __init__(self, source, type, baseInput):
- self.source = source
- self.type = type
- self.baseInput = baseInput
-
- def __repr__(self):
- return '%s(%r, %r, %r)' % (self.__class__.__name__,
- self.source, self.type, self.baseInput)
-
- def isOriginalInput(self):
- return self.source is self.baseInput
-
- def createJobs(tc, phase,
- canAcceptPipe=False, atTopLevel=False, arch=None,
- tcArgs=None, linkingOutput=None):
- if isinstance(phase, Phases.InputAction):
- return InputInfo(phase.filename, phase.type, phase.filename)
- elif isinstance(phase, Phases.BindArchAction):
- archName = args.getValue(phase.arch)
- tc = self.hostInfo.getToolChainForArch(archName)
- return createJobs(tc, phase.inputs[0],
- canAcceptPipe, atTopLevel, phase.arch,
- None, linkingOutput)
-
- if tcArgs is None:
- tcArgs = tc.translateArgs(args, arch)
-
- assert isinstance(phase, Phases.JobAction)
- tool = tc.selectTool(phase)
-
- # See if we should use an integrated CPP. We only use an
- # integrated cpp when we have exactly one input, since this is
- # the only use case we care about.
- useIntegratedCPP = False
- inputList = phase.inputs
- if (not hasNoIntegratedCPP and
- not hasTraditionalCPP and
- not hasSaveTemps and
- tool.hasIntegratedCPP()):
- if (len(phase.inputs) == 1 and
- isinstance(phase.inputs[0], Phases.JobAction) and
- isinstance(phase.inputs[0].phase, Phases.PreprocessPhase)):
- useIntegratedCPP = True
- inputList = phase.inputs[0].inputs
-
- # Only try to use pipes when exactly one input.
- attemptToPipeInput = len(inputList) == 1 and tool.acceptsPipedInput()
- inputs = [createJobs(tc, p, attemptToPipeInput, False,
- arch, tcArgs, linkingOutput)
- for p in inputList]
-
- # Determine if we should output to a pipe.
- canOutputToPipe = canAcceptPipe and tool.canPipeOutput()
- outputToPipe = False
- if canOutputToPipe:
- # Some things default to writing to a pipe if the final
- # phase and there was no user override.
- #
- # FIXME: What is the best way to handle this?
- if atTopLevel:
- if (isinstance(phase.phase, Phases.PreprocessPhase) and
- not finalOutput):
- outputToPipe = True
- elif hasPipe:
- outputToPipe = True
-
- # Figure out where to put the job (pipes).
- jobList = jobs
- if isinstance(inputs[0].source, Jobs.PipedJob):
- jobList = inputs[0].source
-
- baseInput = inputs[0].baseInput
- output,jobList = self.getOutputName(phase, outputToPipe, jobs, jobList, baseInput,
- args, atTopLevel, hasSaveTemps, finalOutput)
- tool.constructJob(phase, arch, jobList, inputs, output, phase.type,
- tcArgs, linkingOutput)
-
- return InputInfo(output, phase.type, baseInput)
-
- # It is an error to provide a -o option if we are making multiple
- # output files.
- if finalOutput and len([a for a in phases if a.type is not Types.NothingType]) > 1:
- raise Arguments.InvalidArgumentsError("cannot specify -o when generating multiple files")
-
- for phase in phases:
- # If we are linking an image for multiple archs then the
- # linker wants -arch_multiple and -final_output <final image
- # name>. Unfortunately this requires some gross contortions.
- #
- # FIXME: This is a hack; find a cleaner way to integrate this
- # into the process.
- linkingOutput = None
- if (isinstance(phase, Phases.JobAction) and
- isinstance(phase.phase, Phases.LipoPhase)):
- finalOutput = args.getLastArg(self.parser.oOption)
- if finalOutput:
- linkingOutput = finalOutput
- else:
- linkingOutput = args.makeSeparateArg('a.out',
- self.parser.oOption)
-
- createJobs(self.toolChain, phase,
- canAcceptPipe=True, atTopLevel=True,
- linkingOutput=linkingOutput)
-
- return jobs
-
- def getOutputName(self, phase, outputToPipe, jobs, jobList, baseInput,
- args, atTopLevel, hasSaveTemps, finalOutput):
- # Figure out where to put the output.
- if phase.type == Types.NothingType:
- output = None
- elif outputToPipe:
- if isinstance(jobList, Jobs.PipedJob):
- output = jobList
- else:
- jobList = output = Jobs.PipedJob([])
- jobs.addJob(output)
- else:
- # Figure out what the derived output location would be.
- if phase.type is Types.ImageType:
- namedOutput = "a.out"
- else:
- assert phase.type.tempSuffix is not None
- inputName = args.getValue(baseInput)
- if phase.type.appendSuffix:
- namedOutput = inputName + '.' + phase.type.tempSuffix
- else:
- base,_ = os.path.splitext(inputName)
- namedOutput = base + '.' + phase.type.tempSuffix
-
- isTemp = False
- # Output to user requested destination?
- if atTopLevel and finalOutput:
- output = finalOutput
- self.resultFiles.append(args.getValue(finalOutput))
-
- # Contruct a named destination?
- elif atTopLevel or hasSaveTemps:
- # As an annoying special case, pch generation
- # doesn't strip the pathname.
- if phase.type is Types.PCHType:
- outputName = namedOutput
- else:
- outputName = os.path.basename(namedOutput)
- output = args.makeSeparateArg(outputName,
- self.parser.oOption)
- self.resultFiles.append(outputName)
-
- else:
- # Output to temp file...
- fd,filename = tempfile.mkstemp(suffix='.'+phase.type.tempSuffix)
- output = args.makeSeparateArg(filename,
- self.parser.oOption)
- self.tempFiles.append(filename)
- return output,jobList
diff --git a/tools/ccc/ccclib/HostInfo.py b/tools/ccc/ccclib/HostInfo.py
deleted file mode 100644
index c40a4f7..0000000
--- a/tools/ccc/ccclib/HostInfo.py
+++ /dev/null
@@ -1,133 +0,0 @@
-import ToolChain
-import Types
-
-class HostInfo(object):
- """HostInfo - Config information about a particular host which may
- interact with driver behavior. This can be very different from the
- target(s) of a particular driver invocation."""
-
- def __init__(self, driver):
- self.driver = driver
-
- def getArchName(self, args):
- abstract
-
- def useDriverDriver(self):
- abstract
-
- def lookupTypeForExtension(self, ext):
- abstract
-
- def getToolChain(self):
- abstract
-
- def getToolChainForArch(self, arch):
- raise RuntimeError,"getToolChainForArch() unsupported on this host."
-
-# Darwin
-
-class DarwinHostInfo(HostInfo):
- def __init__(self, driver):
- super(DarwinHostInfo, self).__init__(driver)
-
- # FIXME: Find right regex for this.
- import re
- m = re.match(r'([0-9]+)\.([0-9]+)\.([0-9]+)', driver.getHostReleaseName())
- if not m:
- raise RuntimeError,"Unable to determine Darwin version."
- self.darwinVersion = tuple(map(int, m.groups()))
- self.gccVersion = (4,2,1)
-
- def useDriverDriver(self):
- return True
-
- def lookupTypeForExtension(self, ext):
- ty = Types.kTypeSuffixMap.get(ext)
- if ty is Types.AsmTypeNoPP:
- return Types.AsmType
- return ty
-
- def getToolChain(self):
- return self.getToolChainForArch(self.getArchName(None))
-
- def getToolChainForArch(self, arch):
- if arch in ('i386', 'x86_64'):
- return ToolChain.Darwin_X86_ToolChain(self.driver,
- arch,
- self.darwinVersion,
- self.gccVersion)
-
- return ToolChain.Darwin_GCC_ToolChain(self.driver, arch)
-
-class DarwinPPCHostInfo(DarwinHostInfo):
- def getArchName(self, args):
- if args and args.getLastArg(args.parser.m_64Option):
- return 'ppc64'
- return 'ppc'
-
-class DarwinPPC_64HostInfo(DarwinHostInfo):
- def getArchName(self, args):
- if args and args.getLastArg(args.parser.m_32Option):
- return 'ppc'
- return 'ppc64'
-
-class DarwinX86HostInfo(DarwinHostInfo):
- def getArchName(self, args):
- if args and args.getLastArg(args.parser.m_64Option):
- return 'x86_64'
- return 'i386'
-
-class DarwinX86_64HostInfo(DarwinHostInfo):
- def getArchName(self, args):
- if args and args.getLastArg(args.parser.m_32Option):
- return 'i386'
- return 'x86_64'
-
-def getDarwinHostInfo(driver):
- machine = driver.getHostMachine()
- bits = driver.getHostBits()
- if machine == 'i386':
- if bits == '32':
- return DarwinX86HostInfo(driver)
- if bits == '64':
- return DarwinX86_64HostInfo(driver)
- elif machine == 'ppc':
- if bits == '32':
- return DarwinPPCHostInfo(driver)
- if bits == '64':
- return DarwinPPC_64HostInfo(driver)
-
- raise RuntimeError,'Unrecognized Darwin platform: %r:%r' % (machine, bits)
-
-# Unknown
-
-class UnknownHostInfo(HostInfo):
- def getArchName(self, args):
- raise RuntimeError,'getArchName() unsupported on unknown host.'
-
- def useDriverDriver(self):
- return False
-
- def lookupTypeForExtension(self, ext):
- return Types.kTypeSuffixMap.get(ext)
-
- def getToolChain(self):
- return ToolChain.Generic_GCC_ToolChain(self.driver, '')
-
-def getUnknownHostInfo(driver):
- return UnknownHostInfo(driver)
-
-####
-
-kSystems = {
- 'darwin' : getDarwinHostInfo,
- 'unknown' : getUnknownHostInfo,
- }
-
-def getHostInfo(driver):
- system = driver.getHostSystemName()
- handler = kSystems.get(system)
- if handler:
- return handler(driver)
-
- return UnknownHostInfo(driver)
diff --git a/tools/ccc/ccclib/Jobs.py b/tools/ccc/ccclib/Jobs.py
deleted file mode 100644
index 0b3c3a3..0000000
--- a/tools/ccc/ccclib/Jobs.py
+++ /dev/null
@@ -1,60 +0,0 @@
-import Arguments
-import Util
-
-class Job(object):
- """Job - A set of commands to execute as a single task."""
-
- def iterjobs(self):
- abstract
-
-class Command(Job):
- """Command - Represent the information needed to execute a single
- process.
-
- This currently assumes that the executable will always be the
- first argument."""
-
- def __init__(self, executable, args):
- assert Util.all_true(args, lambda x: isinstance(x, str))
- self.executable = executable
- self.args = args
-
- def __repr__(self):
- return Util.prefixAndPPrint(self.__class__.__name__,
- (self.executable, self.args))
-
- def getArgv(self):
- return [self.executable] + self.args
-
- def iterjobs(self):
- yield self
-
-class PipedJob(Job):
- """PipedJob - A sequence of piped commands."""
-
- def __init__(self, commands):
- assert Util.all_true(commands, lambda x: isinstance(x, Arguments.Command))
- self.commands = list(commands)
-
- def addJob(self, job):
- assert isinstance(job, Command)
- self.commands.append(job)
-
- def __repr__(self):
- return Util.prefixAndPPrint(self.__class__.__name__, (self.commands,))
-
-class JobList(Job):
- """JobList - A sequence of jobs to perform."""
-
- def __init__(self, jobs=[]):
- self.jobs = list(jobs)
-
- def addJob(self, job):
- self.jobs.append(job)
-
- def __repr__(self):
- return Util.prefixAndPPrint(self.__class__.__name__, (self.jobs,))
-
- def iterjobs(self):
- for j in self.jobs:
- yield j
diff --git a/tools/ccc/ccclib/Phases.py b/tools/ccc/ccclib/Phases.py
deleted file mode 100644
index 0998fd6..0000000
--- a/tools/ccc/ccclib/Phases.py
+++ /dev/null
@@ -1,98 +0,0 @@
-import Util
-
-class Action(object):
- def __init__(self, inputs, type):
- self.inputs = inputs
- self.type = type
-
-class BindArchAction(Action):
- """BindArchAction - Represent an architecture binding for child
- actions."""
-
- def __init__(self, input, arch):
- super(BindArchAction, self).__init__([input], input.type)
- self.arch = arch
-
- def __repr__(self):
- return Util.prefixAndPPrint(self.__class__.__name__,
- (self.inputs[0], self.arch))
-
-class InputAction(Action):
- """InputAction - Adapt an input file to an action & type. """
-
- def __init__(self, filename, type):
- super(InputAction, self).__init__([], type)
- self.filename = filename
-
- def __repr__(self):
- return Util.prefixAndPPrint(self.__class__.__name__,
- (self.filename, self.type))
-
-class JobAction(Action):
- """JobAction - Represent a job tied to a particular compilation
- phase."""
-
- def __init__(self, phase, inputs, type):
- super(JobAction, self).__init__(inputs, type)
- self.phase = phase
-
- def __repr__(self):
- return Util.prefixAndPPrint(self.__class__.__name__,
- (self.phase, self.inputs, self.type))
-
-###
-
-class Phase(object):
- """Phase - Represent an abstract task in the compilation
- pipeline."""
-
- eOrderNone = 0
- eOrderPreprocess = 1
- eOrderCompile = 2
- eOrderAssemble = 3
- eOrderPostAssemble = 4
-
- def __init__(self, name, order):
- self.name = name
- self.order = order
-
- def __repr__(self):
- return Util.prefixAndPPrint(self.__class__.__name__,
- (self.name, self.order))
-
-class PreprocessPhase(Phase):
- def __init__(self):
- super(PreprocessPhase, self).__init__("preprocessor", Phase.eOrderPreprocess)
-
-class PrecompilePhase(Phase):
- def __init__(self):
- super(PrecompilePhase, self).__init__("precompiler", Phase.eOrderCompile)
-
-class AnalyzePhase(Phase):
- def __init__(self):
- super(AnalyzePhase, self).__init__("analyzer", Phase.eOrderCompile)
-
-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)
-
-class AssemblePhase(Phase):
- def __init__(self):
- super(AssemblePhase, self).__init__("assembler", Phase.eOrderAssemble)
-
-class LinkPhase(Phase):
- def __init__(self):
- super(LinkPhase, self).__init__("linker", Phase.eOrderPostAssemble)
-
-class LipoPhase(Phase):
- def __init__(self):
- super(LipoPhase, self).__init__("lipo", Phase.eOrderPostAssemble)
-
diff --git a/tools/ccc/ccclib/ToolChain.py b/tools/ccc/ccclib/ToolChain.py
deleted file mode 100644
index be949e7..0000000
--- a/tools/ccc/ccclib/ToolChain.py
+++ /dev/null
@@ -1,287 +0,0 @@
-import os
-
-import Arguments
-import Phases
-import Tools
-import Types
-
-###
-
-class ToolChain(object):
- """ToolChain - Provide mappings of Actions to Tools."""
-
- def __init__(self, driver, archName,
- filePathPrefixes=[],
- programPathPrefixes=[]):
- self.driver = driver
- self.archName = archName
- self.filePathPrefixes = list(filePathPrefixes)
- self.programPathPrefixes = list(programPathPrefixes)
-
- def getFilePath(self, name):
- return self.driver.getFilePath(name, self)
-
- def getProgramPath(self, name):
- return self.driver.getProgramPath(name, self)
-
- def selectTool(self, action):
- """selectTool - Return a Tool instance to use for handling
- some particular action."""
- abstract
-
- def translateArgs(self, args, arch):
- """translateArgs - Callback to allow argument translation for
- an entire toolchain."""
-
- # FIXME: Would be nice to move arch handling out of generic
- # code.
- if arch:
- archName = args.getValue(arch)
- al = Arguments.DerivedArgList(args)
- for arg in args.args:
- if arg.opt is args.parser.archOption:
- if arg is arch:
- al.append(arg)
- elif arg.opt is args.parser.XarchOption:
- if args.getJoinedValue(arg) == archName:
- # FIXME: Fix this.
- arg = args.parser.lookupOptForArg(Arguments.InputIndex(0, arg.index.pos + 1),
- args.getSeparateValue(arg),
- iter([]))
- al.append(arg)
- else:
- al.append(arg)
- return al
- else:
- return args
-
- def shouldUseClangCompiler(self, action):
- # If user requested no clang, or this isn't a "compile" phase,
- # or this isn't an input clang understands, then don't use clang.
- if (self.driver.cccNoClang or
- not isinstance(action.phase, (Phases.PreprocessPhase,
- Phases.CompilePhase,
- Phases.SyntaxOnlyPhase,
- Phases.EmitLLVMPhase,
- Phases.PrecompilePhase)) or
- action.inputs[0].type not in Types.clangableTypesSet):
- return False
-
- if self.driver.cccNoClangPreprocessor:
- if isinstance(action.phase, Phases.PreprocessPhase):
- return False
-
- if self.driver.cccNoClangCXX:
- if action.inputs[0].type in Types.cxxTypesSet:
- return False
-
- # Don't use clang if this isn't one of the user specified
- # archs to build.
- if (self.driver.cccClangArchs and
- self.archName not in self.driver.cccClangArchs):
- return False
-
- return True
-
- def isMathErrnoDefault(self):
- return True
-
- def isUnwindTablesDefault(self):
- # FIXME: Target hook.
- if self.archName == 'x86_64':
- return True
- return False
-
- def getDefaultRelocationModel(self):
- return 'static'
-
- def getForcedPicModel(self):
- return
-
-class Darwin_X86_ToolChain(ToolChain):
- def __init__(self, driver, archName, darwinVersion, gccVersion):
- super(Darwin_X86_ToolChain, self).__init__(driver, archName)
- assert isinstance(darwinVersion, tuple) and len(darwinVersion) == 3
- assert isinstance(gccVersion, tuple) and len(gccVersion) == 3
- self.darwinVersion = darwinVersion
- self.gccVersion = gccVersion
-
- 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 : cc,
- Phases.EmitLLVMPhase : cc,
- Phases.CompilePhase : cc,
- Phases.PrecompilePhase : cc,
- Phases.AssemblePhase : Tools.Darwin_AssembleTool(self),
- Phases.LinkPhase : Tools.Darwin_X86_LinkTool(self),
- Phases.LipoPhase : Tools.LipoTool(self),
- }
-
- if archName == 'x86_64':
- self.filePathPrefixes.append(os.path.join(self.driver.driverDir,
- '../lib/gcc',
- self.getToolChainDir(),
- 'x86_64'))
- self.filePathPrefixes.append(os.path.join('/usr/lib/gcc',
- self.getToolChainDir(),
- 'x86_64'))
- self.filePathPrefixes.append(os.path.join(self.driver.driverDir,
- '../lib/gcc',
- self.getToolChainDir()))
- self.filePathPrefixes.append(os.path.join('/usr/lib/gcc',
- self.getToolChainDir()))
-
- self.programPathPrefixes.append(os.path.join(self.driver.driverDir,
- '../libexec/gcc',
- self.getToolChainDir()))
- self.programPathPrefixes.append(os.path.join('/usr/libexec/gcc',
- self.getToolChainDir()))
- self.programPathPrefixes.append(os.path.join(self.driver.driverDir,
- '../libexec'))
- self.programPathPrefixes.append(self.driver.driverDir)
-
- def getToolChainDir(self):
- return 'i686-apple-darwin%d/%s' % (self.darwinVersion[0],
- '.'.join(map(str,self.gccVersion)))
-
- def getMacosxVersionMin(self):
- major,minor,minorminor = self.darwinVersion
- return '%d.%d.%d' % (10, major-4, minor)
-
- def selectTool(self, action):
- assert isinstance(action, Phases.JobAction)
-
- if self.shouldUseClangCompiler(action):
- return self.clangTool
-
- return self.toolMap[action.phase.__class__]
-
- def translateArgs(self, args, arch):
- args = super(Darwin_X86_ToolChain, self).translateArgs(args, arch)
-
- # If arch hasn't been bound we don't need to do anything yet.
- if not arch:
- return args
-
- # FIXME: We really want to get out of the tool chain level
- # argument translation business, as it makes the driver
- # functionality much more opaque. For now, we follow gcc
- # closely solely for the purpose of easily achieving feature
- # parity & testability. Once we have something that works, we
- # should reevaluate each translation and try to push it down
- # into tool specific logic.
-
- al = Arguments.DerivedArgList(args)
- if not args.getLastArg(args.parser.m_macosxVersionMinOption):
- al.append(al.makeJoinedArg(self.getMacosxVersionMin(),
- args.parser.m_macosxVersionMinOption))
- for arg in args:
- # Sob. These is strictly gcc compatible for the time
- # being. Apple gcc translates options twice, which means
- # that self-expanding options add duplicates.
- if arg.opt is args.parser.m_kernelOption:
- al.append(arg)
- al.append(al.makeFlagArg(args.parser.staticOption))
- al.append(al.makeFlagArg(args.parser.staticOption))
- elif arg.opt is args.parser.dependencyFileOption:
- al.append(al.makeSeparateArg(args.getValue(arg),
- args.parser.MFOption))
- elif arg.opt is args.parser.gfullOption:
- al.append(al.makeFlagArg(args.parser.gOption))
- al.append(al.makeFlagArg(args.parser.f_noEliminateUnusedDebugSymbolsOption))
- elif arg.opt is args.parser.gusedOption:
- al.append(al.makeFlagArg(args.parser.gOption))
- al.append(al.makeFlagArg(args.parser.f_eliminateUnusedDebugSymbolsOption))
- elif arg.opt is args.parser.f_appleKextOption:
- al.append(arg)
- al.append(al.makeFlagArg(args.parser.staticOption))
- al.append(al.makeFlagArg(args.parser.staticOption))
- elif arg.opt is args.parser.f_terminatedVtablesOption:
- al.append(al.makeFlagArg(args.parser.f_appleKextOption))
- al.append(al.makeFlagArg(args.parser.staticOption))
- elif arg.opt is args.parser.f_indirectVirtualCallsOption:
- al.append(al.makeFlagArg(args.parser.f_appleKextOption))
- al.append(al.makeFlagArg(args.parser.staticOption))
- elif arg.opt is args.parser.sharedOption:
- al.append(al.makeFlagArg(args.parser.dynamiclibOption))
- elif arg.opt is args.parser.f_constantCfstringsOption:
- al.append(al.makeFlagArg(args.parser.m_constantCfstringsOption))
- elif arg.opt is args.parser.f_noConstantCfstringsOption:
- al.append(al.makeFlagArg(args.parser.m_noConstantCfstringsOption))
- elif arg.opt is args.parser.WnonportableCfstringsOption:
- al.append(al.makeFlagArg(args.parser.m_warnNonportableCfstringsOption))
- elif arg.opt is args.parser.WnoNonportableCfstringsOption:
- al.append(al.makeFlagArg(args.parser.m_noWarnNonportableCfstringsOption))
- elif arg.opt is args.parser.f_pascalStringsOption:
- al.append(al.makeFlagArg(args.parser.m_pascalStringsOption))
- elif arg.opt is args.parser.f_noPascalStringsOption:
- al.append(al.makeFlagArg(args.parser.m_noPascalStringsOption))
- else:
- al.append(arg)
-
- # FIXME: Actually, gcc always adds this, but it is filtered
- # for duplicates somewhere. This also changes the order of
- # things, so look it up.
- if arch and args.getValue(arch) == 'x86_64':
- if not args.getLastArg(args.parser.m_64Option):
- al.append(al.makeFlagArg(args.parser.m_64Option))
-
- if not args.getLastArg(args.parser.m_tuneOption):
- al.append(al.makeJoinedArg('core2',
- args.parser.m_tuneOption))
-
- return al
-
- def isMathErrnoDefault(self):
- return False
-
- def getDefaultRelocationModel(self):
- return 'pic'
-
- def getForcedPicModel(self):
- if self.archName == 'x86_64':
- return 'pic'
-
-class Generic_GCC_ToolChain(ToolChain):
- """Generic_GCC_ToolChain - A tool chain using the 'gcc' command to
- perform all subcommands; this relies on gcc translating the
- options appropriately."""
-
- def __init__(self, driver, archName):
- super(Generic_GCC_ToolChain, self).__init__(driver, archName)
- cc = Tools.GCC_CompileTool(self)
- self.clangTool = Tools.Clang_CompileTool(self)
- self.toolMap = {
- Phases.PreprocessPhase : Tools.GCC_PreprocessTool(self),
- Phases.AnalyzePhase : self.clangTool,
- Phases.SyntaxOnlyPhase : cc,
- Phases.EmitLLVMPhase : cc,
- Phases.CompilePhase : cc,
- Phases.PrecompilePhase : Tools.GCC_PrecompileTool(self),
- Phases.AssemblePhase : Tools.GCC_AssembleTool(self),
- Phases.LinkPhase : Tools.GCC_LinkTool(self),
- }
- self.programPathPrefixes.append(os.path.join(self.driver.driverDir,
- '../libexec'))
- self.programPathPrefixes.append(self.driver.driverDir)
-
- def selectTool(self, action):
- assert isinstance(action, Phases.JobAction)
-
- if self.shouldUseClangCompiler(action):
- return self.clangTool
-
- return self.toolMap[action.phase.__class__]
-
-class Darwin_GCC_ToolChain(Generic_GCC_ToolChain):
- def getRelocationModel(self, picEnabled, picDisabled):
- if picEnabled:
- return 'pic'
- elif picDisabled:
- return 'static'
- else:
- return 'dynamic-no-pic'
-
diff --git a/tools/ccc/ccclib/Tools.py b/tools/ccc/ccclib/Tools.py
deleted file mode 100644
index 1d4231e..0000000
--- a/tools/ccc/ccclib/Tools.py
+++ /dev/null
@@ -1,1275 +0,0 @@
-import os
-import sys # FIXME: Shouldn't be needed.
-
-import Arguments
-import Jobs
-import Phases
-import Types
-
-class Tool(object):
- """Tool - A concrete implementation of an action."""
-
- eFlagsPipedInput = 1 << 0
- eFlagsPipedOutput = 1 << 1
- eFlagsIntegratedCPP = 1 << 2
-
- def __init__(self, name, toolChain, flags = 0):
- self.name = name
- self.toolChain = toolChain
- self.flags = flags
-
- def acceptsPipedInput(self):
- return not not (self.flags & Tool.eFlagsPipedInput)
- def canPipeOutput(self):
- return not not (self.flags & Tool.eFlagsPipedOutput)
- def hasIntegratedCPP(self):
- return not not (self.flags & Tool.eFlagsIntegratedCPP)
-
-class GCC_Common_Tool(Tool):
- def getGCCExtraArgs(self):
- return []
-
- def constructJob(self, phase, arch, jobs, inputs,
- output, outputType, arglist, linkingOutput):
- cmd_args = []
- for arg in arglist.args:
- if arg.opt.forwardToGCC():
- cmd_args.extend(arglist.render(arg))
-
- cmd_args.extend(self.getGCCExtraArgs())
-
- # If using a driver driver, force the arch.
- if self.toolChain.driver.hostInfo.useDriverDriver():
- # FIXME: Remove this branch once ok.
- cmd_args.append('-arch')
- cmd_args.append(self.toolChain.archName)
-
- if isinstance(output, Jobs.PipedJob):
- cmd_args.extend(['-o', '-'])
- elif isinstance(phase.phase, Phases.SyntaxOnlyPhase):
- cmd_args.append('-fsyntax-only')
- else:
- assert output
- cmd_args.extend(arglist.render(output))
-
- if (isinstance(self, GCC_LinkTool) and
- linkingOutput):
- cmd_args.append('-Wl,-arch_multiple')
- cmd_args.append('-Wl,-final_output,' +
- arglist.getValue(linkingOutput))
-
- # Only pass -x if gcc will understand it; otherwise hope gcc
- # understands the suffix correctly. The main use case this
- # would go wrong in is for linker inputs if they happened to
- # have an odd suffix; really the only way to get this to
- # happen is a command like '-x foobar a.c' which will treat
- # a.c like a linker input.
- #
- # FIXME: For the linker case specifically, can we safely
- # convert inputs into '-Wl,' options?
- for input in inputs:
- if input.type.canBeUserSpecified:
- cmd_args.extend(['-x', input.type.name])
-
- if isinstance(input.source, Jobs.PipedJob):
- cmd_args.append('-')
- else:
- assert isinstance(input.source, Arguments.Arg)
- # If this is a linker input then assume we can forward
- # just by rendering.
- if input.source.opt.isLinkerInput:
- cmd_args.extend(arglist.render(input.source))
- else:
- cmd_args.extend(arglist.renderAsInput(input.source))
-
- jobs.addJob(Jobs.Command('gcc', cmd_args))
-
-class GCC_PreprocessTool(GCC_Common_Tool):
- def __init__(self, toolChain):
- super(GCC_PreprocessTool, self).__init__('gcc (cpp)', toolChain,
- (Tool.eFlagsPipedInput |
- Tool.eFlagsPipedOutput))
-
- def getGCCExtraArgs(self):
- return ['-E']
-
-class GCC_CompileTool(GCC_Common_Tool):
- def __init__(self, toolChain):
- super(GCC_CompileTool, self).__init__('gcc (cc1)', toolChain,
- (Tool.eFlagsPipedInput |
- Tool.eFlagsPipedOutput |
- Tool.eFlagsIntegratedCPP))
-
- def getGCCExtraArgs(self):
- return ['-S']
-
-class GCC_PrecompileTool(GCC_Common_Tool):
- def __init__(self, toolChain):
- super(GCC_PrecompileTool, self).__init__('gcc (pch)', toolChain,
- (Tool.eFlagsPipedInput |
- Tool.eFlagsIntegratedCPP))
-
- def getGCCExtraArgs(self):
- return []
-
-class GCC_AssembleTool(GCC_Common_Tool):
- def __init__(self, toolChain):
- # Assume that gcc will do any magic necessary to let the
- # assembler take piped input.
- super(GCC_AssembleTool, self).__init__('gcc (as)', toolChain,
- Tool.eFlagsPipedInput)
-
- def getGCCExtraArgs(self):
- return ['-c']
-
-class GCC_LinkTool(GCC_Common_Tool):
- def __init__(self, toolChain):
- super(GCC_LinkTool, self).__init__('gcc (ld)', toolChain)
-
-class Darwin_AssembleTool(Tool):
- def __init__(self, toolChain):
- super(Darwin_AssembleTool, self).__init__('as', toolChain,
- Tool.eFlagsPipedInput)
-
- def constructJob(self, phase, arch, jobs, inputs,
- output, outputType, arglist, linkingOutput):
- assert len(inputs) == 1
- assert outputType is Types.ObjectType
-
- input = inputs[0]
-
- cmd_args = []
-
- # Bit of a hack, this is only used for original inputs.
- if input.isOriginalInput():
- if arglist.getLastArg(arglist.parser.gGroup):
- cmd_args.append('--gstabs')
-
- # Derived from asm spec.
- cmd_args.append('-arch')
- cmd_args.append(self.toolChain.archName)
-
- cmd_args.append('-force_cpusubtype_ALL')
- if (arglist.getLastArg(arglist.parser.m_kernelOption) or
- arglist.getLastArg(arglist.parser.staticOption) or
- arglist.getLastArg(arglist.parser.f_appleKextOption)):
- if not arglist.getLastArg(arglist.parser.dynamicOption):
- cmd_args.append('-static')
-
- for arg in arglist.getArgs2(arglist.parser.WaOption,
- arglist.parser.XassemblerOption):
- cmd_args.extend(arglist.getValues(arg))
-
- cmd_args.extend(arglist.render(output))
- if isinstance(input.source, Jobs.PipedJob):
- pass
- else:
- cmd_args.extend(arglist.renderAsInput(input.source))
-
- # asm_final spec is empty.
-
- jobs.addJob(Jobs.Command(self.toolChain.getProgramPath('as'),
- cmd_args))
-
-class Clang_CompileTool(Tool):
- def __init__(self, toolChain):
- super(Clang_CompileTool, self).__init__('clang', toolChain,
- (Tool.eFlagsPipedInput |
- Tool.eFlagsPipedOutput |
- Tool.eFlagsIntegratedCPP))
-
- def constructJob(self, phase, arch, jobs, inputs,
- output, outputType, arglist, linkingOutput):
- cmd_args = []
-
- 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:
- # FIXME: This is hackish, it would be better if we had the
- # action instead of just looking at types.
- assert len(inputs) == 1
- if inputs[0].type is Types.AsmType:
- cmd_args.append('-E')
- else:
- cmd_args.append('-S')
- elif (inputs[0].type.preprocess and
- outputType is inputs[0].type.preprocess):
- cmd_args.append('-E')
- elif outputType is Types.PCHType:
- # No special option needed, driven by -x.
- #
- # FIXME: Don't drive this by -x, that is gross.
- pass
- else:
- raise ValueError,"Unexpected output type for clang tool."
-
- # The make clang go fast button.
- cmd_args.append('-disable-free')
-
- if isinstance(phase.phase, Phases.AnalyzePhase):
- # Add default argument set.
- #
- # FIXME: Move into clang?
- cmd_args.extend(['-warn-dead-stores',
- '-checker-cfref', '-analyzer-eagerly-assume',
- '-warn-objc-methodsigs',
- # Do not enable the missing -dealloc check.
- # '-warn-objc-missing-dealloc',
- '-warn-objc-unused-ivars'])
-
- cmd_args.append('-analyzer-output=plist')
-
- # Add -Xanalyzer arguments when running as analyzer.
- for arg in arglist.getArgs(arglist.parser.XanalyzerOption):
- cmd_args.extend(arglist.getValues(arg))
- else:
- # Perform argument translation for LLVM backend. This
- # takes some care in reconciling with llvm-gcc. The
- # issue is that llvm-gcc translates these options based on
- # the values in cc1, whereas we are processing based on
- # the driver arguments.
- #
- # FIXME: This is currently broken for -f flags when -fno
- # variants are present.
-
- # This comes from the default translation the driver + cc1
- # would do to enable flag_pic.
- #
- # FIXME: Centralize this code.
- picEnabled = (arglist.getLastArg(arglist.parser.f_PICOption) or
- arglist.getLastArg(arglist.parser.f_picOption) or
- arglist.getLastArg(arglist.parser.f_PIEOption) or
- arglist.getLastArg(arglist.parser.f_pieOption))
- picDisabled = (arglist.getLastArg(arglist.parser.m_kernelOption) or
- arglist.getLastArg(arglist.parser.staticOption))
- model = self.toolChain.getForcedPicModel()
- if not model:
- if arglist.getLastArg(arglist.parser.m_dynamicNoPicOption):
- model = 'dynamic-no-pic'
- elif picDisabled:
- model = 'static'
- elif picEnabled:
- model = 'pic'
- else:
- model = self.toolChain.getDefaultRelocationModel()
- cmd_args.append('--relocation-model')
- cmd_args.append(model)
-
- if arglist.getLastArg(arglist.parser.f_timeReportOption):
- cmd_args.append('--time-passes')
- # FIXME: Set --enable-unsafe-fp-math.
- if not arglist.getLastArg(arglist.parser.f_omitFramePointerOption):
- cmd_args.append('--disable-fp-elim')
- if not arglist.hasFFlag(arglist.parser.f_zeroInitializedInBssOption,
- arglist.parser.f_noZeroInitializedInBssOption,
- True):
- cmd_args.append('--nozero-initialized-in-bss')
- if arglist.getLastArg(arglist.parser.dAOption):
- cmd_args.append('--asm-verbose')
- if arglist.getLastArg(arglist.parser.f_debugPassStructureOption):
- cmd_args.append('--debug-pass=Structure')
- if arglist.getLastArg(arglist.parser.f_debugPassArgumentsOption):
- cmd_args.append('--debug-pass=Arguments')
- # FIXME: set --inline-threshhold=50 if (optimize_size || optimize < 3)
- cmd_args.append('--unwind-tables=%d' %
- arglist.hasFFlag(arglist.parser.f_unwindTablesOption,
- arglist.parser.f_noUnwindTablesOption,
- self.toolChain.isUnwindTablesDefault()))
- if not arglist.hasFFlag(arglist.parser.m_redZoneOption,
- arglist.parser.m_noRedZoneOption,
- True):
- cmd_args.append('--disable-red-zone')
- if arglist.hasFFlag(arglist.parser.m_softFloatOption,
- arglist.parser.m_noSoftFloatOption,
- False):
- cmd_args.append('--soft-float')
-
- # FIXME: Need target hooks.
- if self.toolChain.driver.getHostSystemName() == 'darwin':
- if self.toolChain.archName == 'x86_64':
- cmd_args.append('--mcpu=core2')
- elif self.toolChain.archName == 'i386':
- cmd_args.append('--mcpu=yonah')
- else:
- pass
-
- # FIXME: Ignores ordering
- attrs = []
- for pos,neg,flag in [(arglist.parser.m_mmxOption,
- arglist.parser.m_noMmxOption,
- 'mmx'),
- (arglist.parser.m_sseOption,
- arglist.parser.m_noSseOption,
- 'sse'),
- (arglist.parser.m_sse2Option,
- arglist.parser.m_noSse2Option,
- 'sse2'),
- (arglist.parser.m_sse3Option,
- arglist.parser.m_noSse3Option,
- 'sse3'),
- (arglist.parser.m_ssse3Option,
- arglist.parser.m_noSsse3Option,
- 'ssse3'),
- (arglist.parser.m_sse41Option,
- arglist.parser.m_noSse41Option,
- 'sse41'),
- (arglist.parser.m_sse42Option,
- arglist.parser.m_noSse42Option,
- 'sse42'),
- (arglist.parser.m_sse4aOption,
- arglist.parser.m_noSse4aOption,
- 'sse4a'),
- (arglist.parser.m_3dnowOption,
- arglist.parser.m_no3dnowOption,
- '3dnow'),
- (arglist.parser.m_3dnowaOption,
- arglist.parser.m_no3dnowaOption,
- '3dnowa'),
- ]:
- if arglist.getLastArg(pos):
- attrs.append('+' + flag)
- elif arglist.getLastArg(neg):
- attrs.append('-' + flag)
- if attrs:
- cmd_args.append('--mattr=%s' % ','.join(attrs))
-
- if arglist.hasFFlag(arglist.parser.f_mathErrnoOption,
- arglist.parser.f_noMathErrnoOption,
- self.toolChain.isMathErrnoDefault()):
- cmd_args.append('--fmath-errno=1')
- else:
- cmd_args.append('--fmath-errno=0')
-
- arg = arglist.getLastArg(arglist.parser.f_limitedPrecisionOption)
- if arg:
- cmd_args.append('--limit-float-precision')
- cmd_args.append(arglist.getValue(arg))
-
- # FIXME: Add --stack-protector-buffer-size=<xxx> on -fstack-protect.
-
- arglist.addLastArg(cmd_args, arglist.parser.MDOption)
- arglist.addLastArg(cmd_args, arglist.parser.MMDOption)
- arglist.addAllArgs(cmd_args, arglist.parser.MFOption)
- arglist.addLastArg(cmd_args, arglist.parser.MPOption)
- arglist.addAllArgs(cmd_args, arglist.parser.MTOption)
-
- unsupported = (arglist.getLastArg(arglist.parser.MOption) or
- arglist.getLastArg(arglist.parser.MMOption) or
- arglist.getLastArg(arglist.parser.MGOption) or
- arglist.getLastArg(arglist.parser.MQOption))
- if unsupported:
- raise NotImplementedError('clang support for "%s"' % unsupported.opt.name)
-
- arglist.addAllArgs(cmd_args, arglist.parser.vOption)
- arglist.addAllArgs2(cmd_args, arglist.parser.DOption, arglist.parser.UOption)
- arglist.addAllArgs2(cmd_args, arglist.parser.IGroup, arglist.parser.FOption)
- arglist.addLastArg(cmd_args, arglist.parser.POption)
- arglist.addAllArgs(cmd_args, arglist.parser.m_macosxVersionMinOption)
-
- # Special case debug options to only pass -g to clang. This is
- # wrong.
- if arglist.getLastArg(arglist.parser.gGroup):
- cmd_args.append('-g')
-
- arglist.addLastArg(cmd_args, arglist.parser.nostdincOption)
-
- # FIXME: Clang isn't going to accept just anything here.
-
- # Add i* options and automatically translate to -include-pth
- # for transparent PCH support. It's wonky, but we include
- # looking for .gch so we can support seamless replacement into
- # a build system already set up to be generating .gch files.
- for arg in arglist.getArgs(arglist.parser.iGroup):
- if arg.opt.matches(arglist.parser.includeOption):
- for suffix in ('.pth','.gch'):
- pthPath = arglist.getValue(arg) + suffix
- if os.path.exists(pthPath):
- cmd_args.append('-include-pth')
- cmd_args.append(pthPath)
- break
- else:
- cmd_args.extend(arglist.render(arg))
- else:
- cmd_args.extend(arglist.render(arg))
-
- # Manually translate -O to -O1; let clang reject others.
- arg = arglist.getLastArg(arglist.parser.OOption)
- if arg:
- if arglist.getValue(arg) == '':
- cmd_args.append('-O1')
- else:
- cmd_args.extend(arglist.render(arg))
-
- arglist.addAllArgs2(cmd_args, arglist.parser.ClangWGroup, arglist.parser.pedanticGroup)
- arglist.addLastArg(cmd_args, arglist.parser.wOption)
- arglist.addAllArgs3(cmd_args, arglist.parser.stdOption, arglist.parser.ansiOption, arglist.parser.trigraphsOption)
-
- arg = arglist.getLastArg(arglist.parser.f_templateDepthOption)
- if arg:
- cmd_args.append('-ftemplate-depth')
- cmd_args.append(arglist.getValue(arg))
-
- arglist.addAllArgs(cmd_args, arglist.parser.Clang_fGroup)
-
- arglist.addLastArg(cmd_args, arglist.parser.dMOption)
-
- for arg in arglist.getArgs(arglist.parser.XclangOption):
- cmd_args.extend(arglist.getValues(arg))
-
- # FIXME: We should always pass this once it is always known.
- if self.toolChain.archName:
- cmd_args.append('-arch')
- cmd_args.append(self.toolChain.archName)
-
- if isinstance(output, Jobs.PipedJob):
- cmd_args.extend(['-o', '-'])
- elif output:
- cmd_args.extend(arglist.render(output))
-
- for input in inputs:
- cmd_args.append('-x')
- cmd_args.append(input.type.name)
- if isinstance(input.source, Jobs.PipedJob):
- cmd_args.append('-')
- else:
- cmd_args.extend(arglist.renderAsInput(input.source))
-
- jobs.addJob(Jobs.Command(self.toolChain.getProgramPath('clang-cc'),
- cmd_args))
-
-class Darwin_X86_CC1Tool(Tool):
- def getCC1Name(self, type):
- """getCC1Name(type) -> name, use-cpp, is-cxx"""
-
- # FIXME: Get bool results from elsewhere.
- if type is Types.AsmType:
- return 'cc1',True,False
- elif type is Types.CType or type is Types.CHeaderType:
- return 'cc1',True,False
- elif type is Types.CTypeNoPP or type is Types.CHeaderNoPPType:
- return 'cc1',False,False
- elif type is Types.ObjCType or type is Types.ObjCHeaderType:
- return 'cc1obj',True,False
- elif type is Types.ObjCTypeNoPP or type is Types.ObjCHeaderNoPPType:
- return 'cc1obj',True,False
- elif type is Types.CXXType or type is Types.CXXHeaderType:
- return 'cc1plus',True,True
- elif type is Types.CXXTypeNoPP or type is Types.CXXHeaderNoPPType:
- return 'cc1plus',False,True
- elif type is Types.ObjCXXType or type is Types.ObjCXXHeaderType:
- return 'cc1objplus',True,True
- elif type is Types.ObjCXXTypeNoPP or type is Types.ObjCXXHeaderNoPPType:
- return 'cc1objplus',False,True
- else:
- raise ValueError,"Unexpected type for Darwin compile tool."
-
- def addCC1Args(self, cmd_args, arch, arglist):
- # Derived from cc1 spec.
-
- # FIXME: -fapple-kext seems to disable this too. Investigate.
- if (not arglist.getLastArg(arglist.parser.m_kernelOption) and
- not arglist.getLastArg(arglist.parser.staticOption) and
- not arglist.getLastArg(arglist.parser.m_dynamicNoPicOption)):
- cmd_args.append('-fPIC')
-
- # FIXME: Remove mthumb
- # FIXME: Remove mno-thumb
-
- # FIXME: As with ld, something else is going on. My best guess
- # is gcc is faking an -mmacosx-version-min
- # somewhere. Investigate.
-# if (not arglist.getLastArg(arglist.parser.m_macosxVersionMinOption) and
-# not arglist.getLastArg(arglist.parser.m_iphoneosVersionMinOption)):
-# cmd_args.append('-mmacosx-version-min=' +
-# self.toolChain.getMacosxVersionMin())
-
- # FIXME: Remove faltivec
- # FIXME: Remove mno-fused-madd
- # FIXME: Remove mlong-branch
- # FIXME: Remove mlongcall
- # FIXME: Remove mcpu=G4
- # FIXME: Remove mcpu=G5
-
- if (arglist.getLastArg(arglist.parser.gOption) and
- not arglist.getLastArg(arglist.parser.f_noEliminateUnusedDebugSymbolsOption)):
- cmd_args.append('-feliminate-unused-debug-symbols')
-
- def addCC1OptionsArgs(self, cmd_args, arch, arglist, inputs, output_args, isCXX):
- # Derived from cc1_options spec.
- if (arglist.getLastArg(arglist.parser.fastOption) or
- arglist.getLastArg(arglist.parser.fastfOption) or
- arglist.getLastArg(arglist.parser.fastcpOption)):
- cmd_args.append('-O3')
-
- if (arglist.getLastArg(arglist.parser.pgOption) and
- arglist.getLastArg(arglist.parser.f_omitFramePointerOption)):
- raise Arguments.InvalidArgumentsError("-pg and -fomit-frame-pointer are incompatible")
-
- self.addCC1Args(cmd_args, arch, arglist)
-
- if not arglist.getLastArg(arglist.parser.QOption):
- cmd_args.append('-quiet')
-
- cmd_args.append('-dumpbase')
- cmd_args.append(self.getBaseInputName(inputs, arglist))
-
- arglist.addAllArgs(cmd_args, arglist.parser.dGroup)
-
- arglist.addAllArgs(cmd_args, arglist.parser.mGroup)
- arglist.addAllArgs(cmd_args, arglist.parser.aGroup)
-
- # FIXME: The goal is to use the user provided -o if that is
- # our final output, otherwise to drive from the original input
- # name. Find a clean way to go about this.
- if (arglist.getLastArg(arglist.parser.cOption) or
- arglist.getLastArg(arglist.parser.SOption)):
- outputOpt = arglist.getLastArg(arglist.parser.oOption)
- if outputOpt:
- cmd_args.append('-auxbase-strip')
- cmd_args.append(arglist.getValue(outputOpt))
- else:
- cmd_args.append('-auxbase')
- cmd_args.append(self.getBaseInputStem(inputs, arglist))
- else:
- cmd_args.append('-auxbase')
- cmd_args.append(self.getBaseInputStem(inputs, arglist))
-
- arglist.addAllArgs(cmd_args, arglist.parser.gGroup)
-
- arglist.addAllArgs(cmd_args, arglist.parser.OOption)
- # FIXME: -Wall is getting some special treatment. Investigate.
- arglist.addAllArgs2(cmd_args, arglist.parser.WGroup, arglist.parser.pedanticGroup)
- arglist.addLastArg(cmd_args, arglist.parser.wOption)
- arglist.addAllArgs3(cmd_args, arglist.parser.stdOption, arglist.parser.ansiOption, arglist.parser.trigraphsOption)
- if arglist.getLastArg(arglist.parser.vOption):
- cmd_args.append('-version')
- if arglist.getLastArg(arglist.parser.pgOption):
- cmd_args.append('-p')
- arglist.addLastArg(cmd_args, arglist.parser.pOption)
-
- # ccc treats -fsyntax-only specially.
- arglist.addAllArgs2(cmd_args, arglist.parser.fGroup,
- arglist.parser.syntaxOnlyOption)
-
- arglist.addAllArgs(cmd_args, arglist.parser.undefOption)
- if arglist.getLastArg(arglist.parser.QnOption):
- cmd_args.append('-fno-ident')
-
- # FIXME: This isn't correct.
- #arglist.addLastArg(cmd_args, arglist.parser._helpOption)
- #arglist.addLastArg(cmd_args, arglist.parser._targetHelpOption)
-
- if output_args:
- cmd_args.extend(output_args)
-
- # FIXME: Still don't get what is happening here. Investigate.
- arglist.addAllArgs(cmd_args, arglist.parser._paramOption)
-
- if (arglist.getLastArg(arglist.parser.f_mudflapOption) or
- arglist.getLastArg(arglist.parser.f_mudflapthOption)):
- cmd_args.append('-fno-builtin')
- cmd_args.append('-fno-merge-constants')
-
- if arglist.getLastArg(arglist.parser.coverageOption):
- cmd_args.append('-fprofile-arcs')
- cmd_args.append('-ftest-coverage')
-
- if isCXX:
- cmd_args.append('-D__private_extern__=extern')
-
- def getBaseInputName(self, inputs, arglist):
- # FIXME: gcc uses a temporary name here when the base
- # input is stdin, but only in auxbase. Investigate.
- baseInputValue = arglist.getValue(inputs[0].baseInput)
- return os.path.basename(baseInputValue)
-
- def getBaseInputStem(self, inputs, arglist):
- return os.path.splitext(self.getBaseInputName(inputs, arglist))[0]
-
- def getOutputArgs(self, arglist, output, isCPP=False):
- if isinstance(output, Jobs.PipedJob):
- if isCPP:
- return []
- else:
- return ['-o', '-']
- elif output is None:
- return ['-o', '/dev/null']
- else:
- return arglist.render(output)
-
- def addCPPOptionsArgs(self, cmd_args, arch, arglist, inputs,
- output_args, isCXX):
- # Derived from cpp_options.
- self.addCPPUniqueOptionsArgs(cmd_args, arch, arglist, inputs)
-
- cmd_args.extend(output_args)
-
- self.addCC1Args(cmd_args, arch, arglist)
-
- # NOTE: The code below has some commonality with cpp_options,
- # but in classic gcc style ends up sending things in different
- # orders. This may be a good merge candidate once we drop
- # pedantic compatibility.
-
- arglist.addAllArgs(cmd_args, arglist.parser.mGroup)
- arglist.addAllArgs3(cmd_args, arglist.parser.stdOption,
- arglist.parser.ansiOption,
- arglist.parser.trigraphsOption)
- arglist.addAllArgs2(cmd_args, arglist.parser.WGroup,
- arglist.parser.pedanticGroup)
- arglist.addLastArg(cmd_args, arglist.parser.wOption)
-
- # ccc treats -fsyntax-only specially.
- arglist.addAllArgs2(cmd_args, arglist.parser.fGroup,
- arglist.parser.syntaxOnlyOption)
-
- if (arglist.getLastArg(arglist.parser.gGroup) and
- not arglist.getLastArg(arglist.parser.g0Option) and
- not arglist.getLastArg(arglist.parser.f_noWorkingDirectoryOption)):
- cmd_args.append('-fworking-directory')
-
- arglist.addAllArgs(cmd_args, arglist.parser.OOption)
- arglist.addAllArgs(cmd_args, arglist.parser.undefOption)
- if arglist.getLastArg(arglist.parser.saveTempsOption):
- cmd_args.append('-fpch-preprocess')
-
- def addCPPUniqueOptionsArgs(self, cmd_args, arch, arglist, inputs):
- # Derived from cpp_unique_options.
-
- if (arglist.getLastArg(arglist.parser.COption) or
- arglist.getLastArg(arglist.parser.CCOption)):
- if not arglist.getLastArg(arglist.parser.EOption):
- raise Arguments.InvalidArgumentsError("-C or -CC is not supported without -E")
- if not arglist.getLastArg(arglist.parser.QOption):
- cmd_args.append('-quiet')
- arglist.addAllArgs(cmd_args, arglist.parser.nostdincOption)
- arglist.addLastArg(cmd_args, arglist.parser.vOption)
- arglist.addAllArgs2(cmd_args, arglist.parser.IGroup, arglist.parser.FOption)
- arglist.addLastArg(cmd_args, arglist.parser.POption)
-
- # FIXME: Handle %I properly.
- if self.toolChain.archName == 'x86_64':
- cmd_args.append('-imultilib')
- cmd_args.append('x86_64')
-
- if arglist.getLastArg(arglist.parser.MDOption):
- cmd_args.append('-MD')
- # FIXME: Think about this more.
- outputOpt = arglist.getLastArg(arglist.parser.oOption)
- if outputOpt:
- base,ext = os.path.splitext(arglist.getValue(outputOpt))
- cmd_args.append(base+'.d')
- else:
- cmd_args.append(self.getBaseInputStem(inputs, arglist)+'.d')
- if arglist.getLastArg(arglist.parser.MMDOption):
- cmd_args.append('-MMD')
- # FIXME: Think about this more.
- outputOpt = arglist.getLastArg(arglist.parser.oOption)
- if outputOpt:
- base,ext = os.path.splitext(arglist.getValue(outputOpt))
- cmd_args.append(base+'.d')
- else:
- cmd_args.append(self.getBaseInputStem(inputs, arglist)+'.d')
- arglist.addLastArg(cmd_args, arglist.parser.MOption)
- arglist.addLastArg(cmd_args, arglist.parser.MMOption)
- arglist.addAllArgs(cmd_args, arglist.parser.MFOption)
- arglist.addLastArg(cmd_args, arglist.parser.MGOption)
- arglist.addLastArg(cmd_args, arglist.parser.MPOption)
- arglist.addAllArgs(cmd_args, arglist.parser.MQOption)
- arglist.addAllArgs(cmd_args, arglist.parser.MTOption)
- if (not arglist.getLastArg(arglist.parser.MOption) and
- not arglist.getLastArg(arglist.parser.MMOption) and
- (arglist.getLastArg(arglist.parser.MDOption) or
- arglist.getLastArg(arglist.parser.MMDOption))):
- outputOpt = arglist.getLastArg(arglist.parser.oOption)
- if outputOpt:
- cmd_args.append('-MQ')
- cmd_args.append(arglist.getValue(outputOpt))
-
- arglist.addLastArg(cmd_args, arglist.parser.remapOption)
- if arglist.getLastArg(arglist.parser.g3Option):
- cmd_args.append('-dD')
- arglist.addLastArg(cmd_args, arglist.parser.HOption)
-
- self.addCPPArgs(cmd_args, arch, arglist)
-
- arglist.addAllArgs3(cmd_args,
- arglist.parser.DOption,
- arglist.parser.UOption,
- arglist.parser.AOption)
-
- arglist.addAllArgs(cmd_args, arglist.parser.iGroup)
-
- for input in inputs:
- if isinstance(input.source, Jobs.PipedJob):
- cmd_args.append('-')
- else:
- cmd_args.extend(arglist.renderAsInput(input.source))
-
- for arg in arglist.getArgs2(arglist.parser.WpOption,
- arglist.parser.XpreprocessorOption):
- cmd_args.extend(arglist.getValues(arg))
-
- if arglist.getLastArg(arglist.parser.f_mudflapOption):
- cmd_args.append('-D_MUDFLAP')
- cmd_args.append('-include')
- cmd_args.append('mf-runtime.h')
-
- if arglist.getLastArg(arglist.parser.f_mudflapthOption):
- cmd_args.append('-D_MUDFLAP')
- cmd_args.append('-D_MUDFLAPTH')
- cmd_args.append('-include')
- cmd_args.append('mf-runtime.h')
-
- def addCPPArgs(self, cmd_args, arch, arglist):
- # Derived from cpp spec.
-
- if arglist.getLastArg(arglist.parser.staticOption):
- # The gcc spec is broken here, it refers to dynamic but
- # that has been translated. Start by being bug compatible.
-
- # if not arglist.getLastArg(arglist.parser.dynamicOption):
- cmd_args.append('-D__STATIC__')
- else:
- cmd_args.append('-D__DYNAMIC__')
-
- if arglist.getLastArg(arglist.parser.pthreadOption):
- cmd_args.append('-D_REENTRANT')
-
-class Darwin_X86_PreprocessTool(Darwin_X86_CC1Tool):
- def __init__(self, toolChain):
- super(Darwin_X86_PreprocessTool, self).__init__('cpp', toolChain,
- (Tool.eFlagsPipedInput |
- Tool.eFlagsPipedOutput))
-
- def constructJob(self, phase, arch, jobs, inputs,
- output, outputType, arglist, linkingOutput):
- inputType = inputs[0].type
- assert not [i for i in inputs if i.type != inputType]
-
- cc1Name,usePP,isCXX = self.getCC1Name(inputType)
-
- cmd_args = ['-E']
- if (arglist.getLastArg(arglist.parser.traditionalOption) or
- arglist.getLastArg(arglist.parser.f_traditionalOption) or
- arglist.getLastArg(arglist.parser.traditionalCPPOption)):
- cmd_args.append('-traditional-cpp')
-
- output_args = self.getOutputArgs(arglist, output,
- isCPP=True)
- self.addCPPOptionsArgs(cmd_args, arch, arglist, inputs,
- output_args, isCXX)
-
- arglist.addAllArgs(cmd_args, arglist.parser.dGroup)
-
- jobs.addJob(Jobs.Command(self.toolChain.getProgramPath(cc1Name),
- cmd_args))
-
-class Darwin_X86_CompileTool(Darwin_X86_CC1Tool):
- def __init__(self, toolChain):
- super(Darwin_X86_CompileTool, self).__init__('cc1', toolChain,
- (Tool.eFlagsPipedInput |
- Tool.eFlagsPipedOutput |
- Tool.eFlagsIntegratedCPP))
-
- def constructJob(self, phase, arch, jobs, inputs,
- output, outputType, arglist, linkingOutput):
- inputType = inputs[0].type
- assert not [i for i in inputs if i.type != inputType]
-
- cc1Name,usePP,isCXX = self.getCC1Name(inputType)
-
- cmd_args = []
- if (arglist.getLastArg(arglist.parser.traditionalOption) or
- 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:
- output_args = self.getOutputArgs(arglist, output)
-
- # There is no need for this level of compatibility, but it
- # makes diffing easier.
- if (not arglist.getLastArg(arglist.parser.syntaxOnlyOption) and
- not arglist.getLastArg(arglist.parser.SOption)):
- early_output_args, end_output_args = [], output_args
- else:
- early_output_args, end_output_args = output_args, []
-
- if usePP:
- self.addCPPUniqueOptionsArgs(cmd_args, arch, arglist, inputs)
- self.addCC1OptionsArgs(cmd_args, arch, arglist, inputs,
- early_output_args, isCXX)
- cmd_args.extend(end_output_args)
- else:
- cmd_args.append('-fpreprocessed')
-
- # FIXME: There is a spec command to remove
- # -fpredictive-compilation args here. Investigate.
-
- for input in inputs:
- if isinstance(input.source, Jobs.PipedJob):
- cmd_args.append('-')
- else:
- cmd_args.extend(arglist.renderAsInput(input.source))
-
- self.addCC1OptionsArgs(cmd_args, arch, arglist, inputs,
- early_output_args, isCXX)
- cmd_args.extend(end_output_args)
-
- if outputType is Types.PCHType:
- assert output is not None and not isinstance(output, Jobs.PipedJob)
-
- cmd_args.append('-o')
- # NOTE: gcc uses a temp .s file for this, but there
- # doesn't seem to be a good reason.
- cmd_args.append('/dev/null')
-
- cmd_args.append('--output-pch=')
- cmd_args.append(arglist.getValue(output))
-
- jobs.addJob(Jobs.Command(self.toolChain.getProgramPath(cc1Name),
- cmd_args))
-
-class Darwin_X86_LinkTool(Tool):
- def __init__(self, toolChain):
- super(Darwin_X86_LinkTool, self).__init__('collect2', toolChain)
-
- def getMacosxVersionTuple(self, arglist):
- arg = arglist.getLastArg(arglist.parser.m_macosxVersionMinOption)
- if arg:
- version = arglist.getValue(arg)
- components = version.split('.')
- try:
- return tuple(map(int, components))
- except:
- raise Arguments.InvalidArgumentsError("invalid version number %r" % version)
- else:
- major,minor,minorminor = self.toolChain.darwinVersion
- return (10, major-4, minor)
-
- def addDarwinArch(self, cmd_args, arch, arglist):
- # Derived from darwin_arch spec.
- cmd_args.append('-arch')
- cmd_args.append(self.toolChain.archName)
-
- def addDarwinSubArch(self, cmd_args, arch, arglist):
- # Derived from darwin_subarch spec, not sure what the
- # distinction exists for but at least for this chain it is the same.
- return self.addDarwinArch(cmd_args, arch, arglist)
-
- def addLinkArgs(self, cmd_args, arch, arglist):
- # Derived from link spec.
- arglist.addAllArgs(cmd_args, arglist.parser.staticOption)
- if not arglist.getLastArg(arglist.parser.staticOption):
- cmd_args.append('-dynamic')
- if arglist.getLastArg(arglist.parser.f_gnuRuntimeOption):
- # FIXME: Replace -lobjc in forward args with
- # -lobjc-gnu. How do we wish to handle such things?
- pass
-
- if not arglist.getLastArg(arglist.parser.dynamiclibOption):
- if arglist.getLastArg(arglist.parser.force_cpusubtype_ALLOption):
- self.addDarwinArch(cmd_args, arch, arglist)
- cmd_args.append('-force_cpusubtype_ALL')
- else:
- self.addDarwinSubArch(cmd_args, arch, arglist)
-
- if arglist.getLastArg(arglist.parser.bundleOption):
- cmd_args.append('-bundle')
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.bundle_loaderOption,
- '-bundle_loader')
- arglist.addAllArgs(cmd_args, arglist.parser.client_nameOption)
- if arglist.getLastArg(arglist.parser.compatibility_versionOption):
- # FIXME: Where should diagnostics go?
- print >>sys.stderr, "-compatibility_version only allowed with -dynamiclib"
- sys.exit(1)
- if arglist.getLastArg(arglist.parser.current_versionOption):
- print >>sys.stderr, "-current_version only allowed with -dynamiclib"
- sys.exit(1)
- if arglist.getLastArg(arglist.parser.force_flat_namespaceOption):
- cmd_args.append('-force_flat_namespace')
- if arglist.getLastArg(arglist.parser.install_nameOption):
- print >>sys.stderr, "-install_name only allowed with -dynamiclib"
- sys.exit(1)
- arglist.addLastArg(cmd_args, arglist.parser.keep_private_externsOption)
- arglist.addLastArg(cmd_args, arglist.parser.private_bundleOption)
- else:
- cmd_args.append('-dylib')
- if arglist.getLastArg(arglist.parser.bundleOption):
- print >>sys.stderr, "-bundle not allowed with -dynamiclib"
- sys.exit(1)
- if arglist.getLastArg(arglist.parser.bundle_loaderOption):
- print >>sys.stderr, "-bundle_loader not allowed with -dynamiclib"
- sys.exit(1)
- if arglist.getLastArg(arglist.parser.client_nameOption):
- print >>sys.stderr, "-client_name not allowed with -dynamiclib"
- sys.exit(1)
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.compatibility_versionOption,
- '-dylib_compatibility_version')
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.current_versionOption,
- '-dylib_current_version')
-
- if arglist.getLastArg(arglist.parser.force_cpusubtype_ALLOption):
- self.addDarwinArch(cmd_args, arch, arglist)
- # NOTE: We don't add -force_cpusubtype_ALL on this path. Ok.
- else:
- self.addDarwinSubArch(cmd_args, arch, arglist)
-
- if arglist.getLastArg(arglist.parser.force_flat_namespaceOption):
- print >>sys.stderr, "-force_flat_namespace not allowed with -dynamiclib"
- sys.exit(1)
-
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.install_nameOption,
- '-dylib_install_name')
-
- if arglist.getLastArg(arglist.parser.keep_private_externsOption):
- print >>sys.stderr, "-keep_private_externs not allowed with -dynamiclib"
- sys.exit(1)
- if arglist.getLastArg(arglist.parser.private_bundleOption):
- print >>sys.stderr, "-private_bundle not allowed with -dynamiclib"
- sys.exit(1)
-
- if arglist.getLastArg(arglist.parser.all_loadOption):
- cmd_args.append('-all_load')
-
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.allowable_clientOption,
- '-allowable_client')
-
- if arglist.getLastArg(arglist.parser.bind_at_loadOption):
- cmd_args.append('-bind_at_load')
-
- if arglist.getLastArg(arglist.parser.dead_stripOption):
- cmd_args.append('-dead_strip')
-
- if arglist.getLastArg(arglist.parser.no_dead_strip_inits_and_termsOption):
- cmd_args.append('-no_dead_strip_inits_and_terms')
-
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.dylib_fileOption,
- '-dylib_file')
-
- if arglist.getLastArg(arglist.parser.dynamicOption):
- cmd_args.append('-dynamic')
-
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.exported_symbols_listOption,
- '-exported_symbols_list')
-
- if arglist.getLastArg(arglist.parser.flat_namespaceOption):
- cmd_args.append('-flat_namespace')
-
- arglist.addAllArgs(cmd_args, arglist.parser.headerpad_max_install_namesOption)
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.image_baseOption,
- '-image_base')
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.initOption,
- '-init')
-
- if not arglist.getLastArg(arglist.parser.m_macosxVersionMinOption):
- if not arglist.getLastArg(arglist.parser.m_iphoneosVersionMinOption):
- # FIXME: I don't understand what is going on
- # here. This is supposed to come from
- # darwin_ld_minversion, but gcc doesn't seem to be
- # following that; it must be getting over-ridden
- # somewhere.
- cmd_args.append('-macosx_version_min')
- cmd_args.append(self.toolChain.getMacosxVersionMin())
- else:
- # addAll doesn't make sense here but this is what gcc
- # does.
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.m_macosxVersionMinOption,
- '-macosx_version_min')
-
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.m_iphoneosVersionMinOption,
- '-iphoneos_version_min')
- arglist.addLastArg(cmd_args, arglist.parser.nomultidefsOption)
-
- if arglist.getLastArg(arglist.parser.multi_moduleOption):
- cmd_args.append('-multi_module')
-
- if arglist.getLastArg(arglist.parser.single_moduleOption):
- cmd_args.append('-single_module')
-
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.multiply_definedOption,
- '-multiply_defined')
-
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.multiply_defined_unusedOption,
- '-multiply_defined_unused')
-
- if arglist.getLastArg(arglist.parser.f_pieOption):
- cmd_args.append('-pie')
-
- arglist.addLastArg(cmd_args, arglist.parser.prebindOption)
- arglist.addLastArg(cmd_args, arglist.parser.noprebindOption)
- arglist.addLastArg(cmd_args, arglist.parser.nofixprebindingOption)
- arglist.addLastArg(cmd_args, arglist.parser.prebind_all_twolevel_modulesOption)
- arglist.addLastArg(cmd_args, arglist.parser.read_only_relocsOption)
- arglist.addAllArgs(cmd_args, arglist.parser.sectcreateOption)
- arglist.addAllArgs(cmd_args, arglist.parser.sectorderOption)
- arglist.addAllArgs(cmd_args, arglist.parser.seg1addrOption)
- arglist.addAllArgs(cmd_args, arglist.parser.segprotOption)
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.segaddrOption,
- '-segaddr')
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.segs_read_only_addrOption,
- '-segs_read_only_addr')
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.segs_read_write_addrOption,
- '-segs_read_write_addr')
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.seg_addr_tableOption,
- '-seg_addr_table')
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.seg_addr_table_filenameOption,
- '-seg_addr_table_filename')
- arglist.addAllArgs(cmd_args, arglist.parser.sub_libraryOption)
- arglist.addAllArgs(cmd_args, arglist.parser.sub_umbrellaOption)
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.isysrootOption,
- '-syslibroot')
- arglist.addLastArg(cmd_args, arglist.parser.twolevel_namespaceOption)
- arglist.addLastArg(cmd_args, arglist.parser.twolevel_namespace_hintsOption)
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.umbrellaOption,
- '-umbrella')
- arglist.addAllArgs(cmd_args, arglist.parser.undefinedOption)
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.unexported_symbols_listOption,
- '-unexported_symbols_list')
- arglist.addAllArgsTranslated(cmd_args, arglist.parser.weak_reference_mismatchesOption,
- '-weak_reference_mismatches')
-
- if not arglist.getLastArg(arglist.parser.weak_reference_mismatchesOption):
- cmd_args.append('-weak_reference_mismatches')
- cmd_args.append('non-weak')
-
- arglist.addLastArg(cmd_args, arglist.parser.XOption)
- arglist.addAllArgs(cmd_args, arglist.parser.yOption)
- arglist.addLastArg(cmd_args, arglist.parser.wOption)
- arglist.addAllArgs(cmd_args, arglist.parser.pagezero_sizeOption)
- arglist.addAllArgs(cmd_args, arglist.parser.segs_read_Option)
- arglist.addLastArg(cmd_args, arglist.parser.seglinkeditOption)
- arglist.addLastArg(cmd_args, arglist.parser.noseglinkeditOption)
- arglist.addAllArgs(cmd_args, arglist.parser.sectalignOption)
- arglist.addAllArgs(cmd_args, arglist.parser.sectobjectsymbolsOption)
- arglist.addAllArgs(cmd_args, arglist.parser.segcreateOption)
- arglist.addLastArg(cmd_args, arglist.parser.whyloadOption)
- arglist.addLastArg(cmd_args, arglist.parser.whatsloadedOption)
- arglist.addAllArgs(cmd_args, arglist.parser.dylinker_install_nameOption)
- arglist.addLastArg(cmd_args, arglist.parser.dylinkerOption)
- arglist.addLastArg(cmd_args, arglist.parser.MachOption)
-
- def constructJob(self, phase, arch, jobs, inputs,
- output, outputType, arglist, linkingOutput):
- assert outputType is Types.ImageType
-
- # The logic here is derived from gcc's behavior; most of which
- # comes from specs (starting with link_command). Consult gcc
- # for more information.
-
- # FIXME: gcc's spec controls when this is done; certain things
- # like -filelist or -Wl, still trigger a link stage. I don't
- # quite understand how gcc decides to execute the linker,
- # investigate. Also, the spec references -fdump= which seems
- # to have disappeared?
- cmd_args = []
-
- # Not sure why this particular decomposition exists in gcc.
- self.addLinkArgs(cmd_args, arch, arglist)
-
- # This toolchain never accumlates options in specs, the only
- # place this gets used is to add -ObjC.
- if (arglist.getLastArg(arglist.parser.ObjCOption) or
- arglist.getLastArg(arglist.parser.f_objcOption)):
- cmd_args.append('-ObjC')
- if arglist.getLastArg(arglist.parser.ObjCXXOption):
- cmd_args.append('-ObjC')
-
- # FIXME: gcc has %{x} in here. How could this ever happen?
- # Cruft?
- arglist.addAllArgs(cmd_args, arglist.parser.dOption)
- arglist.addAllArgs(cmd_args, arglist.parser.sOption)
- arglist.addAllArgs(cmd_args, arglist.parser.tOption)
- arglist.addAllArgs(cmd_args, arglist.parser.ZOption)
- arglist.addAllArgs(cmd_args, arglist.parser.uGroup)
- arglist.addAllArgs(cmd_args, arglist.parser.AOption)
- arglist.addLastArg(cmd_args, arglist.parser.eOption)
- arglist.addAllArgs(cmd_args, arglist.parser.mSeparate)
- arglist.addAllArgs(cmd_args, arglist.parser.rOption)
-
- cmd_args.extend(arglist.render(output))
-
- macosxVersion = self.getMacosxVersionTuple(arglist)
- if (not arglist.getLastArg(arglist.parser.AOption) and
- not arglist.getLastArg(arglist.parser.nostdlibOption) and
- not arglist.getLastArg(arglist.parser.nostartfilesOption)):
- # Derived from startfile spec.
- if arglist.getLastArg(arglist.parser.dynamiclibOption):
- # Derived from darwin_dylib1 spec.
- if arglist.getLastArg(arglist.parser.m_iphoneosVersionMinOption):
- cmd_args.append('-ldylib1.o')
- else:
- if macosxVersion < (10,5):
- cmd_args.append('-ldylib1.o')
- else:
- cmd_args.append('-ldylib1.10.5.o')
- else:
- if arglist.getLastArg(arglist.parser.bundleOption):
- if not arglist.getLastArg(arglist.parser.staticOption):
- cmd_args.append('-lbundle1.o')
- else:
- if arglist.getLastArg(arglist.parser.pgOption):
- if arglist.getLastArg(arglist.parser.staticOption):
- cmd_args.append('-lgcrt0.o')
- else:
- if arglist.getLastArg(arglist.parser.objectOption):
- cmd_args.append('-lgcrt0.o')
- else:
- if arglist.getLastArg(arglist.parser.preloadOption):
- cmd_args.append('-lgcrt0.o')
- else:
- cmd_args.append('-lgcrt1.o')
-
- # darwin_crt2 spec is empty.
- pass
- else:
- if arglist.getLastArg(arglist.parser.staticOption):
- cmd_args.append('-lcrt0.o')
- else:
- if arglist.getLastArg(arglist.parser.objectOption):
- cmd_args.append('-lcrt0.o')
- else:
- if arglist.getLastArg(arglist.parser.preloadOption):
- cmd_args.append('-lcrt0.o')
- else:
- # Derived from darwin_crt1 spec.
- if arglist.getLastArg(arglist.parser.m_iphoneosVersionMinOption):
- cmd_args.append('-lcrt1.o')
- else:
- if macosxVersion < (10,5):
- cmd_args.append('-lcrt1.o')
- else:
- cmd_args.append('-lcrt1.10.5.o')
-
- # darwin_crt2 spec is empty.
- pass
-
- if arglist.getLastArg(arglist.parser.sharedLibgccOption):
- if not arglist.getLastArg(arglist.parser.m_iphoneosVersionMinOption):
- if macosxVersion < (10,5):
- cmd_args.append(self.toolChain.getFilePath('crt3.o'))
-
- arglist.addAllArgs(cmd_args, arglist.parser.LOption)
-
- if arglist.getLastArg(arglist.parser.f_openmpOption):
- # This is more complicated in gcc...
- cmd_args.append('-lgomp')
-
- # FIXME: Derive these correctly.
- tcDir = self.toolChain.getToolChainDir()
- if self.toolChain.archName == 'x86_64':
- cmd_args.extend(["-L/usr/lib/gcc/%s/x86_64" % tcDir,
- "-L/usr/lib/gcc/%s/x86_64" % tcDir])
- cmd_args.extend(["-L/usr/lib/%s" % tcDir,
- "-L/usr/lib/gcc/%s" % tcDir,
- "-L/usr/lib/gcc/%s" % tcDir,
- "-L/usr/lib/gcc/%s/../../../%s" % (tcDir,tcDir),
- "-L/usr/lib/gcc/%s/../../.." % tcDir])
-
- for input in inputs:
- cmd_args.extend(arglist.renderAsInput(input.source))
-
- if linkingOutput:
- cmd_args.append('-arch_multiple')
- cmd_args.append('-final_output')
- cmd_args.append(arglist.getValue(linkingOutput))
-
- if (arglist.getLastArg(arglist.parser.f_profileArcsOption) or
- arglist.getLastArg(arglist.parser.f_profileGenerateOption) or
- arglist.getLastArg(arglist.parser.f_createProfileOption) or
- arglist.getLastArg(arglist.parser.coverageOption)):
- cmd_args.append('-lgcov')
-
- if arglist.getLastArg(arglist.parser.f_nestedFunctionsOption):
- cmd_args.append('-allow_stack_execute')
-
- if (not arglist.getLastArg(arglist.parser.nostdlibOption) and
- not arglist.getLastArg(arglist.parser.nodefaultlibsOption)):
- # link_ssp spec is empty.
-
- # Derived from libgcc spec.
- if arglist.getLastArg(arglist.parser.staticOption):
- cmd_args.append('-lgcc_static')
- elif arglist.getLastArg(arglist.parser.staticLibgccOption):
- cmd_args.append('-lgcc_eh')
- cmd_args.append('-lgcc')
- elif arglist.getLastArg(arglist.parser.m_iphoneosVersionMinOption):
- # Derived from darwin_iphoneos_libgcc spec.
- cmd_args.append('-lgcc_s.10.5')
- cmd_args.append('-lgcc')
- elif (arglist.getLastArg(arglist.parser.sharedLibgccOption) or
- arglist.getLastArg(arglist.parser.f_exceptionsOption) or
- arglist.getLastArg(arglist.parser.f_gnuRuntimeOption)):
- if macosxVersion < (10,5):
- cmd_args.append('-lgcc_s.10.4')
- else:
- cmd_args.append('-lgcc_s.10.5')
- cmd_args.append('-lgcc')
- else:
- if macosxVersion < (10,5) and macosxVersion >= (10,3,9):
- cmd_args.append('-lgcc_s.10.4')
- if macosxVersion >= (10,5):
- cmd_args.append('-lgcc_s.10.5')
- cmd_args.append('-lgcc')
-
- # Derived from lib spec.
- if not arglist.getLastArg(arglist.parser.staticOption):
- cmd_args.append('-lSystem')
-
- if (not arglist.getLastArg(arglist.parser.AOption) and
- not arglist.getLastArg(arglist.parser.nostdlibOption) and
- not arglist.getLastArg(arglist.parser.nostartfilesOption)):
- # endfile_spec is empty.
- pass
-
- arglist.addAllArgs(cmd_args, arglist.parser.TGroup)
- arglist.addAllArgs(cmd_args, arglist.parser.FOption)
-
- jobs.addJob(Jobs.Command(self.toolChain.getProgramPath('collect2'),
- cmd_args))
-
- if (arglist.getLastArg(arglist.parser.gGroup) and
- not arglist.getLastArg(arglist.parser.gstabsOption) and
- not arglist.getLastArg(arglist.parser.g0Option)):
- # FIXME: This is gross, but matches gcc. The test only
- # considers the suffix (not the -x type), and then only of the
- # first input.
- inputSuffix = os.path.splitext(arglist.getValue(inputs[0].baseInput))[1]
- if inputSuffix in ('.c','.cc','.C','.cpp','.cp',
- '.c++','.cxx','.CPP','.m','.mm'):
- jobs.addJob(Jobs.Command('dsymutil',
- arglist.renderAsInput(output)))
-
-class LipoTool(Tool):
- def __init__(self, toolChain):
- super(LipoTool, self).__init__('lipo', toolChain)
-
- def constructJob(self, phase, arch, jobs, inputs,
- output, outputType, arglist, linkingOutput):
-
- assert outputType in (Types.ObjectType, Types.ImageType)
-
- cmd_args = ['-create']
- cmd_args.extend(arglist.render(output))
- for input in inputs:
- cmd_args.extend(arglist.renderAsInput(input.source))
- jobs.addJob(Jobs.Command('lipo', cmd_args))
diff --git a/tools/ccc/ccclib/Types.py b/tools/ccc/ccclib/Types.py
deleted file mode 100644
index 77e7907..0000000
--- a/tools/ccc/ccclib/Types.py
+++ /dev/null
@@ -1,170 +0,0 @@
-class InputType(object):
- """InputType - Information about various classes of files which
- the driver recognizes and control processing."""
-
- def __init__(self, name, preprocess=None, onlyAssemble=False,
- onlyPrecompile=False, tempSuffix=None,
- canBeUserSpecified=False, appendSuffix=False):
- assert preprocess is None or isinstance(preprocess, InputType)
- self.name = name
- self.preprocess = preprocess
- self.onlyAssemble = onlyAssemble
- self.onlyPrecompile = onlyPrecompile
- self.tempSuffix = tempSuffix
- self.canBeUserSpecified = canBeUserSpecified
- self.appendSuffix = appendSuffix
-
- def __repr__(self):
- return '%s(%r, %r, %r, %r, %r, %r)' % (self.__class__.__name__,
- self.name,
- self.preprocess,
- self.onlyAssemble,
- self.onlyPrecompile,
- self.tempSuffix,
- self.canBeUserSpecified)
-
-# C family source language (with and without preprocessing).
-CTypeNoPP = InputType('cpp-output', tempSuffix='i',
- canBeUserSpecified=True)
-CType = InputType('c', CTypeNoPP,
- canBeUserSpecified=True)
-ObjCTypeNoPP = InputType('objective-c-cpp-output', tempSuffix='mi',
- canBeUserSpecified=True)
-ObjCType = InputType('objective-c', ObjCTypeNoPP,
- canBeUserSpecified=True)
-CXXTypeNoPP = InputType('c++-cpp-output', tempSuffix='ii',
- canBeUserSpecified=True)
-CXXType = InputType('c++', CXXTypeNoPP,
- canBeUserSpecified=True)
-ObjCXXTypeNoPP = InputType('objective-c++-cpp-output', tempSuffix='mii',
- canBeUserSpecified=True)
-ObjCXXType = InputType('objective-c++', ObjCXXTypeNoPP,
- canBeUserSpecified=True)
-
-# C family input files to precompile.
-CHeaderNoPPType = InputType('c-header-cpp-output', tempSuffix='i',
- onlyPrecompile=True)
-CHeaderType = InputType('c-header', CHeaderNoPPType,
- onlyPrecompile=True, canBeUserSpecified=True)
-ObjCHeaderNoPPType = InputType('objective-c-header-cpp-output', tempSuffix='mi',
- onlyPrecompile=True)
-ObjCHeaderType = InputType('objective-c-header', ObjCHeaderNoPPType,
- onlyPrecompile=True, canBeUserSpecified=True)
-CXXHeaderNoPPType = InputType('c++-header-cpp-output', tempSuffix='ii',
- onlyPrecompile=True)
-CXXHeaderType = InputType('c++-header', CXXHeaderNoPPType,
- onlyPrecompile=True, canBeUserSpecified=True)
-ObjCXXHeaderNoPPType = InputType('objective-c++-header-cpp-output', tempSuffix='mii',
- onlyPrecompile=True)
-ObjCXXHeaderType = InputType('objective-c++-header', ObjCXXHeaderNoPPType,
- onlyPrecompile=True, canBeUserSpecified=True)
-
-# Other languages.
-AdaType = InputType('ada', canBeUserSpecified=True)
-AsmTypeNoPP = InputType('assembler', onlyAssemble=True, tempSuffix='s',
- canBeUserSpecified=True)
-AsmType = InputType('assembler-with-cpp', AsmTypeNoPP, onlyAssemble=True,
- canBeUserSpecified=True)
-FortranTypeNoPP = InputType('f95', canBeUserSpecified=True)
-FortranType = InputType('f95-cpp-input', FortranTypeNoPP, canBeUserSpecified=True)
-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', appendSuffix=True)
-ObjectType = InputType('object', tempSuffix='o')
-TreelangType = InputType('treelang', canBeUserSpecified=True)
-ImageType = InputType('image', tempSuffix='out')
-NothingType = InputType('nothing')
-
-###
-
-kDefaultOutput = "a.out"
-kTypeSuffixMap = {
- '.c' : CType,
- '.i' : CTypeNoPP,
- '.ii' : CXXTypeNoPP,
- '.m' : ObjCType,
- '.mi' : ObjCTypeNoPP,
- '.mm' : ObjCXXType,
- '.M' : ObjCXXType,
- '.mii' : ObjCXXTypeNoPP,
- '.h' : CHeaderType,
- '.cc' : CXXType,
- '.cc' : CXXType,
- '.cp' : CXXType,
- '.cxx' : CXXType,
- '.cpp' : CXXType,
- '.CPP' : CXXType,
- '.cXX' : CXXType,
- '.C' : CXXType,
- '.hh' : CXXHeaderType,
- '.H' : CXXHeaderType,
- '.f' : FortranTypeNoPP,
- '.for' : FortranTypeNoPP,
- '.FOR' : FortranTypeNoPP,
- '.F' : FortranType,
- '.fpp' : FortranType,
- '.FPP' : FortranType,
- '.f90' : FortranTypeNoPP,
- '.f95' : FortranTypeNoPP,
- '.F90' : FortranType,
- '.F95' : FortranType,
- # Apparently the Ada F-E hardcodes these suffixes in many
- # places. This explains why there is only one -x option for ada.
- '.ads' : AdaType,
- '.adb' : AdaType,
- # FIXME: Darwin always uses a preprocessor for asm input. Where
- # does this fit?
- '.s' : AsmTypeNoPP,
- '.S' : AsmType,
-}
-kTypeSpecifierMap = {
- 'none' : None,
-
- 'c' : CType,
- 'c-header' : CHeaderType,
- # NOTE: gcc.info claims c-cpp-output works but the actual spelling
- # is cpp-output. Nice.
- 'cpp-output' : CTypeNoPP,
- 'c++' : CXXType,
- 'c++-header' : CXXHeaderType,
- 'c++-cpp-output' : CXXTypeNoPP,
- 'objective-c' : ObjCType,
- 'objective-c-header' : ObjCHeaderType,
- 'objective-c-cpp-output' : ObjCTypeNoPP,
- 'objective-c++' : ObjCXXType,
- 'objective-c++-header' : ObjCXXHeaderType,
- 'objective-c++-cpp-output' : ObjCXXTypeNoPP,
- 'assembler' : AsmTypeNoPP,
- 'assembler-with-cpp' : AsmType,
- 'ada' : AdaType,
- 'f95-cpp-input' : FortranType,
- 'f95' : FortranTypeNoPP,
- 'java' : JavaType,
- 'treelang' : TreelangType,
-}
-
-# Set of C family types.
-clangableTypesSet = set([AsmType, # Assembler to preprocess
- CType, CTypeNoPP,
- ObjCType, ObjCTypeNoPP,
- CXXType, CXXTypeNoPP,
- ObjCXXType, ObjCXXTypeNoPP,
- CHeaderType, CHeaderNoPPType,
- ObjCHeaderType, ObjCHeaderNoPPType,
- CXXHeaderType, CXXHeaderNoPPType,
- ObjCXXHeaderType, ObjCXXHeaderNoPPType])
-
-# Set of C++ family types.
-cxxTypesSet = set([CXXType, CXXTypeNoPP,
- ObjCXXType, ObjCXXTypeNoPP,
- CXXHeaderType, CXXHeaderNoPPType,
- ObjCXXHeaderType, ObjCXXHeaderNoPPType])
-
-# Check that the type specifier map at least matches what the types
-# believe to be true.
-assert not [name for name,type in kTypeSpecifierMap.items()
- if type and (type.name != name or not type.canBeUserSpecified)]
diff --git a/tools/ccc/ccclib/Util.py b/tools/ccc/ccclib/Util.py
deleted file mode 100644
index 0924e8c..0000000
--- a/tools/ccc/ccclib/Util.py
+++ /dev/null
@@ -1,52 +0,0 @@
-def any_true(list, predicate):
- for i in list:
- if predicate(i):
- return True
- return False
-
-def any_false(list, predicate):
- return any_true(list, lambda x: not predicate(x))
-
-def all_true(list, predicate):
- return not any_false(list, predicate)
-
-def all_false(list, predicate):
- return not any_true(list, predicate)
-
-def prependLines(prependStr, str):
- return ('\n'+prependStr).join(str.splitlines())
-
-def pprint(object, useRepr=True):
- def recur(ob):
- return pprint(ob, useRepr)
- def wrapString(prefix, string, suffix):
- return '%s%s%s' % (prefix,
- prependLines(' ' * len(prefix),
- string),
- suffix)
- def pprintArgs(name, args):
- return wrapString(name + '(', ',\n'.join(map(recur,args)), ')')
-
- if isinstance(object, tuple):
- return wrapString('(', ',\n'.join(map(recur,object)),
- [')',',)'][len(object) == 1])
- elif isinstance(object, list):
- return wrapString('[', ',\n'.join(map(recur,object)), ']')
- elif isinstance(object, set):
- return pprintArgs('set', list(object))
- elif isinstance(object, dict):
- elts = []
- for k,v in object.items():
- kr = recur(k)
- vr = recur(v)
- elts.append('%s : %s' % (kr,
- prependLines(' ' * (3 + len(kr.splitlines()[-1])),
- vr)))
- return wrapString('{', ',\n'.join(elts), '}')
- else:
- if useRepr:
- return repr(object)
- return str(object)
-
-def prefixAndPPrint(prefix, object, useRepr=True):
- return prefix + prependLines(' '*len(prefix), pprint(object, useRepr))
diff --git a/tools/ccc/ccclib/__init__.py b/tools/ccc/ccclib/__init__.py
deleted file mode 100644
index a9a2c5b..0000000
--- a/tools/ccc/ccclib/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-__all__ = []
diff --git a/tools/ccc/test/ccc/O.c b/tools/ccc/test/ccc/O.c
deleted file mode 100644
index 7ef0aba..0000000
--- a/tools/ccc/test/ccc/O.c
+++ /dev/null
@@ -1,4 +0,0 @@
-// Just check that clang accepts these.
-
-// RUN: xcc -fsyntax-only -O1 -O2 %s &&
-// RUN: xcc -fsyntax-only -O %s
diff --git a/tools/ccc/test/ccc/ObjC.c b/tools/ccc/test/ccc/ObjC.c
deleted file mode 100644
index e638cbb..0000000
--- a/tools/ccc/test/ccc/ObjC.c
+++ /dev/null
@@ -1,7 +0,0 @@
-// RUN: xcc -fsyntax-only %s -ObjC &&
-// RUN: ! xcc -fsyntax-only -x c %s -ObjC &&
-// RUN: xcc -fsyntax-only %s -ObjC++ &&
-// RUN: ! xcc -fsyntax-only -x c %s -ObjC++
-
-@interface A
-@end
diff --git a/tools/ccc/test/ccc/Xarch.c b/tools/ccc/test/ccc/Xarch.c
deleted file mode 100644
index 5c3a1f9..0000000
--- a/tools/ccc/test/ccc/Xarch.c
+++ /dev/null
@@ -1,8 +0,0 @@
-// RUN: xcc -ccc-no-clang -### -fsyntax-only -Xarch_i386 -Wall -Xarch_ppc -Wunused -arch i386 -arch ppc %s &> %t &&
-// RUN: grep '"-Xarch"' %t | count 0 &&
-// RUN: grep '"-Wall"' %t | count 1 &&
-// RUN: grep 'i686-apple' %t | grep -v '"-m64"' | count 1 &&
-// RUN: grep '"-Wall"' %t | grep 'i686-apple' | grep -v '"-m64"' | count 1 &&
-// RUN: grep '"-Wunused"' %t | count 1 &&
-// RUN: grep '"-arch" "ppc"' %t | count 1 &&
-// RUN: grep '"-Wunused"' %t | grep '"-arch" "ppc"' | count 1
diff --git a/tools/ccc/test/ccc/Xclang.c b/tools/ccc/test/ccc/Xclang.c
deleted file mode 100644
index 141420e..0000000
--- a/tools/ccc/test/ccc/Xclang.c
+++ /dev/null
@@ -1 +0,0 @@
-// RUN: xcc -fsyntax-only -Xclang --help %s | grep "OVERVIEW: LLVM 'Clang' Compiler"
diff --git a/tools/ccc/test/ccc/aliases.c b/tools/ccc/test/ccc/aliases.c
deleted file mode 100644
index 101c4e7..0000000
--- a/tools/ccc/test/ccc/aliases.c
+++ /dev/null
@@ -1,13 +0,0 @@
-// RUN: xcc -ccc-no-clang -### -S --all-warnings %s &> %t &&
-// RUN: grep -- '"-Wall"' %t &&
-
-// RUN: xcc -ccc-no-clang -### -S --ansi %s &> %t &&
-// RUN: grep -- '"-ansi"' %t &&
-
-// RUN: xcc -ccc-no-clang -### -S --assert foo --assert=foo %s &> %t &&
-// RUN: grep -- '"-A" "foo" "-A" "foo"' %t &&
-
-// RUN: xcc -ccc-no-clang -### -S --classpath foo --classpath=foo %s &> %t &&
-// RUN: grep -- '"-fclasspath=foo" "-fclasspath=foo"' %t &&
-
-// RUN: true
diff --git a/tools/ccc/test/ccc/analyze.c b/tools/ccc/test/ccc/analyze.c
deleted file mode 100644
index 1f4fd72..0000000
--- a/tools/ccc/test/ccc/analyze.c
+++ /dev/null
@@ -1,10 +0,0 @@
-// RUN: xcc --analyze %s -o %t &&
-// RUN: grep '<string>Dereference of null pointer</string>' %t &&
-
-// RUN: xcc -### --analyze %s -Xanalyzer -check-that-program-halts &> %t &&
-// RUN: grep 'check-that-program-halts' %t
-
-void f(int *p) {
- if (!p)
- *p = 0;
-}
diff --git a/tools/ccc/test/ccc/argument-types.c b/tools/ccc/test/ccc/argument-types.c
deleted file mode 100644
index 2de1593..0000000
--- a/tools/ccc/test/ccc/argument-types.c
+++ /dev/null
@@ -1,16 +0,0 @@
-// Input argument:
-// RUN: xcc -ccc-print-options %s | grep 'Name: "<input>", Values: {"%s"}' | count 1 &&
-
-// Joined or separate arguments:
-// RUN: xcc -ccc-print-options -xc -x c | grep 'Name: "-x", Values: {"c"}' | count 2 &&
-
-// Joined and separate arguments:
-// RUN: xcc -ccc-print-options -Xarch_mips -run | grep 'Name: "-Xarch_", Values: {"mips", "-run"}' | count 1 &&
-
-// Multiple arguments:
-// RUN: xcc -ccc-print-options -sectorder 1 2 3 | grep 'Name: "-sectorder", Values: {"1", "2", "3"}' | count 1 &&
-
-// Unknown argument:
-// RUN: xcc -ccc-print-options -=== | grep 'Name: "<unknown>", Values: {"-==="}' | count 1 &&
-
-// RUN: true
diff --git a/tools/ccc/test/ccc/darwin-hello.m b/tools/ccc/test/ccc/darwin-hello.m
deleted file mode 100644
index 51dea65..0000000
--- a/tools/ccc/test/ccc/darwin-hello.m
+++ /dev/null
@@ -1,17 +0,0 @@
-// Check that object files compiled with -mdynamic-no-pic can be
-// linked.
-//
-// RUN: xcc -m32 -mdynamic-no-pic %s -c -o %t.o &&
-// RUN: xcc -m32 %t.o -o %t &&
-// RUN: %t | grep "Hello, World" &&
-// RUN: xcc -m64 -mdynamic-no-pic %s -c -o %t.o &&
-// RUN: xcc -m64 %t.o -o %t &&
-// RUN: %t | grep "Hello, World" &&
-// RUN: true
-
-#include <stdio.h>
-
-int main(int argc, char **argv) {
- fprintf(stdout, "Hello, World");
- return 0;
-}
diff --git a/tools/ccc/test/ccc/darwin-ld-shared.c b/tools/ccc/test/ccc/darwin-ld-shared.c
deleted file mode 100644
index 7aa2252..0000000
--- a/tools/ccc/test/ccc/darwin-ld-shared.c
+++ /dev/null
@@ -1,7 +0,0 @@
-// -shared translates to -dynamiclib on darwin.
-// RUN: xcc -ccc-host-system darwin -### -filelist a &> %t.1 &&
-// RUN: xcc -ccc-host-system darwin -### -filelist a -shared &> %t.2 &&
-
-// -dynamiclib turns on -dylib
-// RUN: not grep -- '-dylib' %t.1 &&
-// RUN: grep -- '-dylib' %t.2
diff --git a/tools/ccc/test/ccc/darwin-pic.c b/tools/ccc/test/ccc/darwin-pic.c
deleted file mode 100644
index 8b2ca31..0000000
--- a/tools/ccc/test/ccc/darwin-pic.c
+++ /dev/null
@@ -1,11 +0,0 @@
-// RUN: xcc -ccc-host-system darwin -ccc-host-machine i386 -m32 -S %s -o - | grep 'L_g0$non_lazy_ptr-' &&
-// RUN: xcc -ccc-host-system darwin -ccc-host-machine i386 -m32 -S %s -o - -fPIC | grep 'L_g0$non_lazy_ptr-' &&
-// RUN: xcc -ccc-host-system darwin -ccc-host-machine i386 -m32 -S %s -o - -mdynamic-no-pic | grep 'L_g0$non_lazy_ptr,' &&
-// RUN: xcc -ccc-host-system darwin -ccc-host-machine i386 -m32 -S %s -o - -static | grep 'non_lazy_ptr' | count 0 &&
-// RUN: xcc -ccc-host-system darwin -ccc-host-machine i386 -m64 -S %s -o - | grep '_g0@GOTPCREL' &&
-// RUN: xcc -ccc-host-system darwin -ccc-host-machine i386 -m64 -S %s -o - -fPIC | grep '_g0@GOTPCREL' &&
-// RUN: xcc -ccc-host-system darwin -ccc-host-machine i386 -m64 -S %s -o - -mdynamic-no-pic | grep '_g0@GOTPCREL' &&
-// RUN: xcc -ccc-host-system darwin -ccc-host-machine i386 -m64 -S %s -o - -static | grep '_g0@GOTPCREL'
-
-int g0;
-int f0() { return g0; }
diff --git a/tools/ccc/test/ccc/darwin-x86-cc1.m b/tools/ccc/test/ccc/darwin-x86-cc1.m
deleted file mode 100644
index c9102ca..0000000
--- a/tools/ccc/test/ccc/darwin-x86-cc1.m
+++ /dev/null
@@ -1,24 +0,0 @@
-// RUN: xcc -ccc-no-clang -ccc-host-bits 32 -ccc-host-machine i386 -ccc-host-system darwin -ccc-host-release 10.5.0 -### -x objective-c -arch i386 -fmessage-length=0 -Wno-trigraphs -fpascal-strings -fasm-blocks -Os -mdynamic-no-pic -DUSER_DEFINE_0 -fvisibility=hidden -mmacosx-version-min=10.5 -gdwarf-2 -IINCLUDE_PATH_0 -Wall -Wextra -Wno-missing-field-initializers -Wno-unused-parameter -Wno-four-char-constants -Wno-unknown-pragmas -Wno-format-y2k -Wpointer-arith -Wreturn-type -Wwrite-strings -Wswitch -Wcast-align -Wchar-subscripts -Winline -Wnested-externs -Wint-to-pointer-cast -Wpointer-to-int-cast -Wshorten-64-to-32 -FFRAMEWORK_0 -IINCLUDE_PATH_1 -FFRAMEWORK_1 -include USER_INCLUDE_0 -c %s -o %t.out &> %t.opts &&
-// RUN: grep ' "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/cc1obj" "-quiet" "-IINCLUDE_PATH_0" "-FFRAMEWORK_0" "-IINCLUDE_PATH_1" "-FFRAMEWORK_1" "-D__DYNAMIC__" "-DUSER_DEFINE_0" "-include" "USER_INCLUDE_0" ".*" "-quiet" "-dumpbase" "darwin-x86-cc1.m" "-mpascal-strings" "-mdynamic-no-pic" "-mmacosx-version-min=10.5" "-mtune=core2" "-auxbase-strip" ".*" "-gdwarf-2" "-Os" "-Wno-trigraphs" "-Wall" "-Wextra" "-Wno-missing-field-initializers" "-Wno-unused-parameter" "-Wno-four-char-constants" "-Wno-unknown-pragmas" "-Wno-format-y2k" "-Wpointer-arith" "-Wreturn-type" "-Wwrite-strings" "-Wswitch" "-Wcast-align" "-Wchar-subscripts" "-Winline" "-Wnested-externs" "-Wint-to-pointer-cast" "-Wpointer-to-int-cast" "-Wshorten-64-to-32" "-fmessage-length=0" "-fasm-blocks" "-fvisibility=hidden" "-o"' %t.opts &&
-// RUN: grep ' "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/as" "-arch" "i386" "-force_cpusubtype_ALL" "-o"' %t.opts &&
-
-// RUN: xcc -ccc-no-clang -ccc-host-bits 32 -ccc-host-machine i386 -ccc-host-system darwin -ccc-host-release 10.5.0 -### -v -E -dM -arch i386 -xobjective-c -c %s &> %t.opts &&
-// RUN: grep ' "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/cc1obj" "-E" "-quiet" "-v" "-D__DYNAMIC__" ".*" "-fPIC" "-mmacosx-version-min=10.6.5" "-mtune=core2" "-dM"' %t.opts &&
-
-// RUN: xcc -ccc-no-clang -ccc-host-bits 32 -ccc-host-machine i386 -ccc-host-system darwin -ccc-host-release 10.5.0 -### -m32 -S -x cpp-output %s &> %t.opts &&
-// RUN: grep ' "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/cc1" "-fpreprocessed" ".*darwin-x86-cc1.m" "-fPIC" "-quiet" "-dumpbase" "darwin-x86-cc1.m" "-mmacosx-version-min=10.6.5" "-m32" "-mtune=core2" "-auxbase" "darwin-x86-cc1" "-o" ".*"' %t.opts &&
-
-// RUN: xcc -ccc-no-clang -ccc-host-bits 32 -ccc-host-machine i386 -ccc-host-system darwin -ccc-host-release 10.5.0 -### -x objective-c-header %s -o /tmp/x.gch &> %t.opts &&
-// RUN: grep ' "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/cc1obj" "-quiet" "-D__DYNAMIC__" ".*darwin-x86-cc1.m" "-fPIC" "-quiet" "-dumpbase" "darwin-x86-cc1.m" "-mmacosx-version-min=10.6.5" "-mtune=core2" "-auxbase" ".*" "-o" "/dev/null" "--output-pch=" "/tmp/x.gch"' %t.opts &&
-
-// RUN: touch %t.s &&
-// RUN: xcc -ccc-no-clang -ccc-host-bits 32 -ccc-host-machine i386 -ccc-host-system darwin -ccc-host-release 10.5.0 -### -c -x assembler %t.s &> %t.opts &&
-// RUN: grep /cc1 %t.opts | count 0 &&
-// RUN: grep ' "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/as" "-arch" "i386" "-force_cpusubtype_ALL" "-o" ".*darwin-x86-cc1.m.out.tmp.s"' %t.opts &&
-
-// RUN: xcc -ccc-no-clang -ccc-host-bits 32 -ccc-host-machine i386 -ccc-host-system darwin -ccc-host-release 10.5.0 -### -c -x assembler-with-cpp %t.s &> %t.opts &&
-// RUN: grep ' "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/cc1" "-E" "-quiet" "-D__DYNAMIC__" ".*darwin-x86-cc1.m.out.tmp.s" "-o" ".*" "-fPIC" "-mmacosx-version-min=10.6.5" "-mtune=core2"' %t.opts &&
-// RUN: grep ' "/usr/libexec/gcc/i686-apple-darwin10/4.2.1/as" "-arch" "i386" "-force_cpusubtype_ALL" "-o" ".*"' %t.opts &&
-
-// RUN: true
-
diff --git a/tools/ccc/test/ccc/hello.c b/tools/ccc/test/ccc/hello.c
deleted file mode 100644
index 120db1a..0000000
--- a/tools/ccc/test/ccc/hello.c
+++ /dev/null
@@ -1,11 +0,0 @@
-// RUN: xcc -ccc-no-clang %s -o %t &&
-// RUN: %t | grep "Hello, World" &&
-// RUN: xcc -ccc-no-clang %s -o %t -pipe &&
-// RUN: %t | grep "Hello, World" &&
-// RUN: xcc %s -o %t &&
-// RUN: %t | grep "Hello, World"
-
-int main() {
- printf("Hello, World!\n");
- return 0;
-}
diff --git a/tools/ccc/test/ccc/hello.cpp b/tools/ccc/test/ccc/hello.cpp
deleted file mode 100644
index 75c7bfd..0000000
--- a/tools/ccc/test/ccc/hello.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-// RUN: xcc -ccc-cxx %s -o %t &&
-// RUN: %t | grep "Hello, World"
-// XFAIL
-
-#include <iostream>
-
-int main() {
- std::cout << "Hello, World!\n";
- return 0;
-}
diff --git a/tools/ccc/test/ccc/hello.m b/tools/ccc/test/ccc/hello.m
deleted file mode 100644
index b1bcaeb..0000000
--- a/tools/ccc/test/ccc/hello.m
+++ /dev/null
@@ -1,9 +0,0 @@
-// RUN: xcc -ccc-no-clang %s -o %t &&
-// RUN: %t | grep "Hello, World" &&
-// RUN: xcc %s -o %t &&
-// RUN: %t | grep "Hello, World"
-
-int main() {
- printf("Hello, World!\n");
- return 0;
-}
diff --git a/tools/ccc/test/ccc/integrated-cpp.c b/tools/ccc/test/ccc/integrated-cpp.c
deleted file mode 100644
index 25c7402..0000000
--- a/tools/ccc/test/ccc/integrated-cpp.c
+++ /dev/null
@@ -1,3 +0,0 @@
-// RUN: xcc -fsyntax-only -### %s 2>&1 | count 2 &&
-// RUN: xcc -fsyntax-only -### %s -no-integrated-cpp 2>&1 | count 3 &&
-// RUN: xcc -fsyntax-only -### %s -save-temps 2>&1 | count 3
diff --git a/tools/ccc/test/ccc/invalid.c b/tools/ccc/test/ccc/invalid.c
deleted file mode 100644
index 3620b45..0000000
--- a/tools/ccc/test/ccc/invalid.c
+++ /dev/null
@@ -1 +0,0 @@
-// RUN: not xcc -### -c -o %t %s %s
diff --git a/tools/ccc/test/ccc/math-errno.c b/tools/ccc/test/ccc/math-errno.c
deleted file mode 100644
index 4f440a3..0000000
--- a/tools/ccc/test/ccc/math-errno.c
+++ /dev/null
@@ -1,5 +0,0 @@
-// RUN: xcc -ccc-host-system unknown -### %s -S 2>&1 | grep -- "--fmath-errno=1" | count 1 &&
-// RUN: xcc -ccc-host-system unknown -### %s -S -fno-math-errno 2>&1 | grep -- "--fmath-errno=0" | count 1 &&
-// RUN: xcc -ccc-host-system unknown -### %s -S -fmath-errno -fno-math-errno 2>&1 | grep -- "--fmath-errno=0" | count 1 &&
-// RUN: xcc -ccc-host-bits 32 -ccc-host-machine i386 -ccc-host-system darwin -ccc-host-release 10.5.0 -### %s -S 2>&1 | grep -- "--fmath-errno=0" | count 1 &&
-// RUN: xcc -ccc-host-bits 32 -ccc-host-machine i386 -ccc-host-system darwin -ccc-host-release 10.5.0 -### %s -S -fmath-errno 2>&1 | grep -- "--fmath-errno=1" | count 1
diff --git a/tools/ccc/test/ccc/phases.c b/tools/ccc/test/ccc/phases.c
deleted file mode 100644
index 2f4571a..0000000
--- a/tools/ccc/test/ccc/phases.c
+++ /dev/null
@@ -1,51 +0,0 @@
-// One C file.
-// RUN: touch %t.c &&
-// RUN: xcc -ccc-host-system unknown -ccc-print-phases %t.c > %t &&
-// RUN: grep '0: input, "%t.c", c' %t &&
-// RUN: grep '1: preprocessor, {0}, cpp-output' %t &&
-// RUN: grep '2: compiler, {1}, assembler' %t &&
-// RUN: grep '3: assembler, {2}, object' %t &&
-// RUN: grep '4: linker, {3}, image' %t &&
-
-// PCH.
-// RUN: touch %t.h &&
-// RUN: xcc -ccc-host-system unknown -ccc-print-phases -x c-header %t.h > %t &&
-// RUN: grep '0: input, "%t.h", c-header' %t &&
-// RUN: grep '1: preprocessor, {0}, c-header-cpp-output' %t &&
-// RUN: grep '2: precompiler, {1}, precompiled-header' %t &&
-
-// Assembler w/ and w/o preprocessor.
-// RUN: touch %t.s &&
-// RUN: xcc -ccc-host-system unknown -ccc-print-phases -x assembler %t.s > %t &&
-// RUN: grep '0: input, "%t.s", assembler' %t &&
-// RUN: grep '1: assembler, {0}, object' %t &&
-// RUN: grep '2: linker, {1}, image' %t &&
-// RUN: xcc -ccc-host-system unknown -ccc-print-phases -x assembler-with-cpp %t.s > %t &&
-// RUN: grep '0: input, "%t.s", assembler-with-cpp' %t &&
-// RUN: grep '1: preprocessor, {0}, assembler' %t &&
-// RUN: grep '2: assembler, {1}, object' %t &&
-// RUN: grep '3: linker, {2}, image' %t &&
-
-// Check the various ways of early termination.
-// RUN: xcc -ccc-host-system unknown -ccc-print-phases -E %s > %t &&
-// RUN: not grep ': compiler, ' %t &&
-// RUN: xcc -ccc-host-system unknown -ccc-print-phases -fsyntax-only %s > %t &&
-// RUN: grep ': syntax-only, {1}, nothing' %t &&
-// RUN: not grep ': assembler, ' %t &&
-// RUN: xcc -ccc-host-system unknown -ccc-print-phases -S %s > %t &&
-// RUN: not grep ': assembler, ' %t &&
-// RUN: xcc -ccc-host-system unknown -ccc-print-phases -c %s > %t &&
-// RUN: not grep ': linker, ' %t &&
-
-// Multiple output files.
-// RUN: touch %t.1.c &&
-// RUN: touch %t.2.c &&
-// RUN: xcc -ccc-host-system unknown -ccc-print-phases -c %t.1.c %t.2.c > %t &&
-// RUN: grep ': assembler,' %t | count 2 &&
-
-// FIXME: Only for darwin.
-// Treat -filelist as a linker input.
-// RUN: xcc -ccc-host-system unknown -ccc-print-phases -filelist /dev/null > %t &&
-// RUN: grep '1: linker, {0}, image' %t &&
-
-// RUN: true
diff --git a/tools/ccc/test/ccc/pth.c b/tools/ccc/test/ccc/pth.c
deleted file mode 100644
index 5cc68a4..0000000
--- a/tools/ccc/test/ccc/pth.c
+++ /dev/null
@@ -1,5 +0,0 @@
-// RUN: cp %s %t.h &&
-// RUN: xcc %t.h &&
-// RUN: xcc -### -S -include %t.h -x c /dev/null &> %t.log &&
-// RUN: grep '"-token-cache" ".*/pth.c.out.tmp.h.pth"' %t.log
-// RUN: true
diff --git a/tools/ccc/test/ccc/stdin.c b/tools/ccc/test/ccc/stdin.c
deleted file mode 100644
index a8df15c..0000000
--- a/tools/ccc/test/ccc/stdin.c
+++ /dev/null
@@ -1,10 +0,0 @@
-// RUN: not xcc -### - &> %t &&
-// RUN: grep 'E or -x required when input is from standard input' %t &&
-// RUN: xcc -ccc-print-phases -### -E - &> %t &&
-// RUN: grep '1: preprocessor.*, {0}, cpp-output' %t &&
-// RUN: xcc -ccc-print-phases -### -ObjC -E - &> %t &&
-// RUN: grep '1: preprocessor.*, {0}, objective-c-cpp-output' %t &&
-// RUN: xcc -ccc-print-phases -### -ObjC -x c -E - &> %t &&
-// RUN: grep '1: preprocessor.*, {0}, cpp-output' %t &&
-
-// RUN: true
diff --git a/tools/ccc/test/ccc/universal-hello.c b/tools/ccc/test/ccc/universal-hello.c
deleted file mode 100644
index 36afd66..0000000
--- a/tools/ccc/test/ccc/universal-hello.c
+++ /dev/null
@@ -1,16 +0,0 @@
-// RUN: xcc -ccc-no-clang -arch ppc -arch i386 -arch x86_64 %s -o %t &&
-// RUN: %t | grep "Hello, World" &&
-
-// RUN: xcc -ccc-no-clang -pipe -arch ppc -arch i386 -arch x86_64 %s -o %t &&
-// RUN: %t | grep "Hello, World" &&
-
-// Check that multiple archs are handled properly.
-// RUN: xcc -ccc-print-phases -### -arch ppc -arch ppc %s | grep 'linker,' | count 1 &&
-
-// Check that -ccc-clang-archs is honored.
-// RUN: xcc -ccc-clang-archs i386 -### -arch ppc -arch i386 %s 2>&1 | grep 'clang-cc"' | count 1
-
-int main() {
- printf("Hello, World!\n");
- return 0;
-}
diff --git a/tools/ccc/test/ccc/x86-target-features.c b/tools/ccc/test/ccc/x86-target-features.c
deleted file mode 100644
index c35db6b..0000000
--- a/tools/ccc/test/ccc/x86-target-features.c
+++ /dev/null
@@ -1,4 +0,0 @@
-// RUN: xcc -ccc-host-machine i386 -### -S %s -mno-red-zone -mno-sse -msse4a -msoft-float &> %t &&
-// RUN: grep '"--mattr=-sse,+sse4a"' %t &&
-// RUN: grep '"--disable-red-zone"' %t &&
-// RUN: grep '"--soft-float"' %t