[AArch64] Add support for a MinGW AArch64 target

[mstorsjo]

Summary

The machine name arm64pe passed to the linker is completely made up; gnu binutils doesn't (afaik) support this, so it only has to match what the corresponding (not yet merged) lld linker supports - similarly to the existing thumb2pe machine name.

[compnerd]

lib/Driver/ToolChains/MinGW.cpp

122–131 ↗

(On Diff #109890)

Can you use a switch here instead?

[mstorsjo]

lib/Driver/ToolChains/MinGW.cpp

122–131 ↗

(On Diff #109890)

Sure, I can change that.

What do you think about the llvm_unreachable part btw? There's nothing stopping a user from trigger that with e.g. -target mips-windows-gnu, and in release builds, such a default: llvm_unreachable() case usually ends up as just running one of the existing cases. Should it be changed into a real runtime error that isn't optimized out from release builds?

[martell]

lib/Driver/ToolChains/MinGW.cpp

129 ↗

(On Diff #109890)

I believe the reason I used thumb2pe for the arm triple is because MS gave us a watered down thumb environment.
If I remember correctly there was also an armce environment in binutils called thumbpe because it was thumb 1 mode.
Anyway, I assume aarch64 on windows is a fully fledged arm64 environment that doesn't use thumb mode over arm64?
I know we don't have any real sdk for this but are you able to tell from link.exe martin?
On arm the branch for a dll call would always set the bit for thumb mode in the instruction.
Although when I think about it arm64pe is probably the most suitable name anyway because we already use thumb2pe

[mstorsjo]

Updated to use a switch, added a mapping of a missed case of thumb while reformatting the if to a switch.

[mstorsjo]

lib/Driver/ToolChains/MinGW.cpp

129 ↗

(On Diff #109890)

There's no thumb mode at all in 64 bit mode (yet at least), so naming it thumb* wouldn't make sense. Modelling the previous name after the old thumbpe makes sense though.

[martell]

lib/Driver/ToolChains/MinGW.cpp

129 ↗

(On Diff #109890)

Great, thanks. Just wanted to clarify because we never had a discussion about the naming.
LGTM

[martell]

lib/Driver/ToolChains/MinGW.cpp

130 ↗

(On Diff #109916)

I believe this was left incase someone wanted to do windows ce in future.
Can you add a todo like in CrossWindows.cpp in this case
// FIXME: this is incorrect for WinCE
or if we don't care about WinCE anymore just remove the TODO from CrossWindows?

[mstorsjo]

lib/Driver/ToolChains/MinGW.cpp

130 ↗

(On Diff #109916)

Sure, I can add a todo. I wanted to add it, since technically, the modern windows on arm stuff is thumb, we should handle it if the user uses the triple thumbv7-windows-gnu (iirc, some of the tests do).

[mstorsjo]

Added a fixme comment about this being incorrect for WinCE.

[martell]

LGTM

[mstorsjo]

@compnerd - are you ok with this one as well?

[compnerd]

Yeah, I think that this is okay.

cfe/trunk/lib/Basic/Targets.cpp

case llvm::Triple::Fuchsia:
       return new FuchsiaTargetInfo<AArch64leTargetInfo>(Triple, Opts);
     case llvm::Triple::Linux:
       return new LinuxTargetInfo<AArch64leTargetInfo>(Triple, Opts);
     case llvm::Triple::NetBSD:
       return new NetBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
     case llvm::Triple::OpenBSD:
       return new OpenBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
     case llvm::Triple::Win32:
+      switch (Triple.getEnvironment()) {
+      case llvm::Triple::GNU:
+        return new MinGWARM64TargetInfo(Triple, Opts);
+      case llvm::Triple::MSVC:
+      default: // Assume MSVC for unknown environments
         return new MicrosoftARM64TargetInfo(Triple, Opts);
+      }
     default:
       return new AArch64leTargetInfo(Triple, Opts);
     }
 
   case llvm::Triple::aarch64_be:
     switch (os) {
     case llvm::Triple::FreeBSD:
       return new FreeBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts);

cfe/trunk/lib/Basic/Targets/AArch64.h

public:
   AArch64leTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts);
 
   void getTargetDefines(const LangOptions &Opts,
                             MacroBuilder &Builder) const override;
 private:
   void setDataLayout() override;
 };
 
-class LLVM_LIBRARY_VISIBILITY MicrosoftARM64TargetInfo
+class LLVM_LIBRARY_VISIBILITY WindowsARM64TargetInfo
     : public WindowsTargetInfo<AArch64leTargetInfo> {
   const llvm::Triple Triple;
 
 public:
-  MicrosoftARM64TargetInfo(const llvm::Triple &Triple,
-                           const TargetOptions &Opts);
+  WindowsARM64TargetInfo(const llvm::Triple &Triple,
 
   void setDataLayout() override;
 
+  BuiltinVaListKind getBuiltinVaListKind() const override;
+
+  CallingConvCheckResult checkCallingConvention(CallingConv CC) const override;
+};
+
+// Windows ARM, MS (C++) ABI
+class LLVM_LIBRARY_VISIBILITY MicrosoftARM64TargetInfo
+    : public WindowsARM64TargetInfo {
+public:
+  MicrosoftARM64TargetInfo(const llvm::Triple &Triple,
+                           const TargetOptions &Opts);
+
   void getVisualStudioDefines(const LangOptions &Opts,
                               MacroBuilder &Builder) const;
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
+};
 
-  BuiltinVaListKind getBuiltinVaListKind() const override;
+// ARM64 MinGW target
+class LLVM_LIBRARY_VISIBILITY MinGWARM64TargetInfo
+    : public WindowsARM64TargetInfo {
+public:
+  MinGWARM64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts);
 
-  CallingConvCheckResult checkCallingConvention(CallingConv CC) const override;
+  void getTargetDefines(const LangOptions &Opts,
+                        MacroBuilder &Builder) const override;
 };
 
 class LLVM_LIBRARY_VISIBILITY AArch64beTargetInfo : public AArch64TargetInfo {
 public:
   AArch64beTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts);
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
 

cfe/trunk/lib/Basic/Targets/AArch64.cpp

void AArch64beTargetInfo::getTargetDefines(const LangOptions &Opts,
   AArch64TargetInfo::getTargetDefines(Opts, Builder);
 }
 
 void AArch64beTargetInfo::setDataLayout() {
   assert(!getTriple().isOSBinFormatMachO());
   resetDataLayout("E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128");
 }
 
-MicrosoftARM64TargetInfo::MicrosoftARM64TargetInfo(const llvm::Triple &Triple,
-                                                   const TargetOptions &Opts)
+WindowsARM64TargetInfo::WindowsARM64TargetInfo(const llvm::Triple &Triple,
     : WindowsTargetInfo<AArch64leTargetInfo>(Triple, Opts), Triple(Triple) {
 
   // This is an LLP64 platform.
   // int:4, long:4, long long:8, long double:8.
   WCharType = UnsignedShort;
   IntWidth = IntAlign = 32;
   LongWidth = LongAlign = 32;
   DoubleAlign = LongLongAlign = 64;
   LongDoubleWidth = LongDoubleAlign = 64;
   LongDoubleFormat = &llvm::APFloat::IEEEdouble();
   IntMaxType = SignedLongLong;
   Int64Type = SignedLongLong;
   SizeType = UnsignedLongLong;
   PtrDiffType = SignedLongLong;
   IntPtrType = SignedLongLong;
-
-  TheCXXABI.set(TargetCXXABI::Microsoft);
 }
 
-void MicrosoftARM64TargetInfo::setDataLayout() {
+void WindowsARM64TargetInfo::setDataLayout() {
   resetDataLayout("e-m:w-p:64:64-i32:32-i64:64-i128:128-n32:64-S128");
 }
 
-void MicrosoftARM64TargetInfo::getVisualStudioDefines(
-    const LangOptions &Opts, MacroBuilder &Builder) const {
-  WindowsTargetInfo<AArch64leTargetInfo>::getVisualStudioDefines(Opts, Builder);
-  Builder.defineMacro("_WIN32", "1");
-  Builder.defineMacro("_WIN64", "1");
-  Builder.defineMacro("_M_ARM64", "1");
-}
-
-void MicrosoftARM64TargetInfo::getTargetDefines(const LangOptions &Opts,
-                                                MacroBuilder &Builder) const {
-  WindowsTargetInfo::getTargetDefines(Opts, Builder);
-  getVisualStudioDefines(Opts, Builder);
-}
-
 TargetInfo::BuiltinVaListKind
-MicrosoftARM64TargetInfo::getBuiltinVaListKind() const {
+WindowsARM64TargetInfo::getBuiltinVaListKind() const {
   return TargetInfo::CharPtrBuiltinVaList;
 }
 
 TargetInfo::CallingConvCheckResult
-MicrosoftARM64TargetInfo::checkCallingConvention(CallingConv CC) const {
+WindowsARM64TargetInfo::checkCallingConvention(CallingConv CC) const {
   switch (CC) {
   case CC_X86StdCall:
   case CC_X86ThisCall:
   case CC_X86FastCall:
   case CC_X86VectorCall:
     return CCCR_Ignore;
   case CC_C:
   case CC_OpenCLKernel:
   case CC_Win64:
     return CCCR_OK;
   default:
     return CCCR_Warning;
   }
 }
 
+MicrosoftARM64TargetInfo::MicrosoftARM64TargetInfo(const llvm::Triple &Triple,
+                                                   const TargetOptions &Opts)
+    : WindowsARM64TargetInfo(Triple, Opts) {
+  TheCXXABI.set(TargetCXXABI::Microsoft);
+}
+
+void MicrosoftARM64TargetInfo::getVisualStudioDefines(
+    const LangOptions &Opts, MacroBuilder &Builder) const {
+  WindowsTargetInfo<AArch64leTargetInfo>::getVisualStudioDefines(Opts, Builder);
+  Builder.defineMacro("_WIN32", "1");
+  Builder.defineMacro("_WIN64", "1");
+  Builder.defineMacro("_M_ARM64", "1");
+}
+
+void MicrosoftARM64TargetInfo::getTargetDefines(const LangOptions &Opts,
+                                                MacroBuilder &Builder) const {
+  WindowsTargetInfo::getTargetDefines(Opts, Builder);
+  getVisualStudioDefines(Opts, Builder);
+}
+
+MinGWARM64TargetInfo::MinGWARM64TargetInfo(const llvm::Triple &Triple,
+                                           const TargetOptions &Opts)
+    : WindowsARM64TargetInfo(Triple, Opts) {
+  TheCXXABI.set(TargetCXXABI::GenericAArch64);
+}
+
+void MinGWARM64TargetInfo::getTargetDefines(const LangOptions &Opts,
+                                            MacroBuilder &Builder) const {
+  WindowsTargetInfo::getTargetDefines(Opts, Builder);
+  Builder.defineMacro("_WIN32", "1");
+  Builder.defineMacro("_WIN64", "1");
+  Builder.defineMacro("WIN32", "1");
+  Builder.defineMacro("WIN64", "1");
+  addMinGWDefines(Opts, Builder);
+}
+
+
 DarwinAArch64TargetInfo::DarwinAArch64TargetInfo(const llvm::Triple &Triple,
                                                  const TargetOptions &Opts)
     : DarwinTargetInfo<AArch64leTargetInfo>(Triple, Opts) {
   Int64Type = SignedLongLong;
   WCharType = SignedInt;
   UseSignedCharForObjCBool = false;
 
   LongDoubleWidth = LongDoubleAlign = SuitableAlign = 64;

cfe/trunk/lib/Driver/ToolChains/CrossWindows.cpp

void tools::CrossWindows::Assembler::ConstructJob(
   ArgStringList CmdArgs;
   const char *Exec;
 
   switch (TC.getArch()) {
   default:
     llvm_unreachable("unsupported architecture");
   case llvm::Triple::arm:
   case llvm::Triple::thumb:
+  case llvm::Triple::aarch64:
     break;
   case llvm::Triple::x86:
     CmdArgs.push_back("--32");
     break;
   case llvm::Triple::x86_64:
     CmdArgs.push_back("--64");
     break;
   }
void tools::CrossWindows::Linker::ConstructJob(
   switch (TC.getArch()) {
   default:
     llvm_unreachable("unsupported architecture");
   case llvm::Triple::arm:
   case llvm::Triple::thumb:
     // FIXME: this is incorrect for WinCE
     CmdArgs.push_back("thumb2pe");
     break;
+  case llvm::Triple::aarch64:
+    CmdArgs.push_back("arm64pe");
+    break;
   case llvm::Triple::x86:
     CmdArgs.push_back("i386pe");
     EntryPoint.append("_");
     break;
   case llvm::Triple::x86_64:
     CmdArgs.push_back("i386pep");
     break;
   }
 
   if (Args.hasArg(options::OPT_shared)) {
     switch (T.getArch()) {
     default:
       llvm_unreachable("unsupported architecture");
+    case llvm::Triple::aarch64:
     case llvm::Triple::arm:
     case llvm::Triple::thumb:
     case llvm::Triple::x86_64:
       EntryPoint.append("_DllMainCRTStartup");
       break;
     case llvm::Triple::x86:
       EntryPoint.append("_DllMainCRTStartup@12");
       break;

cfe/trunk/lib/Driver/ToolChains/MinGW.cpp

void tools::MinGW::Linker::ConstructJob(Compilation &C, const JobAction &JA,
 
   if (!D.SysRoot.empty())
     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
 
   if (Args.hasArg(options::OPT_s))
     CmdArgs.push_back("-s");
 
   CmdArgs.push_back("-m");
-  if (TC.getArch() == llvm::Triple::x86)
+  switch (TC.getArch()) {
+  case llvm::Triple::x86:
     CmdArgs.push_back("i386pe");
-  if (TC.getArch() == llvm::Triple::x86_64)
+    break;
+  case llvm::Triple::x86_64:
     CmdArgs.push_back("i386pep");
-  if (TC.getArch() == llvm::Triple::arm)
+    break;
+  case llvm::Triple::arm:
+  case llvm::Triple::thumb:
+    // FIXME: this is incorrect for WinCE
     CmdArgs.push_back("thumb2pe");
+    break;
+  case llvm::Triple::aarch64:
+    CmdArgs.push_back("arm64pe");
+    break;
+  default:
+    llvm_unreachable("Unsupported target architecture.");
+  }
 
   if (Args.hasArg(options::OPT_mwindows)) {
     CmdArgs.push_back("--subsystem");
     CmdArgs.push_back("windows");
   } else if (Args.hasArg(options::OPT_mconsole)) {
     CmdArgs.push_back("--subsystem");
     CmdArgs.push_back("console");
   }

cfe/trunk/test/Preprocessor/predefined-macros.c

 // MSCOPE:#define __OPENCL_MEMORY_SCOPE_WORK_ITEM 0
 
 // RUN: %clang_cc1 -triple aarch64-windows %s -E -dM -o - \
 // RUN:   | FileCheck -match-full-lines %s --check-prefix=CHECK-ARM64-WIN
 
 // CHECK-ARM64-WIN: #define _M_ARM64 1
 // CHECK-ARM64-WIN: #define _WIN32 1
 // CHECK-ARM64-WIN: #define _WIN64 1
+
+// RUN: %clang_cc1 -triple aarch64-windows-gnu %s -E -dM -o - \
+// RUN:   | FileCheck -match-full-lines %s --check-prefix=CHECK-ARM64-MINGW
+
+// CHECK-ARM64-MINGW-NOT: #define _M_ARM64 1
+// CHECK-ARM64-MINGW: #define WIN32 1
+// CHECK-ARM64-MINGW: #define WIN64 1
+// CHECK-ARM64-MINGW: #define _WIN32 1
+// CHECK-ARM64-MINGW: #define _WIN64 1
+// CHECK-ARM64-MINGW: #define __aarch64__ 1