[BOLT][DWARF] Reduce overhead for sized dealloc

[ayermolo]

Summary

This is a follow up to Fix size mismatch error with jemalloc.
4243b6582cf3bb5fbcde908913d4779ded731321
Although that fix works it increased memory footprint.
With this patch we go back to original memory footprint.

[ayermolo]

addressed nit

[maksfb]

There's a clang-format issue and a nit. Otherwise LGTM.

bolt/include/bolt/Core/DebugData.h

663

[ayermolo]

addressed comments

bolt/include/bolt/Core/DebugData.h

enum class DebugPatchKind {
     DWARFUnitOffsetBaseLabel,
     DestinationReferenceLabel
   };
 
   struct Patch {
     Patch(uint32_t O, DebugPatchKind K) : Offset(O), Kind(K) {}
     DebugPatchKind getKind() const { return Kind; }
 
-    virtual ~Patch(){};
-
     static bool classof(const Patch *Writer) {
       return Writer->getKind() == DebugPatchKind::PatchBaseClass;
     }
 
     uint32_t Offset;
     DebugPatchKind Kind;
   };
 
public:
   /// Sets DWARF Units offset, \p  DWPOffset , within DWP file.
   void setDWPOffset(uint64_t DWPOffset) { DWPUnitOffset = DWPOffset; }
 
   /// When this function is invoked all of the DebugInfo Patches must be done.
   /// Returns a map of old CU offsets to new ones.
   std::unordered_map<uint32_t, uint32_t> computeNewOffsets();
 
 private:
+  struct PatchDeleter {
+    void operator()(Patch *P) const {
+      Patch *Pp = reinterpret_cast<Patch *>(P);
+      switch (Pp->Kind) {
+      default:
+        llvm_unreachable(
+            "Not all delete instances handled for Patch derived classes");
+      case DebugPatchKind::PatchValue32:
+        delete reinterpret_cast<DebugPatch32 *>(P);
+        break;
+      case DebugPatchKind::PatchValue64to32:
+        delete reinterpret_cast<DebugPatch64to32 *>(P);
+        break;
+      case DebugPatchKind::PatchValue64:
+        delete reinterpret_cast<DebugPatch64 *>(P);
+        break;
+      case DebugPatchKind::PatchValueVariable:
+        delete reinterpret_cast<DebugPatchVariableSize *>(P);
+        break;
+      case DebugPatchKind::ReferencePatchValue:
+        delete reinterpret_cast<DebugPatchReference *>(P);
+        break;
+      case DebugPatchKind::DWARFUnitOffsetBaseLabel:
+        delete reinterpret_cast<DWARFUnitOffsetBaseLabel *>(P);
+        break;
+      case DebugPatchKind::DestinationReferenceLabel:
+        delete reinterpret_cast<DestinationReferenceLabel *>(P);
+        break;
+      }
+    }
+  };
+  using UniquePatchPtrType = std::unique_ptr<Patch, PatchDeleter>;
+
   uint64_t DWPUnitOffset{0};
   uint32_t ChangeInSize{0};
-  std::vector<std::unique_ptr<Patch>> DebugPatches;
+  std::vector<UniquePatchPtrType> DebugPatches;
   /// Mutex used for parallel processing of debug info.
   std::mutex WriterMutex;
   /// Stores fully resolved addresses of DIEs that are being referenced.
   std::unordered_set<uint32_t> DestinationLabels;
   /// Map of original debug info references to new ones.
   std::unordered_map<uint32_t, uint32_t> OldToNewOffset;
 };
 

bolt/lib/Core/DebugData.cpp

void DebugLoclistWriter::finalize(uint64_t SectionOffset,
   clearList(Patches);
 }
 
 DebugAddrWriter *DebugLoclistWriter::AddrWriter = nullptr;
 
 void DebugInfoBinaryPatcher::addUnitBaseOffsetLabel(uint64_t Offset) {
   Offset -= DWPUnitOffset;
   std::lock_guard<std::mutex> Lock(WriterMutex);
-  DebugPatches.emplace_back(std::make_unique<DWARFUnitOffsetBaseLabel>(Offset));
+  DebugPatches.emplace_back(new DWARFUnitOffsetBaseLabel(Offset));
 }
 
 void DebugInfoBinaryPatcher::addDestinationReferenceLabel(uint64_t Offset) {
   Offset -= DWPUnitOffset;
   std::lock_guard<std::mutex> Lock(WriterMutex);
   auto RetVal = DestinationLabels.insert(Offset);
   if (!RetVal.second)
     return;
 
-  DebugPatches.emplace_back(
-      std::make_unique<DestinationReferenceLabel>(Offset));
+  DebugPatches.emplace_back(new DestinationReferenceLabel(Offset));
 }
 
 void DebugInfoBinaryPatcher::addReferenceToPatch(uint64_t Offset,
                                                  uint32_t DestinationOffset,
                                                  uint32_t OldValueSize,
                                                  dwarf::Form Form) {
   Offset -= DWPUnitOffset;
   DestinationOffset -= DWPUnitOffset;
   std::lock_guard<std::mutex> Lock(WriterMutex);
-  DebugPatches.emplace_back(std::make_unique<DebugPatchReference>(
-      Offset, OldValueSize, DestinationOffset, Form));
+  DebugPatches.emplace_back(
+      new DebugPatchReference(Offset, OldValueSize, DestinationOffset, Form));
 }
 
 void DebugInfoBinaryPatcher::addUDataPatch(uint64_t Offset, uint64_t NewValue,
                                            uint32_t OldValueSize) {
   Offset -= DWPUnitOffset;
   std::lock_guard<std::mutex> Lock(WriterMutex);
   DebugPatches.emplace_back(
-      std::make_unique<DebugPatchVariableSize>(Offset, OldValueSize, NewValue));
+      new DebugPatchVariableSize(Offset, OldValueSize, NewValue));
 }
 
 void DebugInfoBinaryPatcher::addLE64Patch(uint64_t Offset, uint64_t NewValue) {
   Offset -= DWPUnitOffset;
   std::lock_guard<std::mutex> Lock(WriterMutex);
-  DebugPatches.emplace_back(std::make_unique<DebugPatch64>(Offset, NewValue));
+  DebugPatches.emplace_back(new DebugPatch64(Offset, NewValue));
 }
 
 void DebugInfoBinaryPatcher::addLE32Patch(uint64_t Offset, uint32_t NewValue,
                                           uint32_t OldValueSize) {
   Offset -= DWPUnitOffset;
   std::lock_guard<std::mutex> Lock(WriterMutex);
   if (OldValueSize == 4)
-    DebugPatches.emplace_back(std::make_unique<DebugPatch32>(Offset, NewValue));
+    DebugPatches.emplace_back(new DebugPatch32(Offset, NewValue));
   else
-    DebugPatches.emplace_back(
-        std::make_unique<DebugPatch64to32>(Offset, NewValue));
+    DebugPatches.emplace_back(new DebugPatch64to32(Offset, NewValue));
 }
 
 void SimpleBinaryPatcher::addBinaryPatch(uint64_t Offset,
                                          std::string &&NewValue,
                                          uint32_t OldValueSize) {
   Patches.emplace_back(Offset, std::move(NewValue));
 }
 
for (const auto &Patch : Patches) {
     }
   }
   return BinaryContentsStr;
 }
 
 std::unordered_map<uint32_t, uint32_t>
 DebugInfoBinaryPatcher::computeNewOffsets() {
   std::unordered_map<uint32_t, uint32_t> CUMap;
-  std::sort(
-      DebugPatches.begin(), DebugPatches.end(),
-      [](const std::unique_ptr<Patch> &V1, const std::unique_ptr<Patch> &V2) {
+  std::sort(DebugPatches.begin(), DebugPatches.end(),
+            [](const UniquePatchPtrType &V1, const UniquePatchPtrType &V2) {
               return V1.get()->Offset < V2.get()->Offset;
             });
 
   // Calculating changes in .debug_info size from Patches to build a map of old
   // to updated reference destination offsets.
-  for (std::unique_ptr<Patch> &PatchBase : DebugPatches) {
+  for (UniquePatchPtrType &PatchBase : DebugPatches) {
     Patch *P = PatchBase.get();
     switch (P->Kind) {
     default:
       continue;
     case DebugPatchKind::PatchValue64to32: {
       ChangeInSize -= 4;
       break;
     }
std::string DebugInfoBinaryPatcher::patchBinary(StringRef BinaryContents) {
   uint32_t Offset = 0;
   std::string ByteSequence;
   std::vector<std::pair<uint32_t, uint32_t>> LengthPatches;
   // Wasting one entry to avoid checks for first.
   LengthPatches.push_back({0, 0});
 
   // Applying all the patches replacing current entry.
   // This might change the size of .debug_info section.
-  for (const std::unique_ptr<Patch> &PatchBase : DebugPatches) {
+  for (const UniquePatchPtrType &PatchBase : DebugPatches) {
     Patch *P = PatchBase.get();
     switch (P->Kind) {
     default:
       continue;
     case DebugPatchKind::ReferencePatchValue: {
       DebugPatchReference *RDP = reinterpret_cast<DebugPatchReference *>(P);
       uint32_t DestinationOffset = RDP->DestinationOffset;
       assert(OldToNewOffset.count(DestinationOffset) &&