diff options
| author | Daniel Dunbar <daniel@zuster.org> | 2009-05-02 22:13:56 +0000 |
|---|---|---|
| committer | Daniel Dunbar <daniel@zuster.org> | 2009-05-02 22:13:56 +0000 |
| commit | 49aff46fed32fee0f845278154597f0d03cfe7e3 (patch) | |
| tree | 37ce51c2abd4dfc1d3bdbb7604b104aa27d26578 | |
| parent | 82f61f96ba0410a2e14044976b08ff39768eb659 (diff) | |
| download | bcm5719-llvm-49aff46fed32fee0f845278154597f0d03cfe7e3.tar.gz bcm5719-llvm-49aff46fed32fee0f845278154597f0d03cfe7e3.zip | |
ccc is dead.
llvm-svn: 70649
34 files changed, 0 insertions, 4439 deletions
diff --git a/clang/tools/ccc/Makefile b/clang/tools/ccc/Makefile deleted file mode 100644 index 139c5d8a263..00000000000 --- a/clang/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/clang/tools/ccc/ccc b/clang/tools/ccc/ccc deleted file mode 100755 index 4043150c728..00000000000 --- a/clang/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/clang/tools/ccc/ccclib/Arguments.py b/clang/tools/ccc/ccclib/Arguments.py deleted file mode 100644 index 958dd38b659..00000000000 --- a/clang/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/clang/tools/ccc/ccclib/Driver.py b/clang/tools/ccc/ccclib/Driver.py deleted file mode 100644 index 92f7c87ca0a..00000000000 --- a/clang/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/clang/tools/ccc/ccclib/HostInfo.py b/clang/tools/ccc/ccclib/HostInfo.py deleted file mode 100644 index c40a4f7c4d2..00000000000 --- a/clang/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/clang/tools/ccc/ccclib/Jobs.py b/clang/tools/ccc/ccclib/Jobs.py deleted file mode 100644 index 0b3c3a3935a..00000000000 --- a/clang/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/clang/tools/ccc/ccclib/Phases.py b/clang/tools/ccc/ccclib/Phases.py deleted file mode 100644 index 0998fd611b3..00000000000 --- a/clang/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/clang/tools/ccc/ccclib/ToolChain.py b/clang/tools/ccc/ccclib/ToolChain.py deleted file mode 100644 index be949e70343..00000000000 --- a/clang/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/clang/tools/ccc/ccclib/Tools.py b/clang/tools/ccc/ccclib/Tools.py deleted file mode 100644 index 1d4231ea9f4..00000000000 --- a/clang/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/clang/tools/ccc/ccclib/Types.py b/clang/tools/ccc/ccclib/Types.py deleted file mode 100644 index 77e7907faec..00000000000 --- a/clang/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/clang/tools/ccc/ccclib/Util.py b/clang/tools/ccc/ccclib/Util.py deleted file mode 100644 index 0924e8c2489..00000000000 --- a/clang/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/clang/tools/ccc/ccclib/__init__.py b/clang/tools/ccc/ccclib/__init__.py deleted file mode 100644 index a9a2c5b3bb4..00000000000 --- a/clang/tools/ccc/ccclib/__init__.py +++ /dev/null @@ -1 +0,0 @@ -__all__ = [] diff --git a/clang/tools/ccc/test/ccc/O.c b/clang/tools/ccc/test/ccc/O.c deleted file mode 100644 index 7ef0aba61d1..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/ObjC.c b/clang/tools/ccc/test/ccc/ObjC.c deleted file mode 100644 index e638cbbc4e3..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/Xarch.c b/clang/tools/ccc/test/ccc/Xarch.c deleted file mode 100644 index 5c3a1f954db..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/Xclang.c b/clang/tools/ccc/test/ccc/Xclang.c deleted file mode 100644 index 141420e1bb2..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/aliases.c b/clang/tools/ccc/test/ccc/aliases.c deleted file mode 100644 index 101c4e7a255..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/analyze.c b/clang/tools/ccc/test/ccc/analyze.c deleted file mode 100644 index 1f4fd725124..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/argument-types.c b/clang/tools/ccc/test/ccc/argument-types.c deleted file mode 100644 index 2de1593a9bb..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/darwin-hello.m b/clang/tools/ccc/test/ccc/darwin-hello.m deleted file mode 100644 index 51dea654dcb..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/darwin-ld-shared.c b/clang/tools/ccc/test/ccc/darwin-ld-shared.c deleted file mode 100644 index 7aa2252489d..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/darwin-pic.c b/clang/tools/ccc/test/ccc/darwin-pic.c deleted file mode 100644 index 8b2ca3154c6..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/darwin-x86-cc1.m b/clang/tools/ccc/test/ccc/darwin-x86-cc1.m deleted file mode 100644 index c9102caf9b0..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/hello.c b/clang/tools/ccc/test/ccc/hello.c deleted file mode 100644 index 120db1a6303..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/hello.cpp b/clang/tools/ccc/test/ccc/hello.cpp deleted file mode 100644 index 75c7bfd84e5..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/hello.m b/clang/tools/ccc/test/ccc/hello.m deleted file mode 100644 index b1bcaeb2516..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/integrated-cpp.c b/clang/tools/ccc/test/ccc/integrated-cpp.c deleted file mode 100644 index 25c74027673..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/invalid.c b/clang/tools/ccc/test/ccc/invalid.c deleted file mode 100644 index 3620b458ad2..00000000000 --- a/clang/tools/ccc/test/ccc/invalid.c +++ /dev/null @@ -1 +0,0 @@ -// RUN: not xcc -### -c -o %t %s %s diff --git a/clang/tools/ccc/test/ccc/math-errno.c b/clang/tools/ccc/test/ccc/math-errno.c deleted file mode 100644 index 4f440a34380..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/phases.c b/clang/tools/ccc/test/ccc/phases.c deleted file mode 100644 index 2f4571a769d..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/pth.c b/clang/tools/ccc/test/ccc/pth.c deleted file mode 100644 index 5cc68a484f2..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/stdin.c b/clang/tools/ccc/test/ccc/stdin.c deleted file mode 100644 index a8df15cab44..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/universal-hello.c b/clang/tools/ccc/test/ccc/universal-hello.c deleted file mode 100644 index 36afd66e793..00000000000 --- a/clang/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/clang/tools/ccc/test/ccc/x86-target-features.c b/clang/tools/ccc/test/ccc/x86-target-features.c deleted file mode 100644 index c35db6bb441..00000000000 --- a/clang/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 |
