[UEFI] Aarch64 support front-end changes.

We have a MVP x86_64 UEFI target triple support. Now adding support for
Aarch64.

Author: Prabhuk

clang/lib/Basic/Targets.cpp

@@ -175,6 +175,8 @@ std::unique_ptr<TargetInfo> AllocateTarget(const llvm::Triple &Triple,
     case llvm::Triple::Hurd:
       return std::make_unique<HurdTargetInfo<AArch64leTargetInfo>>(Triple,
                                                                    Opts);
+    case llvm::Triple::UEFI:
+      return std::make_unique<UEFIAArch64TargetInfo>(Triple, Opts);
     case llvm::Triple::Win32:
       switch (Triple.getEnvironment()) {
       case llvm::Triple::GNU:

clang/lib/Basic/Targets/AArch64.cpp

@@ -1772,6 +1772,35 @@ MinGWARM64TargetInfo::MinGWARM64TargetInfo(const llvm::Triple &Triple,
   TheCXXABI.set(TargetCXXABI::GenericAArch64);
 }
 
+TargetInfo::BuiltinVaListKind
+UEFIAArch64TargetInfo::getBuiltinVaListKind() const {
+  return TargetInfo::CharPtrBuiltinVaList;
+}
+
+void UEFIAArch64TargetInfo::getTargetDefines(const LangOptions &Opts,
+                                             MacroBuilder &Builder) const {
+  AArch64leTargetInfo::getTargetDefines(Opts, Builder);
+  Builder.defineMacro("_M_ARM64", "1");
+}
+
+TargetInfo::CallingConvCheckResult
+UEFIAArch64TargetInfo::checkCallingConvention(CallingConv CC) const {
+  switch (CC) {
+  case CC_C:
+  case CC_PreserveMost:
+  case CC_PreserveAll:
+  case CC_Win64:
+    return CCCR_OK;
+  default:
+    return CCCR_Warning;
+  }
+}
+
+TargetInfo::CallingConvKind
+UEFIAArch64TargetInfo::getCallingConvKind(bool ClangABICompat4) const {
+  return CCK_MicrosoftWin64;
+}
+
 AppleMachOAArch64TargetInfo::AppleMachOAArch64TargetInfo(
     const llvm::Triple &Triple, const TargetOptions &Opts)
     : AppleMachOTargetInfo<AArch64leTargetInfo>(Triple, Opts) {}

clang/lib/Basic/Targets/AArch64.h

@@ -351,6 +351,37 @@ class LLVM_LIBRARY_VISIBILITY DarwinAArch64TargetInfo
                     MacroBuilder &Builder) const override;
 };
 
+// aarch64 UEFI target
+class LLVM_LIBRARY_VISIBILITY UEFIAArch64TargetInfo
+    : public UEFITargetInfo<AArch64leTargetInfo> {
+public:
+  UEFIAArch64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
+      : UEFITargetInfo<AArch64leTargetInfo>(Triple, Opts) {
+    this->TheCXXABI.set(TargetCXXABI::Microsoft);
+    // This is an LLP64 platform.
+    // int:4, long:4, long long:8, long double:8.
+    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;
+    this->resetDataLayout(
+        "e-m:w-p270:32:32-p271:32:32-p272:64:64-p:64:64-i32:32-"
+        "i64:64-i128:128-n32:64-S128-Fn32");
+  }
+  BuiltinVaListKind getBuiltinVaListKind() const override;
+  void getTargetDefines(const LangOptions &Opts,
+                        MacroBuilder &Builder) const override;
+  CallingConvCheckResult checkCallingConvention(CallingConv CC) const override;
+  TargetInfo::CallingConvKind
+  getCallingConvKind(bool ClangABICompat4) const override;
+};
+
 } // namespace targets
 } // namespace clang
 

clang/lib/Driver/Driver.cpp

@@ -698,8 +698,10 @@ static llvm::Triple computeTargetTriple(const Driver &D,
     }
   }
 
-  // Currently the only architecture supported by *-uefi triples are x86_64.
-  if (Target.isUEFI() && Target.getArch() != llvm::Triple::x86_64)
+  // Currently the only architectures supported by *-uefi triples are x86_64
+  // and aarch64.
+  if (Target.isUEFI() && Target.getArch() != llvm::Triple::x86_64 &&
+      Target.getArch() != llvm::Triple::aarch64)
     D.Diag(diag::err_target_unknown_triple) << Target.str();
 
   // The `-maix[32|64]` flags are only valid for AIX targets.

clang/lib/Driver/ToolChains/Clang.cpp

@@ -1178,7 +1178,7 @@ static bool isSignedCharDefault(const llvm::Triple &Triple) {
   case llvm::Triple::armeb:
   case llvm::Triple::thumb:
   case llvm::Triple::thumbeb:
-    if (Triple.isOSDarwin() || Triple.isOSWindows())
+    if (Triple.isOSDarwin() || Triple.isOSWindows() || Triple.isUEFI())
       return true;
     return false;
 
@@ -7044,7 +7044,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
   if (!Args.hasFlag(
           options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
           !RawTriple.isOSAIX() &&
-              (!RawTriple.isOSWindows() ||
+              ((!RawTriple.isOSWindows() && !RawTriple.isUEFI()) ||
                RawTriple.isWindowsCygwinEnvironment()) &&
               ((RawTriple.getVendor() != llvm::Triple::MipsTechnologies) ||
                RawTriple.hasEnvironment())) ||
@@ -7079,10 +7079,25 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
     CmdArgs.push_back("-fkeep-system-includes");
   }
 
+  if (IsUEFI) {
+    llvm::outs() << "IsUEFI true;\n";
+  } else {
+    llvm::outs() << "IsUEFI false;\n";
+  }
+  if (IsWindowsMSVC) {
+    llvm::outs() << "IsWindowsMSVC true;\n";
+  } else {
+    llvm::outs() << "IsWindowsMSVC false;\n";
+  }
+
   // -fms-extensions=0 is default.
   if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
-                   IsWindowsMSVC || IsUEFI))
+                   IsWindowsMSVC || IsUEFI)) {
+    llvm::outs() << "set  OPT_fms_extensions\n";
     CmdArgs.push_back("-fms-extensions");
+  } else {
+    llvm::outs() << "DONT SET  OPT_fms_extensions\n";
+  }
 
   // -fms-compatibility=0 is default.
   bool IsMSVCCompat = Args.hasFlag(

clang/lib/Driver/ToolChains/CommonArgs.cpp

@@ -128,6 +128,9 @@ static bool useFramePointerForTargetByDefault(const llvm::opt::ArgList &Args,
     }
   }
 
+  if (Triple.isUEFI())
+    return false;
+
   if (Triple.isOSWindows()) {
     switch (Triple.getArch()) {
     case llvm::Triple::x86:
@@ -198,7 +201,7 @@ static bool mustMaintainValidFrameChain(const llvm::opt::ArgList &Args,
     // Arm64 Windows requires that the frame chain is valid, as there is no
     // way to indicate during a stack walk that a frame has used the frame
     // pointer as a general purpose register.
-    return Triple.isOSWindows();
+    return Triple.isOSWindows() || Triple.isUEFI();
   }
 }
 

clang/test/Driver/aarch64-uefi-constructed-args.c

@@ -0,0 +1,19 @@
+// RUN: %clang -### --target=aarch64-unknown-uefi -g -- %s 2>&1 \
+// RUN:     | FileCheck -check-prefixes=CHECK %s
+// RUN: %clang_cl -### --target=aarch64-unknown-uefi -g -- %s 2>&1 \
+// RUN:     | FileCheck -check-prefixes=CHECK %s
+// CHECK: "-cc1"
+// CHECK-SAME: "-triple" "aarch64-unknown-uefi"
+// CHECK-SAME: "-mrelocation-model" "pic" "-pic-level" "2"
+// CHECK-SAME: "-mframe-pointer=all"
+// CHECK-SAME: "-fms-extensions"
+// CHECK-NEXT: "/nologo"
+// CHECK-SAME: "/subsystem:efi_application"
+// CHECK-SAME: "/entry:EfiMain"
+// CHECK-SAME: "/tsaware:no"
+// CHECK-SAME: "/debug"
+
+// RUN: %clang -### --target=aarch64-unknown-uefi -print-search-dirs 2>&1 \
+// RUN:     | FileCheck -check-prefixes=PROGPATH %s
+// PROGPATH: InstalledDir: [[DRIVER_INSTALLED_DIR:.*]]
+// PROGPATH: programs: =[[DRIVER_INSTALLED_DIR]]

clang/test/Driver/unsupported-target-arch.c

@@ -60,12 +60,6 @@
 // RUN: FileCheck --input-file=%t.err --check-prefix=CHECK-PPCMAC %s
 // CHECK-PPCMAC: error: unknown target triple 'unknown-apple-macosx{{.*}}'
 
-// RUN: not %clang --target=aarch64-unknown-uefi -o %t.o %s 2> %t.err
-// RUN: FileCheck --input-file=%t.err --check-prefix=CHECK-AARCH64 %s
-// RUN: not %clang_cl --target=aarch64-unknown-uefi -o %t.o %s 2> %t.err
-// RUN: FileCheck --input-file=%t.err --check-prefix=CHECK-AARCH64 %s
-// CHECK-AARCH64: error: unknown target triple 'aarch64-unknown-uefi'{{$}}
-
 // RUN: not %clang --target=arm-unknown-uefi -o %t.o %s 2> %t.err
 // RUN: FileCheck --input-file=%t.err -check-prefixes=CHECK-ARM %s
 // RUN: not %clang_cl --target=arm-unknown-uefi -o %t.o %s 2> %t.err

llvm/include/llvm/TargetParser/Triple.h

@@ -689,6 +689,9 @@ class Triple {
   bool isWindowsMSVCEnvironment() const {
     return isKnownWindowsMSVCEnvironment() ||
            (isOSWindows() && getEnvironment() == Triple::UnknownEnvironment);
+    //   ||
+    //  (isUEFI() && isAArch64() && getEnvironment() ==
+    //  Triple::UnknownEnvironment);
   }
 
   // Checks if we're using the Windows Arm64EC ABI.

llvm/lib/TargetParser/AArch64TargetParser.cpp

@@ -138,7 +138,7 @@ void AArch64::fillValidCPUArchList(SmallVectorImpl<StringRef> &Values) {
 
 bool AArch64::isX18ReservedByDefault(const Triple &TT) {
   return TT.isAndroid() || TT.isOSDarwin() || TT.isOSFuchsia() ||
-         TT.isOSWindows() || TT.isOHOSFamily();
+         TT.isOSWindows() || TT.isUEFI() || TT.isOHOSFamily();
 }
 
 // Allows partial match, ex. "v8a" matches "armv8a".