Fixes for Windows on ARM.

* HostTarget::initWithBuiltins was overly complicated in a way that
  needs each triple to be spelled out. For non-Linux, we do not support
  cross-compilation and can just always use
  llvm::sys::getProcessTriple() + "-elf".
* MSVC on ARM defines _M_ARM64, not __aarch64__. Check that.
* We have special MinGW exceptions for where they use different function
  names than MSVC, but MinGW (MSYS) on ARM matches MSVC.

Author: hvdijk

modules/compiler/targets/host/source/target.cpp

@@ -175,76 +175,39 @@ compiler::Result HostTarget::initWithBuiltins(
   auto host_device_info =
       static_cast<host::device_info_s &>(*compiler_info->device_info);
 
-  switch (host_device_info.arch) {
-    case host::arch::ARM:
-      assert(host::os::LINUX == host_device_info.os &&
-             "ARM cross-compile only supports Linux");
-      // For cross compiled ARM builds, we can't rely on sys::getProcessTriple
-      // to determine our target. Instead, we set it to a known working triple.
-      triple = llvm::Triple("armv7-unknown-linux-gnueabihf-elf");
-      break;
-    case host::arch::AARCH64:
-      switch (host_device_info.os) {
-        case host::os::LINUX:
+  switch (host_device_info.os) {
+    case host::os::ANDROID:
+    case host::os::LINUX:
+      // For Linux, we support cross compilation, which means we cannot rely on
+      // sys::getProcessTriple to determine our target. Instead, we set it to a
+      // known working triple.
+      switch (host_device_info.arch) {
+        case host::arch::ARM:
+          triple = llvm::Triple("armv7-unknown-linux-gnueabihf-elf");
+          break;
+        case host::arch::AARCH64:
           triple = llvm::Triple("aarch64-linux-gnu-elf");
           break;
-        case host::os::MACOS:
-          assert(host_device_info.native &&
-                 "macOS cross-compile not supported");
-          // Our generated code does not meet Mach-O restrictions: "mach-o
-          // section specifier requires a segment and section separated by a
-          // comma" when we use "notes" as a section name. Force ELF generation
-          // instead, which makes things easier for us anyway as we can reuse
-          // the existing ELF loading logic.
-          triple = llvm::Triple(llvm::sys::getProcessTriple() + "-elf");
+        case host::arch::RISCV32:
+          triple = llvm::Triple("riscv32-unknown-elf");
           break;
-        default:
-          llvm_unreachable("AArch64 cross-compile only supports Linux");
-      }
-      break;
-    case host::arch::RISCV32:
-      assert(host::os::LINUX == host_device_info.os &&
-             "RISCV cross-compile only supports Linux");
-      // For cross compiled RISCV builds, we can't rely on sys::getProcessTriple
-      // to determine our target. Instead, we set it to a known working triple.
-      triple = llvm::Triple("riscv32-unknown-elf");
-      break;
-    case host::arch::RISCV64:
-      assert(host::os::LINUX == host_device_info.os &&
-             "RISCV cross-compile only supports Linux");
-      triple = llvm::Triple("riscv64-unknown-elf");
-      break;
-    case host::arch::X86:
-    case host::arch::X86_64:
-      switch (host_device_info.os) {
-        case host::os::ANDROID:
-        case host::os::LINUX:
-          triple = llvm::Triple(host::arch::X86 == host_device_info.arch
-                                    ? "i386-unknown-unknown-elf"
-                                    : "x86_64-unknown-unknown-elf");
+        case host::arch::RISCV64:
+          triple = llvm::Triple("riscv64-unknown-elf");
           break;
-        case host::os::WINDOWS:
-          // Using windows here ensures that _chkstk() is called which is
-          // important for paging in the stack.
-#if defined(__MINGW32__) || defined(__MINGW64__)
-          triple = llvm::Triple(host::arch::X86 == host_device_info.arch
-                                    ? "i386-pc-windows-gnu-elf"
-                                    : "x86_64-w64-windows-gnu-elf");
-#else
-          triple = llvm::Triple(host::arch::X86 == host_device_info.arch
-                                    ? "i386-pc-windows-msvc-elf"
-                                    : "x86_64-pc-windows-msvc-elf");
-#endif
+        case host::arch::X86:
+          triple = llvm::Triple("i386-unknown-unknown-elf");
           break;
-        case host::os::MACOS:
-          assert(host_device_info.native &&
-                 "macOS cross-compile not supported");
-          // On Apple, the MachO loader has a bug and can't JIT correctly. We
-          // have to force elf generation for MachO builds. See Redmine #7621.
-          triple = llvm::Triple(llvm::sys::getProcessTriple() + "-elf");
+        case host::arch::X86_64:
+          triple = llvm::Triple("x86_64-unknown-unknown-elf");
           break;
       }
       break;
+    case host::os::WINDOWS:
+    case host::os::MACOS:
+      assert(host_device_info.native &&
+             "Cross compilation only supported for Linux");
+      triple = llvm::Triple(llvm::sys::getProcessTriple() + "-elf");
+      break;
   }
 
   std::string CPU;

modules/mux/targets/host/test/UnitCL/host_clGetDeviceInfo.cpp

@@ -49,7 +49,7 @@ TEST_F(host_clGetDeviceInfoTest, Name) {
 #if defined(__arm__) || defined(__thumb__) || defined(_M_ARM) || \
     defined(_M_ARMT)
   const char *arch = "Arm";
-#elif defined(__aarch64__)
+#elif defined(__aarch64__) || defined(_M_ARM64)
   const char *arch = "AArch64";
 #elif defined(__i386__) || defined(_M_IX86)
   const char *arch = "x86";

modules/utils/include/utils/system.h

@@ -27,14 +27,14 @@
 /// @{
 
 #if defined(__x86_64__) || defined(_M_X64) || defined(__aarch64__) || \
-    (defined(__riscv) && __riscv_xlen == 64)
+    defined(_M_ARM64) || (defined(__riscv) && __riscv_xlen == 64)
 #define UTILS_SYSTEM_64_BIT 1
 #else
 #define UTILS_SYSTEM_32_BIT 1
 #endif
 
 #if defined(__arm__) || defined(__thumb__) || defined(_M_ARM) || \
-    defined(_M_ARMT) || defined(__aarch64__)
+    defined(_M_ARMT) || defined(__aarch64__) || defined(_M_ARM64)
 #define UTILS_SYSTEM_ARM 1
 #elif defined(__i386__) || defined(_M_IX86) || defined(__x86_64__) || \
     defined(_M_X64)

modules/utils/targets/host/source/relocations.cpp

@@ -42,21 +42,21 @@
 extern "C" {
 
 // Windows uses chkstk() to ensure there is enough stack space paged in.
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__)
+#if defined(_MSC_VER) || !defined(UTILS_SYSTEM_X86)
 #if defined(UTILS_SYSTEM_64_BIT)
 extern void __chkstk();
 #else
 extern void _chkstk();
-#endif
-#endif  // _MSC_VER
-
-#if defined(__MINGW32__) || defined(__MINGW64__)
+#endif  // UTILS_SYSTEM_64_BIT
+#else   // _MSC_VER || !UTILS_SYSTEM_X86
 #if defined(UTILS_SYSTEM_64_BIT)
 extern void ___chkstk_ms();
 #else
 extern void(_alloca)();
-#endif
-#endif
+#endif  // UTILS_SYSTEM_64_BIT
+#endif  // _MSC_VER || !UTILS_SYSTEM_X86
+#endif  // _MSC_VER || __MINGW32__ || __MINGW64__
 
 #if defined(UTILS_SYSTEM_32_BIT)
 // On 32-bit (both x86 and Arm) long division is done in software.
@@ -165,21 +165,21 @@ std::vector<std::pair<std::string, uint64_t>> getRelocations() {
 #endif  // NDEBUG
       {"memmove", reinterpret_cast<uint64_t>(&memmove)},
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__)
+#if defined(_MSC_VER) || !defined(UTILS_SYSTEM_X86)
 #if defined(UTILS_SYSTEM_64_BIT)
       {"__chkstk", reinterpret_cast<uint64_t>(&__chkstk)},
 #else
       {"_chkstk", reinterpret_cast<uint64_t>(&_chkstk)},
 #endif  // UTILS_SYSTEM_64_BIT
-#endif  // _MSC_VER
-
-#if defined(__MINGW32__) || defined(__MINGW64__)
+#else   // _MSC_VER || !UTILS_SYSTEM_X86
 #if defined(UTILS_SYSTEM_64_BIT)
       {"___chkstk_ms", reinterpret_cast<uint64_t>(&___chkstk_ms)},
 #else
       {"_alloca", reinterpret_cast<uint64_t>(&_alloca)},
 #endif  // UTILS_SYSTEM_64_BIT
-#endif  // _MSC_VER
+#endif  // _MSC_VER || !UTILS_SYSTEM_X86
+#endif  // _MSC_VER || __MINGW32__ || __MINGW64__
 
 #if defined(UTILS_SYSTEM_32_BIT)
       {"__divdi3", reinterpret_cast<uint64_t>(&__divdi3)},