[MC][ARM] Reuse symbol value in constant pool

[StephenFan]

Summary

Fix https://github.com/llvm/llvm-project/issues/55816

Before this patch, MCConstantExpr were reused, but MCSymbolExpr were
not. To reuse symbol value, this patch added a DenseMap to record the
symbol value.

[StephenFan]

Delete unused header

[MaskRay]

This patch trys to fix https://github.com/llvm/llvm-project/issues/55816

Just say Fix https://github.com/llvm/llvm-project/issues/55816

llvm/lib/MC/ConstantPools.cpp

48

if (C) {
  auto CItr = CachedConstantEntries.find(C->getValue());
  if (CItr != CachedConstantEntries.end())
    return CItr->second;
}
if (S) {
  ...
}

[StephenFan]

Replace ? : statement to if statement

[MaskRay]

Looks great!

llvm/include/llvm/MC/ConstantPools.h

struct ConstantPoolEntry {
   SMLoc Loc;
 };
 
 // A class to keep track of assembler-generated constant pools that are use to
 // implement the ldr-pseudo.
 class ConstantPool {
   using EntryVecTy = SmallVector<ConstantPoolEntry, 4>;
   EntryVecTy Entries;
-  std::map<int64_t, const MCSymbolRefExpr *> CachedEntries;
+  std::map<int64_t, const MCSymbolRefExpr *> CachedConstantEntries;
+  DenseMap<const MCSymbol *, const MCSymbolRefExpr *> CachedSymbolEntries;
 
 public:
   // Initialize a new empty constant pool
   ConstantPool() = default;
 
   // Add a new entry to the constant pool in the next slot.
   // \param Value is the new entry to put in the constant pool.
   // \param Size is the size in bytes of the entry

llvm/lib/MC/ConstantPools.cpp

void ConstantPool::emitEntries(MCStreamer &Streamer) {
   }
   Streamer.emitDataRegion(MCDR_DataRegionEnd);
   Entries.clear();
 }
 
 const MCExpr *ConstantPool::addEntry(const MCExpr *Value, MCContext &Context,
                                      unsigned Size, SMLoc Loc) {
   const MCConstantExpr *C = dyn_cast<MCConstantExpr>(Value);
+  const MCSymbolRefExpr *S = dyn_cast<MCSymbolRefExpr>(Value);
 
   // Check if there is existing entry for the same constant. If so, reuse it.
-  auto Itr = C ? CachedEntries.find(C->getValue()) : CachedEntries.end();
-  if (Itr != CachedEntries.end())
-    return Itr->second;
+  auto CItr = C ? CachedConstantEntries.find(C->getValue())
+                : CachedConstantEntries.end();
+  if (CItr != CachedConstantEntries.end())
+    return CItr->second;
+
+  // Check if there is existing entry for the same symbol. If so, reuse if.
+  auto SItr = S ? CachedSymbolEntries.find(&(S->getSymbol()))
+                : CachedSymbolEntries.end();
+  if (SItr != CachedSymbolEntries.end())
+    return SItr->second;
 
   MCSymbol *CPEntryLabel = Context.createTempSymbol();
 
   Entries.push_back(ConstantPoolEntry(CPEntryLabel, Value, Size, Loc));
   const auto SymRef = MCSymbolRefExpr::create(CPEntryLabel, Context);
   if (C)
-    CachedEntries[C->getValue()] = SymRef;
+    CachedConstantEntries[C->getValue()] = SymRef;
+  if (S)
+    CachedSymbolEntries[&(S->getSymbol())] = SymRef;
   return SymRef;
 }
 
 bool ConstantPool::empty() { return Entries.empty(); }
 
 void ConstantPool::clearCache() {
-  CachedEntries.clear();
+  CachedConstantEntries.clear();
+  CachedSymbolEntries.clear();
 }
 
 //
 // AssemblerConstantPools implementation
 //
 ConstantPool *AssemblerConstantPools::getConstantPool(MCSection *Section) {
   ConstantPoolMapTy::iterator CP = ConstantPools.find(Section);
   if (CP == ConstantPools.end())

llvm/test/MC/ARM/ldr-pseudo-wide.s

f2:
   ldr r0, =foo
 @ CHECK-ARM: ldr r0, .Ltmp[[TMP1:[0-9]+]]
 @ CHECK-DARWIN-ARM: ldr r0, Ltmp1
 @ CHECK-THUMB2: ldr r0, .Ltmp[[TMP1:[0-9]+]]
 @ CHECK-DARWIN-THUMB2: ldr r0, Ltmp1
 
   ldr.w r0, =foo
 @ CHECK-ARM: ldr r0, .Ltmp[[TMP2:[0-9]+]]
-@ CHECK-DARWIN-ARM: ldr r0, Ltmp2
+@ CHECK-DARWIN-ARM: ldr r0, Ltmp1
 @ CHECK-THUMB2: ldr.w r0, .Ltmp[[TMP2:[0-9]+]]
-@ CHECK-DARWIN-THUMB2: ldr.w r0, Ltmp2
+@ CHECK-DARWIN-THUMB2: ldr.w r0, Ltmp1
 @ CHECK-THUMB: error: instruction requires: thumb2
 @ CHECK-THUMB-NEXT:  ldr.w r0, =foo
 
 @ CHECK-LABEL: f3:
 f3:
   ldr.w r1, =0x1
 @ CHECK-ARM: mov r1, #1
 @ CHECK-DARWIN-ARM: mov r1, #1
 @ CHECK-THUMB2: mov.w r1, #1
 @ CHECK-DARWIN-THUMB2: mov.w r1, #1
 @ CHECK-THUMB: error: instruction requires: thumb2
 @ CHECK-THUMB-NEXT:  ldr.w r1, =0x1
 
 @ CHECK: .Ltmp0:
 @ CHECK-NEXT: .long   65538
 @ CHECK: .Ltmp1:
 @ CHECK-NEXT: .long   foo
-@ CHECK: .Ltmp2:
-@ CHECK-NEXT: .long   foo
 
 @ CHECK-DARWIN: Ltmp0:
 @ CHECK-DARWIN-NEXT: .long   65538
 @ CHECK-DARWIN: Ltmp1:
 @ CHECK-DARWIN-NEXT: .long   foo
-@ CHECK-DARWIN: Ltmp2:
-@ CHECK-DARWIN-NEXT: .long   foo