[MC] Emit ELF files with ELFOSABI_GNU if specified in triple

[MoritzS]

Summary

This makes a slight difference when using GNU binutils to inspect ELF
files. For example when defining a symbol of type STT_GNU_IFUNC, readelf
shows this with ELFOSABI_GNU:

3: 0000000000000001     0 IFUNC   GLOBAL DEFAULT    2 my_ifunc

But this with ELFOSABI_NONE:

3: 0000000000000001     0 <OS specific>: 10 GLOBAL DEFAULT    2 my_ifunc

[MoritzS]

llvm/include/llvm/MC/MCELFObjectWriter.h

74

Should I add the clang-format changes here? This adds quite a lot of changes in lines that were not changed.

[MoritzS]

Fixed clang-format error

[MaskRay]

This is known. GNU as by default emits ELFOSABI_NONE on Linux - if it does not use any GNU extensioin. If the assembly uses STT_GNU_IFUNC/STB_GNU_UNIQUE, GNU as will switch to ELFOSABI_GNU.

The patch improves the few cases but regresses other cases, so I am requesting changes. It is also unclear whether respecting the GNU behavior is strictly necessary (see gold https://sourceware.org/bugzilla/show_bug.cgi?id=17735). STT_GNU_IFUNC is GNU extension and it is adopted by some other OSes. I am not sure the readelf -S output is a justifying reason for this change.

[jrtc27]

Looking at the original motivation for the patch I'm not convinced that llvm-readelf etc shouldn't just fall back on displaying the "normal" set of GNU extensions even for ELFOSABI_NONE (i.e. those that FreeBSD and GNU have in common). Things like that are really just part of de-facto generic ELF these days. What does binutils do?

[jrtc27]

Having said that I do think it makes sense to push the getOS call into getOSABI by passing the full triple as it simplifies all the callers (and that also decouples the NFC refactor from your proposed behavioural change).

[MaskRay]

In D94475#2493513, @jrtc27 wrote:

Looking at the original motivation for the patch I'm not convinced that llvm-readelf etc shouldn't just fall back on displaying the "normal" set of GNU extensions even for ELFOSABI_NONE (i.e. those that FreeBSD and GNU have in common). Things like that are really just part of de-facto generic ELF these days. What does binutils do?

For SHF_GNU_RETAIN (new, not in MC), SHT_GNU_IFUNC (useful), SHF_GNU_MBIND (looks like legacy), STB_GNU_UNIQUE, has_gnu_osabi bit is set and emit ELFOSABI_GNU instead of ELFOSABI_NONE for Linux triples. I think FreeBSD uses by ELFOSABI_FREEBSD default and can use such extensions as well. Other triples cannot use these *_GNU_*.

[MoritzS]

In D94475#2493461, @MaskRay wrote:

This is known. GNU as by default emits ELFOSABI_NONE on Linux - if it does not use any GNU extensioin. If the assembly uses STT_GNU_IFUNC/STB_GNU_UNIQUE, GNU as will switch to ELFOSABI_GNU.

The patch improves the few cases but regresses other cases, so I am requesting changes. It is also unclear whether respecting the GNU behavior is strictly necessary (see gold https://sourceware.org/bugzilla/show_bug.cgi?id=17735). STT_GNU_IFUNC is GNU extension and it is adopted by some other OSes. I am not sure the readelf -S output is a justifying reason for this change.

I agree with you that it may not be strictly necessary to set ELFOSABI_GNU just because a GNU extension like IFUNC is used. However, if you do use such an extension and explicitly use the x86_64-unknown-linux-gnu triple for example (which is how I found this), I think it makes sense to use ELFOSABI_GNU.

The failing tests use *-gnu triples and still expect ELFOSABI_NONE, so that's why they fail.

I can write more code that checks if any GNU extension are actually used. Only if they are and you are also using a *-gnu triple, it will then use ELFOSABI_GNU. Would you agree to that kind of behavior?

[MoritzS]

In D94475#2493513, @jrtc27 wrote:

Looking at the original motivation for the patch I'm not convinced that llvm-readelf etc shouldn't just fall back on displaying the "normal" set of GNU extensions even for ELFOSABI_NONE (i.e. those that FreeBSD and GNU have in common). Things like that are really just part of de-facto generic ELF these days. What does binutils do?

The snippets from readelf from the patch are actually from GNU binutils readelf, not from llvm-readelf. So binutils does in fact only display the GNU extensions with ELFOSABI_GNU.

[MaskRay]

In D94475#2493695, @MoritzS wrote:

In D94475#2493461, @MaskRay wrote:

This is known. GNU as by default emits ELFOSABI_NONE on Linux - if it does not use any GNU extensioin. If the assembly uses STT_GNU_IFUNC/STB_GNU_UNIQUE, GNU as will switch to ELFOSABI_GNU.

The patch improves the few cases but regresses other cases, so I am requesting changes. It is also unclear whether respecting the GNU behavior is strictly necessary (see gold https://sourceware.org/bugzilla/show_bug.cgi?id=17735). STT_GNU_IFUNC is GNU extension and it is adopted by some other OSes. I am not sure the readelf -S output is a justifying reason for this change.

I agree with you that it may not be strictly necessary to set ELFOSABI_GNU just because a GNU extension like IFUNC is used. However, if you do use such an extension and explicitly use the x86_64-unknown-linux-gnu triple for example (which is how I found this), I think it makes sense to use ELFOSABI_GNU.

The failing tests use *-gnu triples and still expect ELFOSABI_NONE, so that's why they fail.

I can write more code that checks if any GNU extension are actually used. Only if they are and you are also using a *-gnu triple, it will then use ELFOSABI_GNU. Would you agree to that kind of behavior?

Yes. We may need to do so for at least SHF_GNU_RETAIN.
https://sourceware.org/pipermail/binutils/2021-March/115581.html

STT_GNU_IFUNC/STB_GNU_UNIQUE probably need the similar behavior but they are not urgent.

static uint8_t getOSABI(const Triple &T) { may need to be static uint8_t getOSABI(bool UsedGnuAbi) {

[MaskRay]

In D94475#2595532, @MaskRay wrote:

In D94475#2493695, @MoritzS wrote:

In D94475#2493461, @MaskRay wrote:

This is known. GNU as by default emits ELFOSABI_NONE on Linux - if it does not use any GNU extensioin. If the assembly uses STT_GNU_IFUNC/STB_GNU_UNIQUE, GNU as will switch to ELFOSABI_GNU.

The patch improves the few cases but regresses other cases, so I am requesting changes. It is also unclear whether respecting the GNU behavior is strictly necessary (see gold https://sourceware.org/bugzilla/show_bug.cgi?id=17735). STT_GNU_IFUNC is GNU extension and it is adopted by some other OSes. I am not sure the readelf -S output is a justifying reason for this change.

I agree with you that it may not be strictly necessary to set ELFOSABI_GNU just because a GNU extension like IFUNC is used. However, if you do use such an extension and explicitly use the x86_64-unknown-linux-gnu triple for example (which is how I found this), I think it makes sense to use ELFOSABI_GNU.

The failing tests use *-gnu triples and still expect ELFOSABI_NONE, so that's why they fail.

I can write more code that checks if any GNU extension are actually used. Only if they are and you are also using a *-gnu triple, it will then use ELFOSABI_GNU. Would you agree to that kind of behavior?

Yes. We may need to do so for at least SHF_GNU_RETAIN.
https://sourceware.org/pipermail/binutils/2021-March/115581.html

STT_GNU_IFUNC/STB_GNU_UNIQUE probably need the similar behavior but they are not urgent.

static uint8_t getOSABI(const Triple &T) { may need to be static uint8_t getOSABI(bool UsedGnuAbi) {

Sent D97976

llvm/include/llvm/MC/MCELFObjectWriter.h

 //===- llvm/MC/MCELFObjectWriter.h - ELF Object Writer ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCELFOBJECTWRITER_H

 public:
   virtual ~MCELFObjectTargetWriter() = default;
 
   Triple::ObjectFormatType getFormat() const override { return Triple::ELF; }
   static bool classof(const MCObjectTargetWriter *W) {
     return W->getFormat() == Triple::ELF;
   }
 
-  static uint8_t getOSABI(Triple::OSType OSType) {
-    switch (OSType) {
+  static uint8_t getOSABI(const Triple &T) {
+    switch (T.getOS()) {
       case Triple::CloudABI:
         return ELF::ELFOSABI_CLOUDABI;
       case Triple::HermitCore:
         return ELF::ELFOSABI_STANDALONE;
       case Triple::PS4:
       case Triple::FreeBSD:
         return ELF::ELFOSABI_FREEBSD;
       default:
+        if (T.isGNUEnvironment())
+            return ELF::ELFOSABI_GNU;
+        else
             return ELF::ELFOSABI_NONE;
     }
   }
 
   virtual unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
                                 const MCFixup &Fixup, bool IsPCRel) const = 0;
 
   virtual bool needsRelocateWithSymbol(const MCSymbol &Sym,
                                        unsigned Type) const;

llvm/lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp

if (TheTriple.isOSBinFormatMachO()) {
     return new DarwinAArch64AsmBackend(T, TheTriple, MRI);
   }
 
   if (TheTriple.isOSBinFormatCOFF())
     return new COFFAArch64AsmBackend(T, TheTriple);
 
   assert(TheTriple.isOSBinFormatELF() && "Invalid target");
 
-  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TheTriple.getOS());
+  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TheTriple);
   bool IsILP32 = Options.getABIName() == "ilp32";
   return new ELFAArch64AsmBackend(T, TheTriple, OSABI, /*IsLittleEndian=*/true,
                                   IsILP32);
 }
 
 MCAsmBackend *llvm::createAArch64beAsmBackend(const Target &T,
                                               const MCSubtargetInfo &STI,
                                               const MCRegisterInfo &MRI,
                                               const MCTargetOptions &Options) {
   const Triple &TheTriple = STI.getTargetTriple();
   assert(TheTriple.isOSBinFormatELF() &&
          "Big endian is only supported for ELF targets!");
-  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TheTriple.getOS());
+  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TheTriple);
   bool IsILP32 = Options.getABIName() == "ilp32";
   return new ELFAArch64AsmBackend(T, TheTriple, OSABI, /*IsLittleEndian=*/false,
                                   IsILP32);
 }

llvm/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp

default:
     llvm_unreachable("unsupported object format");
   case Triple::MachO:
     return new ARMAsmBackendDarwin(T, STI, MRI);
   case Triple::COFF:
     assert(TheTriple.isOSWindows() && "non-Windows ARM COFF is not supported");
     return new ARMAsmBackendWinCOFF(T, STI);
   case Triple::ELF:
     assert(TheTriple.isOSBinFormatELF() && "using ELF for non-ELF target");
-    uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TheTriple.getOS());
+    uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TheTriple);
     return new ARMAsmBackendELF(T, STI, OSABI, Endian);
   }
 }
 
 MCAsmBackend *llvm::createARMLEAsmBackend(const Target &T,
                                           const MCSubtargetInfo &STI,
                                           const MCRegisterInfo &MRI,
                                           const MCTargetOptions &Options) {

llvm/lib/Target/AVR/MCTargetDesc/AVRAsmBackend.h

 
 class MCAssembler;
 class MCContext;
 struct MCFixupKindInfo;
 
 /// Utilities for manipulating generated AVR machine code.
 class AVRAsmBackend : public MCAsmBackend {
 public:
-  AVRAsmBackend(Triple::OSType OSType)
-      : MCAsmBackend(support::little), OSType(OSType) {}
+  AVRAsmBackend(uint8_t OSABI) : MCAsmBackend(support::little), OSABI(OSABI) {}
 
   void adjustFixupValue(const MCFixup &Fixup, const MCValue &Target,
                         uint64_t &Value, MCContext *Ctx = nullptr) const;
 
   std::unique_ptr<MCObjectTargetWriter>
   createObjectTargetWriter() const override;
 
   void applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
public:
   }
 
   bool writeNopData(raw_ostream &OS, uint64_t Count) const override;
 
   bool shouldForceRelocation(const MCAssembler &Asm, const MCFixup &Fixup,
                              const MCValue &Target) override;
 
 private:
-  Triple::OSType OSType;
+  uint8_t OSABI;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_AVR_ASM_BACKEND_H
 

llvm/lib/Target/AVR/MCTargetDesc/AVRAsmBackend.cpp

void AVRAsmBackend::adjustFixupValue(const MCFixup &Fixup,
   case FK_GPRel_4:
     llvm_unreachable("don't know how to adjust this fixup");
     break;
   }
 }
 
 std::unique_ptr<MCObjectTargetWriter>
 AVRAsmBackend::createObjectTargetWriter() const {
-  return createAVRELFObjectWriter(MCELFObjectTargetWriter::getOSABI(OSType));
+  return createAVRELFObjectWriter(OSABI);
 }
 
 void AVRAsmBackend::applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
                                const MCValue &Target,
                                MutableArrayRef<char> Data, uint64_t Value,
                                bool IsResolved,
                                const MCSubtargetInfo *STI) const {
   adjustFixupValue(Fixup, Target, Value, &Asm.getContext());
bool AVRAsmBackend::shouldForceRelocation(const MCAssembler &Asm,
   case AVR::fixup_call:
     return true;
   }
 }
 
 MCAsmBackend *createAVRAsmBackend(const Target &T, const MCSubtargetInfo &STI,
                                   const MCRegisterInfo &MRI,
                                   const llvm::MCTargetOptions &TO) {
-  return new AVRAsmBackend(STI.getTargetTriple().getOS());
+  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(STI.getTargetTriple());
+  return new AVRAsmBackend(OSABI);
 }
 
 } // end of namespace llvm
 

llvm/lib/Target/Hexagon/MCTargetDesc/HexagonAsmBackend.cpp

 } // namespace
 
 // MCAsmBackend
 MCAsmBackend *llvm::createHexagonAsmBackend(Target const &T,
                                             const MCSubtargetInfo &STI,
                                             MCRegisterInfo const & /*MRI*/,
                                             const MCTargetOptions &Options) {
   const Triple &TT = STI.getTargetTriple();
-  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TT.getOS());
+  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TT);
 
   StringRef CPUString = Hexagon_MC::selectHexagonCPU(STI.getCPU());
   return new HexagonAsmBackend(T, TT, OSABI, CPUString);
 }

llvm/lib/Target/Lanai/MCTargetDesc/LanaiAsmBackend.cpp

case Lanai::FIXUP_LANAI_LO16:
     return Value;
   default:
     llvm_unreachable("Unknown fixup kind!");
   }
 }
 
 namespace {
 class LanaiAsmBackend : public MCAsmBackend {
-  Triple::OSType OSType;
+  uint8_t OSABI;
 
 public:
-  LanaiAsmBackend(const Target &T, Triple::OSType OST)
-      : MCAsmBackend(support::big), OSType(OST) {}
+  LanaiAsmBackend(const Target &T, uint8_t OSABI)
+      : MCAsmBackend(support::big), OSABI(OSABI) {}
 
   void applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
                   const MCValue &Target, MutableArrayRef<char> Data,
                   uint64_t Value, bool IsResolved,
                   const MCSubtargetInfo *STI) const override;
 
   std::unique_ptr<MCObjectTargetWriter>
   createObjectTargetWriter() const override;
void LanaiAsmBackend::applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
   for (unsigned i = 0; i != NumBytes; ++i) {
     unsigned Idx = (FullSize - 1 - i);
     Data[Offset + Idx] = static_cast<uint8_t>((CurVal >> (i * 8)) & 0xff);
   }
 }
 
 std::unique_ptr<MCObjectTargetWriter>
 LanaiAsmBackend::createObjectTargetWriter() const {
-  return createLanaiELFObjectWriter(MCELFObjectTargetWriter::getOSABI(OSType));
+  return createLanaiELFObjectWriter(OSABI);
 }
 
 const MCFixupKindInfo &
 LanaiAsmBackend::getFixupKindInfo(MCFixupKind Kind) const {
   static const MCFixupKindInfo Infos[Lanai::NumTargetFixupKinds] = {
       // This table *must* be in same the order of fixup_* kinds in
       // LanaiFixupKinds.h.
       // Note: The number of bits indicated here are assumed to be contiguous.

 MCAsmBackend *llvm::createLanaiAsmBackend(const Target &T,
                                           const MCSubtargetInfo &STI,
                                           const MCRegisterInfo & /*MRI*/,
                                           const MCTargetOptions & /*Options*/) {
   const Triple &TT = STI.getTargetTriple();
   if (!TT.isOSBinFormatELF())
     llvm_unreachable("OS not supported");
 
-  return new LanaiAsmBackend(T, TT.getOS());
+  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TT);
+  return new LanaiAsmBackend(T, OSABI);
 }

llvm/lib/Target/Mips/MCTargetDesc/MipsELFObjectWriter.cpp

bool MipsELFObjectWriter::needsRelocateWithSymbol(const MCSymbol &Sym,
   case ELF::R_MIPS16_TLS_TPREL_LO16:
     llvm_unreachable("Unsupported MIPS16 relocation");
     return true;
   }
 }
 
 std::unique_ptr<MCObjectTargetWriter>
 llvm::createMipsELFObjectWriter(const Triple &TT, bool IsN32) {
-  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TT.getOS());
+  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TT);
   bool IsN64 = TT.isArch64Bit() && !IsN32;
   bool HasRelocationAddend = TT.isArch64Bit();
   return std::make_unique<MipsELFObjectWriter>(OSABI, HasRelocationAddend,
                                                 IsN64);
 }

llvm/lib/Target/PowerPC/MCTargetDesc/PPCAsmBackend.cpp

 namespace {
 
 class ELFPPCAsmBackend : public PPCAsmBackend {
 public:
   ELFPPCAsmBackend(const Target &T, const Triple &TT) : PPCAsmBackend(T, TT) {}
 
   std::unique_ptr<MCObjectTargetWriter>
   createObjectTargetWriter() const override {
-    uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TT.getOS());
+    uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TT);
     bool Is64 = TT.isPPC64();
     return createPPCELFObjectWriter(Is64, OSABI);
   }
 
   Optional<MCFixupKind> getFixupKind(StringRef Name) const override;
 };
 
 class XCOFFPPCAsmBackend : public PPCAsmBackend {

llvm/lib/Target/RISCV/MCTargetDesc/RISCVAsmBackend.cpp

RISCVAsmBackend::createObjectTargetWriter() const {
   return createRISCVELFObjectWriter(OSABI, Is64Bit);
 }
 
 MCAsmBackend *llvm::createRISCVAsmBackend(const Target &T,
                                           const MCSubtargetInfo &STI,
                                           const MCRegisterInfo &MRI,
                                           const MCTargetOptions &Options) {
   const Triple &TT = STI.getTargetTriple();
-  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TT.getOS());
+  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TT);
   return new RISCVAsmBackend(STI, OSABI, TT.isArch64Bit(), Options);
 }

llvm/lib/Target/Sparc/MCTargetDesc/SparcAsmBackend.cpp

bool writeNopData(raw_ostream &OS, uint64_t Count) const override {
       for (uint64_t i = 0; i != NumNops; ++i)
         support::endian::write<uint32_t>(OS, 0x01000000, Endian);
 
       return true;
     }
   };
 
   class ELFSparcAsmBackend : public SparcAsmBackend {
-    Triple::OSType OSType;
+    uint8_t OSABI;
+
   public:
-    ELFSparcAsmBackend(const Target &T, Triple::OSType OSType) :
-      SparcAsmBackend(T), OSType(OSType) { }
+    ELFSparcAsmBackend(const Target &T, uint8_t OSABI)
+        : SparcAsmBackend(T), OSABI(OSABI) {}
 
     void applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
                     const MCValue &Target, MutableArrayRef<char> Data,
                     uint64_t Value, bool IsResolved,
                     const MCSubtargetInfo *STI) const override {
 
       Value = adjustFixupValue(Fixup.getKind(), Value);
       if (!Value) return;           // Doesn't change encoding.
 
       unsigned NumBytes = getFixupKindNumBytes(Fixup.getKind());
       unsigned Offset = Fixup.getOffset();
       // For each byte of the fragment that the fixup touches, mask in the bits
       // from the fixup value. The Value has been "split up" into the
       // appropriate bitfields above.
       for (unsigned i = 0; i != NumBytes; ++i) {
         unsigned Idx = Endian == support::little ? i : (NumBytes - 1) - i;
         Data[Offset + Idx] |= uint8_t((Value >> (i * 8)) & 0xff);
       }
     }
 
     std::unique_ptr<MCObjectTargetWriter>
     createObjectTargetWriter() const override {
-      uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(OSType);
       return createSparcELFObjectWriter(Is64Bit, OSABI);
     }
   };
 
 } // end anonymous namespace
 
 MCAsmBackend *llvm::createSparcAsmBackend(const Target &T,
                                           const MCSubtargetInfo &STI,
                                           const MCRegisterInfo &MRI,
                                           const MCTargetOptions &Options) {
-  return new ELFSparcAsmBackend(T, STI.getTargetTriple().getOS());
+  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(STI.getTargetTriple());
+  return new ELFSparcAsmBackend(T, OSABI);
 }

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZMCAsmBackend.cpp

for (uint64_t I = 0; I != Count; ++I)
     OS << '\x7';
   return true;
 }
 
 MCAsmBackend *llvm::createSystemZMCAsmBackend(const Target &T,
                                               const MCSubtargetInfo &STI,
                                               const MCRegisterInfo &MRI,
                                               const MCTargetOptions &Options) {
-  uint8_t OSABI =
-      MCELFObjectTargetWriter::getOSABI(STI.getTargetTriple().getOS());
+  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(STI.getTargetTriple());
   return new SystemZMCAsmBackend(OSABI);
 }

llvm/lib/Target/VE/MCTargetDesc/VEAsmBackend.cpp

 //===-- VEAsmBackend.cpp - VE Assembler Backend ---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "MCTargetDesc/VEFixupKinds.h"
 #include "MCTargetDesc/VEMCTargetDesc.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCELFObjectWriter.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCValue.h"
for (uint64_t i = 0; i < Count; i += 8)
       support::endian::write<uint64_t>(OS, 0x7900000000000000ULL,
                                        support::little);
 
     return true;
   }
 };
 
 class ELFVEAsmBackend : public VEAsmBackend {
-  Triple::OSType OSType;
+  uint8_t OSABI;
 
 public:
-  ELFVEAsmBackend(const Target &T, Triple::OSType OSType)
-      : VEAsmBackend(T), OSType(OSType) {}
+  ELFVEAsmBackend(const Target &T, uint8_t OSABI)
+      : VEAsmBackend(T), OSABI(OSABI) {}
 
   void applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
                   const MCValue &Target, MutableArrayRef<char> Data,
                   uint64_t Value, bool IsResolved,
                   const MCSubtargetInfo *STI) const override {
     Value = adjustFixupValue(Fixup.getKind(), Value);
     if (!Value)
       return; // Doesn't change encoding.
void applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
     for (unsigned i = 0; i != NumBytes; ++i) {
       unsigned Idx = Endian == support::little ? i : (NumBytes - 1) - i;
       Data[Offset + Idx] |= static_cast<uint8_t>((Value >> (i * 8)) & 0xff);
     }
   }
 
   std::unique_ptr<MCObjectTargetWriter>
   createObjectTargetWriter() const override {
-    uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(OSType);
     return createVEELFObjectWriter(OSABI);
   }
 };
 } // end anonymous namespace
 
 MCAsmBackend *llvm::createVEAsmBackend(const Target &T,
                                        const MCSubtargetInfo &STI,
                                        const MCRegisterInfo &MRI,
                                        const MCTargetOptions &Options) {
-  return new ELFVEAsmBackend(T, STI.getTargetTriple().getOS());
+  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(STI.getTargetTriple());
+  return new ELFVEAsmBackend(T, OSABI);
 }

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

MCAsmBackend *llvm::createX86_32AsmBackend(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, false, STI);
 
-  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TheTriple.getOS());
+  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TheTriple);
 
   if (TheTriple.isOSIAMCU())
     return new ELFX86_IAMCUAsmBackend(T, OSABI, STI);
 
   return new ELFX86_32AsmBackend(T, OSABI, STI);
 }
 
 MCAsmBackend *llvm::createX86_64AsmBackend(const Target &T,
                                            const MCSubtargetInfo &STI,
                                            const MCRegisterInfo &MRI,
                                            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);
 
-  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TheTriple.getOS());
+  uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TheTriple);
 
   if (TheTriple.getEnvironment() == Triple::GNUX32)
     return new ELFX86_X32AsmBackend(T, OSABI, STI);
   return new ELFX86_64AsmBackend(T, OSABI, STI);
 }