From 25d4a8fc3bdef9de2cd94a1a73c4e38ff6399340 Mon Sep 17 00:00:00 2001 From: Daniel Dunbar Date: Tue, 13 Jan 2009 21:07:43 +0000 Subject: [PATCH] ccc: Darwin: Implement some important general argument translations for the Darwin tool chain. - Ideally we would localize these to tool specific argument processing but for now this matches gcc closely. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@62181 91177308-0d34-0410-b5e6-96231b3b80d8 --- tools/ccc/ccclib/Arguments.py | 19 ++++++++++++++++- tools/ccc/ccclib/Driver.py | 2 +- tools/ccc/ccclib/ToolChain.py | 40 +++++++++++++++++++++++++++++++++++ tools/ccc/ccclib/Tools.py | 16 +------------- 4 files changed, 60 insertions(+), 17 deletions(-) diff --git a/tools/ccc/ccclib/Arguments.py b/tools/ccc/ccclib/Arguments.py index a8a808bd4d..9471e4fced 100644 --- a/tools/ccc/ccclib/Arguments.py +++ b/tools/ccc/ccclib/Arguments.py @@ -396,6 +396,10 @@ class ArgList(object): 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): @@ -724,6 +728,10 @@ class OptionParser: self.f_exceptionsOption = self.addOption(FlagOption('-fexceptions', self.fGroup)) self.f_objcOption = self.addOption(FlagOption('-fobjc', self.fGroup)) self.f_openmpOption = self.addOption(FlagOption('-fopenmp', self.fGroup)) + self.f_constantCfstringsOption = self.addOption(FlagOption('-fconstant-cfstrings', self.fGroup)) + self.f_noConstantCfstringsOption = self.addOption(FlagOption('-fno-constant-cfstrings', self.fGroup)) + self.f_pascalStringsOption = self.addOption(FlagOption('-fpascal-strings', self.fGroup)) + self.f_noPascalStringsOption = self.addOption(FlagOption('-fno-pascal-strings', self.fGroup)) self.f_gnuRuntimeOption = self.addOption(FlagOption('-fgnu-runtime', self.fGroup)) self.f_mudflapOption = self.addOption(FlagOption('-fmudflap', self.fGroup)) self.f_mudflapthOption = self.addOption(FlagOption('-fmudflapth', self.fGroup)) @@ -745,6 +753,12 @@ class OptionParser: 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)) # Ugh. Need to disambiguate our naming convetion. -m x goes to @@ -761,7 +775,10 @@ class OptionParser: self.trigraphsOption = self.addOption(FlagOption('-trigraphs')) self.pedanticOption = self.addOption(FlagOption('-pedantic')) self.OOption = self.addOption(JoinedOption('-O')) - self.WOption = self.addOption(JoinedOption('-W')) + self.WGroup = OptionGroup('-W') + 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 # '='. diff --git a/tools/ccc/ccclib/Driver.py b/tools/ccc/ccclib/Driver.py index 310607c1da..429142cb66 100644 --- a/tools/ccc/ccclib/Driver.py +++ b/tools/ccc/ccclib/Driver.py @@ -335,7 +335,7 @@ class Driver(object): # revert to unknown. I think this is more likely a # bug / unintended behavior in gcc. Not very # important though. - inputType = ObjectType + inputType = Types.ObjectType # We claim things here so that options for which we silently allow # override only ever claim the used option. diff --git a/tools/ccc/ccclib/ToolChain.py b/tools/ccc/ccclib/ToolChain.py index 07ac926af1..1cb55fa2cf 100644 --- a/tools/ccc/ccclib/ToolChain.py +++ b/tools/ccc/ccclib/ToolChain.py @@ -74,6 +74,46 @@ class Darwin_X86_ToolChain(ToolChain): assert isinstance(action, Phases.JobAction) 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 + + 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: + if 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 + 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 diff --git a/tools/ccc/ccclib/Tools.py b/tools/ccc/ccclib/Tools.py index 1713a144ab..1b8db33597 100644 --- a/tools/ccc/ccclib/Tools.py +++ b/tools/ccc/ccclib/Tools.py @@ -390,20 +390,6 @@ class Darwin_X86_CompileTool(Tool): cmd_args.append(self.getBaseInputName(inputs, arglist)) arglist.addAllArgs(cmd_args, arglist.parser.dGroup) - - # FIXME: Figure out where these are coming from and - # dehardcode. - if not arglist.getLastArg(arglist.parser.m_macosxVersionMinOption): - cmd_args.append('-mmacosx-version-min=' + - self.toolChain.getMacosxVersionMin()) - if (not arglist.getLastArg(arglist.parser.m_32Option) and - not arglist.getLastArg(arglist.parser.m_64Option)): - if arglist.getValue(arch) == 'x86_64': - cmd_args.append('-m64') - else: - cmd_args.append('-m32') - if not arglist.getLastArg(arglist.parser.m_tuneOption): - cmd_args.append('-mtune=core2') arglist.addAllArgs(cmd_args, arglist.parser.mGroup) arglist.addAllArgs(cmd_args, arglist.parser.aGroup) @@ -428,7 +414,7 @@ class Darwin_X86_CompileTool(Tool): arglist.addAllArgs(cmd_args, arglist.parser.OOption) # FIXME: -Wall is getting some special treatment. Investigate. - arglist.addAllArgs2(cmd_args, arglist.parser.WOption, arglist.parser.pedanticOption) + arglist.addAllArgs2(cmd_args, arglist.parser.WGroup, arglist.parser.pedanticOption) 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): -- 2.40.0