[llvm] LiveIntervals: Use BumpPtrAllocator (PR #127057)

[Matt Arsenault via llvm-commits]

https://github.com/arsenm updated https://github.com/llvm/llvm-project/pull/127057

>From e3ac2118700ef3ea4ef19a504d0c514e663fd135 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Thu, 26 Dec 2024 11:52:38 +0700
Subject: [PATCH 1/2] LiveIntervals: Use BumpPtrAllocator

---
 llvm/include/llvm/CodeGen/LiveIntervals.h | 12 ++++++++----
 llvm/lib/CodeGen/LiveIntervals.cpp        |  9 +++++----
 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/llvm/include/llvm/CodeGen/LiveIntervals.h b/llvm/include/llvm/CodeGen/LiveIntervals.h
index 708917be497ef..65b59a9d8b41c 100644
--- a/llvm/include/llvm/CodeGen/LiveIntervals.h
+++ b/llvm/include/llvm/CodeGen/LiveIntervals.h
@@ -30,6 +30,7 @@
 #include "llvm/CodeGen/SlotIndexes.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
 #include "llvm/MC/LaneBitmask.h"
+#include "llvm/Support/Allocator.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -64,6 +65,8 @@ class LiveIntervals {
   MachineDominatorTree *DomTree = nullptr;
   std::unique_ptr<LiveIntervalCalc> LICalc;
 
+  BumpPtrAllocator Allocator;
+
   /// Special pool allocator for VNInfo's (LiveInterval val#).
   VNInfo::Allocator VNInfoAllocator;
 
@@ -170,7 +173,7 @@ class LiveIntervals {
   /// Interval removal.
   void removeInterval(Register Reg) {
     auto &Interval = VirtRegIntervals[Reg];
-    delete Interval;
+    Allocator.Deallocate(Interval);
     Interval = nullptr;
   }
 
@@ -416,7 +419,8 @@ class LiveIntervals {
     if (!LR) {
       // Compute missing ranges on demand.
       // Use segment set to speed-up initial computation of the live range.
-      RegUnitRanges[Unit] = LR = new LiveRange(UseSegmentSetForPhysRegs);
+      RegUnitRanges[Unit] = LR = new (Allocator.Allocate<LiveRange>())
+          LiveRange(UseSegmentSetForPhysRegs);
       computeRegUnitRange(*LR, Unit);
     }
     return *LR;
@@ -433,7 +437,7 @@ class LiveIntervals {
   /// Remove computed live range for register unit \p Unit. Subsequent uses
   /// should rely on on-demand recomputation.
   void removeRegUnit(unsigned Unit) {
-    delete RegUnitRanges[Unit];
+    Allocator.Deallocate(RegUnitRanges[Unit]);
     RegUnitRanges[Unit] = nullptr;
   }
 
@@ -481,7 +485,7 @@ class LiveIntervals {
   bool computeDeadValues(LiveInterval &LI,
                          SmallVectorImpl<MachineInstr *> *dead);
 
-  static LiveInterval *createInterval(Register Reg);
+  LiveInterval *createInterval(Register Reg);
 
   void printInstrs(raw_ostream &O) const;
   void dumpInstrs() const;
diff --git a/llvm/lib/CodeGen/LiveIntervals.cpp b/llvm/lib/CodeGen/LiveIntervals.cpp
index 3485a27335f13..f12bf87023979 100644
--- a/llvm/lib/CodeGen/LiveIntervals.cpp
+++ b/llvm/lib/CodeGen/LiveIntervals.cpp
@@ -144,14 +144,14 @@ bool LiveIntervals::invalidate(
 void LiveIntervals::clear() {
   // Free the live intervals themselves.
   for (unsigned i = 0, e = VirtRegIntervals.size(); i != e; ++i)
-    delete VirtRegIntervals[Register::index2VirtReg(i)];
+    Allocator.Deallocate(VirtRegIntervals[Register::index2VirtReg(i)]);
   VirtRegIntervals.clear();
   RegMaskSlots.clear();
   RegMaskBits.clear();
   RegMaskBlocks.clear();
 
   for (LiveRange *LR : RegUnitRanges)
-    delete LR;
+    Allocator.Deallocate(LR);
   RegUnitRanges.clear();
 
   // Release VNInfo memory regions, VNInfo objects don't need to be dtor'd.
@@ -222,7 +222,7 @@ LLVM_DUMP_METHOD void LiveIntervals::dump() const { print(dbgs()); }
 
 LiveInterval *LiveIntervals::createInterval(Register reg) {
   float Weight = reg.isPhysical() ? huge_valf : 0.0F;
-  return new LiveInterval(reg, Weight);
+  return new (Allocator.Allocate<LiveInterval>()) LiveInterval(reg, Weight);
 }
 
 /// Compute the live interval of a virtual register, based on defs and uses.
@@ -374,7 +374,8 @@ void LiveIntervals::computeLiveInRegUnits() {
         LiveRange *LR = RegUnitRanges[Unit];
         if (!LR) {
           // Use segment set to speed-up initial computation of the live range.
-          LR = RegUnitRanges[Unit] = new LiveRange(UseSegmentSetForPhysRegs);
+          LR = RegUnitRanges[Unit] = new (Allocator.Allocate<LiveRange>())
+              LiveRange(UseSegmentSetForPhysRegs);
           NewRanges.push_back(Unit);
         }
         VNInfo *VNI = LR->createDeadDef(Begin, getVNInfoAllocator());

>From c15e46a58e8f88157fa42b0b795a6dafc6eae1e6 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Mon, 24 Feb 2025 18:50:33 +0700
Subject: [PATCH 2/2] Use SpecificBumpPtrAllocator for LiveInterval

I didn't realize we used a singly linked list for storing subranges,
but that seems bad.

I didn't realize we used a singly linked list for storing subranges.
That seems bad and we should probably switch this to an array
---
 llvm/include/llvm/CodeGen/LiveIntervals.h |  6 +++++-
 llvm/lib/CodeGen/LiveIntervals.cpp        | 10 +++++-----
 2 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/llvm/include/llvm/CodeGen/LiveIntervals.h b/llvm/include/llvm/CodeGen/LiveIntervals.h
index 65b59a9d8b41c..7cee939d352af 100644
--- a/llvm/include/llvm/CodeGen/LiveIntervals.h
+++ b/llvm/include/llvm/CodeGen/LiveIntervals.h
@@ -65,8 +65,12 @@ class LiveIntervals {
   MachineDominatorTree *DomTree = nullptr;
   std::unique_ptr<LiveIntervalCalc> LICalc;
 
+  // Allocator for RegUnitRanges and SubRanges.
   BumpPtrAllocator Allocator;
 
+  // Allocator for VirtRegIntervals
+  SpecificBumpPtrAllocator<LiveInterval> LIAllocator;
+
   /// Special pool allocator for VNInfo's (LiveInterval val#).
   VNInfo::Allocator VNInfoAllocator;
 
@@ -173,7 +177,7 @@ class LiveIntervals {
   /// Interval removal.
   void removeInterval(Register Reg) {
     auto &Interval = VirtRegIntervals[Reg];
-    Allocator.Deallocate(Interval);
+    // FIXME: SpecificBumpPtrAllocator missing deallocate for asan poisoning
     Interval = nullptr;
   }
 
diff --git a/llvm/lib/CodeGen/LiveIntervals.cpp b/llvm/lib/CodeGen/LiveIntervals.cpp
index f12bf87023979..fd5cc38358319 100644
--- a/llvm/lib/CodeGen/LiveIntervals.cpp
+++ b/llvm/lib/CodeGen/LiveIntervals.cpp
@@ -142,10 +142,6 @@ bool LiveIntervals::invalidate(
 }
 
 void LiveIntervals::clear() {
-  // Free the live intervals themselves.
-  for (unsigned i = 0, e = VirtRegIntervals.size(); i != e; ++i)
-    Allocator.Deallocate(VirtRegIntervals[Register::index2VirtReg(i)]);
-  VirtRegIntervals.clear();
   RegMaskSlots.clear();
   RegMaskBits.clear();
   RegMaskBlocks.clear();
@@ -154,6 +150,10 @@ void LiveIntervals::clear() {
     Allocator.Deallocate(LR);
   RegUnitRanges.clear();
 
+  // Free the live intervals themselves.
+  LIAllocator.DestroyAll();
+  VirtRegIntervals.clear();
+
   // Release VNInfo memory regions, VNInfo objects don't need to be dtor'd.
   VNInfoAllocator.Reset();
 }
@@ -222,7 +222,7 @@ LLVM_DUMP_METHOD void LiveIntervals::dump() const { print(dbgs()); }
 
 LiveInterval *LiveIntervals::createInterval(Register reg) {
   float Weight = reg.isPhysical() ? huge_valf : 0.0F;
-  return new (Allocator.Allocate<LiveInterval>()) LiveInterval(reg, Weight);
+  return new (LIAllocator.Allocate()) LiveInterval(reg, Weight);
 }
 
 /// Compute the live interval of a virtual register, based on defs and uses.