Add -mno-iamcu option

[aturetsk]

Summary

Add -mno-iamcu option to:

1. Countervail -miamcu option easily
2. Be compatible with GCC which supports this option

[echristo]

OK.

-eric

cfe/trunk/include/clang/Driver/Options.td

def mqdsp6_compat : Flag<["-"], "mqdsp6-compat">, Group<m_Group>, Flags<[DriverOption,CC1Option]>,
   HelpText<"Enable hexagon-qdsp6 backward compatibility">;
 def m3dnowa : Flag<["-"], "m3dnowa">, Group<m_x86_Features_Group>;
 def m3dnow : Flag<["-"], "m3dnow">, Group<m_x86_Features_Group>;
 def m64 : Flag<["-"], "m64">, Group<m_Group>, Flags<[DriverOption, CoreOption]>;
 def mx32 : Flag<["-"], "mx32">, Group<m_Group>, Flags<[DriverOption, CoreOption]>;
 def mabi_EQ : Joined<["-"], "mabi=">, Group<m_Group>;
 def miamcu : Flag<["-"], "miamcu">, Group<m_Group>, Flags<[DriverOption, CoreOption]>,
   HelpText<"Use Intel MCU ABI">;
+def mno_iamcu : Flag<["-"], "mno-iamcu">, Group<m_Group>, Flags<[DriverOption, CoreOption]>;
 def malign_functions_EQ : Joined<["-"], "malign-functions=">, Group<clang_ignored_m_Group>;
 def malign_loops_EQ : Joined<["-"], "malign-loops=">, Group<clang_ignored_m_Group>;
 def malign_jumps_EQ : Joined<["-"], "malign-jumps=">, Group<clang_ignored_m_Group>;
 def mfancy_math_387 : Flag<["-"], "mfancy-math-387">, Group<clang_ignored_m_Group>;
 def mtvos_version_min_EQ : Joined<["-"], "mtvos-version-min=">, Group<m_Group>;
 def mappletvos_version_min_EQ : Joined<["-"], "mappletvos-version-min=">, Alias<mtvos_version_min_EQ>;
 def mtvos_simulator_version_min_EQ : Joined<["-"], "mtvos-simulator-version-min=">, Alias<mtvos_version_min_EQ>;
 def mappletvsimulator_version_min_EQ : Joined<["-"], "mappletvsimulator-version-min=">, Alias<mtvos_version_min_EQ>;

cfe/trunk/lib/Driver/Driver.cpp

if (A->getOption().matches(options::OPT__DASH_DASH)) {
         DAL->append(MakeInputArg(*DAL, Opts, Val));
       continue;
     }
 
     DAL->append(A);
   }
 
   // Enforce -static if -miamcu is present.
-  if (Args.hasArg(options::OPT_miamcu))
+  if (Arg *Ar = Args.getLastArg(options::OPT_miamcu, options::OPT_mno_iamcu))
+    if (Ar->getOption().matches(options::OPT_miamcu))
       DAL->AddFlagArg(0, Opts->getOption(options::OPT_static));
 
 // Add a default value of -mlinker-version=, if one was given and the user
 // didn't specify one.
 #if defined(HOST_LINK_VERSION)
   if (!Args.hasArg(options::OPT_mlinker_version_EQ) &&
       strlen(HOST_LINK_VERSION) > 0) {
     DAL->AddJoinedArg(0, Opts->getOption(options::OPT_mlinker_version_EQ),
                       HOST_LINK_VERSION);
if (A->getOption().matches(options::OPT_m64)) {
       Target.setEnvironment(llvm::Triple::CODE16);
     }
 
     if (AT != llvm::Triple::UnknownArch && AT != Target.getArch())
       Target.setArch(AT);
   }
 
   // Handle -miamcu flag.
-  if (Args.hasArg(options::OPT_miamcu)) {
+  if (Arg *Ar = Args.getLastArg(options::OPT_miamcu, options::OPT_mno_iamcu)) {
+    if (Ar->getOption().matches(options::OPT_miamcu)) {
       if (Target.get32BitArchVariant().getArch() != llvm::Triple::x86)
         D.Diag(diag::err_drv_unsupported_opt_for_target) << "-miamcu"
                                                          << Target.str();
 
       if (A && !A->getOption().matches(options::OPT_m32))
         D.Diag(diag::err_drv_argument_not_allowed_with)
             << "-miamcu" << A->getBaseArg().getAsString(Args);
 
       Target.setArch(llvm::Triple::x86);
       Target.setArchName("i586");
       Target.setEnvironment(llvm::Triple::UnknownEnvironment);
       Target.setEnvironmentName("");
       Target.setOS(llvm::Triple::ELFIAMCU);
       Target.setVendor(llvm::Triple::UnknownVendor);
       Target.setVendorName("intel");
     }
+  }
 
   return Target;
 }
 
 // \brief Parse the LTO options and record the type of LTO compilation
 // based on which -f(no-)?lto(=.*)? option occurs last.
 void Driver::setLTOMode(const llvm::opt::ArgList &Args) {
   LTOMode = LTOK_None;

cfe/trunk/lib/Driver/Tools.cpp

if (Value == "intel" || Value == "att") {
       CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
     } else {
       getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
           << A->getOption().getName() << Value;
     }
   }
 
   // Set flags to support MCU ABI.
-  if (Args.hasArg(options::OPT_miamcu)) {
+  if (Arg *A = Args.getLastArg(options::OPT_miamcu, options::OPT_mno_iamcu)) {
+    if (A->getOption().matches(options::OPT_miamcu)) {
       CmdArgs.push_back("-mfloat-abi");
       CmdArgs.push_back("soft");
       CmdArgs.push_back("-mstack-alignment=4");
     }
   }
+}
 
 void Clang::AddHexagonTargetArgs(const ArgList &Args,
                                  ArgStringList &CmdArgs) const {
   CmdArgs.push_back("-mqdsp6-compat");
   CmdArgs.push_back("-Wreturn-type");
 
   if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
     std::string N = llvm::utostr(G.getValue());

cfe/trunk/test/Driver/miamcu-opt.c

 // REQUIRES: clang-driver
 // REQUIRES: x86-registered-target
 //
 // RUN: %clang -miamcu -no-canonical-prefixes %s -### -o %t.o 2>&1 | FileCheck %s
 // RUN: %clang -miamcu -no-canonical-prefixes -m32 %s -### -o %t.o 2>&1 | FileCheck %s
 // RUN: %clang -miamcu -no-canonical-prefixes -target x86_64-unknown-linux-gnu %s -### -o %t.o 2>&1 | FileCheck %s
+// RUN: %clang -mno-iamcu -miamcu -no-canonical-prefixes %s -### -o %t.o 2>&1 | FileCheck %s
 // RUN: %clang -miamcu -no-canonical-prefixes -m64 %s -### -o %t.o 2>&1 | FileCheck %s -check-prefix=M64
 // RUN: %clang -miamcu -no-canonical-prefixes -dynamic %s -### -o %t.o 2>&1 | FileCheck %s -check-prefix=DYNAMIC
 // RUN: %clang -miamcu -no-canonical-prefixes  -target armv8-eabi %s -### -o %t.o 2>&1 | FileCheck %s -check-prefix=NOT-X86
+// RUN: %clang -miamcu -mno-iamcu -no-canonical-prefixes -target x86_64-unknown-linux-gnu %s -### -o %t.o 2>&1 | FileCheck %s -check-prefix=MNOIAMCU
 
 // M64: error: invalid argument '-miamcu' not allowed with '-m64'
 
 // DYNAMIC: error: invalid argument '-dynamic' not allowed with '-static'
 
 // NOT-X86: error: unsupported option '-miamcu' for target 'armv8---eabi'
 
+// MNOIAMCU-NOT: "-triple" "i586-intel-elfiamcu"
+
 // CHECK: "{{.*}}clang{{.*}}" "-cc1"
 // CHECK: "-triple" "i586-intel-elfiamcu"
 // CHECK: "-static-define"
 // CHECK: "-mfloat-abi" "soft"
 // CHECK: "-mstack-alignment=4"
 
 // CHECK: "{{.*}}ld{{(.exe)?}}"
 // CHECK: "-m" "elf_iamcu"
 // CHECK: "-static"
 // CHECK-NOT: crt1
 // CHECK-NOT: crti
 // CHECK-NOT: ctrbegin
 // CHECK: crt0
 // CHECK: "--start-group" "-lgcc" "-lc" "-lgloss" "--end-group" "--as-needed" "-lsoftfp" "--no-as-needed"
 // CHECK-NOT: crtend
 // CHECK-NOT: ctrn