[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

 //===-- PowerPCSubtarget.cpp - PPC Subtarget Information ------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
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

 //===-- PPCTargetMachine.h - Define TargetMachine for PowerPC ---*- 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
 //
 //===----------------------------------------------------------------------===//
 //

 
 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 };
+  Endian Endianness = Endian::NOT_DETECTED;
 private:
   std::unique_ptr<TargetLoweringObjectFile> TLOF;
   PPCABI TargetABI;
 
   mutable StringMap<std::unique_ptr<PPCSubtarget>> SubtargetMap;
 
 public:
   PPCTargetMachine(const Target &T, const Triple &TT, StringRef CPU,
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

 //===-- PPCTargetMachine.cpp - Define TargetMachine for PowerPC -----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
#endif
   initializePPCPreEmitPeepholePass(PR);
   initializePPCTLSDynamicCallPass(PR);
   initializePPCMIPeepholePass(PR);
   initializePPCLowerMASSVEntriesPass(PR);
   initializeGlobalISel(PR);
 }
 
 /// Return the datalayout string of a subtarget.
-static std::string getDataLayoutString(const Triple &T) {
+static std::string getDataLayoutString(const Triple &T,
+                                       PPCTargetMachine *TM) {
   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 (T.getArch() == Triple::ppc64le || T.getArch() == Triple::ppcle){
     Ret = "e";
-  else
+    TM->Endianness = TM->Endian::LITTLE;
+  }
+  else{
     Ret = "E";
+    TM->Endianness = TM->Endian::BIG;
+  }
 
   Ret += DataLayout::getManglingComponent(T);
 
   // PPC32 has 32 bit pointers. The PS3 (OS Lv2) is a PPC64 machine with 32 bit
   // pointers.
   if (!is64Bit || T.getOS() == Triple::Lv2)
     Ret += "-p:32:32";
 

 // into the LLVMTargetMachine constructor and then using the stored value in the
 // Subtarget constructor below it.
 PPCTargetMachine::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)
-    : LLVMTargetMachine(T, getDataLayoutString(TT), TT, CPU,
+    : LLVMTargetMachine(T, getDataLayoutString(TT, this), TT, CPU,
                         computeFSAdditions(FS, OL, TT), Options,
                         getEffectiveRelocModel(TT, RM),
                         getEffectivePPCCodeModel(TT, CM, JIT), OL),
       TLOF(createTLOF(getTargetTriple())),
       TargetABI(computeTargetABI(TT, Options)) {
   initAsmInfo();
 }
 
void PPCPassConfig::addPreEmitPass() {
   addPass(createPPCBranchSelectionPass());
 }
 
 TargetTransformInfo
 PPCTargetMachine::getTargetTransformInfo(const Function &F) {
   return TargetTransformInfo(PPCTTIImpl(this, F));
 }
 
+bool PPCTargetMachine::isLittleEndian() const {
+  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",