[AArch64] Wire up ILP32 ABI support in Clang

[Amanieu]

Summary

This is a follow-up to D94143 which added the necessary support in LLVM.

ILP32 mode is enabled by specifying an ILP32 target (aarch64[_be]-*-gnu_ilp32) with -target.

[Amanieu]

Ping.

[Amanieu]

Ping.

[nickdesaulniers]

The linux kernel uses a build time invocation of the compiler for feature detection of the -mabi=lp64 command line flag, which clang-16 currently doesn't support.

Looking at https://gcc.gnu.org/onlinedocs/gcc/AArch64-Options.html, it looks like an alternate value of -mabi=ilp32. Should this patch wire that up in clang?

[Amanieu]

The situation around -mabi for AArch64 is a bit awkward: Clang uses it to select the ARM64 calling convention (-mabi=aapcs vs -mabi=darwinpcs) while GCC uses it to select between LP64 and ILP32. I'm not sure how we should be handling this.

[MaskRay]

We need some tests. https://maskray.me/blog/2021-08-08-toolchain-testing#i-dont-know-whether-a-test-is-needed

Adding some to clang/test/Preprocessor/init-aarch64.c should cover many changes, but we also need one to cover setDataLayout.

clang/lib/Basic/Targets/AArch64.cpp

 #define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE)         \
   {#ID, TYPE, ATTRS, HEADER, LANGS, FEATURE},
 #include "clang/Basic/BuiltinsAArch64.def"
 };
 
 AArch64TargetInfo::AArch64TargetInfo(const llvm::Triple &Triple,
                                      const TargetOptions &Opts)
     : TargetInfo(Triple), ABI("aapcs") {
-  if (getTriple().isOSOpenBSD()) {
+  if (getTriple().isOSOpenBSD() ||
+      getTriple().getEnvironment() == llvm::Triple::GNUILP32) {
     Int64Type = SignedLongLong;
     IntMaxType = SignedLongLong;
   } else {
     if (!getTriple().isOSDarwin() && !getTriple().isOSNetBSD())
       WCharType = UnsignedInt;
 
     Int64Type = SignedLong;
     IntMaxType = SignedLong;
   }
 
   // All AArch64 implementations support ARMv8 FP, which makes half a legal type.
   HasLegalHalfType = true;
   HasFloat16 = true;
 
-  if (Triple.isArch64Bit())
+  if (Triple.isArch64Bit() &&
+      getTriple().getEnvironment() != llvm::Triple::GNUILP32)
     LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
   else
     LongWidth = LongAlign = PointerWidth = PointerAlign = 32;
 
   MaxVectorAlign = 128;
   MaxAtomicInlineWidth = 128;
   MaxAtomicPromoteWidth = 128;
 
void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts,
   // Target identification.
   Builder.defineMacro("__aarch64__");
   // For bare-metal.
   if (getTriple().getOS() == llvm::Triple::UnknownOS &&
       getTriple().isOSBinFormatELF())
     Builder.defineMacro("__ELF__");
 
   // Target properties.
-  if (!getTriple().isOSWindows() && getTriple().isArch64Bit()) {
+  if (!getTriple().isOSWindows() && getTriple().isArch64Bit() &&
+      getTriple().getEnvironment() != llvm::Triple::GNUILP32) {
     Builder.defineMacro("_LP64");
     Builder.defineMacro("__LP64__");
   }
+  if (getTriple().getEnvironment() == llvm::Triple::GNUILP32) {
+    Builder.defineMacro("_ILP32");
+    Builder.defineMacro("__ILP32__");
+  }
 
   std::string CodeModel = getTargetOpts().CodeModel;
   if (CodeModel == "default")
     CodeModel = "small";
   for (char &c : CodeModel)
     c = toupper(c);
   Builder.defineMacro("__AARCH64_CMODEL_" + CodeModel + "__");
 
AArch64leTargetInfo::AArch64leTargetInfo(const llvm::Triple &Triple,
     : AArch64TargetInfo(Triple, Opts) {}
 
 void AArch64leTargetInfo::setDataLayout() {
   if (getTriple().isOSBinFormatMachO()) {
     if(getTriple().isArch32Bit())
       resetDataLayout("e-m:o-p:32:32-i64:64-i128:128-n32:64-S128", "_");
     else
       resetDataLayout("e-m:o-i64:64-i128:128-n32:64-S128", "_");
-  } else
+  } else {
+    if (getTriple().getEnvironment() == llvm::Triple::GNUILP32)
+      resetDataLayout(
+          "e-m:e-p:32:32-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128");
+    else
       resetDataLayout("e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128");
   }
+}
 
 void AArch64leTargetInfo::getTargetDefines(const LangOptions &Opts,
                                            MacroBuilder &Builder) const {
   Builder.defineMacro("__AARCH64EL__");
   AArch64TargetInfo::getTargetDefines(Opts, Builder);
 }
 
 AArch64beTargetInfo::AArch64beTargetInfo(const llvm::Triple &Triple,
                                          const TargetOptions &Opts)
     : AArch64TargetInfo(Triple, Opts) {}
 
 void AArch64beTargetInfo::getTargetDefines(const LangOptions &Opts,
                                            MacroBuilder &Builder) const {
   Builder.defineMacro("__AARCH64EB__");
   Builder.defineMacro("__AARCH_BIG_ENDIAN");
   Builder.defineMacro("__ARM_BIG_ENDIAN");
   AArch64TargetInfo::getTargetDefines(Opts, Builder);
 }
 
 void AArch64beTargetInfo::setDataLayout() {
   assert(!getTriple().isOSBinFormatMachO());
+  if (getTriple().getEnvironment() == llvm::Triple::GNUILP32)
+    resetDataLayout(
+        "E-m:e-p:32:32-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128");
+  else
     resetDataLayout("E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128");
 }
 
 WindowsARM64TargetInfo::WindowsARM64TargetInfo(const llvm::Triple &Triple,
                                                const TargetOptions &Opts)
     : WindowsTargetInfo<AArch64leTargetInfo>(Triple, Opts), Triple(Triple) {
 
   // This is an LLP64 platform.
   // int:4, long:4, long long:8, long double:8.