[LoongArch] Add basic UEFI support

This patch adds initial UEFI support for LoongArch64, enabling the
compilation and generation of UEFI applications for LoongArch targets.

Key changes include:

1. Target support enhancements:
   - Updated data layout for UEFI target (Windows-style instead of ELF)
   - Added LoongArch64 (0x6264) COFF machine type definitions. See:
     https://learn.microsoft.com/en-us/windows/win32/debug/pe-format#machine-types

2. COFF object file support:
   - Added LoongArch64 machine type recognition in COFF headers
   - Enhanced magic number detection for LoongArch COFF files
   - Updated COFF object file handling for LoongArch64 architecture

3. Code generation infrastructure:
   - Implemented Windows COFF object writer for LoongArch
   - Added COFF streamer support for UEFI target
   - Created COFF-specific MCAsmInfo for Microsoft compatibility
   - Enhanced AsmBackend to support both ELF and COFF output formats

4. Toolchain updates:
   - Extended llvm-readobj to recognize LoongArch64 COFF files
   - Updated triple handling to default to COFF format for UEFI targets
   - Added build system support for new COFF components

The implementation provides the foundational infrastructure for generating
UEFI-compatible PE/COFF binaries for LoongArch64 systems.

Co-Authored-By: WANG Rui <[email protected]>

Author: leecheechen

llvm/include/llvm/BinaryFormat/COFF.h

@@ -104,6 +104,7 @@ enum MachineTypes : unsigned {
   IMAGE_FILE_MACHINE_EBC = 0xEBC,
   IMAGE_FILE_MACHINE_I386 = 0x14C,
   IMAGE_FILE_MACHINE_IA64 = 0x200,
+  IMAGE_FILE_MACHINE_LOONGARCH64 = 0x6264,
   IMAGE_FILE_MACHINE_M32R = 0x9041,
   IMAGE_FILE_MACHINE_MIPS16 = 0x266,
   IMAGE_FILE_MACHINE_MIPSFPU = 0x366,
@@ -132,7 +133,8 @@ template <typename T> bool isAnyArm64(T Machine) {
 }
 
 template <typename T> bool is64Bit(T Machine) {
-  return Machine == IMAGE_FILE_MACHINE_AMD64 || isAnyArm64(Machine);
+  return Machine == IMAGE_FILE_MACHINE_AMD64 || isAnyArm64(Machine) ||
+         Machine == IMAGE_FILE_MACHINE_LOONGARCH64;
 }
 
 enum Characteristics : unsigned {

llvm/include/llvm/Object/WindowsMachineFlag.h

@@ -44,6 +44,8 @@ template <typename T> Triple::ArchType getMachineArchType(T machine) {
   case COFF::IMAGE_FILE_MACHINE_ARM64EC:
   case COFF::IMAGE_FILE_MACHINE_ARM64X:
     return llvm::Triple::ArchType::aarch64;
+  case COFF::IMAGE_FILE_MACHINE_LOONGARCH64:
+    return llvm::Triple::ArchType::loongarch64;
   case COFF::IMAGE_FILE_MACHINE_R4000:
     return llvm::Triple::ArchType::mipsel;
   default:

llvm/lib/BinaryFormat/Magic.cpp

@@ -237,8 +237,9 @@ file_magic llvm::identify_magic(StringRef Magic) {
       return file_magic::minidump;
     break;
 
-  case 0x64: // x86-64 or ARM64 Windows.
-    if (Magic[1] == char(0x86) || Magic[1] == char(0xaa))
+  case 0x64: // x86-64, ARM64 Windows, or loongarch64.
+    if (Magic[1] == char(0x86) || Magic[1] == char(0xaa) ||
+        Magic[1] == char(0x62))
       return file_magic::coff_object;
     break;
 

llvm/lib/Object/COFFObjectFile.cpp

@@ -1115,7 +1115,14 @@ dynamic_reloc_iterator COFFObjectFile::dynamic_reloc_end() const {
 }
 
 uint8_t COFFObjectFile::getBytesInAddress() const {
-  return getArch() == Triple::x86_64 || getArch() == Triple::aarch64 ? 8 : 4;
+  switch (getArch()) {
+  case Triple::x86_64:
+  case Triple::aarch64:
+  case Triple::loongarch64:
+    return 8;
+  default:
+    return 4;
+  }
 }
 
 StringRef COFFObjectFile::getFileFormatName() const {
@@ -1132,6 +1139,8 @@ StringRef COFFObjectFile::getFileFormatName() const {
     return "COFF-ARM64EC";
   case COFF::IMAGE_FILE_MACHINE_ARM64X:
     return "COFF-ARM64X";
+  case COFF::IMAGE_FILE_MACHINE_LOONGARCH64:
+    return "COFF-loongarch64";
   case COFF::IMAGE_FILE_MACHINE_R4000:
     return "COFF-MIPS";
   default:

llvm/lib/Target/LoongArch/LoongArchTargetMachine.cpp

@@ -82,14 +82,20 @@ getEffectiveLoongArchCodeModel(const Triple &TT,
   }
 }
 
+static std::unique_ptr<TargetLoweringObjectFile> createTLOF(const Triple &TT) {
+  if (TT.isOSBinFormatCOFF())
+    return std::make_unique<TargetLoweringObjectFileCOFF>();
+  return std::make_unique<TargetLoweringObjectFileELF>();
+}
+
 LoongArchTargetMachine::LoongArchTargetMachine(
     const Target &T, const Triple &TT, StringRef CPU, StringRef FS,
     const TargetOptions &Options, std::optional<Reloc::Model> RM,
     std::optional<CodeModel::Model> CM, CodeGenOptLevel OL, bool JIT)
     : CodeGenTargetMachineImpl(T, TT.computeDataLayout(), TT, CPU, FS, Options,
                                getEffectiveRelocModel(TT, RM),
                                getEffectiveLoongArchCodeModel(TT, CM), OL),
-      TLOF(std::make_unique<TargetLoweringObjectFileELF>()) {
+      TLOF(createTLOF(getTargetTriple())) {
   initAsmInfo();
 }
 

llvm/lib/Target/LoongArch/MCTargetDesc/CMakeLists.txt

@@ -9,6 +9,8 @@ add_llvm_component_library(LLVMLoongArchDesc
   LoongArchMCTargetDesc.cpp
   LoongArchMatInt.cpp
   LoongArchTargetStreamer.cpp
+  LoongArchWinCOFFObjectWriter.cpp
+  LoongArchWinCOFFStreamer.cpp
 
   LINK_COMPONENTS
   MC

llvm/lib/Target/LoongArch/MCTargetDesc/LoongArchAsmBackend.cpp

@@ -29,10 +29,10 @@
 using namespace llvm;
 
 LoongArchAsmBackend::LoongArchAsmBackend(const MCSubtargetInfo &STI,
-                                         uint8_t OSABI, bool Is64Bit,
+                                         bool Is64Bit,
                                          const MCTargetOptions &Options)
-    : MCAsmBackend(llvm::endianness::little), STI(STI), OSABI(OSABI),
-      Is64Bit(Is64Bit), TargetOptions(Options) {}
+    : MCAsmBackend(llvm::endianness::little), STI(STI), TargetOptions(Options),
+      Is64Bit(Is64Bit) {}
 
 std::optional<MCFixupKind>
 LoongArchAsmBackend::getFixupKind(StringRef Name) const {
@@ -484,16 +484,46 @@ bool LoongArchAsmBackend::addReloc(const MCFragment &F, const MCFixup &Fixup,
   return true;
 }
 
-std::unique_ptr<MCObjectTargetWriter>
-LoongArchAsmBackend::createObjectTargetWriter() const {
-  return createLoongArchELFObjectWriter(OSABI, Is64Bit);
-}
+namespace {
+class ELFLoongArchAsmBackend : public LoongArchAsmBackend {
+  uint8_t OSABI;
+
+public:
+  ELFLoongArchAsmBackend(const MCSubtargetInfo &STI, uint8_t OSABI,
+                         bool Is64Bit, const MCTargetOptions &Options)
+      : LoongArchAsmBackend(STI, Is64Bit, Options), OSABI(OSABI) {}
+
+  std::unique_ptr<MCObjectTargetWriter>
+  createObjectTargetWriter() const override {
+    return createLoongArchELFObjectWriter(OSABI, Is64Bit);
+  }
+};
+} // namespace
+
+namespace {
+class COFFLoongArchAsmBackend : public LoongArchAsmBackend {
+public:
+  COFFLoongArchAsmBackend(const MCSubtargetInfo &STI, bool Is64Bit,
+                          const MCTargetOptions &Options)
+      : LoongArchAsmBackend(STI, Is64Bit, Options) {}
+
+  std::unique_ptr<MCObjectTargetWriter>
+  createObjectTargetWriter() const override {
+    return createLoongArchWinCOFFObjectWriter(Is64Bit);
+  }
+};
+} // namespace
 
 MCAsmBackend *llvm::createLoongArchAsmBackend(const Target &T,
                                               const MCSubtargetInfo &STI,
                                               const MCRegisterInfo &MRI,
                                               const MCTargetOptions &Options) {
   const Triple &TT = STI.getTargetTriple();
+  if (TT.isOSBinFormatCOFF())
+    return new COFFLoongArchAsmBackend(STI, TT.isArch64Bit(), Options);
+
+  assert(TT.isOSBinFormatELF() && "Invalid target");
+
   uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TT.getOS());
-  return new LoongArchAsmBackend(STI, OSABI, TT.isArch64Bit(), Options);
+  return new ELFLoongArchAsmBackend(STI, OSABI, TT.isArch64Bit(), Options);
 }

llvm/lib/Target/LoongArch/MCTargetDesc/LoongArchAsmBackend.h

@@ -24,18 +24,19 @@
 namespace llvm {
 
 class LoongArchAsmBackend : public MCAsmBackend {
-  const MCSubtargetInfo &STI;
-  uint8_t OSABI;
-  bool Is64Bit;
-  const MCTargetOptions &TargetOptions;
   DenseMap<MCSection *, const MCSymbolRefExpr *> SecToAlignSym;
   // Temporary symbol used to check whether a PC-relative fixup is resolved.
   MCSymbol *PCRelTemp = nullptr;
 
   bool isPCRelFixupResolved(const MCSymbol *SymA, const MCFragment &F);
 
+protected:
+  const MCSubtargetInfo &STI;
+  const MCTargetOptions &TargetOptions;
+  bool Is64Bit;
+
 public:
-  LoongArchAsmBackend(const MCSubtargetInfo &STI, uint8_t OSABI, bool Is64Bit,
+  LoongArchAsmBackend(const MCSubtargetInfo &STI, bool Is64Bit,
                       const MCTargetOptions &Options);
 
   bool addReloc(const MCFragment &, const MCFixup &, const MCValue &,
@@ -57,8 +58,6 @@ class LoongArchAsmBackend : public MCAsmBackend {
   bool writeNopData(raw_ostream &OS, uint64_t Count,
                     const MCSubtargetInfo *STI) const override;
 
-  std::unique_ptr<MCObjectTargetWriter>
-  createObjectTargetWriter() const override;
   const MCTargetOptions &getTargetOptions() const { return TargetOptions; }
   DenseMap<MCSection *, const MCSymbolRefExpr *> &getSecToAlignSym() {
     return SecToAlignSym;

llvm/lib/Target/LoongArch/MCTargetDesc/LoongArchMCAsmInfo.cpp

@@ -14,6 +14,7 @@
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/TargetParser/Triple.h"
 
@@ -194,9 +195,9 @@ LoongArchMCExpr::Specifier LoongArch::parseSpecifier(StringRef name) {
       .Default(0);
 }
 
-void LoongArchMCAsmInfo::anchor() {}
+void LoongArchMCAsmInfoELF::anchor() {}
 
-LoongArchMCAsmInfo::LoongArchMCAsmInfo(const Triple &TT) {
+LoongArchMCAsmInfoELF::LoongArchMCAsmInfoELF(const Triple &TT) {
   CodePointerSize = CalleeSaveStackSlotSize = TT.isArch64Bit() ? 8 : 4;
   AlignmentIsInBytes = false;
   Data8bitsDirective = "\t.byte\t";
@@ -211,8 +212,8 @@ LoongArchMCAsmInfo::LoongArchMCAsmInfo(const Triple &TT) {
   ExceptionsType = ExceptionHandling::DwarfCFI;
 }
 
-void LoongArchMCAsmInfo::printSpecifierExpr(raw_ostream &OS,
-                                            const MCSpecifierExpr &Expr) const {
+void LoongArchMCAsmInfoELF::printSpecifierExpr(
+    raw_ostream &OS, const MCSpecifierExpr &Expr) const {
   auto S = Expr.getSpecifier();
   bool HasSpecifier = S != 0 && S != ELF::R_LARCH_B26;
   if (HasSpecifier)
@@ -221,3 +222,21 @@ void LoongArchMCAsmInfo::printSpecifierExpr(raw_ostream &OS,
   if (HasSpecifier)
     OS << ')';
 }
+
+void LoongArchMCAsmInfoMicrosoftCOFF::anchor() {}
+
+LoongArchMCAsmInfoMicrosoftCOFF::LoongArchMCAsmInfoMicrosoftCOFF(
+    const Triple &TT) {
+  PrivateGlobalPrefix = ".L";
+  PrivateLabelPrefix = ".L";
+
+  Data16bitsDirective = "\t.hword\t";
+  Data32bitsDirective = "\t.word\t";
+
+  AlignmentIsInBytes = false;
+  SupportsDebugInformation = true;
+  CodePointerSize = 8;
+
+  ExceptionsType = ExceptionHandling::WinEH;
+  WinEHEncodingType = WinEH::EncodingType::Itanium;
+}

llvm/lib/Target/LoongArch/MCTargetDesc/LoongArchMCAsmInfo.h

@@ -13,6 +13,7 @@
 #ifndef LLVM_LIB_TARGET_LOONGARCH_MCTARGETDESC_LOONGARCHMCASMINFO_H
 #define LLVM_LIB_TARGET_LOONGARCH_MCTARGETDESC_LOONGARCHMCASMINFO_H
 
+#include "llvm/MC/MCAsmInfoCOFF.h"
 #include "llvm/MC/MCAsmInfoELF.h"
 #include "llvm/MC/MCExpr.h"
 
@@ -38,15 +39,22 @@ class LoongArchMCExpr : public MCSpecifierExpr {
   bool getRelaxHint() const { return RelaxHint; }
 };
 
-class LoongArchMCAsmInfo : public MCAsmInfoELF {
+class LoongArchMCAsmInfoELF : public MCAsmInfoELF {
   void anchor() override;
 
 public:
-  explicit LoongArchMCAsmInfo(const Triple &TargetTriple);
+  explicit LoongArchMCAsmInfoELF(const Triple &TargetTriple);
   void printSpecifierExpr(raw_ostream &OS,
                           const MCSpecifierExpr &Expr) const override;
 };
 
+class LoongArchMCAsmInfoMicrosoftCOFF : public MCAsmInfoMicrosoft {
+  void anchor() override;
+
+public:
+  explicit LoongArchMCAsmInfoMicrosoftCOFF(const Triple &Triple);
+};
+
 namespace LoongArch {
 uint16_t parseSpecifier(StringRef name);
 } // namespace LoongArch