[PPC64] Replace several endianess checks with abi checks.

[sfertile]

Summary

There is no limitation that restricts the V2 abi to little endian machines. Rather then checking based on endianess we should be gating behavior based on abi flags.

This cleans up most of the existing checks, but unfortunately the PPC64 target constructor has one such endianess check that comes before we have processed the e_flags and don't know the abi version yet. Since we are working on a patch to remove the remaining V1 abi specific code I've left that check as is for now.

[echristo]

This LGTM FWIW. (Acking to have it pop back up in people's queues).

ELF/Target.h

157–161

IMO this is going to get unwieldy after a while (making it part of the base class), but it looks like you're also just following existing practice.

[sfertile]

In D46076#1083405, @echristo wrote:

This LGTM FWIW. (Acking to have it pop back up in people's queues).

Thanks for review.

I was using this to help cleanup some of the checks in the Plt stub and glink patches as well as run some of the lit tests for both BE and LE. D46316 (remove support for V1 abi) is approved, so I think I can abandon this and cleanup the dependent patches to not need this check.

ELF/Target.h

157–161

I agree, I would have liked to sink this into the PPC64 target directly. If the targets were setup with the LLVM style RTTI then I would have done it this way.

ELF/Arch/PPC64.cpp

 using namespace llvm::object;
 using namespace llvm::support::endian;
 using namespace llvm::ELF;
 using namespace lld;
 using namespace lld::elf;
 
 static uint64_t PPC64TocOffset = 0x8000;
 
+enum { AbiV1 = 1, AbiV2 = 2 };
+
 uint64_t elf::getPPC64TocBase() {
   // The TOC consists of sections .got, .toc, .tocbss, .plt in that order. The
   // TOC starts where the first of these sections starts. We always create a
   // .got when we see a relocation that uses it, so for us the start is always
   // the .got.
   uint64_t TocVA = InX::Got->getVA();
 
   // Per the ppc64-elf-linux ABI, The TOC base is TOC value plus 0x8000
   // thus permitting a full 64 Kbytes segment. Note that the glibc startup
   // code (crt1.o) assumes that you can get from the TOC base to the
   // start of the .toc section with only a single (signed) 16-bit relocation.
   return TocVA + PPC64TocOffset;
 }
 
+bool elf::isPPC64ElfV2() {
+  assert(Config->EMachine == EM_PPC64 &&
+         "Should only be called when targeting PPC64!");
+  return  (Config->EFlags & EF_PPC64_ABI) == AbiV2;
+}
+
 namespace {
 class PPC64 final : public TargetInfo {
 public:
   PPC64();
   uint32_t calcEFlags() const override;
   RelExpr getRelExpr(RelType Type, const Symbol &S,
                      const uint8_t *Loc) const override;
   void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
static uint32_t getEFlags(InputFile *File) {
 
   // We are currently handling both ELF64LE and ELF64BE but eventually will
   // remove BE support once v2 ABI support is complete.
   switch (Config->EKind) {
   case ELF64BEKind:
     if (uint32_t EFlags =
         cast<ObjFile<ELF64BE>>(File)->getObj().getHeader()->e_flags)
       return EFlags;
-    return 1;
+    return AbiV1;
   case ELF64LEKind:
     if (uint32_t EFlags =
         cast<ObjFile<ELF64LE>>(File)->getObj().getHeader()->e_flags)
       return EFlags;
-    return 2;
+    return AbiV2;
   default:
     llvm_unreachable("unknown Config->EKind");
   }
 }
 
 uint32_t PPC64::calcEFlags() const {
   assert(!ObjectFiles.empty());
   uint32_t Ret = getEFlags(ObjectFiles[0]);
RelExpr PPC64::getRelExpr(RelType Type, const Symbol &S,
   case R_PPC64_REL16_HA:
     return R_PC;
   default:
     return R_ABS;
   }
 }
 
 void PPC64::writeGotHeader(uint8_t *Buf) const {
-  if (Config->EKind == ELF64LEKind)
+  if (isPPC64ElfV2())
     write64(Buf, getPPC64TocBase());
 }
 
 void PPC64::writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr,
                      uint64_t PltEntryAddr, int32_t Index,
                      unsigned RelOff) const {
   uint64_t Off = GotPltEntryAddr - getPPC64TocBase();
 
-  if (Config->EKind == ELF64LEKind) {
+  if (isPPC64ElfV2()) {
     // The most-common form of the plt stub. This assumes that the toc-pointer
     // register is properly initalized, and that the stub must save the toc
     // pointer value to the stack-save slot reserved for it (sp + 24).
     // There are 2 other variants but we don't have to emit those until we add
     // support for R_PPC64_REL24_NOTOC and R_PPC64_TOCSAVE relocations.
     // We are missing a super simple optimization, where if the upper 16 bits of
     // the offset are zero, then we can omit the addis instruction, and load
     // r2 + lo-offset directly into r12. I decided to leave this out in the

ELF/Target.h

 
 // Returns input section and corresponding source string for the given location.
 ErrorPlace getErrorPlace(const uint8_t *Loc);
 
 static inline std::string getErrorLocation(const uint8_t *Loc) {
   return getErrorPlace(Loc).Loc;
 }
 
+// Checks for abi version 2 when targeting PPC64.
+bool isPPC64ElfV2();
+
 uint64_t getPPC64TocBase();
 uint64_t getAArch64Page(uint64_t Expr);
 
 extern TargetInfo *Target;
 TargetInfo *getTarget();
 
 template <class ELFT> bool isMipsPIC(const Defined *Sym);
 
 static inline void reportRangeError(uint8_t *Loc, RelType Type, const Twine &V,
                                     int64_t Min, uint64_t Max) {