[Triple] Add triple for UEFI

[Prabhuk]

Summary

Target triple to support "x86_64-unknown-uefi"

[phosek]

clang/lib/Basic/Targets.cpp

579

What does this comment refer to?

clang/lib/Basic/Targets/OSTargets.h

945

I'd start with only necessary minimum and add more later if needed. Initially we probably only need a define to identify this target, likely __UEFI__.

[Prabhuk]

Added changes to the Driver.cpp.
This version uses underlying MSVC toolchain to compile UEFI target introduced here.

[Prabhuk]

Introducing UEFIX86_64TargetInfo.

[Prabhuk]

Add UEFI macro.

[phosek]

clang/lib/Basic/Targets/X86.h

812–828

According to https://wiki.osdev.org/UEFI#Calling_Conventions, only cdecl, Microsoft's 64-bit calling convention and ARM SMC are supported for UEFI. This would translate to CC_C and CC_Win64 (I'm not sure if SMC is supported by Clang, it doesn't appear to be).

[Prabhuk]

Introducing a new toolchain for UEFI COFF.

[Prabhuk]

Added tests to the new UEFI target.

[phosek]

clang/lib/Driver/ToolChains/UEFI.cpp

41–45 ↗

(On Diff #477634)

I'd hardcode and inline this for simplicity, this toolchain is only used for x86_64 and arm64 right now so now need to duplicate that here.

48–49 ↗

(On Diff #477634)

I'd hardcode and inline this for simplicity, this toolchain is only used for x86_64 and arm64 right now so now need to duplicate that here.

52 ↗

(On Diff #477634)

I'd inline this.

55–56 ↗

(On Diff #477634)

I'd hardcode and inline this for simplicity, this toolchain is only used for x86_64 and arm64 right now so now need to duplicate that here.

59 ↗

(On Diff #477634)

I'd inline this.

clang/lib/Driver/ToolChains/UEFI.h

22 ↗

(On Diff #477634)

You also need HasNativeLLVMSupport, see https://github.com/llvm/llvm-project/blob/46dee4a3a3dfb372a0eaa0b4490c80be2f421f29/clang/lib/Driver/ToolChains/Fuchsia.h#L43

28 ↗

(On Diff #477634)

You'll also need to override buildLinker since the default implementation doesn't do anything, see https://github.com/llvm/llvm-project/blob/46dee4a3a3dfb372a0eaa0b4490c80be2f421f29/clang/lib/Driver/ToolChain.cpp#L319

I'd hardcode it to use lld-link for simplicty. You can use Fuchsia's implementation for inspiration (although the flags are going to be different since Fuchsia uses ld.lld, not lld-link):

https://github.com/llvm/llvm-project/blob/main/clang/lib/Driver/ToolChains/Fuchsia.h#L17-L34
https://github.com/llvm/llvm-project/blob/609b789170625277f631139c790c22d527ff1eed/clang/lib/Driver/ToolChains/Fuchsia.cpp#L31-L191

[Prabhuk]

Added UEFI toolchain. Constructing linker and started a WIP UEFI toolchain to break away from MSVC toolchain.

[Prabhuk]

Not ready for review yet. Updating build files and tests.
Fixed a compile time error.

[Prabhuk]

Use make_unique instead of new for UEFI TargetInfo.

[Prabhuk]

Addressing Petr's comments. Adding buildLinker initial draft for UEFI.

[Prabhuk]

Simplifying the patch to include just the scaffolding for X86_64 platform.
Removing the predefines to be added as a separate patch.

[phosek]

I'd split the llvm/ changes into a separate change.

clang/lib/Driver/ToolChains/UEFI.cpp

58–59 ↗

(On Diff #528064)

I don't think these should be needed for UEFI targets.

llvm/test/ExecutionEngine/RuntimeDyld/X86/coff-alignment.ll

4 ↗

(On Diff #528064)

Should this be uefi?

llvm/test/Instrumentation/InstrProfiling/profiling.ll

10 ↗

(On Diff #528064)

Should this be uefi?

llvm/test/Transforms/PGOProfile/comdat_rename.ll

3 ↗

(On Diff #528064)

Should this be uefi?

[phosek]

I'd omit the lit test cases for now since they're not necessary. There should be a test case in https://github.com/llvm/llvm-project/blob/86b6ac5d54d7fe5cd21beff64b5c2194b1368bdf/llvm/unittests/TargetParser/TripleTest.cpp though.

[Prabhuk]

Update the test. Remove unnecessary items in UEFI toolchain.

[Prabhuk]

Updated commit message.

[phosek]

Can you also provide description for this change (this should be the same you'll use for the Git message).

llvm/include/llvm/MC/TargetRegistry.h

568 ↗

(On Diff #528610)

Nit: phrasing.

llvm/lib/MC/MCContext.cpp

90 ↗

(On Diff #528610)

Nit: update the error message.

llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp

1521 ↗

(On Diff #528610)

Nit: consistent case in assert messages.

clang/lib/Basic/Targets.cpp

case llvm::Triple::x86_64:
     case llvm::Triple::FreeBSD:
       return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
     case llvm::Triple::Fuchsia:
       return new FuchsiaTargetInfo<X86_64TargetInfo>(Triple, Opts);
     case llvm::Triple::KFreeBSD:
       return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
     case llvm::Triple::Solaris:
       return new SolarisTargetInfo<X86_64TargetInfo>(Triple, Opts);
+    case llvm::Triple::UEFI:
+      return new UEFIX86_64TargetInfo(Triple, Opts);
     case llvm::Triple::Win32: {
       switch (Triple.getEnvironment()) {
       case llvm::Triple::Cygnus:
         return new CygwinX86_64TargetInfo(Triple, Opts);
       case llvm::Triple::GNU:
         return new MinGWX86_64TargetInfo(Triple, Opts);
       case llvm::Triple::MSVC:
       default: // Assume MSVC for unknown environments

clang/lib/Basic/Targets/OSTargets.h

ZOSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
     this->MaxAlignedAttribute = 128;
     this->UseBitFieldTypeAlignment = false;
     this->UseZeroLengthBitfieldAlignment = true;
     this->UseLeadingZeroLengthBitfield = false;
     this->ZeroLengthBitfieldBoundary = 32;
   }
 };
 
+// UEFI target
+template <typename Target>
+class LLVM_LIBRARY_VISIBILITY UEFITargetInfo : public OSTargetInfo<Target> {
+protected:
+  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
+                    MacroBuilder &Builder) const override {
+    Builder.defineMacro("__UEFI__");
+  }
+
+public:
+  UEFITargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
+      : OSTargetInfo<Target>(Triple, Opts) {
+    this->WCharType = TargetInfo::UnsignedShort;
+    this->WIntType = TargetInfo::UnsignedShort;
+  }
+};
+
 void addWindowsDefines(const llvm::Triple &Triple, const LangOptions &Opts,
                        MacroBuilder &Builder);
 
 // Windows target
 template <typename Target>
 class LLVM_LIBRARY_VISIBILITY WindowsTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,

 };
 
 // Fuchsia Target
 template <typename Target>
 class LLVM_LIBRARY_VISIBILITY FuchsiaTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     Builder.defineMacro("__Fuchsia__");
     Builder.defineMacro("__ELF__");
     if (Opts.POSIXThreads)
       Builder.defineMacro("_REENTRANT");
     // Required by the libc++ locale support.
     if (Opts.CPlusPlus)
       Builder.defineMacro("_GNU_SOURCE");
     Builder.defineMacro("__Fuchsia_API_level__", Twine(Opts.FuchsiaAPILevel));
     this->PlatformName = "fuchsia";

clang/lib/Basic/Targets/X86.h

if (hasFeature("cx16"))
       MaxAtomicInlineWidth = 128;
   }
 
   ArrayRef<Builtin::Info> getTargetBuiltins() const override;
 
   bool hasBitIntType() const override { return true; }
 };
 
+// x86-64 UEFI target
+class LLVM_LIBRARY_VISIBILITY UEFIX86_64TargetInfo
+    : public UEFITargetInfo<X86_64TargetInfo> {
+public:
+  UEFIX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
+      : UEFITargetInfo<X86_64TargetInfo>(Triple, Opts) {
+    LongWidth = LongAlign = 32;
+    DoubleAlign = LongLongAlign = 64;
+    IntMaxType = SignedLongLong;
+    Int64Type = SignedLongLong;
+    SizeType = UnsignedLongLong;
+    PtrDiffType = SignedLongLong;
+    IntPtrType = SignedLongLong;
+    LongDoubleWidth = LongDoubleAlign = 64;
+    LongDoubleFormat = &llvm::APFloat::IEEEdouble();
+  }
+
+  void getTargetDefines(const LangOptions &Opts,
+                        MacroBuilder &Builder) const override {
+    Builder.defineMacro("_M_X64", "100");
+    Builder.defineMacro("_M_AMD64", "100");
+  }
+
+  BuiltinVaListKind getBuiltinVaListKind() const override {
+    return TargetInfo::CharPtrBuiltinVaList;
+  }
+
+  CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
+    switch (CC) {
+    case CC_X86StdCall:
+    case CC_X86ThisCall:
+    case CC_X86FastCall:
+      return CCCR_Ignore;
+    case CC_C:
+    case CC_X86VectorCall:
+    case CC_IntelOclBicc:
+    case CC_PreserveMost:
+    case CC_PreserveAll:
+    case CC_X86_64SysV:
+    case CC_Swift:
+    case CC_SwiftAsync:
+    case CC_X86RegCall:
+    case CC_OpenCLKernel:
+      return CCCR_OK;
+    default:
+      return CCCR_Warning;
+    }
+  }
+
+  TargetInfo::CallingConvKind
+  getCallingConvKind(bool ClangABICompat4) const override {
+    return CCK_MicrosoftWin64;
+  }
+};
+
 // x86-64 Windows target
 class LLVM_LIBRARY_VISIBILITY WindowsX86_64TargetInfo
     : public WindowsTargetInfo<X86_64TargetInfo> {
 public:
   WindowsX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : WindowsTargetInfo<X86_64TargetInfo>(Triple, Opts) {
     LongWidth = LongAlign = 32;
     DoubleAlign = LongLongAlign = 64;

clang/lib/Driver/Driver.cpp

case llvm::Triple::Solaris:
       break;
     case llvm::Triple::AMDHSA:
       TC = std::make_unique<toolchains::ROCMToolChain>(*this, Target, Args);
       break;
     case llvm::Triple::AMDPAL:
     case llvm::Triple::Mesa3D:
       TC = std::make_unique<toolchains::AMDGPUToolChain>(*this, Target, Args);
       break;
+    case llvm::Triple::UEFI:
+      TC = std::make_unique<toolchains::MSVCToolChain>(*this, Target, Args); ////TODO(prabhukr): Replace with a new UEFI toolchain
+      break;
     case llvm::Triple::Win32:
       switch (Target.getEnvironment()) {
       default:
         if (Target.isOSBinFormatELF())
           TC = std::make_unique<toolchains::Generic_ELF>(*this, Target, Args);
         else if (Target.isOSBinFormatMachO())
           TC = std::make_unique<toolchains::MachO>(*this, Target, Args);
         else

llvm/include/llvm/ADT/Triple.h

enum OSType {
     IOS,
     KFreeBSD,
     Linux,
     Lv2,        // PS3
     MacOSX,
     NetBSD,
     OpenBSD,
     Solaris,
+    UEFI,
     Win32,
     ZOS,
     Haiku,
     Minix,
     RTEMS,
     NaCl,       // Native Client
     AIX,
     CUDA,       // NVIDIA CUDA

llvm/lib/Support/Triple.cpp

StringRef Triple::getOSTypeName(OSType Kind) {
   case NaCl: return "nacl";
   case NetBSD: return "netbsd";
   case OpenBSD: return "openbsd";
   case PS4: return "ps4";
   case PS5: return "ps5";
   case RTEMS: return "rtems";
   case Solaris: return "solaris";
   case TvOS: return "tvos";
+  case UEFI: return "uefi";
   case WASI: return "wasi";
   case WatchOS: return "watchos";
   case Win32: return "windows";
   case ZOS: return "zos";
   case ShaderModel: return "shadermodel";
   }
 
   llvm_unreachable("Invalid OSType");
return StringSwitch<Triple::OSType>(OSName)
     .StartsWith("ios", Triple::IOS)
     .StartsWith("kfreebsd", Triple::KFreeBSD)
     .StartsWith("linux", Triple::Linux)
     .StartsWith("lv2", Triple::Lv2)
     .StartsWith("macos", Triple::MacOSX)
     .StartsWith("netbsd", Triple::NetBSD)
     .StartsWith("openbsd", Triple::OpenBSD)
     .StartsWith("solaris", Triple::Solaris)
+    .StartsWith("uefi", Triple::UEFI)
     .StartsWith("win32", Triple::Win32)
     .StartsWith("windows", Triple::Win32)
     .StartsWith("zos", Triple::ZOS)
     .StartsWith("haiku", Triple::Haiku)
     .StartsWith("minix", Triple::Minix)
     .StartsWith("rtems", Triple::RTEMS)
     .StartsWith("nacl", Triple::NaCl)
     .StartsWith("aix", Triple::AIX)