[Triple] Add triple for UEFI

[Prabhuk]

Summary

Target triple to support "x86_64-unknown-uefi"

[phosek]

clang/lib/Basic/Targets.cpp

579 ↗

(On Diff #451529)

What does this comment refer to?

clang/lib/Basic/Targets/OSTargets.h

928 ↗

(On Diff #451529)

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 ↗

(On Diff #468600)

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

Nit: phrasing.

llvm/lib/MC/MCContext.cpp

90

Nit: update the error message.

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

1521

Nit: consistent case in assert messages.

llvm/include/llvm/MC/TargetRegistry.h

MCStreamer *createMCObjectStreamer(const Triple &T, MCContext &Ctx,
                                      const MCSubtargetInfo &STI, bool RelaxAll,
                                      bool IncrementalLinkerCompatible,
                                      bool DWARFMustBeAtTheEnd) const {
     MCStreamer *S = nullptr;
     switch (T.getObjectFormat()) {
     case Triple::UnknownObjectFormat:
       llvm_unreachable("Unknown object format");
     case Triple::COFF:
-      assert(T.isOSWindows() && "only Windows COFF is supported");
+      assert((T.isOSWindows() || T.isUEFI()) &&
+             "only Windows and UEFI COFF are supported");
       S = COFFStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
                              std::move(Emitter), RelaxAll,
                              IncrementalLinkerCompatible);
       break;
     case Triple::MachO:
       if (MachOStreamerCtorFn)
         S = MachOStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
                                 std::move(Emitter), RelaxAll,

llvm/include/llvm/TargetParser/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
bool isOSContiki() const {
     return getOS() == Triple::Contiki;
   }
 
   /// Tests whether the OS is Haiku.
   bool isOSHaiku() const {
     return getOS() == Triple::Haiku;
   }
 
+  /// Tests whether the OS is UEFI.
+  bool isUEFI() const {
+    return getOS() == Triple::UEFI;
+  }
+
   /// Tests whether the OS is Windows.
   bool isOSWindows() const {
     return getOS() == Triple::Win32;
   }
 
   /// Checks if the environment is MSVC.
   bool isKnownWindowsMSVCEnvironment() const {
     return isOSWindows() && getEnvironment() == Triple::MSVC;

llvm/lib/MC/MCContext.cpp

if (SrcMgr && SrcMgr->getNumBuffers())
     MainFileName = std::string(SrcMgr->getMemoryBuffer(SrcMgr->getMainFileID())
                                    ->getBufferIdentifier());
 
   switch (TheTriple.getObjectFormat()) {
   case Triple::MachO:
     Env = IsMachO;
     break;
   case Triple::COFF:
-    if (!TheTriple.isOSWindows())
+    if (!TheTriple.isOSWindows() && !TheTriple.isUEFI())
       report_fatal_error(
           "Cannot initialize MC for non-Windows COFF object files.");
 
     Env = IsCOFF;
     break;
   case Triple::ELF:
     Env = IsELF;
     break;
   case Triple::Wasm:
     Env = IsWasm;

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

MCAsmBackend *llvm::createX86_64AsmBackend(const Target &T,
                                            const MCTargetOptions &Options) {
   const Triple &TheTriple = STI.getTargetTriple();
   if (TheTriple.isOSBinFormatMachO())
     return new DarwinX86AsmBackend(T, MRI, STI);
 
   if (TheTriple.isOSWindows() && TheTriple.isOSBinFormatCOFF())
     return new WindowsX86AsmBackend(T, true, STI);
 
+  if (TheTriple.isUEFI()) {
+    assert(TheTriple.isOSBinFormatCOFF() &&
+         "Only COFF format is supported in UEFI environment.");
+    return new WindowsX86AsmBackend(T, true, STI);
+  }
+
   uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TheTriple.getOS());
 
   if (TheTriple.isX32())
     return new ELFX86_X32AsmBackend(T, OSABI, STI);
   return new ELFX86_64AsmBackend(T, OSABI, STI);
 }

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

X86MCAsmInfoMicrosoftMASM::X86MCAsmInfoMicrosoftMASM(const Triple &Triple)
   AllowQuestionAtStartOfIdentifier = true;
   AllowDollarAtStartOfIdentifier = true;
   AllowAtAtStartOfIdentifier = true;
 }
 
 void X86MCAsmInfoGNUCOFF::anchor() { }
 
 X86MCAsmInfoGNUCOFF::X86MCAsmInfoGNUCOFF(const Triple &Triple) {
-  assert(Triple.isOSWindows() && "Windows is the only supported COFF target");
+  assert((Triple.isOSWindows() || Triple.isUEFI()) &&
+         "Windows and UEFI are the only supported COFF targets");
   if (Triple.getArch() == Triple::x86_64) {
     PrivateGlobalPrefix = ".L";
     PrivateLabelPrefix = ".L";
     CodePointerSize = 8;
     WinEHEncodingType = WinEH::EncodingType::Itanium;
     ExceptionsType = ExceptionHandling::WinEH;
   } else {
     ExceptionsType = ExceptionHandling::DwarfCFI;
   }
 
   AssemblerDialect = AsmWriterFlavor;
 
   TextAlignFillValue = 0x90;
 
   AllowAtInName = true;
 }

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

MAI = new X86ELFMCAsmInfo(TheTriple);
              TheTriple.isWindowsCoreCLREnvironment()) {
     if (Options.getAssemblyLanguage().equals_insensitive("masm"))
       MAI = new X86MCAsmInfoMicrosoftMASM(TheTriple);
     else
       MAI = new X86MCAsmInfoMicrosoft(TheTriple);
   } else if (TheTriple.isOSCygMing() ||
              TheTriple.isWindowsItaniumEnvironment()) {
     MAI = new X86MCAsmInfoGNUCOFF(TheTriple);
+  } else if (TheTriple.isUEFI()) {
+    MAI = new X86MCAsmInfoGNUCOFF(TheTriple);
   } else {
     // The default is ELF.
     MAI = new X86ELFMCAsmInfo(TheTriple);
   }
 
   // Initialize initial frame state.
   // Calculate amount of bytes used for return address storing
   int stackGrowth = is64Bit ? -8 : -4;

llvm/lib/Target/X86/X86MCInstLower.cpp

if (isa<UndefValue>(COp)) {
     }
   } else {
     CS << "?";
   }
 }
 
 void X86AsmPrinter::EmitSEHInstruction(const MachineInstr *MI) {
   assert(MF->hasWinCFI() && "SEH_ instruction in function without WinCFI?");
-  assert(getSubtarget().isOSWindows() && "SEH_ instruction Windows only");
+  assert((getSubtarget().isOSWindows() || TM.getTargetTriple().isUEFI()) &&
+         "SEH_ instruction Windows and UEFI only");
 
   // Use the .cv_fpo directives if we're emitting CodeView on 32-bit x86.
   if (EmitFPOData) {
     X86TargetStreamer *XTS =
         static_cast<X86TargetStreamer *>(OutStreamer->getTargetStreamer());
     switch (MI->getOpcode()) {
     case X86::SEH_PushReg:
       XTS->emitFPOPushReg(MI->getOperand(0).getImm());

llvm/lib/TargetParser/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";
   case LiteOS: return "liteos";
   }
 
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)

llvm/unittests/TargetParser/TripleTest.cpp

TEST(TripleTest, ParsedIDs) {
   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 
   T = Triple("x86_64-unknown-hermit");
   EXPECT_EQ(Triple::x86_64, T.getArch());
   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
   EXPECT_EQ(Triple::HermitCore, T.getOS());
   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 
+  T = Triple("x86_64-unknown-uefi");
+  EXPECT_EQ(Triple::x86_64, T.getArch());
+  EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
+  EXPECT_EQ(Triple::UEFI, T.getOS());
+  EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
+
   T = Triple("wasm32-unknown-unknown");
   EXPECT_EQ(Triple::wasm32, T.getArch());
   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
   EXPECT_EQ(Triple::UnknownOS, T.getOS());
   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 
   T = Triple("wasm32-unknown-wasi");
   EXPECT_EQ(Triple::wasm32, T.getArch());