[AIX] Append hex string of constant value to the end of constant symbol name

[lkail]

Summary

Change constant symbol's format to CP<FUNC_NUM>_<CPID> to CP<FUNC_NUM>_<CPID>_<HEX> to improve verbosity. This can make user to identify the constants easier via binary utilities.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
+#include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
 #include "llvm/CodeGen/MachineOperand.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/StackMaps.h"
 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
public:
 
   void emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const override;
 
   void emitInstruction(const MachineInstr *MI) override;
 
   bool doFinalization(Module &M) override;
 
   void emitTTypeReference(const GlobalValue *GV, unsigned Encoding) override;
+
+  MCSymbol *GetCPISymbol(unsigned CPID) const override;
 };
 
 } // end anonymous namespace
 
 void PPCAsmPrinter::PrintSymbolOperand(const MachineOperand &MO,
                                        raw_ostream &O) {
   // Computing the address of a global symbol, not calling it.
   const GlobalValue *GV = MO.getGlobal();
if (GV) {
     const MCExpr *Exp =
         MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCEntry, Ctx),
                                 MCSymbolRefExpr::create(TOCBaseSym, Ctx), Ctx);
     OutStreamer->emitValue(Exp, GetSizeOfEncodedValue(Encoding));
   } else
     OutStreamer->emitIntValue(0, GetSizeOfEncodedValue(Encoding));
 }
 
+// GetCPISymbol - Return the symbol for the specified constant pool entry.
+MCSymbol *PPCAIXAsmPrinter::GetCPISymbol(unsigned CPID) const {
+  // Append hex string of the constant value at the end of the symbol for
+  // verbosity.
+  const MachineConstantPoolEntry &CPE =
+      MF->getConstantPool()->getConstants()[CPID];
+  if (!CPE.isMachineConstantPoolEntry()) {
+    const Constant *C = CPE.Val.ConstVal;
+    APInt Rep;
+    bool Valid = false;
+    if (const ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
+      Rep = CI->getValue();
+      Valid = true;
+    }
+    if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
+      Rep = CFP->getValueAPF().bitcastToAPInt();
+      Valid = true;
+    }
+    if (Valid) {
+      const DataLayout &DL = getDataLayout();
+      const uint64_t *RawData = Rep.getRawData();
+      SmallString<32> HexRep("0x");
+      for (unsigned I = 0; I < Rep.getNumWords(); ++I)
+        HexRep += utohexstr(RawData[I]);
+      return OutContext.getOrCreateSymbol(Twine(DL.getPrivateGlobalPrefix()) +
+                                          "CPI" + Twine(getFunctionNumber()) +
+                                          "_" + Twine(CPID) + "_" + HexRep);
+    }
+  }
+
+  return AsmPrinter::GetCPISymbol(CPID);
+}
+
 // Return a pass that prints the PPC assembly code for a MachineFunction to the
 // given output stream.
 static AsmPrinter *
 createPPCAsmPrinterPass(TargetMachine &tm,
                         std::unique_ptr<MCStreamer> &&Streamer) {
   if (tm.getTargetTriple().isOSAIX())
     return new PPCAIXAsmPrinter(tm, std::move(Streamer));
 

llvm/test/CodeGen/PowerPC/aix-constant-align.ll

 
 define float @PIfloat() #0 {
   entry:
     ret float 0x400921FA00000000
 }
 
 ; CHECK:         .csect .rodata.8[RO],3
 ; CHECK-NEXT:    .align  3
-; CHECK-NEXT:  L..CPI0_0:
+; CHECK-NEXT:  L..CPI0_0_0x400921F9F01B866E:
 ; CHECK32-NEXT:  .vbyte  4, 1074340345
 ; CHECK32-NEXT:  .vbyte  4, 4028335726
 ; CHECK64-NEXT:  .vbyte  8, 0x400921f9f01b866e
 
 
 ; CHECK:         .csect .rodata[RO],2
 ; CHECK-NEXT:    .align  2
-; CHECK-NEXT:  L..CPI1_0:
+; CHECK-NEXT:  L..CPI1_0_0x40490FD0:
 ; CHECK-NEXT:    .vbyte  4, 0x40490fd0
 
 ; CHECK:         .csect NOT_PI[RO],3

llvm/test/CodeGen/PowerPC/aix-lower-constant-pool-index.ll

 ; 64SMALL-MIR: renamable $f[[REG2:[0-9]+]] = LFS 0, killed renamable $x[[REG1]] :: (load (s32) from constant-pool)
 
 ; 64LARGE-MIR: renamable $x[[REG1:[0-9]+]] = ADDIStocHA8 $x2, %const.0
 ; 64LARGE-MIR: renamable $x[[REG2:[0-9]+]] = LDtocL %const.0, killed renamable $x[[REG1]], implicit $x2 :: (load (s64) from got)
 ; 64LARGE-MIR: renamable $f[[REG3:[0-9]+]] = LFS 0, killed renamable $x[[REG2]] :: (load (s32) from constant-pool)
 
 ; 32SMALL-ASM:         .csect .rodata[RO],2
 ; 32SMALL-ASM:         .align  2
-; 32SMALL-ASM: L..CPI0_0:
+; 32SMALL-ASM: L..CPI0_0_0x40B00000:
 ; 32SMALL-ASM:         .vbyte 4, 0x40b00000
 ; 32SMALL-ASM: .test_float:
 ; 32SMALL-ASM:         lwz [[REG1:[0-9]+]], L..C0(2)
 ; 32SMALL-ASM:         lfs 1, 0([[REG1]])
 ; 32SMALL-ASM:         blr
 
 ; 32LARGE-ASM:         .csect .rodata[RO],2
 ; 32LARGE-ASM:         .align  2
-; 32LARGE-ASM: L..CPI0_0:
+; 32LARGE-ASM: L..CPI0_0_0x40B00000:
 ; 32LARGE-ASM:         .vbyte 4, 0x40b00000
 ; 32LARGE-ASM: .test_float:
 ; 32LARGE-ASM:         addis [[REG1:[0-9]+]], L..C0@u(2)
 ; 32LARGE-ASM:         lwz [[REG2:[0-9]+]], L..C0@l([[REG1]])
 ; 32LARGE-ASM:         lfs 1, 0([[REG2]])
 ; 32LARGE-ASM:         blr
 
 ; 64SMALL-ASM:         .csect .rodata[RO],2
 ; 64SMALL-ASM:         .align  2
-; 64SMALL-ASM: L..CPI0_0:
+; 64SMALL-ASM: L..CPI0_0_0x40B00000:
 ; 64SMALL-ASM:         .vbyte 4, 0x40b00000
 ; 64SMALL-ASM: .test_float:
 ; 64SMALL-ASM:         ld [[REG1:[0-9]+]], L..C0(2)
 ; 64SMALL-ASM:         lfs 1, 0([[REG1]])
 ; 64SMALL-ASM:         blr
 
 ; 64LARGE-ASM:         .csect .rodata[RO],2
 ; 64LARGE-ASM:         .align  2
-; 64LARGE-ASM: L..CPI0_0:
+; 64LARGE-ASM: L..CPI0_0_0x40B00000:
 ; 64LARGE-ASM:         .vbyte 4, 0x40b00000
 ; 64LARGE-ASM: .test_float:
 ; 64LARGE-ASM:         addis [[REG1:[0-9]+]], L..C0@u(2)
 ; 64LARGE-ASM:         ld [[REG2:[0-9]+]], L..C0@l([[REG1]])
 ; 64LARGE-ASM:         lfs 1, 0([[REG2]])
 ; 64LARGE-ASM:         blr
 
 ; SMALL-ASM: .toc
-; SMALL-ASM: .tc L..CPI0_0[TC],L..CPI0_0
+; SMALL-ASM: .tc L..CPI0_0_0x40B00000[TC],L..CPI0_0_0x40B00000
 
 ; LARGE-ASM: .toc
-; LARGE-ASM: .tc L..CPI0_0[TE],L..CPI0_0
+; LARGE-ASM: .tc L..CPI0_0_0x40B00000[TE],L..CPI0_0_0x40B00000