[NFC] [PowerPC] Determine Endianness in PPCTargetMachine

[gandhi21299]

Summary

Added a member in PPCTargetMachine class which stores the endianness of the target. The endianness is detected from triple which is passed into the static function getDataLayoutString().

[nemanjai]

LGTM (after the clang-format nits are addressed). Thanks for fixing this. Also, please mark this as [NFC] since there are no functional changes and make the title more descriptive. Perhaps:
[NFC][PowerPC] Determine endianness in PPCTargetMachine

[gandhi21299]

Sounds good! Thanks for reviewing @nemanjai

[gandhi21299]

applying clang-format

[gandhi21299]

Please commit this patch at your convenience, thank you. @nemanjai

[gandhi21299]

Can someone who has commit access, commit this patch? Thanks

[nemanjai]

In D98674#2631993, @gandhi21299 wrote:

Can someone who has commit access, commit this patch? Thanks

Sorry for the delay. Will commit today.

[nemanjai]

As it turns out, this can't be committed as-is. The initialization order is incorrect. We compute the endianness while initializing the base class, but the data member is part of the derived class and the default initialization happens afterwards. I'll fix it up and commit it.

[nemanjai]

A couple of notes:

• Please test all patches for PPC on a PPC machine. If you don't have access, please reach out to me and I'll provide access to one on an OSU/OSL machine.
• When running clang-format, please run it only on the code you changed. You can do this using git clang-format (you can find the details at https://llvm.org/docs/Contributing.html#how-to-submit-a-patch)

llvm/lib/Target/PowerPC/PPCSubtarget.cpp

void PPCSubtarget::initSubtargetFeatures(StringRef CPU, StringRef FS) {
 
   // If not SPE, set standard FPU
   if (!HasSPE)
     HasFPU = true;
 
   StackAlignment = getPlatformStackAlignment();
 
   // Determine endianness.
-  // FIXME: Part of the TargetMachine.
-  IsLittleEndian = (TargetTriple.getArch() == Triple::ppc64le ||
-                    TargetTriple.getArch() == Triple::ppcle);
+  IsLittleEndian = TM.isLittleEndian();
 }
 
 bool PPCSubtarget::enableMachineScheduler() const { return true; }
 
 bool PPCSubtarget::enableMachinePipeliner() const {
   return getSchedModel().hasInstrSchedModel() && EnableMachinePipeliner;
 }
 

llvm/lib/Target/PowerPC/PPCTargetMachine.h

 
 namespace llvm {
 
 /// Common code between 32-bit and 64-bit PowerPC targets.
 ///
 class PPCTargetMachine final : public LLVMTargetMachine {
 public:
   enum PPCABI { PPC_ABI_UNKNOWN, PPC_ABI_ELFv1, PPC_ABI_ELFv2 };
+  enum Endian { NOT_DETECTED, LITTLE, BIG };
+
 private:
   std::unique_ptr<TargetLoweringObjectFile> TLOF;
   PPCABI TargetABI;
+  Endian Endianness = Endian::NOT_DETECTED;
 
   mutable StringMap<std::unique_ptr<PPCSubtarget>> SubtargetMap;
 
 public:
   PPCTargetMachine(const Target &T, const Triple &TT, StringRef CPU,
                    StringRef FS, const TargetOptions &Options,
                    Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
                    CodeGenOpt::Level OL, bool JIT);
bool isPPC64() const {
     const Triple &TT = getTargetTriple();
     return (TT.getArch() == Triple::ppc64 || TT.getArch() == Triple::ppc64le);
   };
 
   bool isNoopAddrSpaceCast(unsigned SrcAS, unsigned DestAS) const override {
     // Addrspacecasts are always noops.
     return true;
   }
+
+  bool isLittleEndian() const;
 };
 } // end namespace llvm
 
 #endif

llvm/lib/Target/PowerPC/PPCTargetMachine.cpp

#endif
   initializePPCExpandISELPass(PR);
   initializePPCPreEmitPeepholePass(PR);
   initializePPCTLSDynamicCallPass(PR);
   initializePPCMIPeepholePass(PR);
   initializePPCLowerMASSVEntriesPass(PR);
   initializeGlobalISel(PR);
 }
 
+static bool isLittleEndianTriple(const Triple &T) {
+  return T.getArch() == Triple::ppc64le || T.getArch() == Triple::ppcle;
+}
+
 /// Return the datalayout string of a subtarget.
 static std::string getDataLayoutString(const Triple &T) {
   bool is64Bit = T.getArch() == Triple::ppc64 || T.getArch() == Triple::ppc64le;
   std::string Ret;
 
   // Most PPC* platforms are big endian, PPC(64)LE is little endian.
-  if (T.getArch() == Triple::ppc64le || T.getArch() == Triple::ppcle)
+  if (isLittleEndianTriple(T))
     Ret = "e";
   else
     Ret = "E";
 
   Ret += DataLayout::getManglingComponent(T);
 
   // PPC32 has 32 bit pointers. The PS3 (OS Lv2) is a PPC64 machine with 32 bit
   // pointers.
PPCTargetMachine::PPCTargetMachine(const Target &T, const Triple &TT,
                                    Optional<Reloc::Model> RM,
                                    Optional<CodeModel::Model> CM,
                                    CodeGenOpt::Level OL, bool JIT)
     : LLVMTargetMachine(T, getDataLayoutString(TT), TT, CPU,
                         computeFSAdditions(FS, OL, TT), Options,
                         getEffectiveRelocModel(TT, RM),
                         getEffectivePPCCodeModel(TT, CM, JIT), OL),
       TLOF(createTLOF(getTargetTriple())),
-      TargetABI(computeTargetABI(TT, Options)) {
+      TargetABI(computeTargetABI(TT, Options)),
+      Endianness(isLittleEndianTriple(TT) ? Endian::LITTLE : Endian::BIG) {
   initAsmInfo();
 }
 
 PPCTargetMachine::~PPCTargetMachine() = default;
 
 const PPCSubtarget *
 PPCTargetMachine::getSubtargetImpl(const Function &F) const {
   Attribute CPUAttr = F.getFnAttribute("target-cpu");
void PPCPassConfig::addPreEmitPass() {
   addPass(createPPCBranchSelectionPass());
 }
 
 TargetTransformInfo
 PPCTargetMachine::getTargetTransformInfo(const Function &F) {
   return TargetTransformInfo(PPCTTIImpl(this, F));
 }
 
+bool PPCTargetMachine::isLittleEndian() const {
+  assert(Endianness != Endian::NOT_DETECTED &&
+         "Unable to determine endianness");
+  return Endianness == Endian::LITTLE;
+}
+
 static MachineSchedRegistry
 PPCPreRASchedRegistry("ppc-prera",
                       "Run PowerPC PreRA specific scheduler",
                       createPPCMachineScheduler);
 
 static MachineSchedRegistry
 PPCPostRASchedRegistry("ppc-postra",
                        "Run PowerPC PostRA specific scheduler",