Introduction of -miamcu option

[aturetsk]

Summary

Add initial support of -miamcu option which triggers MCU ABI.

[aturetsk]

Extended to take into account recent MCU related changes

[aturetsk]

The patch will be completely reworked and extended to support compilation for MCU.

include/clang/Driver/Options.td

 def m32 : Flag<["-"], "m32">, Group<m_Group>, Flags<[DriverOption, CoreOption]>;
 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 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>;

lib/Driver/Tools.h

 
 /// \brief Clang integrated assembler tool.
 class LLVM_LIBRARY_VISIBILITY ClangAs : public Tool {
 public:
   ClangAs(const ToolChain &TC)
       : Tool("clang::as", "clang integrated assembler", TC, RF_Full) {}
   void AddMIPSTargetArgs(const llvm::opt::ArgList &Args,
                          llvm::opt::ArgStringList &CmdArgs) const;
+  void AddX86TargetArgs(const llvm::opt::ArgList &Args,
+                        llvm::opt::ArgStringList &CmdArgs) const;
   bool hasGoodDiagnostics() const override { return true; }
   bool hasIntegratedAssembler() const override { return false; }
   bool hasIntegratedCPP() const override { return false; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;

lib/Driver/Tools.cpp

if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
     if (Value == "intel" || Value == "att") {
       CmdArgs.push_back("-mllvm");
       CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
     } else {
       getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
           << A->getOption().getName() << Value;
     }
   }
+
+  // If -miamcu is set then set flags to support MCU ABI and use MCU triple.
+  if (Args.getLastArg(options::OPT_miamcu)) {
+    if (getToolChain().getArch() != llvm::Triple::x86)
+      getToolChain().getDriver().Diag(diag::err_drv_unsupported_opt)
+          << "-miamcu";
+    CmdArgs.push_back("-triple");
+    CmdArgs.push_back("i586-intel-elfiamcu");
+    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 (const char *v =
void ClangAs::AddMIPSTargetArgs(const ArgList &Args,
   StringRef ABIName;
   const llvm::Triple &Triple = getToolChain().getTriple();
   mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
 
   CmdArgs.push_back("-target-abi");
   CmdArgs.push_back(ABIName.data());
 }
 
+void ClangAs::AddX86TargetArgs(const ArgList &Args,
+                               ArgStringList &CmdArgs) const {
+  // If -miamcu is set then use MCU triple.
+  if (Args.getLastArg(options::OPT_miamcu)) {
+    if (getToolChain().getArch() != llvm::Triple::x86)
+      getToolChain().getDriver().Diag(diag::err_drv_unsupported_opt)
+          << "-miamcu";
+    CmdArgs.push_back("-triple");
+    CmdArgs.push_back("i586-intel-elfiamcu");
+  }
+}
+
 void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
                            const InputInfo &Output, const InputInfoList &Inputs,
                            const ArgList &Args,
                            const char *LinkingOutput) const {
   ArgStringList CmdArgs;
 
   assert(Inputs.size() == 1 && "Unexpected number of inputs.");
   const InputInfo &Input = Inputs[0];
default:
     break;
 
   case llvm::Triple::mips:
   case llvm::Triple::mipsel:
   case llvm::Triple::mips64:
   case llvm::Triple::mips64el:
     AddMIPSTargetArgs(Args, CmdArgs);
     break;
+
+  case llvm::Triple::x86:
+  case llvm::Triple::x86_64:
+    AddX86TargetArgs(Args, CmdArgs);
+    break;
   }
 
   // Consume all the warning flags. Usually this would be handled more
   // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
   // doesn't handle that so rather than warning about unused flags that are
   // actually used, we'll lie by omission instead.
   // FIXME: Stop lying and consume only the appropriate driver flags
   for (const Arg *A : Args.filtered(options::OPT_W_Group))

test/Driver/miamcu-opt.c

+// RUN: %clang -m32 -miamcu %s -### -o %t.o 2>&1 | FileCheck %s -check-prefix=M32
+// RUN: %clang -m64 -miamcu %s -### -o %t.o 2>&1 | FileCheck %s -check-prefix=M64
+
+// M32-NOT: error: unsupported option '-miamcu'
+// M32: "-cc1"
+// M32: "-triple" "i586-intel-elfiamcu"
+// M32: "-mfloat-abi" "soft"
+// M32: "-mstack-alignment=4"
+
+// M64: error: unsupported option '-miamcu'
+// M64: "-cc1"

test/Driver/miamcu-opt.s

+// RUN: %clang -m32 -miamcu %s -### -o %t.o 2>&1 | FileCheck %s -check-prefix=M32
+// RUN: %clang -m64 -miamcu %s -### -o %t.o 2>&1 | FileCheck %s -check-prefix=M64
+
+// M32-NOT: error: unsupported option '-miamcu'
+// M32: "-cc1as"
+// M32: "-triple" "i586-intel-elfiamcu"
+
+// M64: error: unsupported option '-miamcu'
+// M64: "-cc1as"