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

diff --git a/tools/ccc/ccclib/Arguments.py b/tools/ccc/ccclib/Arguments.py
index a8a808bd4d0f3a1d31e1554e426045ab12151a5c..9471e4fced88027dddb0f885705ab31e5fe9e08c 100644 (file)
--- 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 310607c1da4ac9066f03916d019a04179e1286d4..429142cb669b1276b7ec6ce1696416ba84af46c9 100644 (file)
--- 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 07ac926af1eaeb875ccc8148426579baf9a2b026..1cb55fa2cfe705bdebdeb39b0fd368d71689bd60 100644 (file)
--- 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 1713a144abb194d5173ea9cf4e3bbb9a846413ae..1b8db3359733d5cc92c8d78becec77ee8587ad63 100644 (file)
--- 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):