[BOLT][DWARF] Implement new mechanism for DWARFRewriter

[ayermolo]

Summary

This revision implement new mechanism for DWARFRewriter.
In the new mechanism, we adopt the same way with DWARFLinker did. By parsing Debug information into IR, we are allowed to handle debug information more flexible. Now the debug information updating process relies on IR and IR will be written out to binary once the updating finished.

A new class was added: DIEBuilder. This class is responsible for parsing debug information and raising it to the IR level.
This class is also used to write out the .debug_info and .debug_abbrev sections.
Since we output brand new Abbrev section we won't need to always convert low_pc/high_pc into ranges.
When conversion does happen we can also remove low_pc entry.

Followup patches:
https://reviews.llvm.org/D151906
https://reviews.llvm.org/D151908
https://reviews.llvm.org/D151909

[ayermolo]

bolt/test/X86/shared-abbrev.s

107

just remove this.

[zr33]

change the non-null parameter from pointer to reference.

[ayermolo]

Please update the summary to be more descriptive.

[ayermolo]

Move bolt/test/X86/shared-abbrev.s into a separate diff.

[zr33]

In D130315#3670735, @ayermolo wrote:

Move bolt/test/X86/shared-abbrev.s into a separate diff.

I will create a new revision for that test, however, this diff should also keep it, because I fix the abbrev offset to 0.

[zr33]

make some parameters const

[ayermolo]

bolt/include/bolt/Rewrite/DIEBuilder.h

56

59

79

80

82

Is this necessary? I don't think this implementation is multi threaded. Right?

109

125

Should DWARFExpression be by reference?

156

159

Can DU be null? If not can you make it a const reference?
Tangental thought. Would it make sense to have a separate unordered map to look up of DWARFUnit pointer to uniqueID?
Instead of doing linear search every single time this function is invoked.
The uniqueID can be an index in this vector.
So wrapper that ads *DU to this vector and stores size() -1 in the unordered map as ID, keyed by ptr address.
Something like that?

173

173

Maybe just turn this in to print out of BOLT-ERROR?

bolt/lib/Rewrite/DIEBuilder.cpp

38

67

If DU can't be null, pass by reference.

[ayermolo]

bolt/lib/Rewrite/DIEBuilder.cpp

121

When will DwarfContext be null?

181

Where is UnitDIEId actually used?

305

383

Does this need to be a unique_ptr? Can we just store a struct itself?

[ayermolo]

bolt/lib/Rewrite/DWARFRewriter.cpp

759

As discussed can you move this to a separate commit + test?

[zr33]

Adopt new Unit ID lookup approach.
fix names

[ayermolo]

bolt/lib/Rewrite/DWARFRewriter.cpp

988

Not sure this logic is correct.

The DW_OP_addrx operation has a single operand that encodes an unsigned
15 LEB128

[zr33]

bolt/lib/Rewrite/DWARFRewriter.cpp

988

This part is create a DIE IR for DW_AT_location. In this process, we keep tracking the size of new expressions.

1. We first get the new Index and calculate the LEB128 format for this index.
2. Append the opcode into IR.
3. Append the the LEB128 format index into IR.

After iterating all the expression, update the size of IR.

[zr33]

1. Rewrite finding TypeDIE part. It used to find by traversing the tree and find according to the Attribute name. However, this is not accurate because a type unit can have multiple Attributes which can be TypeDIE, but there is only 1 can represent the Type Unit. Currently, the TypeDIE is record during IR construction.

2. Re-calibrate the cross-CU reference in case there are type units in .debug_types section.

3. clean up code and fix nits.

[zr33]

optimize the Type unit part and rebase.

[zr33]

rebase and add error message for new typeunit search

[ayermolo]

Taking over this from @zr33 as his internship has ended.

[ayermolo]

rebase, nits. Future changes will be on subsequent commits.

[ayermolo]

rebase

[ayermolo]

fixed Optional, after rebase

[ayermolo]

rebase

[maksfb]

Let's add a better summary with the description of the new rewriter classes.

[ayermolo]

rebase

[ayermolo]

rebase + fix for upstream change https://reviews.llvm.org/D147270

[ayermolo]

rebase

[ayermolo]

rebase + moved DIEBuilder under Core

[gribozavr2]

Hi,

This commit introduces a null pointer dereference in a unit test, so I'm going to revert it together with all dependent commits:

$ lldb -- ./unittests/DebugInfo/DWARF/DebugInfoDWARFTests --gtest_filter=DWARFDebugInfo.TestDwarfToFunctions
This is google-lldb.
Help: http://go/lldb. File a bug: http://go/lldb-bug.
(lldb) target create "./unittests/DebugInfo/DWARF/DebugInfoDWARFTests"
Current executable set to '/usr/local/google/home/dmitrig/llvm2/build-debug/unittests/DebugInfo/DWARF/DebugInfoDWARFTests' (x86_64).
(lldb) settings set -- target.run-args  "--gtest_filter=DWARFDebugInfo.TestDwarfToFunctions"
(lldb) r
Process 2771099 launched: '/usr/local/google/home/dmitrig/llvm2/build-debug/unittests/DebugInfo/DWARF/DebugInfoDWARFTests' (x86_64)
Note: Google Test filter = DWARFDebugInfo.TestDwarfToFunctions
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from DWARFDebugInfo
[ RUN      ] DWARFDebugInfo.TestDwarfToFunctions
Process 2771099 stopped
* thread #1, name = 'DebugInfoDWARFT', stop reason = signal SIGSEGV: address not mapped to object (fault address: 0x20)
    frame #0: 0x0000555555c0d41c DebugInfoDWARFTests`llvm::DWARFUnitHeader::getVersion(this=0x0000000000000018) const at DWARFUnit.h:89:33
   86     bool applyIndexEntry(const DWARFUnitIndex::Entry *Entry);
   87     uint64_t getOffset() const { return Offset; }
   88     const dwarf::FormParams &getFormParams() const { return FormParams; }
-> 89     uint16_t getVersion() const { return FormParams.Version; }
   90     dwarf::DwarfFormat getFormat() const { return FormParams.Format; }
   91     uint8_t getAddressByteSize() const { return FormParams.AddrSize; }
   92     uint8_t getRefAddrByteSize() const { return FormParams.getRefAddrByteSize(); }
(lldb) up
frame #1: 0x000055555810bc59 DebugInfoDWARFTests`llvm::DWARFUnit::getVersion(this=0x0000000000000000) const at DWARFUnit.h:323:47
   320    const dwarf::FormParams &getFormParams() const {
   321      return Header.getFormParams();
   322    }
-> 323    uint16_t getVersion() const { return Header.getVersion(); }
   324    uint8_t getAddressByteSize() const { return Header.getAddressByteSize(); }
   325    uint8_t getRefAddrByteSize() const { return Header.getRefAddrByteSize(); }
   326    uint8_t getDwarfOffsetByteSize() const {
(lldb) up
frame #2: 0x00005555581953a3 DebugInfoDWARFTests`llvm::DWARFFormValue::getAsSectionedAddress(Value=0x00007fffffffd2e8, Form=0, U=0x0000000000000000) at DWARFFormValue.cpp:642:51
   639
   640  std::optional<object::SectionedAddress> DWARFFormValue::getAsSectionedAddress(
   641      const ValueType &Value, const dwarf::Form Form, const DWARFUnit *U) {
-> 642    if (!doesFormBelongToClass(Form, FC_Address, U->getVersion()))
   643      return std::nullopt;
   644    bool AddrOffset = Form == dwarf::DW_FORM_LLVM_addrx_offset;
   645    if (Form == DW_FORM_GNU_addr_index || Form == DW_FORM_addrx ||
(lldb) p U
(const llvm::DWARFUnit *) nullptr

Please also note that https://github.com/llvm/llvm-project/commit/460a2244430fae192298a5fd9fa2a269e540e8c1 was landed with an incorrect Phabricator link.

This commit also needed numerous fixup commits, which is a good signal that this commit chain needs better testing before landing.

[ayermolo]

This comment was removed by ayermolo.

[clayborg]

In D130315#4480361, @gribozavr2 wrote:

Hi,

This commit introduces a null pointer dereference in a unit test, so I'm going to revert it together with all dependent commits:

$ lldb -- ./unittests/DebugInfo/DWARF/DebugInfoDWARFTests --gtest_filter=DWARFDebugInfo.TestDwarfToFunctions
This is google-lldb.
Help: http://go/lldb. File a bug: http://go/lldb-bug.
(lldb) target create "./unittests/DebugInfo/DWARF/DebugInfoDWARFTests"
Current executable set to '/usr/local/google/home/dmitrig/llvm2/build-debug/unittests/DebugInfo/DWARF/DebugInfoDWARFTests' (x86_64).
(lldb) settings set -- target.run-args  "--gtest_filter=DWARFDebugInfo.TestDwarfToFunctions"
(lldb) r
Process 2771099 launched: '/usr/local/google/home/dmitrig/llvm2/build-debug/unittests/DebugInfo/DWARF/DebugInfoDWARFTests' (x86_64)
Note: Google Test filter = DWARFDebugInfo.TestDwarfToFunctions
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from DWARFDebugInfo
[ RUN      ] DWARFDebugInfo.TestDwarfToFunctions
Process 2771099 stopped
* thread #1, name = 'DebugInfoDWARFT', stop reason = signal SIGSEGV: address not mapped to object (fault address: 0x20)
    frame #0: 0x0000555555c0d41c DebugInfoDWARFTests`llvm::DWARFUnitHeader::getVersion(this=0x0000000000000018) const at DWARFUnit.h:89:33
   86     bool applyIndexEntry(const DWARFUnitIndex::Entry *Entry);
   87     uint64_t getOffset() const { return Offset; }
   88     const dwarf::FormParams &getFormParams() const { return FormParams; }
-> 89     uint16_t getVersion() const { return FormParams.Version; }
   90     dwarf::DwarfFormat getFormat() const { return FormParams.Format; }
   91     uint8_t getAddressByteSize() const { return FormParams.AddrSize; }
   92     uint8_t getRefAddrByteSize() const { return FormParams.getRefAddrByteSize(); }
(lldb) up
frame #1: 0x000055555810bc59 DebugInfoDWARFTests`llvm::DWARFUnit::getVersion(this=0x0000000000000000) const at DWARFUnit.h:323:47
   320    const dwarf::FormParams &getFormParams() const {
   321      return Header.getFormParams();
   322    }
-> 323    uint16_t getVersion() const { return Header.getVersion(); }
   324    uint8_t getAddressByteSize() const { return Header.getAddressByteSize(); }
   325    uint8_t getRefAddrByteSize() const { return Header.getRefAddrByteSize(); }
   326    uint8_t getDwarfOffsetByteSize() const {
(lldb) up
frame #2: 0x00005555581953a3 DebugInfoDWARFTests`llvm::DWARFFormValue::getAsSectionedAddress(Value=0x00007fffffffd2e8, Form=0, U=0x0000000000000000) at DWARFFormValue.cpp:642:51
   639
   640  std::optional<object::SectionedAddress> DWARFFormValue::getAsSectionedAddress(
   641      const ValueType &Value, const dwarf::Form Form, const DWARFUnit *U) {
-> 642    if (!doesFormBelongToClass(Form, FC_Address, U->getVersion()))
   643      return std::nullopt;
   644    bool AddrOffset = Form == dwarf::DW_FORM_LLVM_addrx_offset;
   645    if (Form == DW_FORM_GNU_addr_index || Form == DW_FORM_addrx ||
(lldb) p U
(const llvm::DWARFUnit *) nullptr

Please also note that https://github.com/llvm/llvm-project/commit/460a2244430fae192298a5fd9fa2a269e540e8c1 was landed with an incorrect Phabricator link.

This commit also needed numerous fixup commits, which is a good signal that this commit chain needs better testing before landing.

Please specify OS and architecture that this is failing for. Not sure what OS version this was failing for you on?

[ayermolo]

In D130315#4480361, @gribozavr2 wrote:

Hi,

This commit introduces a null pointer dereference in a unit test, so I'm going to revert it together with all dependent commits:

$ lldb -- ./unittests/DebugInfo/DWARF/DebugInfoDWARFTests --gtest_filter=DWARFDebugInfo.TestDwarfToFunctions
This is google-lldb.
Help: http://go/lldb. File a bug: http://go/lldb-bug.
(lldb) target create "./unittests/DebugInfo/DWARF/DebugInfoDWARFTests"
Current executable set to '/usr/local/google/home/dmitrig/llvm2/build-debug/unittests/DebugInfo/DWARF/DebugInfoDWARFTests' (x86_64).
(lldb) settings set -- target.run-args  "--gtest_filter=DWARFDebugInfo.TestDwarfToFunctions"
(lldb) r
Process 2771099 launched: '/usr/local/google/home/dmitrig/llvm2/build-debug/unittests/DebugInfo/DWARF/DebugInfoDWARFTests' (x86_64)
Note: Google Test filter = DWARFDebugInfo.TestDwarfToFunctions
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from DWARFDebugInfo
[ RUN      ] DWARFDebugInfo.TestDwarfToFunctions
Process 2771099 stopped
* thread #1, name = 'DebugInfoDWARFT', stop reason = signal SIGSEGV: address not mapped to object (fault address: 0x20)
    frame #0: 0x0000555555c0d41c DebugInfoDWARFTests`llvm::DWARFUnitHeader::getVersion(this=0x0000000000000018) const at DWARFUnit.h:89:33
   86     bool applyIndexEntry(const DWARFUnitIndex::Entry *Entry);
   87     uint64_t getOffset() const { return Offset; }
   88     const dwarf::FormParams &getFormParams() const { return FormParams; }
-> 89     uint16_t getVersion() const { return FormParams.Version; }
   90     dwarf::DwarfFormat getFormat() const { return FormParams.Format; }
   91     uint8_t getAddressByteSize() const { return FormParams.AddrSize; }
   92     uint8_t getRefAddrByteSize() const { return FormParams.getRefAddrByteSize(); }
(lldb) up
frame #1: 0x000055555810bc59 DebugInfoDWARFTests`llvm::DWARFUnit::getVersion(this=0x0000000000000000) const at DWARFUnit.h:323:47
   320    const dwarf::FormParams &getFormParams() const {
   321      return Header.getFormParams();
   322    }
-> 323    uint16_t getVersion() const { return Header.getVersion(); }
   324    uint8_t getAddressByteSize() const { return Header.getAddressByteSize(); }
   325    uint8_t getRefAddrByteSize() const { return Header.getRefAddrByteSize(); }
   326    uint8_t getDwarfOffsetByteSize() const {
(lldb) up
frame #2: 0x00005555581953a3 DebugInfoDWARFTests`llvm::DWARFFormValue::getAsSectionedAddress(Value=0x00007fffffffd2e8, Form=0, U=0x0000000000000000) at DWARFFormValue.cpp:642:51
   639
   640  std::optional<object::SectionedAddress> DWARFFormValue::getAsSectionedAddress(
   641      const ValueType &Value, const dwarf::Form Form, const DWARFUnit *U) {
-> 642    if (!doesFormBelongToClass(Form, FC_Address, U->getVersion()))
   643      return std::nullopt;
   644    bool AddrOffset = Form == dwarf::DW_FORM_LLVM_addrx_offset;
   645    if (Form == DW_FORM_GNU_addr_index || Form == DW_FORM_addrx ||
(lldb) p U
(const llvm::DWARFUnit *) nullptr

Please also note that https://github.com/llvm/llvm-project/commit/460a2244430fae192298a5fd9fa2a269e540e8c1 was landed with an incorrect Phabricator link.

This commit also needed numerous fixup commits, which is a good signal that this commit chain needs better testing before landing.

That is why it's part of the stack. Original diff was done by someone else. I commandeered it. All the fixes are in subsequent commit to separate work done. Thus I didn't squash into one commit.
I tried it locally, and for me it passes. Either on full stack or on this diff.

Although looking at stack trace I see where it goes wrong.
I can change
if (!doesFormBelongToClass(Form, FC_Address, U->getVersion()))
to
if (!U&&!isFormClass(FC_Address) || !doesFormBelongToClass(Form, FC_Address, U->getVersion()))
which should restore to old behavior in case U is nullptr.

[ayermolo]

OK, I was able to repro on mac.

[ayermolo]

fixed lldb nullpr exception + rebase

bolt/include/bolt/Core/DebugData.h

 // DWARF-related entities.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef BOLT_CORE_DEBUG_DATA_H
 #define BOLT_CORE_DEBUG_DATA_H
 
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/CodeGen/DIE.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/Support/SMLoc.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdint>
 #include <map>
 #include <mutex>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
 #include <vector>
 
 #define DWARF2_FLAG_END_SEQUENCE (1 << 4)
 
 namespace llvm {
 
 namespace bolt {
 
+class DIEBuilder;
 struct AttrInfo {
   DWARFFormValue V;
   const DWARFAbbreviationDeclaration *AbbrevDecl;
   uint64_t Offset;
   uint32_t Size; // Size of the attribute.
 };
 
 /// Finds attributes FormValue and Offset.
DebugLocWriter(uint8_t DwarfVersion, LocWriterKind Kind)
     init();
   }
 
 public:
   DebugLocWriter() { init(); };
   virtual ~DebugLocWriter(){};
 
   /// Writes out location lists and stores internal patches.
-  virtual void addList(AttrInfo &AttrVal, DebugLocationsVector &LocList,
-                       DebugInfoBinaryPatcher &DebugInfoPatcher,
-                       DebugAbbrevWriter &AbbrevWriter);
+  virtual void addList(DIEBuilder &DIEBldr, DIE *Die, DIEValue &AttrInfo,
+                       DebugLocationsVector &LocList);
 
   /// Writes out locations in to a local buffer, and adds Debug Info patches.
-  virtual void finalize(DebugInfoBinaryPatcher &DebugInfoPatcher,
-                        DebugAbbrevWriter &AbbrevWriter);
+  virtual void finalize(DIEBuilder &DIEBldr, DIE *Die);
 
   /// Return internal buffer.
   virtual std::unique_ptr<DebugBufferVector> getBuffer();
 
   /// Returns DWARF version.
   uint8_t getDwarfVersion() const { return DwarfVersion; }
 
   /// Offset of an empty location list.
if (DwarfVersion >= 5) {
       const char Zeroes[16] = {0};
       *LocStream << StringRef(Zeroes, 16);
     }
   }
 
   static void setAddressWriter(DebugAddrWriter *AddrW) { AddrWriter = AddrW; }
 
   /// Stores location lists internally to be written out during finalize phase.
-  virtual void addList(AttrInfo &AttrVal, DebugLocationsVector &LocList,
-                       DebugInfoBinaryPatcher &DebugInfoPatcher,
-                       DebugAbbrevWriter &AbbrevWriter) override;
+  virtual void addList(DIEBuilder &DIEBldr, DIE *Die, DIEValue &AttrInfo,
+                       DebugLocationsVector &LocList) override;
 
   /// Writes out locations in to a local buffer and applies debug info patches.
-  void finalize(DebugInfoBinaryPatcher &DebugInfoPatcher,
-                DebugAbbrevWriter &AbbrevWriter) override;
+  void finalize(DIEBuilder &DIEBldr, DIE *Die) override;
 
   /// Returns CU ID.
   /// For Skelton CU it is a CU Offset.
   /// For DWO CU it is a DWO ID.
   uint64_t getCUID() const {
     return CU.isDWOUnit() ? *CU.getDWOId() : CU.getOffset();
   }
 
   LocWriterKind getKind() const { return DebugLocWriter::getKind(); }
 
   static bool classof(const DebugLocWriter *Writer) {
     return Writer->getKind() == LocWriterKind::DebugLoclistWriter;
   }
 
   bool isSplitDwarf() const { return IsSplitDwarf; }
 
   constexpr static uint32_t InvalidIndex = UINT32_MAX;
 
 private:
   /// Writes out locations in to a local buffer and applies debug info patches.
-  void finalizeDWARF5(DebugInfoBinaryPatcher &DebugInfoPatcher,
-                      DebugAbbrevWriter &AbbrevWriter);
+  void finalizeDWARF5(DIEBuilder &DIEBldr, DIE *Die);
 
   static DebugAddrWriter *AddrWriter;
   DWARFUnit &CU;
   bool IsSplitDwarf{false};
   // Used for DWARF5 to store location lists before being finalized.
   std::unique_ptr<DebugBufferVector> LocBodyBuffer;
   std::unique_ptr<raw_svector_ostream> LocBodyStream;
   std::vector<uint32_t> RelativeLocListOffsets;

bolt/include/bolt/Rewrite/DIEBuilder.h

+//===- bolt/Rewrite/DIEBuilder.h -----------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains the declaration of the DIEBuilder class, which is the
+/// base class for Debug Information IR construction.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef BOLT_REWRITE_DIE_BUILDER_H
+#define BOLT_REWRITE_DIE_BUILDER_H
+
+#include "llvm/CodeGen/DIE.h"
+#include "llvm/DWARFLinker/DWARFLinkerCompileUnit.h"
+#include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
+#include "llvm/DebugInfo/DWARF/DWARFDie.h"
+#include "llvm/DebugInfo/DWARF/DWARFExpression.h"
+#include "llvm/DebugInfo/DWARF/DWARFUnit.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/ErrorHandling.h"
+
+#include <cstdint>
+#include <forward_list>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <set>
+#include <shared_mutex>
+#include <sys/types.h>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace llvm {
+
+namespace bolt {
+
+class DIEBuilder {
+  struct DIEInfo {
+    DIE *Die;
+    uint32_t DieId;
+    uint32_t UnitId;
+    uint32_t CanonicalDIEOffset;
+  };
+
+  struct UnitInfo {
+    std::list<DIEInfo> DieInfoList;
+    uint32_t UnitId;
+    uint32_t UnitOffset;
+    bool is_constructed = false;
+    uint32_t NewDieId = 0;
+    std::unordered_map<uint64_t, uint32_t> DIEIDMap;
+    std::unordered_map<uint32_t, DIEInfo *> DIEId2Info;
+  };
+
+  struct ForwardReferenceInfo {
+    ForwardReferenceInfo(DIEInfo *Die,
+                         DWARFAbbreviationDeclaration::AttributeSpec spec)
+        : Dst(Die), AttrSpec(spec) {}
+    DIEInfo *Dst;
+    DWARFAbbreviationDeclaration::AttributeSpec AttrSpec;
+  };
+
+  bool IsBuilt = false;
+  std::unordered_map<DWARFUnit *, std::vector<DIE *>> UnitDIEs;
+  std::vector<DWARFUnit *> DUList;
+  std::vector<UnitInfo> CloneUnitCtxMap;
+  std::vector<uint32_t> UnitDIEId;
+  std::vector<std::pair<DIEInfo *, std::unique_ptr<ForwardReferenceInfo>>>
+      ForwardReferences;
+  FoldingSet<DIEAbbrev> AbbreviationsSet;
+  std::vector<std::unique_ptr<DIEAbbrev>> Abbreviations;
+  std::vector<DWARFUnit *> DWARF4TUList;
+  std::vector<DWARFUnit *> DWARF4CUList;
+
+  std::shared_timed_mutex AllocateDIEMutex;
+  BumpPtrAllocator DIEAlloc;
+
+  /// Resolve the reference in DIE, if target is not loaded into IR,
+  /// pre-allocate it. \p RefCU will be updated to the Unit specific by \p
+  /// RefValue.
+  DWARFDie
+  resolveDIEReference(const DWARFFormValue &RefValue,
+                      DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+                      DWARFUnit *&RefCU,
+                      DWARFDebugInfoEntry &DwarfDebugInfoEntry,
+                      std::vector<DWARFUnit *> &DUOffsetList);
+
+  /// Clone one attribute according the format. \return the size of this
+  /// attribute.
+  uint32_t
+  cloneAttribute(DIE &Die, const DWARFDie &InputDIE, DWARFUnit &U,
+                 const DWARFFormValue &Val,
+                 const DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+                 unsigned AttrSize, bool IsLittleEndian,
+                 std::vector<DWARFUnit *> &DUOffsetList);
+
+  /// Clone an attribute in string format.
+  uint32_t cloneStringAttribute(
+      DIE &Die, DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+      unsigned AttrSize, const DWARFFormValue &Val, const DWARFUnit &U);
+
+  /// CClone an attribute in reference format.
+  uint32_t cloneDieReferenceAttribute(
+      DIE &Die, const DWARFDie &InputDIE,
+      DWARFAbbreviationDeclaration::AttributeSpec AttrSpec, unsigned AttrSize,
+      const DWARFFormValue &Val, DWARFUnit &U,
+      std::vector<DWARFUnit *> &DUOffsetList);
+
+  /// Clone an attribute in block format.
+  uint32_t
+  cloneBlockAttribute(DIE &Die, DWARFUnit &U,
+                      DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+                      const DWARFFormValue &Val, unsigned AttrSize,
+                      bool IsLittleEndian);
+
+  /// Clone an attribute in expression format. \p OutputBuffer will hold the
+  /// output content.
+  void cloneExpression(DataExtractor &Data, DWARFExpression Expression,
+                       DWARFUnit &U, SmallVectorImpl<uint8_t> &OutputBuffer);
+
+  /// Clone an attribute in address format.
+  uint32_t
+  cloneAddressAttribute(DIE &Die,
+                        DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+                        const DWARFFormValue &Val, const DWARFUnit &U);
+
+  /// Clone an attribute in Refsig format.
+  uint32_t
+  cloneRefsigAttribute(DIE &Die,
+                       DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+                       unsigned AttrSize, const DWARFFormValue &Val);
+
+  /// Clone an attribute in scalar format.
+  uint32_t
+  cloneScalarAttribute(DIE &Die, const DWARFDie &InputDIE,
+                       DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+                       const DWARFFormValue &Val, unsigned AttrSize);
+
+  /// Clone an attribute in loclist format.
+  uint32_t
+  cloneLoclistAttrubute(DIE &Die, const DWARFDie &InputDIE,
+                        DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+                        const DWARFFormValue &Val, unsigned AttrSize);
+
+  /// Update the Cross-CU reference offset.
+  void computeReference();
+
+  /// Update the Offset and Size of DIE.
+  uint32_t computeDIEOffset(DWARFUnit &CU, DIE &Die, uint32_t &curOffset);
+
+  /// \return the unique ID of \p U if it exists.
+  Optional<uint32_t> getUnitId(DWARFUnit *DU) {
+    auto it = std::find(DUList.begin(), DUList.end(), DU);
+    if (it != DUList.end())
+      return Optional<uint32_t>(std::distance(DUList.begin(), it));
+
+    return None;
+  }
+
+  UnitInfo &getUnitInfo(uint32_t UnitId) { return CloneUnitCtxMap[UnitId]; }
+
+  DIEInfo &getDIEInfo(uint32_t UnitId, uint32_t DIEId) {
+    if (CloneUnitCtxMap[UnitId].DIEId2Info.count(DIEId))
+      return *CloneUnitCtxMap[UnitId].DIEId2Info[DIEId];
+
+    llvm_unreachable("The DIE is not allocated before looking up it, some "
+                     "unexpected corner cases happened.");
+    return CloneUnitCtxMap[UnitId].DieInfoList.front();
+  }
+
+  UnitInfo &getUnitInfoByDwarfUnit(DWARFUnit *DwarfUnit) {
+    Optional<uint32_t> UnitId = getUnitId(DwarfUnit);
+    return getUnitInfo(*UnitId);
+  }
+
+  Optional<uint32_t> getAllocDIEId(DWARFUnit &DU, DWARFDie &DDie) {
+    std::shared_lock<std::shared_timed_mutex> lock(AllocateDIEMutex);
+    UnitInfo &UnitInfo = getUnitInfoByDwarfUnit(&DU);
+    uint64_t Offset = DDie.getOffset();
+
+    if (!UnitInfo.DIEIDMap.count(Offset))
+      return None;
+    return UnitInfo.DIEIDMap[Offset];
+  }
+
+  Optional<uint32_t> getAllocDIEId(DWARFUnit &DU, uint64_t Offset) {
+    std::shared_lock<std::shared_timed_mutex> lock(AllocateDIEMutex);
+    UnitInfo &UnitInfo = getUnitInfoByDwarfUnit(&DU);
+
+    if (!UnitInfo.DIEIDMap.count(Offset))
+      return None;
+    return UnitInfo.DIEIDMap[Offset];
+  }
+
+  // To avoid overhead, do not use this unless we do get the UnitInfo first.
+  // We can use getDIEInfo with UnitId and DieId
+  DIEInfo &getDIEInfoByDwarfDie(DWARFDie *DwarfDie) {
+    DWARFUnit *DwarfUnit = DwarfDie->getDwarfUnit();
+    Optional<uint32_t> UnitId = getUnitId(DwarfUnit);
+    Optional<uint32_t> hasDIEId = getAllocDIEId(*DwarfUnit, *DwarfDie);
+    assert(hasDIEId.hasValue());
+
+    return getDIEInfo(*UnitId, *hasDIEId);
+  }
+
+  Optional<uint32_t> allocDIE(DWARFUnit &DU, DWARFDie &DDie,
+                              BumpPtrAllocator &Alloc, uint32_t UId,
+                              uint32_t offset = 0);
+
+  uint32_t AllocDIEId(DWARFUnit &DU) {
+    UnitInfo &UnitInfo = getUnitInfoByDwarfUnit(&DU);
+    return UnitInfo.NewDieId++;
+  }
+
+  /// Construct IR for \p DU. \p DUOffsetList specific the Unit in current
+  /// Section.
+  void constructFromUnit(DWARFUnit *DU, std::vector<DWARFUnit *> &DUOffsetList);
+
+  /// Construct a DIE for \p DDie in \p U. \p DUOffsetList specific the Unit in
+  /// current Section.
+  DIE *constructDIEFast(DWARFDie &DDie, DWARFUnit &U, bool IsLittleEndian,
+                        uint32_t UnitId,
+                        std::vector<DWARFUnit *> &DUOffsetList);
+
+public:
+  DIEBuilder(DWARFContext *DwarfContext, bool IsDWO = false);
+
+  std::vector<DIE *> getDIEsByUnit(DWARFUnit &DU) { return UnitDIEs[&DU]; }
+  std::vector<std::unique_ptr<DIEAbbrev>> &getAbbrevs() {
+    return Abbreviations;
+  }
+
+  std::vector<DWARFUnit *> getDWARF4TUList() { return DWARF4TUList; }
+  bool isEmpty() { return !IsBuilt; }
+
+  DIE *getUnitDIEbyUnit(DWARFUnit &DU) { return UnitDIEs[&DU].front(); }
+
+  /// Generate and populate all Abbrevs.
+  void generateAbbrevs();
+  void generateUnitAbbrevs(DIE *die);
+  void assignAbbrev(DIEAbbrev &Abbrev);
+
+  /// Finish current DIE construction.
+  void finish();
+
+  // Interface to edit DIE
+  template <class T> T *allocateDIEValue() { return new (DIEAlloc) T; }
+
+  DIEValueList::value_iterator addValue(DIEValueList *Die, const DIEValue &V) {
+    return Die->addValue(DIEAlloc, V);
+  }
+
+  template <class T>
+  DIEValueList::value_iterator addValue(DIEValueList *Die,
+                                        dwarf::Attribute Attribute,
+                                        dwarf::Form Form, T &&Value) {
+    return Die->addValue(DIEAlloc, Attribute, Form, std::forward<T>(Value));
+  }
+
+  template <class T>
+  bool replaceValue(DIEValueList *Die, dwarf::Attribute Attribute,
+                    dwarf::Form Form, T &&NewValue) {
+    return Die->replaceValue(DIEAlloc, Attribute, Form,
+                             std::forward<T>(NewValue));
+  }
+
+  template <class T>
+  bool replaceValue(DIEValueList *Die, dwarf::Attribute Attribute,
+                    dwarf::Attribute NewAttribute, dwarf::Form Form,
+                    T &&NewValue) {
+    return Die->replaceValue(DIEAlloc, Attribute, NewAttribute, Form,
+                             std::forward<T>(NewValue));
+  }
+
+  bool replaceValue(DIEValueList *Die, dwarf::Attribute Attribute,
+                    dwarf::Form Form, DIEValue &NewValue) {
+    return Die->replaceValue(DIEAlloc, Attribute, Form, NewValue);
+  }
+
+  template <class T>
+  bool deleteValue(DIEValueList *Die, dwarf::Attribute Attribute) {
+    return Die->deleteValue(Attribute);
+  }
+};
+} // namespace bolt
+} // namespace llvm
+
+#endif

bolt/include/bolt/Rewrite/DWARFRewriter.h

 //===- bolt/Rewrite/DWARFRewriter.h -----------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef BOLT_REWRITE_DWARF_REWRITER_H
 #define BOLT_REWRITE_DWARF_REWRITER_H
 
 #include "bolt/Core/DebugData.h"
+#include "bolt/Rewrite/DIEBuilder.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/CodeGen/DIE.h"
 #include "llvm/MC/MCAsmLayout.h"
 #include <cstdint>
 #include <memory>
 #include <mutex>
 #include <set>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
private:
   /// Binary patchers for DWO debug_info sections.
   DebugInfoDWOPatchers BinaryDWODebugInfoPatchers;
 
   /// Stores all the Type Signatures for DWO CU.
   DebugTypesSignaturesPerCUMap TypeSignaturesPerCU;
 
   std::mutex LocListDebugInfoPatchesMutex;
 
+  /// Dwo id specific its .debug_info.dwo section content.
+  std::unordered_map<uint64_t, std::string> DwoDebufInfoMap;
+
+  /// Dwo id specific its .debug_abbrev.dwo section content.
+  std::unordered_map<uint64_t, std::string> DwoDebugAbbrevMap;
+
+  /// Dwo id specific its .debug_types.dwo section content.
+  std::unordered_map<uint64_t, std::string> DwoDebugTypeMap;
+
+  /// Dwo id specific its RangesBase.
+  std::unordered_map<uint64_t, uint64_t> DwoRangesBase;
+
+  std::unordered_map<DWARFUnit *, uint64_t> LineTablePatchMap;
+
   /// DWARFLegacy is all DWARF versions before DWARF 5.
   enum class DWARFVersion { DWARFLegacy, DWARF5 };
 
   /// Update debug info for all DIEs in \p Unit.
-  void updateUnitDebugInfo(DWARFUnit &Unit,
-                           DebugInfoBinaryPatcher &DebugInfoPatcher,
-                           DebugAbbrevWriter &AbbrevWriter,
+  void updateUnitDebugInfo(DWARFUnit &Unit, DIEBuilder &DIEBldr,
                            DebugLocWriter &DebugLocWriter,
-                           DebugRangesSectionWriter &RangesWriter,
+                           DebugRangesSectionWriter &RangesSectionWriter,
                            Optional<uint64_t> RangesBase = None);
 
   /// Patches the binary for an object's address ranges to be updated.
   /// The object can be anything that has associated address ranges via either
   /// DW_AT_low/high_pc or DW_AT_ranges (i.e. functions, lexical blocks, etc).
   /// \p DebugRangesOffset is the offset in .debug_ranges of the object's
   /// new address ranges in the output binary.
   /// \p Unit Compile unit the object belongs to.
   /// \p DIE is the object's DIE in the input binary.
   /// \p RangesBase if present, update \p DIE to use  DW_AT_GNU_ranges_base
   ///    attribute.
-  void updateDWARFObjectAddressRanges(const DWARFDie DIE,
-                                      uint64_t DebugRangesOffset,
-                                      SimpleBinaryPatcher &DebugInfoPatcher,
-                                      DebugAbbrevWriter &AbbrevWriter,
+  void updateDWARFObjectAddressRanges(DWARFUnit &Unit, DIEBuilder &DIEBldr,
+                                      DIE *Die, uint64_t DebugRangesOffset,
                                       Optional<uint64_t> RangesBase = None);
 
   std::unique_ptr<DebugBufferVector>
-  makeFinalLocListsSection(DebugInfoBinaryPatcher &DebugInfoPatcher,
-                           DWARFVersion Version);
+  makeFinalLocListsSection(DWARFVersion Version);
 
   /// Finalize debug sections in the main binary.
-  CUOffsetMap finalizeDebugSections(DebugInfoBinaryPatcher &DebugInfoPatcher);
+  CUOffsetMap finalizeDebugSections(DIEBuilder &DIEBlder);
 
   /// Patches the binary for DWARF address ranges (e.g. in functions and lexical
   /// blocks) to be updated.
   void updateDebugAddressRanges();
 
   /// Rewrite .gdb_index section if present.
   void updateGdbIndexSection(CUOffsetMap &CUMap);
 
private:
   void convertToRangesPatchAbbrev(const DWARFUnit &Unit,
                                   const DWARFAbbreviationDeclaration *Abbrev,
                                   DebugAbbrevWriter &AbbrevWriter,
                                   Optional<uint64_t> RangesBase = None);
 
   /// Update \p DIE that was using DW_AT_(low|high)_pc with DW_AT_ranges offset.
   /// Updates to the DIE should be synced with abbreviation updates using the
   /// function above.
-  void convertToRangesPatchDebugInfo(DWARFDie DIE, uint64_t RangesSectionOffset,
-                                     SimpleBinaryPatcher &DebugInfoPatcher,
-                                     Optional<uint64_t> RangesBase = None);
+  void convertToRangesPatchDebugInfo(DWARFUnit &Unit, DIEBuilder &DIEBldr,
+                                     DIE *Die, uint64_t RangesSectionOffset,
+                                     DIEValue &LowPCAttrInfo,
+                                     DIEValue &HighPCAttrInfo,
+                                     Optional<uint64_t> RangesBase);
 
   /// Helper function for creating and returning per-DWO patchers/writers.
   template <class T, class Patcher>
   Patcher *getBinaryDWOPatcherHelper(T &BinaryPatchers, uint64_t DwoId) {
     std::lock_guard<std::mutex> Lock(DebugInfoPatcherMutex);
     auto Iter = BinaryPatchers.find(DwoId);
     if (Iter == BinaryPatchers.end()) {
       // Using make_pair instead of {} to work around bug in older version of
       // the library. https://timsong-cpp.github.io/lwg-issues/2354
       Iter = BinaryPatchers
                  .insert(std::make_pair(DwoId, std::make_unique<Patcher>()))
                  .first;
     }
 
     return static_cast<Patcher *>(Iter->second.get());
   }
 
   /// Adds a \p Str to .debug_str section.
   /// Uses \p AttrInfoVal to either update entry in a DIE for legacy DWARF using
   /// \p DebugInfoPatcher, or for DWARF5 update an index in .debug_str_offsets
   /// for this contribution of \p Unit.
-  void addStringHelper(DebugInfoBinaryPatcher &DebugInfoPatcher,
-                       const DWARFUnit &Unit, const AttrInfo &AttrInfoVal,
-                       StringRef Str);
+  void addStringHelper(DIEBuilder &DIEBldr, DIE *Die, const DWARFUnit &Unit,
+                       DIEValue &DIEAttrInfo, StringRef Str);
 
 public:
   DWARFRewriter(BinaryContext &BC) : BC(BC) {}
 
   /// Main function for updating the DWARF debug info.
   void updateDebugInfo();
 
   /// Update stmt_list for CUs based on the new .debug_line \p Layout.
public:
   }
 
   /// Given a \p DWOId, return its DebugLocWriter if it exists.
   DebugLocWriter *getDebugLocWriter(uint64_t DWOId) {
     auto Iter = LocListWritersByCU.find(DWOId);
     return Iter == LocListWritersByCU.end() ? nullptr
                                             : LocListWritersByCU[DWOId].get();
   }
+
+  StringRef getDwoDebugInfoStr(uint64_t DWOId) {
+    return DwoDebufInfoMap[DWOId];
+  }
+
+  StringRef getDwoDebugAbbrevStr(uint64_t DWOId) {
+    return DwoDebugAbbrevMap[DWOId];
+  }
+
+  StringRef getDwoDebugTypeStr(uint64_t DWOId) {
+    return DwoDebugTypeMap[DWOId];
+  }
+
+  uint64_t getDwoRangesBase(uint64_t DWOId) { return DwoRangesBase[DWOId]; }
+
+  void setDwoDebugInfoStr(uint64_t DWOId, StringRef str) {
+    DwoDebufInfoMap[DWOId] = str.str();
+  }
+
+  void setDwoDebugAbbrevStr(uint64_t DWOId, StringRef str) {
+    DwoDebugAbbrevMap[DWOId] = str.str();
+  }
+
+  void setDwoDebugTypeStr(uint64_t DWOId, StringRef str) {
+    DwoDebugTypeMap[DWOId] = str.str();
+  }
+
+  void setDwoRangesBase(uint64_t DWOId, uint64_t RangesBase) {
+    DwoRangesBase[DWOId] = RangesBase;
+  }
 };
 
 } // namespace bolt
 } // namespace llvm
 
 #endif

bolt/lib/Core/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   DebugInfoDWARF
   Demangle
   MC
   MCDisassembler
   Object
   Support
+  AsmPrinter
   )
 
 add_llvm_library(LLVMBOLTCore
   BinaryBasicBlock.cpp
   BinaryContext.cpp
   BinaryData.cpp
   BinaryEmitter.cpp
   BinaryFunction.cpp

bolt/lib/Core/DebugData.cpp

 //===- bolt/Core/DebugData.cpp - Debugging information handling -----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements functions and classes for handling debug info.
 //
 //===----------------------------------------------------------------------===//
 
 #include "bolt/Core/DebugData.h"
 #include "bolt/Core/BinaryContext.h"
+#include "bolt/Rewrite/DIEBuilder.h"
 #include "bolt/Rewrite/RewriteInstance.h"
 #include "bolt/Utils/Utils.h"
+#include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/CodeGen/DIE.h"
 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugAddr.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCObjectStreamer.h"
+#include "llvm/Support/Allocator.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/SHA1.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <limits>
 #include <unordered_map>
 #include <vector>
 
 #define DEBUG_TYPE "bolt-debug-info"
 
 namespace opts {
 extern llvm::cl::opt<unsigned> Verbosity;
 } // namespace opts
 
 namespace llvm {
 class MCSymbol;
 
 namespace bolt {
 
+static void replaceLocValbyForm(DIEBuilder &DIEBldr, DIE *Die, DIEValue DIEVal,
+                                dwarf::Form Format, uint64_t NewVal) {
+  if (Format == dwarf::DW_FORM_loclistx)
+    DIEBldr.replaceValue(Die, DIEVal.getAttribute(), Format,
+                         DIELocList(NewVal));
+  else
+    DIEBldr.replaceValue(Die, DIEVal.getAttribute(), Format,
+                         DIEInteger(NewVal));
+}
+
 Optional<AttrInfo>
 findAttributeInfo(const DWARFDie DIE,
                   const DWARFAbbreviationDeclaration *AbbrevDecl,
                   uint32_t Index) {
   const DWARFUnit &U = *DIE.getDwarfUnit();
   uint64_t Offset =
       AbbrevDecl->getAttributeOffsetFromIndex(Index, DIE.getOffset(), U);
   Optional<DWARFFormValue> Value =
       AbbrevDecl->getAttributeValueFromOffset(Index, Offset, U);
   if (!Value)
     return None;
+
   // AttributeSpec
   const DWARFAbbreviationDeclaration::AttributeSpec *AttrVal =
       AbbrevDecl->attributes().begin() + Index;
   uint32_t ValSize = 0;
   Optional<int64_t> ValSizeOpt = AttrVal->getByteSize(U);
   if (ValSizeOpt) {
     ValSize = static_cast<uint32_t>(*ValSizeOpt);
   } else {
void DebugLocWriter::init() {
   if (!LocSectionOffset && DwarfVersion < 5) {
     const char Zeroes[16] = {0};
     *LocStream << StringRef(Zeroes, 16);
     LocSectionOffset += 16;
   }
 }
 
 uint32_t DebugLocWriter::LocSectionOffset = 0;
-void DebugLocWriter::addList(AttrInfo &AttrVal, DebugLocationsVector &LocList,
-                             DebugInfoBinaryPatcher &DebugInfoPatcher,
-                             DebugAbbrevWriter &AbbrevWriter) {
-  const uint64_t AttrOffset = AttrVal.Offset;
+void DebugLocWriter::addList(DIEBuilder &DIEBldr, DIE *Die, DIEValue &AttrInfo,
+                             DebugLocationsVector &LocList) {
   if (LocList.empty()) {
-    DebugInfoPatcher.addLE32Patch(AttrOffset, DebugLocWriter::EmptyListOffset);
+    replaceLocValbyForm(DIEBldr, Die, AttrInfo, AttrInfo.getForm(),
+                        DebugLocWriter::EmptyListOffset);
     return;
   }
   // Since there is a separate DebugLocWriter for each thread,
   // we don't need a lock to read the SectionOffset and update it.
   const uint32_t EntryOffset = LocSectionOffset;
 
   for (const DebugLocationEntry &Entry : LocList) {
     support::endian::write(*LocStream, static_cast<uint64_t>(Entry.LowPC),
                            support::little);
     support::endian::write(*LocStream, static_cast<uint64_t>(Entry.HighPC),
                            support::little);
     support::endian::write(*LocStream, static_cast<uint16_t>(Entry.Expr.size()),
                            support::little);
     *LocStream << StringRef(reinterpret_cast<const char *>(Entry.Expr.data()),
                             Entry.Expr.size());
     LocSectionOffset += 2 * 8 + 2 + Entry.Expr.size();
   }
   LocStream->write_zeros(16);
   LocSectionOffset += 16;
-  LocListDebugInfoPatches.push_back({AttrOffset, EntryOffset});
-  DebugInfoPatcher.addLE32Patch(AttrOffset, EntryOffset);
+  LocListDebugInfoPatches.push_back({0xdeadbeee, EntryOffset}); // never seen
+                                                                // use
+  replaceLocValbyForm(DIEBldr, Die, AttrInfo, AttrInfo.getForm(), EntryOffset);
 }
 
 std::unique_ptr<DebugBufferVector> DebugLocWriter::getBuffer() {
   return std::move(LocBuffer);
 }
 
 // DWARF 4: 2.6.2
-void DebugLocWriter::finalize(DebugInfoBinaryPatcher &DebugInfoPatcher,
-                              DebugAbbrevWriter &AbbrevWriter) {}
+void DebugLocWriter::finalize(DIEBuilder &DIEBldr, DIE *Die) {}
 
 static void writeEmptyListDwarf5(raw_svector_ostream &Stream) {
   support::endian::write(Stream, static_cast<uint32_t>(4), support::little);
   support::endian::write(Stream, static_cast<uint8_t>(dwarf::DW_LLE_start_end),
                          support::little);
 
   const char Zeroes[16] = {0};
   Stream << StringRef(Zeroes, 16);
   encodeULEB128(0, Stream);
   support::endian::write(
       Stream, static_cast<uint8_t>(dwarf::DW_LLE_end_of_list), support::little);
 }
 
-static void writeLegacyLocList(AttrInfo &AttrVal, DebugLocationsVector &LocList,
-                               DebugInfoBinaryPatcher &DebugInfoPatcher,
+static void writeLegacyLocList(DIEValue &AttrInfo,
+                               DebugLocationsVector &LocList,
+                               DIEBuilder &DIEBldr, DIE *Die,
                                DebugAddrWriter &AddrWriter,
-                               DebugBufferVector &LocBuffer, DWARFUnit &CU,
+                               DebugBufferVector LocBuffer, DWARFUnit &CU,
                                raw_svector_ostream &LocStream) {
-  const uint64_t AttrOffset = AttrVal.Offset;
   if (LocList.empty()) {
-    DebugInfoPatcher.addLE32Patch(AttrOffset, DebugLocWriter::EmptyListOffset);
+    replaceLocValbyForm(DIEBldr, Die, AttrInfo, AttrInfo.getForm(),
+                        DebugLocWriter::EmptyListOffset);
     return;
   }
 
   const uint32_t EntryOffset = LocBuffer.size();
   for (const DebugLocationEntry &Entry : LocList) {
     support::endian::write(LocStream,
                            static_cast<uint8_t>(dwarf::DW_LLE_startx_length),
                            support::little);
     const uint32_t Index = AddrWriter.getIndexFromAddress(Entry.LowPC, CU);
     encodeULEB128(Index, LocStream);
 
     support::endian::write(LocStream,
                            static_cast<uint32_t>(Entry.HighPC - Entry.LowPC),
                            support::little);
     support::endian::write(LocStream, static_cast<uint16_t>(Entry.Expr.size()),
                            support::little);
     LocStream << StringRef(reinterpret_cast<const char *>(Entry.Expr.data()),
                            Entry.Expr.size());
   }
   support::endian::write(LocStream,
                          static_cast<uint8_t>(dwarf::DW_LLE_end_of_list),
                          support::little);
-  DebugInfoPatcher.addLE32Patch(AttrOffset, EntryOffset);
+  replaceLocValbyForm(DIEBldr, Die, AttrInfo, AttrInfo.getForm(), EntryOffset);
 }
 
-static void writeDWARF5LocList(
-    uint32_t &NumberOfEntries, AttrInfo &AttrVal, DebugLocationsVector &LocList,
-    DebugInfoBinaryPatcher &DebugInfoPatcher, DebugAbbrevWriter &AbbrevWriter,
-    DebugAddrWriter &AddrWriter, DebugBufferVector &LocBodyBuffer,
-    std::vector<uint32_t> &RelativeLocListOffsets, DWARFUnit &CU,
+static void writeDWARF5LocList(uint32_t &NumberOfEntries, DIEValue &AttrInfo,
+                               DebugLocationsVector &LocList, DIE *Die,
+                               DIEBuilder &DIEBldr, DebugAddrWriter &AddrWriter,
+                               DebugBufferVector &LocBodyBuffer,
+                               std::vector<uint32_t> &RelativeLocListOffsets,
+                               DWARFUnit &CU,
                                raw_svector_ostream &LocBodyStream) {
-  if (AttrVal.V.getForm() != dwarf::DW_FORM_loclistx) {
-    AbbrevWriter.addAttributePatch(CU, AttrVal.AbbrevDecl,
-                                   dwarf::DW_AT_location, dwarf::DW_AT_location,
-                                   dwarf::DW_FORM_loclistx);
-  }
-  DebugInfoPatcher.addUDataPatch(AttrVal.Offset, NumberOfEntries, AttrVal.Size);
+
+  replaceLocValbyForm(DIEBldr, Die, AttrInfo, dwarf::DW_FORM_loclistx,
+                      NumberOfEntries);
+
   RelativeLocListOffsets.push_back(LocBodyBuffer.size());
   ++NumberOfEntries;
   if (LocList.empty()) {
     writeEmptyListDwarf5(LocBodyStream);
     return;
   }
 
   std::vector<uint64_t> OffsetsArray;
   for (const DebugLocationEntry &Entry : LocList) {
     support::endian::write(LocBodyStream,
                            static_cast<uint8_t>(dwarf::DW_LLE_startx_length),
                            support::little);
     const uint32_t Index = AddrWriter.getIndexFromAddress(Entry.LowPC, CU);
     encodeULEB128(Index, LocBodyStream);
     encodeULEB128(Entry.HighPC - Entry.LowPC, LocBodyStream);
     encodeULEB128(Entry.Expr.size(), LocBodyStream);
     LocBodyStream << StringRef(
         reinterpret_cast<const char *>(Entry.Expr.data()), Entry.Expr.size());
   }
   support::endian::write(LocBodyStream,
                          static_cast<uint8_t>(dwarf::DW_LLE_end_of_list),
                          support::little);
 }
 
-void DebugLoclistWriter::addList(AttrInfo &AttrVal,
-                                 DebugLocationsVector &LocList,
-                                 DebugInfoBinaryPatcher &DebugInfoPatcher,
-                                 DebugAbbrevWriter &AbbrevWriter) {
+void DebugLoclistWriter::addList(DIEBuilder &DIEBldr, DIE *Die,
+                                 DIEValue &AttrInfo,
+                                 DebugLocationsVector &LocList) {
   if (DwarfVersion < 5)
-    writeLegacyLocList(AttrVal, LocList, DebugInfoPatcher, *AddrWriter,
-                       *LocBuffer, CU, *LocStream);
+    writeLegacyLocList(AttrInfo, LocList, DIEBldr, Die, *AddrWriter, *LocBuffer,
+                       CU, *LocStream);
   else
-    writeDWARF5LocList(NumberOfEntries, AttrVal, LocList, DebugInfoPatcher,
-                       AbbrevWriter, *AddrWriter, *LocBodyBuffer,
-                       RelativeLocListOffsets, CU, *LocBodyStream);
+    writeDWARF5LocList(NumberOfEntries, AttrInfo, LocList, Die, DIEBldr,
+                       *AddrWriter, *LocBodyBuffer, RelativeLocListOffsets, CU,
+                       *LocBodyStream);
 }
 
 uint32_t DebugLoclistWriter::LoclistBaseOffset = 0;
-void DebugLoclistWriter::finalizeDWARF5(
-    DebugInfoBinaryPatcher &DebugInfoPatcher, DebugAbbrevWriter &AbbrevWriter) {
+void DebugLoclistWriter::finalizeDWARF5(DIEBuilder &DIEBldr, DIE *Die) {
   if (LocBodyBuffer->empty())
     return;
 
   std::unique_ptr<DebugBufferVector> LocArrayBuffer =
       std::make_unique<DebugBufferVector>();
   std::unique_ptr<raw_svector_ostream> LocArrayStream =
       std::make_unique<raw_svector_ostream>(*LocArrayBuffer);
 
   const uint32_t SizeOfArraySection = NumberOfEntries * sizeof(uint32_t);
   // Write out IndexArray
   for (uint32_t RelativeOffset : RelativeLocListOffsets)
     support::endian::write(
         *LocArrayStream,
         static_cast<uint32_t>(SizeOfArraySection + RelativeOffset),
         support::little);
 
   std::unique_ptr<DebugBufferVector> Header = getDWARF5Header(
       {static_cast<uint32_t>(SizeOfArraySection + LocBodyBuffer.get()->size()),
        5, 8, 0, NumberOfEntries});
   *LocStream << *Header;
   *LocStream << *LocArrayBuffer;
   *LocStream << *LocBodyBuffer;
 
   if (!isSplitDwarf()) {
-    if (Optional<AttrInfo> AttrInfoVal =
-            findAttributeInfo(CU.getUnitDIE(), dwarf::DW_AT_loclists_base))
-      DebugInfoPatcher.addLE32Patch(AttrInfoVal->Offset,
-                                    LoclistBaseOffset +
-                                        getDWARF5RngListLocListHeaderSize());
-    else {
-      AbbrevWriter.addAttribute(
-          CU, CU.getUnitDIE().getAbbreviationDeclarationPtr(),
-          dwarf::DW_AT_loclists_base, dwarf::DW_FORM_sec_offset);
-      DebugInfoPatcher.insertNewEntry(CU.getUnitDIE(),
-                                      LoclistBaseOffset + Header->size());
+    DIEValue LocListBaseAttrInfo =
+        Die->findAttribute(dwarf::DW_AT_loclists_base);
+    if (LocListBaseAttrInfo.getType()) {
+      DIEBldr.replaceValue(
+          Die, dwarf::DW_AT_loclists_base, LocListBaseAttrInfo.getForm(),
+          DIEInteger(LoclistBaseOffset + getDWARF5RngListLocListHeaderSize()));
+    } else {
+      DIEBldr.addValue(Die, dwarf::DW_AT_loclists_base,
+                       dwarf::DW_FORM_sec_offset,
+                       DIEInteger(LoclistBaseOffset + Header->size()));
     }
     LoclistBaseOffset += LocBuffer->size();
   }
   clearList(RelativeLocListOffsets);
   clearList(*LocArrayBuffer);
   clearList(*LocBodyBuffer);
 }
 
-void DebugLoclistWriter::finalize(DebugInfoBinaryPatcher &DebugInfoPatcher,
-                                  DebugAbbrevWriter &AbbrevWriter) {
+void DebugLoclistWriter::finalize(DIEBuilder &DIEBldr, DIE *Die) {
   if (DwarfVersion >= 5)
-    finalizeDWARF5(DebugInfoPatcher, AbbrevWriter);
+    finalizeDWARF5(DIEBldr, Die);
 }
 
 DebugAddrWriter *DebugLoclistWriter::AddrWriter = nullptr;
 
 void DebugInfoBinaryPatcher::addUnitBaseOffsetLabel(uint64_t Offset) {
   Offset -= DWPUnitOffset;
   std::lock_guard<std::mutex> Lock(WriterMutex);
   DebugPatches.emplace_back(new DWARFUnitOffsetBaseLabel(Offset));

bolt/lib/Rewrite/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   DebugInfoDWARF
   DWP
   ExecutionEngine
   MC
   Object
   Support
+  DWARFLinker
+  AsmPrinter
+  BinaryFormat
   )
 
 set(TARGET_LINK_LIBRARIES
   LLVMBOLTCore
   LLVMBOLTPasses
   LLVMBOLTProfile
   LLVMBOLTRuntimeLibs
   LLVMBOLTUtils

 
 add_llvm_library(LLVMBOLTRewrite
   BinaryPassManager.cpp
   BoltDiff.cpp
   DWARFRewriter.cpp
   ExecutableFileMemoryManager.cpp
   MachORewriteInstance.cpp
   RewriteInstance.cpp
-
+  DIEBuilder.cpp
   LINK_LIBS
   ${LLVM_PTHREAD_LIB}
   )
 
 target_link_libraries(LLVMBOLTRewrite
   PRIVATE
   ${TARGET_LINK_LIBRARIES}
   )
 
 if (DEFINED BOLT_AArch64)
   target_compile_definitions(LLVMBOLTRewrite PRIVATE AARCH64_AVAILABLE)
 endif()
 
 if (DEFINED BOLT_X64)
   target_compile_definitions(LLVMBOLTRewrite PRIVATE X86_AVAILABLE)
 endif()

bolt/lib/Rewrite/DIEBuilder.cpp

+#include "bolt/Rewrite/DIEBuilder.h"
+#include "bolt/Core/BinaryContext.h"
+#include "bolt/Core/ParallelUtilities.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/CodeGen/DIE.h"
+#include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
+#include "llvm/DebugInfo/DWARF/DWARFDie.h"
+#include "llvm/DebugInfo/DWARF/DWARFExpression.h"
+#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
+#include "llvm/DebugInfo/DWARF/DWARFTypeUnit.h"
+#include "llvm/DebugInfo/DWARF/DWARFUnit.h"
+#include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
+#include "llvm/ObjectYAML/DWARFYAML.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/LEB128.h"
+#include "llvm/Support/ThreadPool.h"
+#include "llvm/Support/YAMLTraits.h"
+
+#include <algorithm>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+#undef DEBUG_TYPE
+#define DEBUG_TYPE "bolt"
+namespace llvm {
+namespace bolt {
+
+void DIEBuilder::computeReference() {
+  for (auto &[SrcDIEInfo, ReferenceInfo] : ForwardReferences) {
+    DIEInfo *DstDIEInfo = ReferenceInfo->Dst;
+    UnitInfo &dstUnitInfo = getUnitInfo(DstDIEInfo->UnitId);
+    dwarf::Attribute Attr = ReferenceInfo->AttrSpec.Attr;
+    dwarf::Form Form = ReferenceInfo->AttrSpec.Form;
+
+    uint64_t NewAddr = DstDIEInfo->Die->getOffset() + dstUnitInfo.UnitOffset;
+    SrcDIEInfo->Die->replaceValue(DIEAlloc, Attr, Form, DIEInteger(NewAddr));
+  }
+
+  return;
+}
+
+Optional<uint32_t> DIEBuilder::allocDIE(DWARFUnit &DU, DWARFDie &DDie,
+                                        BumpPtrAllocator &Alloc, uint32_t UId,
+                                        uint32_t offset) {
+  std::lock_guard<std::shared_timed_mutex> lock(AllocateDIEMutex);
+  auto &UnitInfo = getUnitInfo(UId);
+  auto DDieOffset = DDie.getOffset();
+  if (UnitInfo.DIEIDMap.count(DDieOffset))
+    return UnitInfo.DIEIDMap[DDieOffset];
+  uint32_t DId = AllocDIEId(DU);
+
+  DIE *Die = DIE::get(Alloc, dwarf::Tag(DDie.getTag()));
+  UnitInfo.DIEIDMap[DDieOffset] = DId;
+  UnitInfo.DieInfoList.push_back(DIEInfo{Die, DId, UId, offset});
+  UnitInfo.DIEId2Info[DId] = &UnitInfo.DieInfoList.back();
+
+  return DId;
+}
+
+void DIEBuilder::constructFromUnit(DWARFUnit *DU,
+                                   std::vector<DWARFUnit *> &DUOffsetList) {
+  Optional<uint32_t> UnitId = getUnitId(DU);
+  if (!UnitId.hasValue()) {
+    errs() << "BOLT-WARNING: "
+           << format("Skip Unit at 0x%x\n", DU->getOffset());
+    return;
+  }
+
+  const uint32_t UnitHeaderSize = DU->getHeaderSize();
+  uint64_t DIEOffset = DU->getOffset() + UnitHeaderSize;
+  uint64_t NextCUOffset = DU->getNextUnitOffset();
+  DWARFDataExtractor DebugInfoData = DU->getDebugInfoExtractor();
+  DWARFDebugInfoEntry DIEEntry;
+  std::vector<DIE *> CurParentDIEStack;
+  std::vector<uint32_t> Parents;
+  bool IsCUDie = true;
+
+  assert(DebugInfoData.isValidOffset(NextCUOffset - 1));
+  Parents.push_back(UINT32_MAX);
+  do {
+    if (!DIEEntry.extractFast(*DU, &DIEOffset, DebugInfoData, NextCUOffset,
+                              Parents.back()))
+      break;
+
+    if (const DWARFAbbreviationDeclaration *AbbrDecl =
+            DIEEntry.getAbbreviationDeclarationPtr()) {
+      DWARFDie DDie(DU, &DIEEntry);
+
+      DIE *CurDIE = constructDIEFast(
+          DDie, *DU, DU->getContext().isLittleEndian(), *UnitId, DUOffsetList);
+
+      if (!CurParentDIEStack.empty())
+        CurParentDIEStack.back()->addChild(CurDIE);
+
+      if (AbbrDecl->hasChildren()) {
+        CurParentDIEStack.push_back(CurDIE);
+      } else if (IsCUDie) {
+        // Stop if we have single compile unit die w/o children.
+        break;
+      }
+    } else {
+      // NULL DIE: finishes current children scope.
+      CurParentDIEStack.pop_back();
+    }
+
+    if (IsCUDie)
+      IsCUDie = false;
+  } while (CurParentDIEStack.size() > 0);
+
+  CloneUnitCtxMap[*UnitId].is_constructed = true;
+}
+
+DIEBuilder::DIEBuilder(DWARFContext *DwarfContext, bool IsDWO) {
+  if (!DwarfContext)
+    return;
+
+  outs() << "BOLT-INFO: Constructing DIE...\n";
+  IsBuilt = true;
+
+  const DWARFUnitIndex &TUIndex = DwarfContext->getTUIndex();
+  if (!TUIndex.getRows().empty()) {
+    for (auto &Row : TUIndex.getRows()) {
+      uint64_t Signature = Row.getSignature();
+
+      // manually populate TypeUnit to UnitVector
+      DwarfContext->getTypeUnitForHash(DwarfContext->getMaxVersion(), Signature,
+                                       true);
+    }
+  }
+
+  uint32_t MaxVersion =
+      IsDWO ? DwarfContext->getMaxDWOVersion() : DwarfContext->getMaxVersion();
+  unsigned int CUNum = IsDWO ? DwarfContext->getNumDWOCompileUnits()
+                             : DwarfContext->getNumCompileUnits();
+  DWARFContext::compile_unit_range CU4Ranges =
+      IsDWO ? DwarfContext->dwo_compile_units() : DwarfContext->compile_units();
+  DWARFContext::unit_iterator_range CU5Ranges =
+      IsDWO ? DwarfContext->dwo_info_section_units()
+            : DwarfContext->info_section_units();
+
+  if (MaxVersion >= 5) {
+    CUNum = IsDWO ? DwarfContext->getNumDWOCompileUnits() +
+                        DwarfContext->getNumDWOTypeUnits()
+                  : DwarfContext->getNumCompileUnits() +
+                        DwarfContext->getNumTypeUnits();
+  }
+
+  CloneUnitCtxMap = std::vector<UnitInfo>(CUNum);
+  UnitDIEId = std::vector<uint32_t>(CUNum, 0);
+
+  ThreadPool &ThreadPool = ParallelUtilities::getThreadPool();
+  if (MaxVersion >= 5) {
+    for (std::unique_ptr<DWARFUnit> &DU : CU5Ranges) {
+      if (!DU.get())
+        continue;
+      DUList.push_back(DU.get());
+    }
+    for (std::unique_ptr<DWARFUnit> &DU : CU5Ranges) {
+      if (!DU.get())
+        continue;
+      ThreadPool.async(
+          [&](DWARFUnit *DU, std::vector<DWARFUnit *> &DUList) {
+            constructFromUnit(DU, DUList);
+          },
+          DU.get(), DUList);
+      ThreadPool.wait();
+    }
+  } else {
+    DWARFContext::unit_iterator_range CU4TURanges =
+        IsDWO ? DwarfContext->dwo_types_section_units()
+              : DwarfContext->types_section_units();
+    for (std::unique_ptr<DWARFUnit> &DU : CU4TURanges) {
+      CloneUnitCtxMap.resize(CloneUnitCtxMap.size() + 1);
+      UnitDIEId.resize(UnitDIEId.size() + 1);
+      DUList.push_back(DU.get());
+      DWARF4TUList.push_back(DU.get());
+    }
+    for (std::unique_ptr<DWARFUnit> &DU : CU4TURanges) {
+      constructFromUnit(DU.get(), DWARF4TUList);
+    }
+
+    for (std::unique_ptr<DWARFUnit> &DU : CU4Ranges) {
+      DUList.push_back(DU.get());
+      DWARF4CUList.push_back(DU.get());
+    }
+    for (std::unique_ptr<DWARFUnit> &DU : CU4Ranges) {
+      constructFromUnit(DU.get(), DWARF4CUList);
+    }
+  }
+  outs() << "BOLT-INFO: Finish constructing DIE\n";
+}
+
+DIE *DIEBuilder::constructDIEFast(DWARFDie &DDie, DWARFUnit &U,
+                                  bool IsLittleEndian, uint32_t UnitId,
+                                  std::vector<DWARFUnit *> &DUOffsetList) {
+
+  Optional<uint32_t> Idx = getAllocDIEId(U, DDie);
+  if (Idx.hasValue()) {
+    UnitInfo &UnitInfo = getUnitInfo(UnitId);
+    DIEInfo &DieInfo = getDIEInfo(UnitId, *Idx);
+    if (UnitInfo.is_constructed && DieInfo.Die)
+      return DieInfo.Die;
+  } else {
+    Idx = allocDIE(U, DDie, DIEAlloc, UnitId);
+  }
+
+  DIEInfo &DieInfo = getDIEInfo(UnitId, *Idx);
+  DIE *Die = DieInfo.Die;
+
+  UnitDIEs[&U].push_back(Die);
+
+  uint64_t Offset = DDie.getOffset();
+  uint64_t NextOffset = Offset;
+  DWARFDataExtractor Data = U.getDebugInfoExtractor();
+  DWARFDebugInfoEntry DDIEntry;
+
+  if (DDIEntry.extractFast(U, &NextOffset, Data, U.getNextUnitOffset(), 0)) {
+    assert(NextOffset - U.getOffset() <= Data.getData().size() &&
+           "NextOffset OOB");
+  }
+
+  SmallString<40> DIECopy(Data.getData().substr(Offset, NextOffset - Offset));
+  Data =
+      DWARFDataExtractor(DIECopy, Data.isLittleEndian(), Data.getAddressSize());
+  Offset = 0;
+
+  const DWARFAbbreviationDeclaration *Abbrev =
+      DDie.getAbbreviationDeclarationPtr();
+  Offset += getULEB128Size(Abbrev->getCode());
+
+  for (const auto &AttrSpec : Abbrev->attributes()) {
+    DWARFFormValue Val(AttrSpec.Form);
+    uint64_t AttrSize = Offset;
+    Val.extractValue(Data, &Offset, U.getFormParams(), &U);
+    AttrSize = Offset - AttrSize;
+    cloneAttribute(*Die, DDie, U, Val, AttrSpec, AttrSize, IsLittleEndian,
+                   DUOffsetList);
+  }
+  return Die;
+}
+
+static DWARFUnit *getUnitForOffset(const std::vector<DWARFUnit *> &Units,
+                                   uint64_t Offset) {
+  auto CU =
+      llvm::upper_bound(Units, Offset, [](uint64_t LHS, const DWARFUnit *RHS) {
+        return LHS < RHS->getNextUnitOffset();
+      });
+  return CU != Units.end() ? *CU : nullptr;
+}
+
+uint32_t DIEBuilder::computeDIEOffset(DWARFUnit &CU, DIE &Die,
+                                      uint32_t &curOffset) {
+  uint32_t curSize = 0;
+
+  Die.setOffset(curOffset);
+  for (DIEValue &Val : Die.values()) {
+    curSize += Val.sizeOf(CU.getFormParams());
+  }
+  curSize += getULEB128Size(Die.getAbbrevNumber());
+  curOffset += curSize;
+
+  for (DIE &Child : Die.children()) {
+    uint32_t childSize = computeDIEOffset(CU, Child, curOffset);
+    curSize += childSize;
+  }
+  // for children end mark.
+  if (Die.hasChildren()) {
+    curSize += sizeof(uint8_t);
+    curOffset += sizeof(uint8_t);
+  }
+
+  Die.setSize(curSize);
+
+  return curSize;
+}
+
+void DIEBuilder::finish() {
+  uint64_t unitStartOffset = 0;
+
+  for (DWARFUnit *CU : DUList) {
+    DIE *UnitDIE = getUnitDIEbyUnit(*CU);
+    uint32_t headerSize = CU->getHeaderSize();
+    uint32_t curOffset = headerSize;
+    computeDIEOffset(*CU, *UnitDIE, curOffset);
+
+    UnitInfo &curUnitInfo = getUnitInfoByDwarfUnit(CU);
+    curUnitInfo.UnitOffset = unitStartOffset;
+    unitStartOffset += headerSize + UnitDIE->getSize();
+  }
+
+  computeReference();
+}
+
+DWARFDie DIEBuilder::resolveDIEReference(
+    const DWARFFormValue &RefValue,
+    DWARFAbbreviationDeclaration::AttributeSpec AttrSpec, DWARFUnit *&RefCU,
+    DWARFDebugInfoEntry &DwarfDebugInfoEntry,
+    std::vector<DWARFUnit *> &DUOffsetList) {
+  assert(RefValue.isFormClass(DWARFFormValue::FC_Reference));
+  uint64_t RefOffset = *RefValue.getAsReference();
+
+  if ((RefCU = getUnitForOffset(DUOffsetList, RefOffset))) {
+    DWARFDataExtractor DebugInfoData = RefCU->getDebugInfoExtractor();
+    if (DwarfDebugInfoEntry.extractFast(*RefCU, &RefOffset, DebugInfoData,
+                                        RefCU->getNextUnitOffset(), 0)) {
+      // In a file with broken references, an attribute might point to a NULL
+      // DIE.
+      DWARFDie RefDie = DWARFDie(RefCU, &DwarfDebugInfoEntry);
+      if (!RefDie.isNULL()) {
+        Optional<uint32_t> UnitId = getUnitId(RefCU);
+
+        // forward reference
+        if (UnitId.hasValue() && !CloneUnitCtxMap[*UnitId].is_constructed) {
+          Optional<uint32_t> isAllocId = getAllocDIEId(*RefCU, RefDie);
+          if (!isAllocId.hasValue()) {
+            // forward reference but need allocate a empty one
+            isAllocId = allocDIE(*RefCU, RefDie, DIEAlloc, *UnitId);
+          }
+
+          uint32_t DIEId = *isAllocId;
+          DIEInfo &DieInfo = getDIEInfo(*UnitId, DIEId);
+          DieInfo.CanonicalDIEOffset = 0xDEADBEEF;
+        }
+        return RefDie;
+      }
+    }
+  }
+
+  llvm_unreachable("could not find referenced CU\n");
+  return DWARFDie();
+}
+
+uint32_t DIEBuilder::cloneDieReferenceAttribute(
+    DIE &Die, const DWARFDie &InputDIE,
+    DWARFAbbreviationDeclaration::AttributeSpec AttrSpec, unsigned AttrSize,
+    const DWARFFormValue &Val, DWARFUnit &U,
+    std::vector<DWARFUnit *> &DUOffsetList) {
+  uint64_t Ref = *Val.getAsReference();
+
+  DIE *NewRefDie = nullptr;
+  DWARFUnit *RefUnit = nullptr;
+
+  DWARFDebugInfoEntry DDIEntry;
+  DWARFDie RefDie =
+      resolveDIEReference(Val, AttrSpec, RefUnit, DDIEntry, DUOffsetList);
+
+  if (!RefDie || AttrSpec.Attr == dwarf::DW_AT_sibling)
+    return 0;
+
+  Optional<uint32_t> UnitId = getUnitId(RefUnit);
+  Optional<uint32_t> IsAllocId = getAllocDIEId(*RefUnit, RefDie);
+  if (!IsAllocId.hasValue())
+    llvm_unreachable(
+        "[error] encounter unexpected unallocated DIE. Should be alloc!");
+  uint32_t DIEId = *IsAllocId;
+  DIEInfo &DieInfo = getDIEInfo(*UnitId, DIEId);
+
+  if (!DieInfo.Die) {
+    assert(Ref > InputDIE.getOffset());
+    llvm_unreachable(
+        "[error] encounter unexpected unallocated DIE. Should be alloc!");
+    // We haven't cloned this DIE yet. Just create an empty one and
+    // store it. It'll get really cloned when we process it.
+    DieInfo.Die = DIE::get(DIEAlloc, dwarf::Tag(RefDie.getTag()));
+  }
+  NewRefDie = DieInfo.Die;
+
+  if (AttrSpec.Form == dwarf::DW_FORM_ref_addr) {
+    // no matter forward reference or backward reference, we are supposed
+    // to calculate them in `finish` due to the possible modification of
+    // the DIE.
+    DWARFDie curDIE = const_cast<DWARFDie &>(InputDIE);
+    DIEInfo *curDIEInfo = &getDIEInfoByDwarfDie(&curDIE);
+    ForwardReferences.push_back(std::make_pair(
+        curDIEInfo,
+        std::make_unique<ForwardReferenceInfo>(&DieInfo, AttrSpec)));
+
+    Die.addValue(DIEAlloc, AttrSpec.Attr, dwarf::DW_FORM_ref_addr,
+                 DIEInteger(0xDEADBEEF));
+    return U.getRefAddrByteSize();
+  }
+
+  Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
+               dwarf::Form(AttrSpec.Form), DIEEntry(*NewRefDie));
+
+  return AttrSize;
+}
+
+uint32_t DIEBuilder::cloneStringAttribute(
+    DIE &Die, DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+    unsigned AttrSize, const DWARFFormValue &Val, const DWARFUnit &U) {
+  if (AttrSpec.Form == dwarf::DW_FORM_string) {
+    auto StrAddr = Val.getAsCString();
+    if (!StrAddr) {
+      consumeError(StrAddr.takeError());
+      return AttrSize;
+    }
+    Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
+                 dwarf::DW_FORM_string,
+                 new (DIEAlloc) DIEInlineString(StrAddr.get(), DIEAlloc));
+  } else {
+    Optional<uint64_t> OffsetIndex = Val.getRawUValue();
+    Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr), AttrSpec.Form,
+                 DIEInteger(*OffsetIndex));
+  }
+  return AttrSize;
+}
+
+void DIEBuilder::cloneExpression(DataExtractor &Data,
+                                 DWARFExpression Expression, DWARFUnit &U,
+                                 SmallVectorImpl<uint8_t> &OutputBuffer) {
+  using Encoding = DWARFExpression::Operation::Encoding;
+
+  uint64_t OpOffset = 0;
+  for (auto &Op : Expression) {
+    auto Description = Op.getDescription();
+    // DW_OP_const_type is variable-length and has 3
+    // operands. DWARFExpression thus far only supports 2.
+    auto Op0 = Description.Op[0];
+    auto Op1 = Description.Op[1];
+    if ((Op0 == Encoding::BaseTypeRef && Op1 != Encoding::SizeNA) ||
+        (Op1 == Encoding::BaseTypeRef && Op0 != Encoding::Size1))
+      outs() << "BOLT-INFO: Unsupported DW_OP encoding.\n";
+
+    if ((Op0 == Encoding::BaseTypeRef && Op1 == Encoding::SizeNA) ||
+        (Op1 == Encoding::BaseTypeRef && Op0 == Encoding::Size1)) {
+      // This code assumes that the other non-typeref operand fits into 1
+      // byte.
+      assert(OpOffset < Op.getEndOffset());
+      uint32_t ULEBsize = Op.getEndOffset() - OpOffset - 1;
+      assert(ULEBsize <= 16);
+
+      // Copy over the operation.
+      OutputBuffer.push_back(Op.getCode());
+      uint64_t RefOffset;
+      if (Op1 == Encoding::SizeNA) {
+        RefOffset = Op.getRawOperand(0);
+      } else {
+        OutputBuffer.push_back(Op.getRawOperand(0));
+        RefOffset = Op.getRawOperand(1);
+      }
+      uint32_t Offset = 0;
+      if (RefOffset > 0 || Op.getCode() != dwarf::DW_OP_convert) {
+        DWARFDie RefDie = U.getDIEForOffset(RefOffset);
+        Optional<uint32_t> RefDieID = getAllocDIEId(U, RefOffset);
+        Optional<uint32_t> RefUnitID = getUnitId(&U);
+        if (RefDieID.has_value() && RefUnitID.has_value()) {
+          DIEInfo &RefDieInfo = getDIEInfo(*RefUnitID, *RefDieID);
+          if (DIE *Clone = RefDieInfo.Die)
+            Offset = RefDie.getOffset();
+          else
+            errs() << "BOLT-WARNING: base type ref doesn't point to "
+                      "DW_TAG_base_type.\n";
+        }
+      }
+      uint8_t ULEB[16];
+      unsigned RealSize = encodeULEB128(Offset, ULEB, ULEBsize);
+      if (RealSize > ULEBsize) {
+        // Emit the generic type as a fallback.
+        RealSize = encodeULEB128(0, ULEB, ULEBsize);
+        errs() << "BOLT-WARNING: base type ref doesn't fit.\n";
+      }
+      assert(RealSize == ULEBsize && "padding failed");
+      ArrayRef<uint8_t> ULEBbytes(ULEB, ULEBsize);
+      OutputBuffer.append(ULEBbytes.begin(), ULEBbytes.end());
+    } else {
+      // Copy over everything else unmodified.
+      StringRef Bytes = Data.getData().slice(OpOffset, Op.getEndOffset());
+      OutputBuffer.append(Bytes.begin(), Bytes.end());
+    }
+    OpOffset = Op.getEndOffset();
+  }
+}
+
+uint32_t DIEBuilder::cloneBlockAttribute(
+    DIE &Die, DWARFUnit &U,
+    DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+    const DWARFFormValue &Val, unsigned AttrSize, bool IsLittleEndian) {
+  DIEValueList *Attr;
+  DIEValue Value;
+  DIELoc *Loc = nullptr;
+  DIEBlock *Block = nullptr;
+
+  if (AttrSpec.Form == dwarf::DW_FORM_exprloc) {
+    Loc = new (DIEAlloc) DIELoc;
+  } else {
+    Block = new (DIEAlloc) DIEBlock;
+  }
+  Attr = Loc ? static_cast<DIEValueList *>(Loc)
+             : static_cast<DIEValueList *>(Block);
+
+  if (Loc)
+    Value = DIEValue(dwarf::Attribute(AttrSpec.Attr),
+                     dwarf::Form(AttrSpec.Form), Loc);
+  else
+    Value = DIEValue(dwarf::Attribute(AttrSpec.Attr),
+                     dwarf::Form(AttrSpec.Form), Block);
+
+  SmallVector<uint8_t, 32> Buffer;
+  ArrayRef<uint8_t> Bytes = *Val.getAsBlock();
+  if (DWARFAttribute::mayHaveLocationExpr(AttrSpec.Attr) &&
+      (Val.isFormClass(DWARFFormValue::FC_Block) ||
+       Val.isFormClass(DWARFFormValue::FC_Exprloc))) {
+    DataExtractor Data(StringRef((const char *)Bytes.data(), Bytes.size()),
+                       IsLittleEndian, U.getAddressByteSize());
+    DWARFExpression Expr(Data, U.getAddressByteSize(),
+                         U.getFormParams().Format);
+    cloneExpression(Data, Expr, U, Buffer);
+    Bytes = Buffer;
+  }
+  for (auto Byte : Bytes)
+    Attr->addValue(DIEAlloc, static_cast<dwarf::Attribute>(0),
+                   dwarf::DW_FORM_data1, DIEInteger(Byte));
+
+  if (Loc)
+    Loc->setSize(Bytes.size());
+  else
+    Block->setSize(Bytes.size());
+
+  Die.addValue(DIEAlloc, Value);
+  return AttrSize;
+}
+
+uint32_t DIEBuilder::cloneAddressAttribute(
+    DIE &Die, DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+    const DWARFFormValue &Val, const DWARFUnit &U) {
+  Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
+               dwarf::Form(AttrSpec.Form), DIEInteger(Val.getRawUValue()));
+  return U.getAddressByteSize();
+}
+
+uint32_t DIEBuilder::cloneRefsigAttribute(
+    DIE &Die, DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+    unsigned AttrSize, const DWARFFormValue &Val) {
+  Optional<uint64_t> SigVal = Val.getRawUValue();
+  Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
+               dwarf::DW_FORM_ref_sig8, DIEInteger(*SigVal));
+  return AttrSize;
+}
+
+uint32_t DIEBuilder::cloneScalarAttribute(
+    DIE &Die, const DWARFDie &InputDIE,
+    DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+    const DWARFFormValue &Val, unsigned AttrSize) {
+  uint64_t Value;
+
+  if (auto OptionalValue = Val.getAsUnsignedConstant())
+    Value = *OptionalValue;
+  else if (auto OptionalValue = Val.getAsSignedConstant())
+    Value = *OptionalValue;
+  else if (auto OptionalValue = Val.getAsSectionOffset())
+    Value = *OptionalValue;
+  else {
+    errs() << "BOLT-WARNING: Unsupported scalar attribute form. Dropping "
+              "attribute.\n";
+    return 0;
+  }
+
+  Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
+               dwarf::Form(AttrSpec.Form), DIEInteger(Value));
+  return AttrSize;
+}
+
+uint32_t DIEBuilder::cloneLoclistAttrubute(
+    DIE &Die, const DWARFDie &InputDIE,
+    DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+    const DWARFFormValue &Val, unsigned AttrSize) {
+  uint64_t Value;
+
+  if (auto OptionalValue = Val.getAsUnsignedConstant())
+    Value = *OptionalValue;
+  else if (auto OptionalValue = Val.getAsSignedConstant())
+    Value = *OptionalValue;
+  else if (auto OptionalValue = Val.getAsSectionOffset())
+    Value = *OptionalValue;
+  else {
+    errs() << "BOLT-WARNING: Unsupported scalar attribute form. Dropping "
+              "attribute.\n";
+    return 0;
+  }
+
+  Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
+               dwarf::Form(AttrSpec.Form), DIELocList(Value));
+  return AttrSize;
+}
+
+uint32_t DIEBuilder::cloneAttribute(
+    DIE &Die, const DWARFDie &InputDIE, DWARFUnit &U, const DWARFFormValue &Val,
+    const DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
+    unsigned AttrSize, bool IsLittleEndian,
+    std::vector<DWARFUnit *> &DUOffsetList) {
+  switch (AttrSpec.Form) {
+  case dwarf::DW_FORM_strp:
+  case dwarf::DW_FORM_string:
+  case dwarf::DW_FORM_strx:
+  case dwarf::DW_FORM_strx1:
+  case dwarf::DW_FORM_strx2:
+  case dwarf::DW_FORM_strx3:
+  case dwarf::DW_FORM_strx4:
+  case dwarf::DW_FORM_GNU_str_index:
+  case dwarf::DW_FORM_line_strp:
+    return cloneStringAttribute(Die, AttrSpec, AttrSize, Val, U);
+  case dwarf::DW_FORM_ref_addr:
+  case dwarf::DW_FORM_ref1:
+  case dwarf::DW_FORM_ref2:
+  case dwarf::DW_FORM_ref4:
+  case dwarf::DW_FORM_ref8:
+    return cloneDieReferenceAttribute(Die, InputDIE, AttrSpec, AttrSize, Val, U,
+                                      DUOffsetList);
+  case dwarf::DW_FORM_block:
+  case dwarf::DW_FORM_block1:
+  case dwarf::DW_FORM_block2:
+  case dwarf::DW_FORM_block4:
+  case dwarf::DW_FORM_exprloc:
+    return cloneBlockAttribute(Die, U, AttrSpec, Val, AttrSize, IsLittleEndian);
+  case dwarf::DW_FORM_addr:
+  case dwarf::DW_FORM_addrx:
+  case dwarf::DW_FORM_GNU_addr_index:
+    return cloneAddressAttribute(Die, AttrSpec, Val, U);
+  case dwarf::DW_FORM_data1:
+  case dwarf::DW_FORM_data2:
+  case dwarf::DW_FORM_data4:
+  case dwarf::DW_FORM_data8:
+  case dwarf::DW_FORM_udata:
+  case dwarf::DW_FORM_sdata:
+  case dwarf::DW_FORM_sec_offset:
+  case dwarf::DW_FORM_rnglistx:
+  case dwarf::DW_FORM_flag:
+  case dwarf::DW_FORM_flag_present:
+  case dwarf::DW_FORM_implicit_const:
+    return cloneScalarAttribute(Die, InputDIE, AttrSpec, Val, AttrSize);
+  case dwarf::DW_FORM_loclistx:
+    return cloneLoclistAttrubute(Die, InputDIE, AttrSpec, Val, AttrSize);
+  case dwarf::DW_FORM_ref_sig8:
+    return cloneRefsigAttribute(Die, AttrSpec, AttrSize, Val);
+  default:
+    std::string Msg = "Unsupported attribute form " +
+                      dwarf::FormEncodingString(AttrSpec.Form).str() +
+                      " in cloneAttribute. Dropping.";
+    llvm_unreachable(Msg.c_str());
+  }
+
+  return 0;
+}
+void DIEBuilder::assignAbbrev(DIEAbbrev &Abbrev) {
+  // Check the set for priors.
+  FoldingSetNodeID ID;
+  Abbrev.Profile(ID);
+  void *InsertToken;
+  DIEAbbrev *InSet = AbbreviationsSet.FindNodeOrInsertPos(ID, InsertToken);
+
+  // If it's newly added.
+  if (InSet) {
+    // Assign existing abbreviation number.
+    Abbrev.setNumber(InSet->getNumber());
+  } else {
+    // Add to abbreviation list.
+    Abbreviations.push_back(
+        std::make_unique<DIEAbbrev>(Abbrev.getTag(), Abbrev.hasChildren()));
+    for (const auto &Attr : Abbrev.getData())
+      Abbreviations.back()->AddAttribute(Attr.getAttribute(), Attr.getForm());
+    AbbreviationsSet.InsertNode(Abbreviations.back().get(), InsertToken);
+    // Assign the unique abbreviation number.
+    Abbrev.setNumber(Abbreviations.size());
+    Abbreviations.back()->setNumber(Abbreviations.size());
+  }
+}
+
+void DIEBuilder::generateAbbrevs() {
+  if (!IsBuilt)
+    return;
+
+  for (DWARFUnit *DU : DUList) {
+    DIE *UnitDIE = getUnitDIEbyUnit(*DU);
+    generateUnitAbbrevs(UnitDIE);
+  }
+}
+
+void DIEBuilder::generateUnitAbbrevs(DIE *Die) {
+  DIEAbbrev NewAbbrev = Die->generateAbbrev();
+
+  if (Die->hasChildren())
+    NewAbbrev.setChildrenFlag(dwarf::DW_CHILDREN_yes);
+  assignAbbrev(NewAbbrev);
+  Die->setAbbrevNumber(NewAbbrev.getNumber());
+
+  for (auto &Child : Die->children()) {
+    generateUnitAbbrevs(&Child);
+  }
+}
+
+} // namespace bolt
+} // namespace llvm

bolt/lib/Rewrite/DWARFRewriter.cpp

 //===- bolt/Rewrite/DWARFRewriter.cpp -------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "bolt/Rewrite/DWARFRewriter.h"
 #include "bolt/Core/BinaryContext.h"
 #include "bolt/Core/BinaryFunction.h"
 #include "bolt/Core/DebugData.h"
+#include "bolt/Core/DynoStats.h"
 #include "bolt/Core/ParallelUtilities.h"
+#include "bolt/Rewrite/DIEBuilder.h"
 #include "bolt/Rewrite/RewriteInstance.h"
 #include "bolt/Utils/Utils.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/CodeGen/AsmPrinter.h"
+#include "llvm/CodeGen/DIE.h"
+#include "llvm/DWARFLinker/DWARFStreamer.h"
 #include "llvm/DWP/DWP.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
+#include "llvm/DebugInfo/DWARF/DWARFTypeUnit.h"
+#include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmLayout.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/ToolOutputFile.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstdint>
+#include <functional>
+#include <iterator>
 #include <string>
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
-#undef  DEBUG_TYPE
+#undef DEBUG_TYPE
 #define DEBUG_TYPE "bolt"
 
 LLVM_ATTRIBUTE_UNUSED
 static void printDie(const DWARFDie &DIE) {
   DIDumpOptions DumpOpts;
   DumpOpts.ShowForm = true;
   DumpOpts.Verbose = true;
   DumpOpts.ChildRecurseDepth = 0;
   DumpOpts.ShowChildren = 0;
   DIE.dump(dbgs(), 0, DumpOpts);
 }
 
 namespace llvm {
 namespace bolt {
+
+class DIEStreamer : public DwarfStreamer {
+private:
+  DIE *findTypeDIE(DIE &CurDIE) {
+    if (CurDIE.getTag() == dwarf::DW_TAG_structure_type ||
+        CurDIE.getTag() == dwarf::DW_TAG_class_type)
+      return &CurDIE;
+
+    for (DIE &Child : CurDIE.children()) {
+      if (DIE *TypeDIE = findTypeDIE(Child))
+        return TypeDIE;
+    }
+    return nullptr;
+  }
+
+  /// Emit the compilation unit header for \p Unit in the debug_info
+  /// section.
+  ///
+  /// A Dwarf 4 section header is encoded as:
+  ///  uint32_t   Unit length (omitting this field)
+  ///  uint16_t   Version
+  ///  uint32_t   Abbreviation table offset
+  ///  uint8_t    Address size
+  /// Leading to a total of 11 bytes.
+  ///
+  /// A Dwarf 5 section header is encoded as:
+  ///  uint32_t   Unit length (omitting this field)
+  ///  uint16_t   Version
+  ///  uint8_t    Unit type
+  ///  uint8_t    Address size
+  ///  uint32_t   Abbreviation table offset
+  /// Leading to a total of 12 bytes.
+  void emitCompileUnitHeader(DWARFUnit &Unit, DIE &UnitDIE,
+                             unsigned DwarfVersion) {
+
+    AsmPrinter &Asm = getAsmPrinter();
+    switchToDebugInfoSection(DwarfVersion);
+
+    emitCommonHeader(Unit, UnitDIE, DwarfVersion);
+
+    if (DwarfVersion >= 5 &&
+        Unit.getUnitType() != dwarf::UnitType::DW_UT_compile) {
+      Optional<uint64_t> DWOId = Unit.getDWOId();
+      assert(DWOId &&
+             "DWOId does not exist and this is not a DW_UT_compile Unit");
+      Asm.emitInt64(*DWOId);
+    }
+  }
+
+  void emitCommonHeader(DWARFUnit &Unit, DIE &UnitDIE, uint16_t Version) {
+    dwarf::UnitType UT = dwarf::UnitType(Unit.getUnitType());
+    llvm::AsmPrinter &Asm = getAsmPrinter();
+
+    // Emit size of content not including length itself
+    Asm.emitInt32(Unit.getHeaderSize() + UnitDIE.getSize() - 4);
+    Asm.emitInt16(Version);
+
+    // DWARF v5 reorders the address size and adds a unit type.
+    if (Version >= 5) {
+      Asm.emitInt8(UT);
+      Asm.emitInt8(Asm.MAI->getCodePointerSize());
+    }
+
+    Asm.emitInt32(0);
+    if (Version <= 4) {
+      Asm.emitInt8(Asm.MAI->getCodePointerSize());
+    }
+  }
+
+  void emitTypeUnitHeader(DWARFUnit &Unit, DIE &UnitDIE,
+                          unsigned DwarfVersion) {
+
+    AsmPrinter &Asm = getAsmPrinter();
+
+    if (Unit.getVersion() < 5) {
+      // Switch the section to .debug_types section.
+      std::unique_ptr<MCStreamer> &MS = Asm.OutStreamer;
+      llvm::MCContext &MC = Asm.OutContext;
+      const llvm::MCObjectFileInfo *MOFI = MC.getObjectFileInfo();
+
+      MS->switchSection(MOFI->getDwarfTypesSection(0));
+      MC.setDwarfVersion(DwarfVersion);
+    } else
+      switchToDebugInfoSection(DwarfVersion);
+
+    DWARFTypeUnit *DTU = dyn_cast_or_null<DWARFTypeUnit>(&Unit);
+    assert(DTU && Unit.isTypeUnit() &&
+           "Emit TypeUnit header but not a type unit");
+
+    const uint64_t TypeSignature = DTU->getTypeHash();
+    DIE *TypeDIE = findTypeDIE(UnitDIE);
+
+    emitCommonHeader(Unit, UnitDIE, DwarfVersion);
+    Asm.OutStreamer->emitIntValue(TypeSignature, sizeof(TypeSignature));
+    Asm.emitDwarfLengthOrOffset(TypeDIE ? TypeDIE->getOffset() : 0);
+  }
+
+  void emitUnitHeader(DWARFUnit &Unit, DIE &UnitDIE) {
+    if (Unit.isTypeUnit())
+      emitTypeUnitHeader(Unit, UnitDIE, Unit.getVersion());
+    else
+      emitCompileUnitHeader(Unit, UnitDIE, Unit.getVersion());
+  }
+
+  void emitDIE(DIE &Die) override {
+    AsmPrinter &Asm = getAsmPrinter();
+    Asm.emitDwarfDIE(Die);
+  }
+
+public:
+  DIEStreamer(OutputFileType OutFileType, raw_pwrite_stream &OutFile,
+              std::function<StringRef(StringRef Input)> Translator,
+              messageHandler Error, messageHandler Warning)
+      : DwarfStreamer(OutFileType, OutFile, Translator, Error, Warning){};
+
+  using DwarfStreamer::emitCompileUnitHeader;
+
+  void emitUnit(DWARFUnit &Unit, DIE &UnitDIE) {
+    emitUnitHeader(Unit, UnitDIE);
+    emitDIE(UnitDIE);
+  }
+};
+
 /// Finds attributes FormValue and Offset.
 ///
 /// \param DIE die to look up in.
 /// \param Attrs finds the first attribute that matches and extracts it.
 /// \return an optional AttrInfo with DWARFFormValue and Offset.
 Optional<AttrInfo> findAttributeInfo(const DWARFDie DIE,
                                      std::vector<dwarf::Attribute> Attrs) {
   for (dwarf::Attribute &Attr : Attrs)
     if (Optional<AttrInfo> Info = findAttributeInfo(DIE, Attr))
       return Info;
   return None;
 }
+
 } // namespace bolt
 } // namespace llvm
 
 using namespace llvm;
 using namespace llvm::support::endian;
 using namespace object;
 using namespace bolt;
 
 namespace opts {
 
 extern cl::OptionCategory BoltCategory;
 extern cl::opt<unsigned> Verbosity;
 extern cl::opt<std::string> OutputFilename;
 
 static cl::opt<bool> KeepARanges(
     "keep-aranges",
     cl::desc(
         "keep or generate .debug_aranges section if .gdb_index is written"),
     cl::Hidden, cl::cat(BoltCategory));
 
-static cl::opt<bool>
-DeterministicDebugInfo("deterministic-debuginfo",
+static cl::opt<bool> DeterministicDebugInfo(
+    "deterministic-debuginfo",
     cl::desc("disables parallel execution of tasks that may produce"
              "nondeterministic debug info"),
-  cl::init(true),
-  cl::cat(BoltCategory));
+    cl::init(true), cl::cat(BoltCategory));
 
 static cl::opt<std::string> DwarfOutputPath(
     "dwarf-output-path",
     cl::desc("Path to where .dwo files or dwp file will be written out to."),
     cl::init(""), cl::cat(BoltCategory));
 
 static cl::opt<bool>
     WriteDWP("write-dwp",
              cl::desc("output a single dwarf package file (dwp) instead of "
                       "multiple non-relocatable dwarf object files (dwo)."),
              cl::init(false), cl::cat(BoltCategory));
 
 static cl::opt<bool>
     DebugSkeletonCu("debug-skeleton-cu",
                     cl::desc("prints out offsetrs for abbrev and debu_info of "
                              "Skeleton CUs that get patched."),
                     cl::ZeroOrMore, cl::Hidden, cl::init(false),
                     cl::cat(BoltCategory));
 } // namespace opts
 
+static bool getLowAndHighPC(DIE *Die, DWARFUnit *DU, uint64_t &LowPC,
+                            uint64_t &HighPC, uint64_t &SectionIndex) {
+  DIEValue DvalLowPc = Die->findAttribute(dwarf::DW_AT_low_pc);
+  DIEValue DvalHighPc = Die->findAttribute(dwarf::DW_AT_high_pc);
+  if (!DvalLowPc || !DvalHighPc)
+    return false;
+
+  dwarf::Form Form = DvalLowPc.getForm();
+  bool AddrOffset = Form == dwarf::DW_FORM_LLVM_addrx_offset;
+  uint64_t LowPcValue = DvalLowPc.getDIEInteger().getValue();
+  if (Form == dwarf::DW_FORM_GNU_addr_index || Form == dwarf::DW_FORM_addrx ||
+      AddrOffset) {
+
+    uint32_t Index = AddrOffset ? (LowPcValue >> 32) : LowPcValue;
+    if (!DU)
+      return false;
+    Optional<object::SectionedAddress> SA = DU->getAddrOffsetSectionItem(Index);
+    if (!SA)
+      return false;
+    if (AddrOffset)
+      SA->Address += (LowPcValue & 0xffffffff);
+
+    LowPC = SA->Address;
+    SectionIndex = SA->SectionIndex;
+  } else {
+    LowPC = LowPcValue;
+    SectionIndex = 0;
+  }
+  if (DvalHighPc.getForm() == dwarf::DW_FORM_addr)
+    HighPC = DvalHighPc.getDIEInteger().getValue();
+  else
+    HighPC = LowPC + DvalHighPc.getDIEInteger().getValue();
+
+  return true;
+}
+
+static Expected<llvm::DWARFAddressRangesVector>
+getDIEAddressRanges(DIE *Die, DWARFUnit *DU) {
+  if (!Die || !DU)
+    return DWARFAddressRangesVector();
+  uint64_t LowPC, HighPC, Index;
+  if (getLowAndHighPC(Die, DU, LowPC, HighPC, Index))
+    return DWARFAddressRangesVector{{LowPC, HighPC, Index}};
+  if (DIEValue Dval = Die->findAttribute(dwarf::DW_AT_ranges)) {
+    if (Dval.getForm() == dwarf::DW_FORM_rnglistx)
+      return DU->findRnglistFromIndex(Dval.getDIEInteger().getValue());
+    else
+      return DU->findRnglistFromOffset(Dval.getDIEInteger().getValue());
+  }
+
+  return DWARFAddressRangesVector();
+}
+
+static Optional<object::SectionedAddress>
+getAsSectionedAddress(DWARFUnit *DU, DIEValue &AttrVal) {
+  if (!DWARFFormValue::isFormClass(AttrVal.getForm(),
+                                   DWARFFormValue::FC_Address, DU)) {
+    return None;
+  }
+
+  dwarf::Form Form = AttrVal.getForm();
+  uint64_t Value = AttrVal.getDIEInteger().getValue();
+  bool AddrOffset = Form == dwarf::DW_FORM_LLVM_addrx_offset;
+  if (Form == dwarf::DW_FORM_GNU_addr_index || Form == dwarf::DW_FORM_addrx ||
+      AddrOffset) {
+    uint32_t Index = AddrOffset ? (Value >> 32) : Value;
+    if (!DU)
+      return None;
+    Optional<object::SectionedAddress> SA = DU->getAddrOffsetSectionItem(Index);
+    if (!SA)
+      return None;
+    if (AddrOffset)
+      SA->Address += (Value & 0xffffffff);
+    return SA;
+  }
+  return {{Value, 0}};
+}
+
+static Optional<uint64_t> getAsAddress(DWARFUnit *DU, DIEValue &AttrVal) {
+  if (Optional<object::SectionedAddress> SA =
+          getAsSectionedAddress(DU, AttrVal))
+    return SA->Address;
+  return None;
+}
+
 /// Returns DWO Name to be used. Handles case where user specifies output DWO
 /// directory, and there are duplicate names. Assumes DWO ID is unique.
 static std::string
 getDWOName(llvm::DWARFUnit &CU,
            std::unordered_map<std::string, uint32_t> *NameToIndexMap,
            std::unordered_map<uint64_t, std::string> &DWOIdToName) {
   llvm::Optional<uint64_t> DWOId = CU.getDWOId();
   assert(DWOId && "DWO ID not found.");
if (NameToIndexMap && !opts::DwarfOutputPath.empty()) {
     DWOName.append(std::to_string(Iter->second));
     ++Iter->second;
   }
   DWOName.append(".dwo");
   DWOIdToName[*DWOId] = DWOName;
   return DWOName;
 }
 
-void DWARFRewriter::addStringHelper(DebugInfoBinaryPatcher &DebugInfoPatcher,
+static void emitUnit(DIEBuilder &DIEBldr,
+                     std::unique_ptr<DIEStreamer> &Streamer, DWARFUnit &Unit) {
+  DIE *UnitDIE = DIEBldr.getUnitDIEbyUnit(Unit);
+  Streamer->emitUnit(Unit, *UnitDIE);
+}
+
+static std::unique_ptr<DIEStreamer>
+createDIEStreamer(const Triple &TheTriple, raw_pwrite_stream &OutFile,
+                  StringRef Swift5ReflectionSegmentName) {
+
+  std::unique_ptr<DIEStreamer> Streamer = std::make_unique<DIEStreamer>(
+      OutputFileType::Object, OutFile,
+      [](StringRef Input) -> StringRef { return Input; },
+      [&](const Twine &Error, StringRef Context, const DWARFDie *) {},
+      [&](const Twine &Warning, StringRef Context, const DWARFDie *) {});
+  Streamer->init(TheTriple, Swift5ReflectionSegmentName);
+  return Streamer;
+}
+
+void DWARFRewriter::addStringHelper(DIEBuilder &DIEBldr, DIE *Die,
                                     const DWARFUnit &Unit,
-                                    const AttrInfo &AttrInfoVal,
-                                    StringRef Str) {
+                                    DIEValue &DIEAttrInfo, StringRef Str) {
   uint32_t NewOffset = StrWriter->addString(Str);
   if (Unit.getVersion() == 5) {
-    StrOffstsWriter->updateAddressMap(AttrInfoVal.V.getRawUValue(), NewOffset);
+    StrOffstsWriter->updateAddressMap(DIEAttrInfo.getDIEInteger().getValue(),
+                                      NewOffset);
     return;
   }
-  DebugInfoPatcher.addLE32Patch(AttrInfoVal.Offset, NewOffset,
-                                AttrInfoVal.Size);
+  DIEBldr.replaceValue(Die, DIEAttrInfo.getAttribute(), DIEAttrInfo.getForm(),
+                       DIEInteger(NewOffset));
 }
 
 void DWARFRewriter::updateDebugInfo() {
   ErrorOr<BinarySection &> DebugInfo = BC.getUniqueSectionByName(".debug_info");
   if (!DebugInfo)
     return;
 
-  auto *DebugInfoPatcher =
-      static_cast<DebugInfoBinaryPatcher *>(DebugInfo->getPatcher());
-
   ARangesSectionWriter = std::make_unique<DebugARangesSectionWriter>();
   StrWriter = std::make_unique<DebugStrWriter>(BC);
 
   StrOffstsWriter = std::make_unique<DebugStrOffsetsWriter>();
 
-  AbbrevWriter = std::make_unique<DebugAbbrevWriter>(*BC.DwCtx);
-
   if (!opts::DeterministicDebugInfo) {
     opts::DeterministicDebugInfo = true;
     errs() << "BOLT-WARNING: --deterministic-debuginfo is being deprecated\n";
   }
 
   if (BC.isDWARF5Used()) {
     AddrWriter = std::make_unique<DebugAddrWriterDwarf5>(&BC);
     RangeListsSectionWriter = std::make_unique<DebugRangeListsSectionWriter>();
void DWARFRewriter::updateDebugInfo() {
   }
 
   // Unordered maps to handle name collision if output DWO directory is
   // specified.
   std::unordered_map<std::string, uint32_t> NameToIndexMap;
   std::unordered_map<uint64_t, std::string> DWOIdToName;
   std::mutex AccessMutex;
 
-  auto updateDWONameCompDir = [&](DWARFUnit &Unit) -> void {
-    const DWARFDie &DIE = Unit.getUnitDIE();
-    Optional<AttrInfo> AttrInfoVal = findAttributeInfo(
-        DIE, {dwarf::DW_AT_dwo_name, dwarf::DW_AT_GNU_dwo_name});
-    (void)AttrInfoVal;
-    assert(AttrInfoVal && "Skeleton CU doesn't have dwo_name.");
-
+  auto updateDWONameCompDir = [&](DWARFUnit &Unit, DIEBuilder &DIEBldr,
+                                  DIE *UnitDIE) -> void {
+    DIEValue DWONameAttrInfo = UnitDIE->findAttribute(dwarf::DW_AT_dwo_name);
+    if (!DWONameAttrInfo)
+      DWONameAttrInfo = UnitDIE->findAttribute(dwarf::DW_AT_GNU_dwo_name);
+    assert(DWONameAttrInfo &&
+           "DW_AT_dwo_name is not in Skeleton CU.");
     std::string ObjectName = "";
 
     {
       std::lock_guard<std::mutex> Lock(AccessMutex);
       ObjectName = getDWOName(Unit, &NameToIndexMap, DWOIdToName);
     }
-    addStringHelper(*DebugInfoPatcher, Unit, *AttrInfoVal, ObjectName.c_str());
+    addStringHelper(DIEBldr, UnitDIE, Unit, DWONameAttrInfo,
+                    ObjectName.c_str());
 
-    AttrInfoVal = findAttributeInfo(DIE, dwarf::DW_AT_comp_dir);
-    (void)AttrInfoVal;
-    assert(AttrInfoVal && "DW_AT_comp_dir is not in Skeleton CU.");
+    DIEValue CompDirAttrInfo = UnitDIE->findAttribute(dwarf::DW_AT_comp_dir);
+    assert(CompDirAttrInfo &&
+           "DW_AT_comp_dir is not in Skeleton CU.");
 
     if (!opts::DwarfOutputPath.empty()) {
-      addStringHelper(*DebugInfoPatcher, Unit, *AttrInfoVal,
+      addStringHelper(DIEBldr, UnitDIE, Unit, CompDirAttrInfo,
                       opts::DwarfOutputPath.c_str());
     }
   };
 
-  auto processUnitDIE = [&](size_t CUIndex, DWARFUnit *Unit) {
+  auto processUnitDIE = [&](size_t CUIndex, DWARFUnit *Unit,
+                            DIEBuilder *DIEBlder) {
     // Check if the unit is a skeleton and we need special updates for it and
     // its matching split/DWO CU.
     Optional<DWARFUnit *> SplitCU;
     Optional<uint64_t> RangesBase;
     llvm::Optional<uint64_t> DWOId = Unit->getDWOId();
     StrOffstsWriter->initialize(Unit->getStringOffsetSection(),
                                 Unit->getStringOffsetsTableContribution());
     if (DWOId)
       SplitCU = BC.getDWOCU(*DWOId);
 
     DebugLocWriter *DebugLocWriter = nullptr;
     DebugRangesSectionWriter *RangesSectionWriter =
         Unit->getVersion() >= 5 ? RangeListsSectionWriter.get()
                                 : LegacyRangesSectionWriter.get();
     // Skipping CUs that failed to load.
     if (SplitCU) {
-      updateDWONameCompDir(*Unit);
-
-      DebugInfoBinaryPatcher *DwoDebugInfoPatcher =
-          llvm::cast<DebugInfoBinaryPatcher>(
-              getBinaryDWODebugInfoPatcher(*DWOId));
-      DWARFContext *DWOCtx = BC.getDWOContext();
-      // Setting this CU offset with DWP to normalize DIE offsets to uint32_t
-      if (DWOCtx && !DWOCtx->getCUIndex().getRows().empty())
-        DwoDebugInfoPatcher->setDWPOffset((*SplitCU)->getOffset());
+      DIEBuilder DwoDIEBlder(&(*SplitCU)->getContext(), true);
+      updateDWONameCompDir(*Unit, *DIEBlder, DIEBlder->getUnitDIEbyUnit(*Unit));
 
       {
         std::lock_guard<std::mutex> Lock(AccessMutex);
         DebugLocWriter = LocListWritersByCU[*DWOId].get();
       }
       DebugRangesSectionWriter *TempRangesSectionWriter = RangesSectionWriter;
       if (Unit->getVersion() >= 5) {
         TempRangesSectionWriter = RangeListsWritersByCU[*DWOId].get();
       } else {
         RangesBase = RangesSectionWriter->getSectionOffset();
         // For DWARF5 there is now .debug_rnglists.dwo, so don't need to
         // update rnglists base.
-        DwoDebugInfoPatcher->setRangeBase(*RangesBase);
+        if (RangesBase) {
+          DwoRangesBase[*DWOId] = *RangesBase;
+          setDwoRangesBase(*DWOId, *RangesBase);
+        }
       }
 
-      DwoDebugInfoPatcher->addUnitBaseOffsetLabel((*SplitCU)->getOffset());
-      DebugAbbrevWriter *DWOAbbrevWriter =
-          createBinaryDWOAbbrevWriter((*SplitCU)->getContext(), *DWOId);
-      updateUnitDebugInfo(*(*SplitCU), *DwoDebugInfoPatcher, *DWOAbbrevWriter,
-                          *DebugLocWriter, *TempRangesSectionWriter);
-      DebugLocWriter->finalize(*DwoDebugInfoPatcher, *DWOAbbrevWriter);
-      DwoDebugInfoPatcher->clearDestinationLabels();
-      if (!DwoDebugInfoPatcher->getWasRangBasedUsed())
-        RangesBase = None;
+      updateUnitDebugInfo(*(*SplitCU), DwoDIEBlder, *DebugLocWriter,
+                          *TempRangesSectionWriter);
+      DebugLocWriter->finalize(DwoDIEBlder,
+                               DwoDIEBlder.getUnitDIEbyUnit(**SplitCU));
       if (Unit->getVersion() >= 5)
         TempRangesSectionWriter->finalizeSection();
+
+      // populate debug_info and debug_abbrev for current dwo into stringRef.
+      DwoDIEBlder.generateAbbrevs();
+      DwoDIEBlder.finish();
+
+      SmallVector<char, 20> outBuffer;
+      std::shared_ptr<raw_svector_ostream> ObjOS =
+          std::make_shared<raw_svector_ostream>(outBuffer);
+      const object::ObjectFile *File =
+          (*SplitCU)->getContext().getDWARFObj().getFile();
+      auto TheTriple = std::make_unique<Triple>(File->makeTriple());
+      std::unique_ptr<DIEStreamer> Streamer =
+          createDIEStreamer(*TheTriple, *ObjOS, "DwoStreamerInitAug2");
+
+      if ((*SplitCU)->getContext().getMaxDWOVersion() >= 5) {
+        for (std::unique_ptr<llvm::DWARFUnit> &CU :
+             (*SplitCU)->getContext().dwo_info_section_units())
+          emitUnit(DwoDIEBlder, Streamer, *CU.get());
+      } else {
+        for (std::unique_ptr<llvm::DWARFUnit> &CU :
+             (*SplitCU)->getContext().dwo_compile_units())
+          emitUnit(DwoDIEBlder, Streamer, *CU.get());
+
+        // emit debug_types sections for dwarf4
+        for (DWARFUnit *CU : DwoDIEBlder.getDWARF4TUList())
+          emitUnit(DwoDIEBlder, Streamer, *CU);
+      }
+
+      Streamer->emitAbbrevs(DwoDIEBlder.getAbbrevs(),
+                            (*SplitCU)->getContext().getMaxVersion());
+      Streamer->finish();
+
+      std::unique_ptr<MemoryBuffer> ObjectMemBuffer =
+          MemoryBuffer::getMemBuffer(ObjOS->str(), "in-memory object file",
+                                     false);
+      std::unique_ptr<object::ObjectFile> Obj =
+          cantFail(object::ObjectFile::createObjectFile(
+                       ObjectMemBuffer->getMemBufferRef()),
+                   "error creating in-memory object");
+
+      for (const SectionRef &secs : Obj->sections()) {
+        StringRef contents = cantFail(secs.getContents());
+        StringRef name = cantFail(secs.getName());
+        if (name.equals(".debug_abbrev"))
+          setDwoDebugAbbrevStr(*DWOId, contents);
+        else if (name.equals(".debug_info"))
+          setDwoDebugInfoStr(*DWOId, contents);
+        else if (name.equals(".debug_types"))
+          setDwoDebugTypeStr(*DWOId, contents);
+      }
     }
 
     {
       std::lock_guard<std::mutex> Lock(AccessMutex);
       auto LocListWriterIter = LocListWritersByCU.find(CUIndex);
       if (LocListWriterIter != LocListWritersByCU.end())
         DebugLocWriter = LocListWriterIter->second.get();
     }
     if (Unit->getVersion() >= 5) {
       RangesBase = RangesSectionWriter->getSectionOffset() +
                    getDWARF5RngListLocListHeaderSize();
       RangesSectionWriter->initSection(*Unit);
       StrOffstsWriter->finalizeSection();
     }
 
-    DebugInfoPatcher->addUnitBaseOffsetLabel(Unit->getOffset());
-    updateUnitDebugInfo(*Unit, *DebugInfoPatcher, *AbbrevWriter,
-                        *DebugLocWriter, *RangesSectionWriter, RangesBase);
-    DebugLocWriter->finalize(*DebugInfoPatcher, *AbbrevWriter);
+    updateUnitDebugInfo(*Unit, *DIEBlder, *DebugLocWriter, *RangesSectionWriter,
+                        RangesBase);
+    DebugLocWriter->finalize(*DIEBlder, DIEBlder->getUnitDIEbyUnit(*Unit));
     if (Unit->getVersion() >= 5)
       RangesSectionWriter->finalizeSection();
   };
 
   CUIndex = 0;
+  DIEBuilder DIEBlder(BC.DwCtx.get());
   if (opts::NoThreads || opts::DeterministicDebugInfo) {
-    for (std::unique_ptr<DWARFUnit> &CU : BC.DwCtx->compile_units())
-      processUnitDIE(CUIndex++, CU.get());
+    for (std::unique_ptr<DWARFUnit> &CU : BC.DwCtx->compile_units()) {
+      processUnitDIE(CUIndex++, CU.get(), &DIEBlder);
+    }
   } else {
     // Update unit debug info in parallel
     ThreadPool &ThreadPool = ParallelUtilities::getThreadPool();
     for (std::unique_ptr<DWARFUnit> &CU : BC.DwCtx->compile_units()) {
-      ThreadPool.async(processUnitDIE, CUIndex, CU.get());
+      ThreadPool.async(processUnitDIE, CUIndex, CU.get(), &DIEBlder);
       CUIndex++;
     }
     ThreadPool.wait();
   }
 
-  DebugInfoPatcher->clearDestinationLabels();
-  CUOffsetMap OffsetMap = finalizeDebugSections(*DebugInfoPatcher);
+  CUOffsetMap OffsetMap = finalizeDebugSections(DIEBlder);
 
   if (opts::WriteDWP)
     writeDWP(DWOIdToName);
   else
     writeDWOFiles(DWOIdToName);
 
   updateGdbIndexSection(OffsetMap);
 }
 
 void DWARFRewriter::updateUnitDebugInfo(
-    DWARFUnit &Unit, DebugInfoBinaryPatcher &DebugInfoPatcher,
-    DebugAbbrevWriter &AbbrevWriter, DebugLocWriter &DebugLocWriter,
+    DWARFUnit &Unit, DIEBuilder &DIEBldr, DebugLocWriter &DebugLocWriter,
     DebugRangesSectionWriter &RangesSectionWriter,
     Optional<uint64_t> RangesBase) {
   // Cache debug ranges so that the offset for identical ranges could be reused.
   std::map<DebugAddressRangesVector, uint64_t> CachedRanges;
 
   uint64_t DIEOffset = Unit.getOffset() + Unit.getHeaderSize();
   uint64_t NextCUOffset = Unit.getNextUnitOffset();
-  DWARFDebugInfoEntry Die;
-  DWARFDataExtractor DebugInfoData = Unit.getDebugInfoExtractor();
-  uint32_t Depth = 0;
+  std::vector<DIE *> DIEs = DIEBldr.getDIEsByUnit(Unit);
 
   bool IsDWP = false;
   if (DWARFContext *DWOCtx = BC.getDWOContext())
     IsDWP = !DWOCtx->getCUIndex().getRows().empty();
 
-  while (
-      DIEOffset < NextCUOffset &&
-      Die.extractFast(Unit, &DIEOffset, DebugInfoData, NextCUOffset, Depth)) {
-    if (const DWARFAbbreviationDeclaration *AbbrDecl =
-            Die.getAbbreviationDeclarationPtr()) {
-      if (AbbrDecl->hasChildren())
-        ++Depth;
-    } else {
-      // NULL entry.
-      if (Depth > 0)
-        --Depth;
-      if (Depth == 0)
-        break;
-    }
-
-    DWARFDie DIE(&Unit, &Die);
-
-    switch (DIE.getTag()) {
+  for (DIE *Die : DIEs) {
+    switch (Die->getTag()) {
     case dwarf::DW_TAG_compile_unit:
     case dwarf::DW_TAG_skeleton_unit: {
       // For dwarf5 section 3.1.3
       // The following attributes are not part of a split full compilation unit
       // entry but instead are inherited (if present) from the corresponding
       // skeleton compilation unit: DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges,
       // DW_AT_stmt_list, DW_AT_comp_dir, DW_AT_str_offsets_base,
       // DW_AT_addr_base and DW_AT_rnglists_base.
       if (Unit.getVersion() == 5 && Unit.isDWOUnit())
         continue;
-      auto ModuleRangesOrError = DIE.getAddressRanges();
+      auto ModuleRangesOrError = getDIEAddressRanges(Die, &Unit);
       if (!ModuleRangesOrError) {
         consumeError(ModuleRangesOrError.takeError());
         break;
       }
       DWARFAddressRangesVector &ModuleRanges = *ModuleRangesOrError;
       DebugAddressRangesVector OutputRanges =
           BC.translateModuleAddressRanges(ModuleRanges);
+
       const uint64_t RangesSectionOffset =
           RangesSectionWriter.addRanges(OutputRanges);
       if (!Unit.isDWOUnit())
         ARangesSectionWriter->addCURanges(Unit.getOffset(),
                                           std::move(OutputRanges));
-      updateDWARFObjectAddressRanges(DIE, RangesSectionOffset, DebugInfoPatcher,
-                                     AbbrevWriter, RangesBase);
+      updateDWARFObjectAddressRanges(Unit, DIEBldr, Die, RangesSectionOffset,
+                                     RangesBase);
+      DIEValue StmtListAttrVal = Die->findAttribute(dwarf::DW_AT_stmt_list);
+      if (StmtListAttrVal) {
+        if (LineTablePatchMap.count(&Unit)) {
+          DIEBldr.replaceValue(Die, dwarf::DW_AT_stmt_list,
+                               StmtListAttrVal.getForm(),
+                               DIEInteger(LineTablePatchMap[&Unit]));
+        }
+      }
+
       break;
     }
+
     case dwarf::DW_TAG_subprogram: {
       // Get function address either from ranges or [LowPC, HighPC) pair.
       uint64_t Address;
       uint64_t SectionIndex, HighPC;
-      if (!DIE.getLowAndHighPC(Address, HighPC, SectionIndex)) {
+      if (!getLowAndHighPC(Die, &Unit, Address, HighPC, SectionIndex)) {
         Expected<DWARFAddressRangesVector> RangesOrError =
-            DIE.getAddressRanges();
+            getDIEAddressRanges(Die, &Unit);
         if (!RangesOrError) {
           consumeError(RangesOrError.takeError());
           break;
         }
         DWARFAddressRangesVector Ranges = *RangesOrError;
         // Not a function definition.
         if (Ranges.empty())
           break;
 
         Address = Ranges.front().LowPC;
       }
 
       // Clear cached ranges as the new function will have its own set.
       CachedRanges.clear();
 
       DebugAddressRangesVector FunctionRanges;
       if (const BinaryFunction *Function =
               BC.getBinaryFunctionAtAddress(Address))
         FunctionRanges = Function->getOutputAddressRanges();
 
       if (FunctionRanges.empty())
         FunctionRanges.push_back({0, 0});
 
       updateDWARFObjectAddressRanges(
-          DIE, RangesSectionWriter.addRanges(FunctionRanges), DebugInfoPatcher,
-          AbbrevWriter);
+          Unit, DIEBldr, Die, RangesSectionWriter.addRanges(FunctionRanges));
 
       break;
     }
     case dwarf::DW_TAG_lexical_block:
     case dwarf::DW_TAG_inlined_subroutine:
     case dwarf::DW_TAG_try_block:
     case dwarf::DW_TAG_catch_block: {
       uint64_t RangesSectionOffset = RangesSectionWriter.getEmptyRangesOffset();
-      Expected<DWARFAddressRangesVector> RangesOrError = DIE.getAddressRanges();
+      Expected<DWARFAddressRangesVector> RangesOrError =
+          getDIEAddressRanges(Die, &Unit);
       const BinaryFunction *Function =
           RangesOrError && !RangesOrError->empty()
               ? BC.getBinaryFunctionContainingAddress(
                     RangesOrError->front().LowPC)
               : nullptr;
       if (Function) {
         DebugAddressRangesVector OutputRanges =
             Function->translateInputToOutputRanges(*RangesOrError);
         LLVM_DEBUG(if (OutputRanges.empty() != RangesOrError->empty()) {
           dbgs() << "BOLT-DEBUG: problem with DIE at 0x"
-                 << Twine::utohexstr(DIE.getOffset()) << " in CU at 0x"
+                 << Twine::utohexstr(Die->getOffset()) << " in CU at 0x"
                  << Twine::utohexstr(Unit.getOffset()) << '\n';
         });
         RangesSectionOffset = RangesSectionWriter.addRanges(
             std::move(OutputRanges), CachedRanges);
       } else if (!RangesOrError) {
         consumeError(RangesOrError.takeError());
       }
-      updateDWARFObjectAddressRanges(DIE, RangesSectionOffset, DebugInfoPatcher,
-                                     AbbrevWriter);
+      updateDWARFObjectAddressRanges(Unit, DIEBldr, Die, RangesSectionOffset);
       break;
     }
     case dwarf::DW_TAG_call_site: {
-      auto patchPC = [&](AttrInfo &AttrVal, StringRef Entry) -> void {
-        Optional<uint64_t> Address = AttrVal.V.getAsAddress();
+      auto patchPC = [&](DIE *Die, DIEValue &AttrVal, StringRef Entry) -> void {
+        Optional<uint64_t> Address = getAsAddress(&Unit, AttrVal);
         const BinaryFunction *Function =
             BC.getBinaryFunctionContainingAddress(*Address);
+        // a nullptr check in case Function will be NULL for some reason we do
+        // not know.
+        if (!Function)
+          return;
+
         const uint64_t UpdatedAddress =
             Function->translateInputToOutputAddress(*Address);
         const uint32_t Index =
             AddrWriter->getIndexFromAddress(UpdatedAddress, Unit);
-        if (AttrVal.V.getForm() == dwarf::DW_FORM_addrx)
-          DebugInfoPatcher.addUDataPatch(AttrVal.Offset, Index, AttrVal.Size);
-        else
+        if (AttrVal.getForm() == dwarf::DW_FORM_addrx) {
+          DIEBldr.replaceValue(Die, AttrVal.getAttribute(), AttrVal.getForm(),
+                               DIEInteger(Index));
+        } else
           errs() << "BOLT-ERROR: unsupported form for " << Entry << "\n";
       };
+      DIEValue CallPcAttrVal = Die->findAttribute(dwarf::DW_AT_call_pc);
+      if (CallPcAttrVal) {
+        patchPC(Die, CallPcAttrVal, "DW_AT_call_pc");
+      }
 
-      if (Optional<AttrInfo> AttrVal =
-              findAttributeInfo(DIE, dwarf::DW_AT_call_pc))
-        patchPC(*AttrVal, "DW_AT_call_pc");
-
-      if (Optional<AttrInfo> AttrVal =
-              findAttributeInfo(DIE, dwarf::DW_AT_call_return_pc))
-        patchPC(*AttrVal, "DW_AT_call_return_pc");
+      DIEValue CallRetPcAttrVal =
+          Die->findAttribute(dwarf::DW_AT_call_return_pc);
+      if (CallRetPcAttrVal) {
+        patchPC(Die, CallRetPcAttrVal, "DW_AT_call_return_pc");
+      }
 
       break;
     }
     default: {
       // Handle any tag that can have DW_AT_location attribute.
-      DWARFFormValue Value;
-      uint64_t AttrOffset;
-      if (Optional<AttrInfo> AttrVal =
-              findAttributeInfo(DIE, dwarf::DW_AT_location)) {
-        AttrOffset = AttrVal->Offset;
-        Value = AttrVal->V;
-        if (Value.isFormClass(DWARFFormValue::FC_Constant) ||
-            Value.isFormClass(DWARFFormValue::FC_SectionOffset)) {
-          uint64_t Offset = Value.isFormClass(DWARFFormValue::FC_Constant)
-                                ? Value.getAsUnsignedConstant().getValue()
-                                : Value.getAsSectionOffset().getValue();
+      DIEValue LocAttrInfo = Die->findAttribute(dwarf::DW_AT_location);
+      DIEValue LowPCAttrInfo = Die->findAttribute(dwarf::DW_AT_low_pc);
+      if (LocAttrInfo) {
+        if (DWARFFormValue::isFormClass(LocAttrInfo.getForm(),
+                                        DWARFFormValue::FC_Constant, &Unit) ||
+            DWARFFormValue::isFormClass(LocAttrInfo.getForm(),
+                                        DWARFFormValue::FC_SectionOffset,
+                                        &Unit)) {
+          uint64_t Offset = LocAttrInfo.getForm() == dwarf::DW_FORM_loclistx
+                                ? LocAttrInfo.getDIELocList().getValue()
+                                : LocAttrInfo.getDIEInteger().getValue();
           DebugLocationsVector InputLL;
 
           Optional<object::SectionedAddress> SectionAddress =
               Unit.getBaseAddress();
           uint64_t BaseAddress = 0;
           if (SectionAddress)
             BaseAddress = SectionAddress->Address;
 
           if (Unit.getVersion() >= 5 &&
-              AttrVal->V.getForm() == dwarf::DW_FORM_loclistx) {
+              LocAttrInfo.getForm() == dwarf::DW_FORM_loclistx) {
             Optional<uint64_t> LocOffset = Unit.getLoclistOffset(Offset);
             assert(LocOffset && "Location Offset is invalid.");
             Offset = *LocOffset;
           }
 
           Error E = Unit.getLocationTable().visitLocationList(
               &Offset, [&](const DWARFLocationEntry &Entry) {
                 switch (Entry.Kind) {
default: {
                 }
                 }
                 return true;
               });
 
           if (E || InputLL.empty()) {
             consumeError(std::move(E));
             errs() << "BOLT-WARNING: empty location list detected at 0x"
-                   << Twine::utohexstr(Offset) << " for DIE at 0x"
-                   << Twine::utohexstr(DIE.getOffset()) << " in CU at 0x"
-                   << Twine::utohexstr(Unit.getOffset()) << '\n';
+                   << Twine::utohexstr(Offset) << " for DIE at 0x" << Die
+                   << " in CU at 0x" << Twine::utohexstr(Unit.getOffset())
+                   << '\n';
           } else {
             const uint64_t Address = InputLL.front().LowPC;
             DebugLocationsVector OutputLL;
             if (const BinaryFunction *Function =
                     BC.getBinaryFunctionContainingAddress(Address)) {
               OutputLL = Function->translateInputToOutputLocationList(InputLL);
               LLVM_DEBUG(if (OutputLL.empty()) {
                 dbgs() << "BOLT-DEBUG: location list translated to an empty "
                           "one at 0x"
-                       << Twine::utohexstr(DIE.getOffset()) << " in CU at 0x"
+                       << Die << " in CU at 0x"
                        << Twine::utohexstr(Unit.getOffset()) << '\n';
               });
             } else {
               // It's possible for a subprogram to be removed and to have
               // address of 0. Adding this entry to output to preserve debug
               // information.
               OutputLL = InputLL;
             }
-            DebugLocWriter.addList(*AttrVal, OutputLL, DebugInfoPatcher,
-                                   AbbrevWriter);
+            DebugLocWriter.addList(DIEBldr, Die, LocAttrInfo, OutputLL);
           }
         } else {
-          assert((Value.isFormClass(DWARFFormValue::FC_Exprloc) ||
-                  Value.isFormClass(DWARFFormValue::FC_Block)) &&
-                 "unexpected DW_AT_location form");
+          assert(
+              (DWARFFormValue::isFormClass(LocAttrInfo.getForm(),
+                                           DWARFFormValue::FC_Exprloc, &Unit) ||
+               DWARFFormValue::isFormClass(LocAttrInfo.getForm(),
+                                           DWARFFormValue::FC_Block, &Unit)) &&
           if (Unit.isDWOUnit() || Unit.getVersion() >= 5) {
-            ArrayRef<uint8_t> Expr = *Value.getAsBlock();
+            std::vector<uint8_t> sblock;
+            DIEValueList *AttrLocValList;
+            if (DWARFFormValue::isFormClass(
+                    LocAttrInfo.getForm(), DWARFFormValue::FC_Exprloc, &Unit)) {
+              for (const DIEValue &Val : LocAttrInfo.getDIELoc().values()) {
+                sblock.push_back(Val.getDIEInteger().getValue());
+              }
+              DIELoc *LocAttr = const_cast<DIELoc *>(&LocAttrInfo.getDIELoc());
+              AttrLocValList = static_cast<DIEValueList *>(LocAttr);
+            } else {
+              for (const DIEValue &Val : LocAttrInfo.getDIEBlock().values()) {
+                sblock.push_back(Val.getDIEInteger().getValue());
+              }
+              DIEBlock *BlockAttr =
+                  const_cast<DIEBlock *>(&LocAttrInfo.getDIEBlock());
+              AttrLocValList = static_cast<DIEValueList *>(BlockAttr);
+            }
+            ArrayRef<uint8_t> Expr = makeArrayRef<uint8_t>(sblock);
             DataExtractor Data(
                 StringRef((const char *)Expr.data(), Expr.size()),
                 Unit.getContext().isLittleEndian(), 0);
             DWARFExpression LocExpr(Data, Unit.getAddressByteSize(),
                                     Unit.getFormParams().Format);
             uint32_t PrevOffset = 0;
-            constexpr uint32_t SizeOfOpcode = 1;
-            constexpr uint32_t SizeOfForm = 1;
-            for (auto &Expr : LocExpr) {
+            DIEValueList *NewAttr;
+            DIEValue Value;
+            uint32_t NewExprSize = 0;
+            DIELoc *Loc = nullptr;
+            DIEBlock *Block = nullptr;
+            if (LocAttrInfo.getForm() == dwarf::DW_FORM_exprloc) {
+              Loc = DIEBldr.allocateDIEValue<DIELoc>();
+              NewAttr = Loc;
+              Value = DIEValue(LocAttrInfo.getAttribute(),
+                               LocAttrInfo.getForm(), Loc);
+            } else {
+              Block = DIEBldr.allocateDIEValue<DIEBlock>();
+              NewAttr = Block;
+              Value = DIEValue(LocAttrInfo.getAttribute(),
+                               LocAttrInfo.getForm(), Block);
+            }
+
+            for (const DWARFExpression::Operation &Expr : LocExpr) {
+              uint32_t CurEndOffset = PrevOffset + 1;
+              if (Expr.getDescription().Op[0] !=
+                  DWARFExpression::Operation::SizeNA)
+                CurEndOffset = Expr.getOperandEndOffset(0);
+              if (Expr.getDescription().Op[1] !=
+                  DWARFExpression::Operation::SizeNA)
+                CurEndOffset = Expr.getOperandEndOffset(1);
+              // not addr index, just copy.
               if (!(Expr.getCode() == dwarf::DW_OP_GNU_addr_index ||
-                    Expr.getCode() == dwarf::DW_OP_addrx))
+                    Expr.getCode() == dwarf::DW_OP_addrx)) {
+                auto itr = AttrLocValList->values().begin();
+                std::advance(itr, PrevOffset);
+                uint32_t CopyNum = CurEndOffset - PrevOffset;
+                NewExprSize += CopyNum;
+                while (CopyNum--) {
+                  DIEBldr.addValue(NewAttr, *itr);
+                  std::advance(itr, 1);
+                }
+                PrevOffset = CurEndOffset;
                 continue;
+              }
 
               const uint64_t Index = Expr.getRawOperand(0);
               Optional<object::SectionedAddress> EntryAddress =
                   Unit.getAddrOffsetSectionItem(Index);
               assert(EntryAddress && "Address is not found.");
               assert(Index <= std::numeric_limits<uint32_t>::max() &&
                      "Invalid Operand Index.");
               if (Expr.getCode() == dwarf::DW_OP_addrx) {
-                const uint32_t EncodingSize =
-                    Expr.getOperandEndOffset(0) - PrevOffset - SizeOfOpcode;
                 const uint32_t Index = AddrWriter->getIndexFromAddress(
                     EntryAddress->Address, Unit);
-                // Encoding new size.
+                // update Index for DW_AT_location. The Size field is not stored
+                // in IR, we need to minus 1 in offset for each expr.
                 SmallString<8> Tmp;
                 raw_svector_ostream OSE(Tmp);
                 encodeULEB128(Index, OSE);
-                DebugInfoPatcher.addUDataPatch(AttrOffset, Tmp.size() + 1, 1);
-                DebugInfoPatcher.addUDataPatch(AttrOffset + PrevOffset +
-                                                   SizeOfOpcode + SizeOfForm,
-                                               Index, EncodingSize);
+
+                DIEBldr.addValue(NewAttr, static_cast<dwarf::Attribute>(0),
+                                 dwarf::DW_FORM_data1,
+                                 DIEInteger(dwarf::DW_OP_addrx));
+                NewExprSize += 1;
+                for (uint8_t byte : Tmp) {
+                  DIEBldr.addValue(NewAttr, static_cast<dwarf::Attribute>(0),
+                                   dwarf::DW_FORM_data1, DIEInteger(byte));
+                  NewExprSize += 1;
+                }
               } else {
                 // TODO: Re-do this as DWARF5.
+                auto Itr = AttrLocValList->values().begin();
+                std::advance(Itr, PrevOffset);
+                uint32_t CopyNum = CurEndOffset - PrevOffset;
+                NewExprSize += CopyNum;
+                while (CopyNum--) {
+                  DIEBldr.addValue(NewAttr, *Itr);
+                  std::advance(Itr, 1);
+                }
                 AddrWriter->addIndexAddress(EntryAddress->Address,
                                             static_cast<uint32_t>(Index), Unit);
               }
-              if (Expr.getDescription().Op[1] ==
-                  DWARFExpression::Operation::SizeNA)
-                PrevOffset = Expr.getOperandEndOffset(0);
-              else
-                PrevOffset = Expr.getOperandEndOffset(1);
+              PrevOffset = CurEndOffset;
             }
+
+            // update the size since the index might be changed
+            if (Loc)
+              Loc->setSize(NewExprSize);
+            else
+              Block->setSize(NewExprSize);
+            DIEBldr.replaceValue(Die, LocAttrInfo.getAttribute(),
+                                 LocAttrInfo.getForm(), Value);
           }
         }
-      } else if (Optional<AttrInfo> AttrVal =
-                     findAttributeInfo(DIE, dwarf::DW_AT_low_pc)) {
-        AttrOffset = AttrVal->Offset;
-        Value = AttrVal->V;
-        const Optional<uint64_t> Result = Value.getAsAddress();
+      } else if (LowPCAttrInfo) {
+
+        const Optional<uint64_t> Result =
+            LowPCAttrInfo.getDIEInteger().getValue();
         if (Result.hasValue()) {
           const uint64_t Address = Result.getValue();
           uint64_t NewAddress = 0;
           if (const BinaryFunction *Function =
                   BC.getBinaryFunctionContainingAddress(Address)) {
             NewAddress = Function->translateInputToOutputAddress(Address);
             LLVM_DEBUG(dbgs()
                        << "BOLT-DEBUG: Fixing low_pc 0x"
                        << Twine::utohexstr(Address) << " for DIE with tag "
-                       << DIE.getTag() << " to 0x"
+                       << Die->getTag() << " to 0x"
                        << Twine::utohexstr(NewAddress) << '\n');
           }
 
-          dwarf::Form Form = Value.getForm();
+          dwarf::Form Form = LowPCAttrInfo.getForm();
           assert(Form != dwarf::DW_FORM_LLVM_addrx_offset &&
                  "DW_FORM_LLVM_addrx_offset is not supported");
           std::lock_guard<std::mutex> Lock(DebugInfoPatcherMutex);
           if (Form == dwarf::DW_FORM_GNU_addr_index) {
-            const uint64_t Index = Value.getRawUValue();
             // If there is no new address, storing old address.
             // Re-using Index to make implementation easier.
             // DW_FORM_GNU_addr_index is variable lenght encoding
             // so we either have to create indices of same sizes, or use same
             // index.
             // TODO: We can now re-write .debug_info. This can be simplified to
             // just getting a new index and creating a patch.
+            const uint64_t Index = *Result;
             AddrWriter->addIndexAddress(NewAddress ? NewAddress : Address,
                                         Index, Unit);
           } else if (Form == dwarf::DW_FORM_addrx) {
             const uint32_t Index = AddrWriter->getIndexFromAddress(
                 NewAddress ? NewAddress : Address, Unit);
-            DebugInfoPatcher.addUDataPatch(AttrOffset, Index, AttrVal->Size);
+            DIEBldr.replaceValue(Die, LowPCAttrInfo.getAttribute(),
+                                 LowPCAttrInfo.getForm(), DIEInteger(Index));
           } else {
-            DebugInfoPatcher.addLE64Patch(AttrOffset, NewAddress);
+            DIEBldr.replaceValue(Die, LowPCAttrInfo.getAttribute(),
+                                 LowPCAttrInfo.getForm(),
+                                 DIEInteger(NewAddress));
           }
         } else if (opts::Verbosity >= 1) {
-          errs() << "BOLT-WARNING: unexpected form value for attribute at 0x"
-                 << Twine::utohexstr(AttrOffset);
+          errs() << "BOLT-WARNING: unexpected form value for attribute "
+                    "LowPCAttrInfo\n";
         }
       } else if (IsDWP && Unit.isDWOUnit()) {
         // Not a common path so don't want to search all DIEs all the time.
-        Optional<AttrInfo> SignatureAttrVal =
-            findAttributeInfo(DIE, dwarf::DW_AT_signature);
-        if (!SignatureAttrVal)
+        DIEValue SignatureAttrInfo = Die->findAttribute(dwarf::DW_AT_signature);
+        if (!SignatureAttrInfo)
           continue;
         // If input is DWP file we need to keep track of which TU came from each
         // CU, so we can write it out correctly.
-        if (Optional<uint64_t> Val = SignatureAttrVal->V.getAsReferenceUVal())
-          TypeSignaturesPerCU[*DIE.getDwarfUnit()->getDWOId()].insert(*Val);
+        if (uint64_t Val = SignatureAttrInfo.getDIEInteger().getValue())
+          TypeSignaturesPerCU[*Unit.getDWOId()].insert(Val);
         else {
           errs() << "BOT-ERROR: DW_AT_signature form is not supported.\n";
           exit(1);
         }
       }
     }
     }
-
-    // Handling references.
-    assert(DIE.isValid() && "Invalid DIE.");
-    const DWARFAbbreviationDeclaration *AbbrevDecl =
-        DIE.getAbbreviationDeclarationPtr();
-    if (!AbbrevDecl)
-      continue;
-    uint32_t Index = 0;
-    for (const DWARFAbbreviationDeclaration::AttributeSpec &Decl :
-         AbbrevDecl->attributes()) {
-      switch (Decl.Form) {
-      default:
-        break;
-      case dwarf::DW_FORM_ref1:
-      case dwarf::DW_FORM_ref2:
-      case dwarf::DW_FORM_ref4:
-      case dwarf::DW_FORM_ref8:
-      case dwarf::DW_FORM_ref_udata:
-      case dwarf::DW_FORM_ref_addr: {
-        Optional<AttrInfo> AttrVal = findAttributeInfo(DIE, AbbrevDecl, Index);
-        uint32_t DestinationAddress =
-            AttrVal->V.getRawUValue() +
-            (Decl.Form == dwarf::DW_FORM_ref_addr ? 0 : Unit.getOffset());
-        DebugInfoPatcher.addReferenceToPatch(
-            AttrVal->Offset, DestinationAddress, AttrVal->Size, Decl.Form);
-        // We can have only one reference, and it can be backward one.
-        DebugInfoPatcher.addDestinationReferenceLabel(DestinationAddress);
-        break;
-      }
-      }
-      ++Index;
-    }
   }
   if (DIEOffset > NextCUOffset)
     errs() << "BOLT-WARNING: corrupt DWARF detected at 0x"
            << Twine::utohexstr(Unit.getOffset()) << '\n';
 }
 
 void DWARFRewriter::updateDWARFObjectAddressRanges(
-    const DWARFDie DIE, uint64_t DebugRangesOffset,
-    SimpleBinaryPatcher &DebugInfoPatcher, DebugAbbrevWriter &AbbrevWriter,
+    DWARFUnit &Unit, DIEBuilder &DIEBldr, DIE *Die, uint64_t DebugRangesOffset,
     Optional<uint64_t> RangesBase) {
 
   // Some objects don't have an associated DIE and cannot be updated (such as
   // compiler-generated functions).
-  if (!DIE)
-    return;
-
-  const DWARFAbbreviationDeclaration *AbbreviationDecl =
-      DIE.getAbbreviationDeclarationPtr();
-  if (!AbbreviationDecl) {
-    if (opts::Verbosity >= 1)
-      errs() << "BOLT-WARNING: object's DIE doesn't have an abbreviation: "
-             << "skipping update. DIE at offset 0x"
-             << Twine::utohexstr(DIE.getOffset()) << '\n';
+  if (!Die)
     return;
-  }
 
   if (RangesBase) {
     // If DW_AT_GNU_ranges_base is present, update it. No further modifications
     // are needed for ranges base.
-    Optional<AttrInfo> RangesBaseAttrInfo =
-        findAttributeInfo(DIE, dwarf::DW_AT_GNU_ranges_base);
-    if (!RangesBaseAttrInfo)
-      RangesBaseAttrInfo = findAttributeInfo(DIE, dwarf::DW_AT_rnglists_base);
-
-    if (RangesBaseAttrInfo) {
-      DebugInfoPatcher.addLE32Patch(RangesBaseAttrInfo->Offset,
-                                    static_cast<uint32_t>(*RangesBase),
-                                    RangesBaseAttrInfo->Size);
+
+    DIEValue RangesBaseInfo = Die->findAttribute(dwarf::DW_AT_GNU_ranges_base);
+    if (!RangesBaseInfo) {
+      RangesBaseInfo = Die->findAttribute(dwarf::DW_AT_rnglists_base);
+    }
+
+    if (RangesBaseInfo) {
+      DIEBldr.replaceValue(Die, RangesBaseInfo.getAttribute(),
+                           RangesBaseInfo.getForm(),
+                           DIEInteger(static_cast<uint32_t>(*RangesBase)));
       RangesBase = None;
     }
   }
 
-  Optional<AttrInfo> LowPCAttrInfo =
-      findAttributeInfo(DIE, dwarf::DW_AT_low_pc);
-  if (Optional<AttrInfo> AttrVal =
-          findAttributeInfo(DIE, dwarf::DW_AT_ranges)) {
+  DIEValue LowPCAttrInfo = Die->findAttribute(dwarf::DW_AT_low_pc);
+  DIEValue RangesAttrInfo = Die->findAttribute(dwarf::DW_AT_ranges);
+  if (RangesAttrInfo) {
     // Case 1: The object was already non-contiguous and had DW_AT_ranges.
     // In this case we simply need to update the value of DW_AT_ranges
     // and introduce DW_AT_GNU_ranges_base if required.
-    std::lock_guard<std::mutex> Lock(DebugInfoPatcherMutex);
     // For DWARF5 converting all of DW_AT_ranges into DW_FORM_rnglistx
-    bool Converted = false;
-    if (DIE.getDwarfUnit()->getVersion() >= 5 &&
-        AttrVal->V.getForm() == dwarf::DW_FORM_sec_offset) {
-      AbbrevWriter.addAttributePatch(*DIE.getDwarfUnit(), AbbreviationDecl,
-                                     dwarf::DW_AT_ranges, dwarf::DW_AT_ranges,
-                                     dwarf::DW_FORM_rnglistx);
-      Converted = true;
-    }
-    if (Converted || AttrVal->V.getForm() == dwarf::DW_FORM_rnglistx)
-      DebugInfoPatcher.addUDataPatch(AttrVal->Offset, DebugRangesOffset,
-                                     AttrVal->Size);
+    bool need_Converted = false;
+
+    if (Unit.getVersion() >= 5 &&
+        RangesAttrInfo.getForm() == dwarf::DW_FORM_sec_offset)
+      need_Converted = true;
+
+    uint64_t curRangeBase = 0;
+    if (Optional<uint64_t> DWOId = Unit.getDWOId()) {
+      curRangeBase = getDwoRangesBase(*DWOId);
+    }
+    if (need_Converted || RangesAttrInfo.getForm() == dwarf::DW_FORM_rnglistx)
+      DIEBldr.replaceValue(Die, dwarf::DW_AT_ranges, dwarf::DW_FORM_rnglistx,
+                           DIEInteger(DebugRangesOffset));
     else
-      DebugInfoPatcher.addLE32Patch(
-          AttrVal->Offset, DebugRangesOffset - DebugInfoPatcher.getRangeBase(),
-          AttrVal->Size);
+      DIEBldr.replaceValue(Die, dwarf::DW_AT_ranges, RangesAttrInfo.getForm(),
+                           DIEInteger(DebugRangesOffset - curRangeBase));
 
     if (!RangesBase) {
       if (LowPCAttrInfo &&
-          LowPCAttrInfo->V.getForm() != dwarf::DW_FORM_GNU_addr_index &&
-          LowPCAttrInfo->V.getForm() != dwarf::DW_FORM_addrx)
-        DebugInfoPatcher.addLE64Patch(LowPCAttrInfo->Offset, 0);
+          LowPCAttrInfo.getForm() != dwarf::DW_FORM_GNU_addr_index &&
+          LowPCAttrInfo.getForm() != dwarf::DW_FORM_addrx)
+        DIEBldr.replaceValue(Die, dwarf::DW_AT_low_pc, LowPCAttrInfo.getForm(),
+                             DIEInteger(0));
       return;
     }
 
     // Convert DW_AT_low_pc into DW_AT_GNU_ranges_base.
     if (!LowPCAttrInfo) {
       errs() << "BOLT-ERROR: skeleton CU at 0x"
-             << Twine::utohexstr(DIE.getOffset())
+             << Twine::utohexstr(Die->getOffset())
              << " does not have DW_AT_GNU_ranges_base or DW_AT_low_pc to"
                 " convert to update ranges base\n";
       return;
     }
-
-    AbbrevWriter.addAttribute(*DIE.getDwarfUnit(), AbbreviationDecl,
-                              dwarf::DW_AT_GNU_ranges_base,
-                              dwarf::DW_FORM_sec_offset);
-    reinterpret_cast<DebugInfoBinaryPatcher &>(DebugInfoPatcher)
-        .insertNewEntry(DIE, *RangesBase);
-
+    if (Unit.getVersion() < 4)
+      DIEBldr.addValue(Die, dwarf::DW_AT_GNU_ranges_base, dwarf::DW_FORM_data4,
+                       DIEInteger(*RangesBase));
+    else
+      DIEBldr.addValue(Die, dwarf::DW_AT_GNU_ranges_base,
+                       dwarf::DW_FORM_sec_offset, DIEInteger(*RangesBase));
     return;
   }
 
   // Case 2: The object has both DW_AT_low_pc and DW_AT_high_pc emitted back
   // to back. Replace with new attributes and patch the DIE.
-  Optional<AttrInfo> HighPCAttrInfo =
-      findAttributeInfo(DIE, dwarf::DW_AT_high_pc);
-  if (LowPCAttrInfo && HighPCAttrInfo) {
-    convertToRangesPatchAbbrev(*DIE.getDwarfUnit(), AbbreviationDecl,
-                               AbbrevWriter, RangesBase);
-    convertToRangesPatchDebugInfo(DIE, DebugRangesOffset, DebugInfoPatcher,
-                                  RangesBase);
+  DIEValue HighPCAttrInfo = Die->findAttribute(dwarf::DW_AT_high_pc);
+  if (LowPCAttrInfo &&
+      HighPCAttrInfo) {
+
+    convertToRangesPatchDebugInfo(Unit, DIEBldr, Die, DebugRangesOffset,
+                                  LowPCAttrInfo, HighPCAttrInfo, RangesBase);
   } else {
     if (opts::Verbosity >= 1)
-      errs() << "BOLT-ERROR: cannot update ranges for DIE at offset 0x"
-             << Twine::utohexstr(DIE.getOffset()) << '\n';
+      errs() << "BOLT-ERROR: cannot update ranges for DIE at offset 0x" << Die
+             << '\n';
   }
 }
 
 void DWARFRewriter::updateLineTableOffsets(const MCAsmLayout &Layout) {
   ErrorOr<BinarySection &> DbgInfoSection =
       BC.getUniqueSectionByName(".debug_info");
   ErrorOr<BinarySection &> TypeInfoSection =
       BC.getUniqueSectionByName(".debug_types");
   assert(((BC.DwCtx->getNumTypeUnits() > 0 && TypeInfoSection) ||
           BC.DwCtx->getNumTypeUnits() == 0) &&
          "Was not able to retrieve Debug Types section.");
 
-  // We will be re-writing .debug_info so relocation mechanism doesn't work for
-  // Debug Info Patcher.
-  DebugInfoBinaryPatcher *DebugInfoPatcher = nullptr;
-  if (BC.DwCtx->getNumCompileUnits()) {
-    DbgInfoSection->registerPatcher(std::make_unique<DebugInfoBinaryPatcher>());
-    DebugInfoPatcher =
-        static_cast<DebugInfoBinaryPatcher *>(DbgInfoSection->getPatcher());
-  }
-
   // There is no direct connection between CU and TU, but same offsets,
   // encoded in DW_AT_stmt_list, into .debug_line get modified.
   // We take advantage of that to map original CU line table offsets to new
   // ones.
   std::unordered_map<uint64_t, uint64_t> DebugLineOffsetMap;
 
   auto GetStatementListValue = [](DWARFUnit *Unit) {
     Optional<DWARFFormValue> StmtList =
         Unit->getUnitDIE().find(dwarf::DW_AT_stmt_list);
     Optional<uint64_t> Offset = dwarf::toSectionOffset(StmtList);
     assert(Offset && "Was not able to retreive value of DW_AT_stmt_list.");
     return *Offset;
   };
 
   const uint64_t Reloc32Type = BC.isAArch64()
                                    ? static_cast<uint64_t>(ELF::R_AARCH64_ABS32)
                                    : static_cast<uint64_t>(ELF::R_X86_64_32);
 
   for (const std::unique_ptr<DWARFUnit> &CU : BC.DwCtx->compile_units()) {
     const unsigned CUID = CU->getOffset();
     MCSymbol *Label = BC.getDwarfLineTable(CUID).getLabel();
     if (!Label)
       continue;
 
-    Optional<AttrInfo> AttrVal =
-        findAttributeInfo(CU.get()->getUnitDIE(), dwarf::DW_AT_stmt_list);
-    if (!AttrVal)
-      continue;
-
-    const uint64_t AttributeOffset = AttrVal->Offset;
     const uint64_t LineTableOffset = Layout.getSymbolOffset(*Label);
     DebugLineOffsetMap[GetStatementListValue(CU.get())] = LineTableOffset;
     assert(DbgInfoSection && ".debug_info section must exist");
-    DebugInfoPatcher->addLE32Patch(AttributeOffset, LineTableOffset);
+    LineTablePatchMap[CU.get()] = LineTableOffset;
   }
 
   for (const std::unique_ptr<DWARFUnit> &TU : BC.DwCtx->types_section_units()) {
     DWARFUnit *Unit = TU.get();
     Optional<AttrInfo> AttrVal =
         findAttributeInfo(TU.get()->getUnitDIE(), dwarf::DW_AT_stmt_list);
     if (!AttrVal)
       continue;
void DWARFRewriter::updateLineTableOffsets(const MCAsmLayout &Layout) {
   // that the pending relocations will be processed and not ignored.
   if (DbgInfoSection)
     DbgInfoSection->setIsFinalized();
 
   if (TypeInfoSection)
     TypeInfoSection->setIsFinalized();
 }
 
-CUOffsetMap
-DWARFRewriter::finalizeDebugSections(DebugInfoBinaryPatcher &DebugInfoPatcher) {
+CUOffsetMap DWARFRewriter::finalizeDebugSections(DIEBuilder &DIEBlder) {
   if (StrWriter->isInitialized()) {
     RewriteInstance::addToDebugSectionsToOverwrite(".debug_str");
     std::unique_ptr<DebugStrBufferVector> DebugStrSectionContents =
         StrWriter->releaseBuffer();
     BC.registerOrUpdateNoteSection(".debug_str",
                                    copyByteArray(*DebugStrSectionContents),
                                    DebugStrSectionContents->size());
   }
std::unique_ptr<DebugBufferVector> RangesSectionContents =
         RangeListsSectionWriter->releaseBuffer();
     BC.registerOrUpdateNoteSection(".debug_rnglists",
                                    copyByteArray(*RangesSectionContents),
                                    RangesSectionContents->size());
   }
 
   if (BC.isDWARF5Used()) {
     std::unique_ptr<DebugBufferVector> LocationListSectionContents =
-        makeFinalLocListsSection(DebugInfoPatcher, DWARFVersion::DWARF5);
+        makeFinalLocListsSection(DWARFVersion::DWARF5);
     if (!LocationListSectionContents->empty())
       BC.registerOrUpdateNoteSection(
           ".debug_loclists", copyByteArray(*LocationListSectionContents),
           LocationListSectionContents->size());
   }
 
   if (BC.isDWARFLegacyUsed()) {
     std::unique_ptr<DebugBufferVector> LocationListSectionContents =
-        makeFinalLocListsSection(DebugInfoPatcher, DWARFVersion::DWARFLegacy);
+        makeFinalLocListsSection(DWARFVersion::DWARFLegacy);
     if (!LocationListSectionContents->empty())
       BC.registerOrUpdateNoteSection(
           ".debug_loc", copyByteArray(*LocationListSectionContents),
           LocationListSectionContents->size());
   }
 
   // AddrWriter should be finalized after debug_loc since more addresses can be
   // added there.
   if (AddrWriter->isInitialized()) {
     AddressSectionBuffer AddressSectionContents = AddrWriter->finalize();
     BC.registerOrUpdateNoteSection(".debug_addr",
                                    copyByteArray(AddressSectionContents),
                                    AddressSectionContents.size());
-    for (auto &CU : BC.DwCtx->compile_units()) {
-      DWARFDie DIE = CU->getUnitDIE();
+    for (std::unique_ptr<llvm::DWARFUnit> &CU : BC.DwCtx->compile_units()) {
+      DIE *Die = DIEBlder.getUnitDIEbyUnit(*CU.get());
       uint64_t Offset = 0;
-      uint64_t AttrOffset = 0;
-      uint32_t Size = 0;
-      Optional<AttrInfo> AttrValGnu =
-          findAttributeInfo(DIE, dwarf::DW_AT_GNU_addr_base);
-      Optional<AttrInfo> AttrVal =
-          findAttributeInfo(DIE, dwarf::DW_AT_addr_base);
-
+      DIEValue GnuAddrBaseAttrInfo =
+          Die->findAttribute(dwarf::DW_AT_GNU_addr_base);
+      DIEValue AddrBaseAttrInfo = Die->findAttribute(dwarf::DW_AT_addr_base);
+      dwarf::Form BaseAttrForm;
+      dwarf::Attribute BaseAttr;
       // For cases where Skeleton CU does not have DW_AT_GNU_addr_base
-      if (!AttrValGnu && CU->getVersion() < 5)
+      if (!GnuAddrBaseAttrInfo && CU->getVersion() < 5)
         continue;
 
       Offset = AddrWriter->getOffset(*CU);
 
-      if (AttrValGnu) {
-        AttrOffset = AttrValGnu->Offset;
-        Size = AttrValGnu->Size;
+      if (GnuAddrBaseAttrInfo) {
+        BaseAttrForm = GnuAddrBaseAttrInfo.getForm();
+        BaseAttr = GnuAddrBaseAttrInfo.getAttribute();
       }
 
-      if (AttrVal) {
-        AttrOffset = AttrVal->Offset;
-        Size = AttrVal->Size;
+      if (AddrBaseAttrInfo) {
+        BaseAttrForm = AddrBaseAttrInfo.getForm();
+        BaseAttr = AddrBaseAttrInfo.getAttribute();
       }
 
-      if (AttrValGnu || AttrVal) {
-        DebugInfoPatcher.addLE32Patch(AttrOffset, static_cast<int32_t>(Offset),
-                                      Size);
+      if (GnuAddrBaseAttrInfo ||
+          AddrBaseAttrInfo) {
+        DIEBlder.replaceValue(Die, BaseAttr, BaseAttrForm, DIEInteger(Offset));
       } else if (CU->getVersion() >= 5) {
         // A case where we were not using .debug_addr section, but after update
         // now using it.
-        const DWARFAbbreviationDeclaration *Abbrev =
-            DIE.getAbbreviationDeclarationPtr();
-        AbbrevWriter->addAttribute(*CU, Abbrev, dwarf::DW_AT_addr_base,
-                                   dwarf::DW_FORM_sec_offset);
-        DebugInfoPatcher.insertNewEntry(DIE, static_cast<int32_t>(Offset));
+        DIEBlder.addValue(Die, dwarf::DW_AT_addr_base,
+                          dwarf::DW_FORM_sec_offset, DIEInteger(Offset));
       }
     }
   }
 
-  std::unique_ptr<DebugBufferVector> AbbrevSectionContents =
-      AbbrevWriter->finalize();
-  BC.registerOrUpdateNoteSection(".debug_abbrev",
-                                 copyByteArray(*AbbrevSectionContents),
-                                 AbbrevSectionContents->size());
-
-  // Update abbreviation offsets for CUs/TUs if they were changed.
-  SimpleBinaryPatcher *DebugTypesPatcher = nullptr;
-  for (auto &Unit : BC.DwCtx->normal_units()) {
-    const uint64_t NewAbbrevOffset =
-        AbbrevWriter->getAbbreviationsOffsetForUnit(*Unit);
-    if (Unit->getAbbreviationsOffset() == NewAbbrevOffset)
-      continue;
-
-    // DWARFv4 or earlier
-    // unit_length - 4 bytes
-    // version - 2 bytes
-    // So + 6 to patch debug_abbrev_offset
-    constexpr uint64_t AbbrevFieldOffsetLegacy = 6;
-    // DWARFv5
-    // unit_length - 4 bytes
-    // version - 2 bytes
-    // unit_type - 1 byte
-    // address_size - 1 byte
-    // So + 8 to patch debug_abbrev_offset
-    constexpr uint64_t AbbrevFieldOffsetV5 = 8;
-    uint64_t AbbrevOffset =
-        Unit->getVersion() >= 5 ? AbbrevFieldOffsetV5 : AbbrevFieldOffsetLegacy;
-    if (!Unit->isTypeUnit() || Unit->getVersion() >= 5) {
-      DebugInfoPatcher.addLE32Patch(Unit->getOffset() + AbbrevOffset,
-                                    static_cast<uint32_t>(NewAbbrevOffset));
-      continue;
-    }
+  // generate and populate abbrevs here
+  DIEBlder.generateAbbrevs();
+  DIEBlder.finish();
+  SmallVector<char, 20> outBuffer;
+  std::shared_ptr<raw_svector_ostream> ObjOS =
+      std::make_shared<raw_svector_ostream>(outBuffer);
+  const object::ObjectFile *File = BC.DwCtx->getDWARFObj().getFile();
+  auto TheTriple = std::make_unique<Triple>(File->makeTriple());
+  std::unique_ptr<DIEStreamer> Streamer =
+      createDIEStreamer(*TheTriple, *ObjOS, "AbbrevStreamerInitAug2");
+
+  // generate debug_info and CUMap
+  CUOffsetMap CUMap;
+  uint32_t CUOffset = 0;
+  for (std::unique_ptr<llvm::DWARFUnit> &CU : BC.DwCtx->compile_units()) {
+    emitUnit(DIEBlder, Streamer, *CU.get());
+
+    uint32_t StartOffset = CUOffset;
+    DIE *UnitDIE = DIEBlder.getUnitDIEbyUnit(*CU.get());
+    CUOffset += CU.get()->getHeaderSize();
+    CUOffset += UnitDIE->getSize();
+    CUMap[CU.get()->getOffset()] = {StartOffset, CUOffset - StartOffset - 4};
+  }
+
+  if (BC.DwCtx->getMaxVersion() < 5) {
+    // Emit Type Unit of DWARF 4 to .debug_type section
+    for (DWARFUnit *TU : DIEBlder.getDWARF4TUList())
+      emitUnit(DIEBlder, Streamer, *TU);
 
-    if (!DebugTypesPatcher) {
-      ErrorOr<BinarySection &> DebugTypes =
-          BC.getUniqueSectionByName(".debug_types");
-      DebugTypes->registerPatcher(std::make_unique<SimpleBinaryPatcher>());
-      DebugTypesPatcher =
-          static_cast<SimpleBinaryPatcher *>(DebugTypes->getPatcher());
+  Streamer->emitAbbrevs(DIEBlder.getAbbrevs(), BC.DwCtx->getMaxVersion());
+  Streamer->finish();
+
+  std::unique_ptr<MemoryBuffer> ObjectMemBuffer =
+      MemoryBuffer::getMemBuffer(ObjOS->str(), "in-memory object file", false);
+  std::unique_ptr<object::ObjectFile> Obj = cantFail(
+      object::ObjectFile::createObjectFile(ObjectMemBuffer->getMemBufferRef()),
+      "error creating in-memory object");
+
+  for (const SectionRef &secs : Obj->sections()) {
+    StringRef contents = cantFail(secs.getContents());
+    StringRef name = cantFail(secs.getName());
+    if (name.equals(".debug_abbrev")) {
+      BC.registerOrUpdateNoteSection(".debug_abbrev", copyByteArray(contents),
+                                     contents.size());
+    } else if (name.equals(".debug_info")) {
+      BC.registerOrUpdateNoteSection(".debug_info", copyByteArray(contents),
+                                     contents.size());
+    } else if (name.equals(".debug_types")) {
+      BC.registerOrUpdateNoteSection(".debug_types", copyByteArray(contents),
+                                     contents.size());
     }
-    DebugTypesPatcher->addLE32Patch(Unit->getOffset() + AbbrevOffset,
-                                    static_cast<uint32_t>(NewAbbrevOffset));
   }
 
-  // No more creating new DebugInfoPatches.
-  CUOffsetMap CUMap =
-      DebugInfoPatcher.computeNewOffsets(*BC.DwCtx.get(), false);
-
   // Skip .debug_aranges if we are re-generating .gdb_index.
   if (opts::KeepARanges || !BC.getGdbIndexSection()) {
     SmallVector<char, 16> ARangesBuffer;
     raw_svector_ostream OS(ARangesBuffer);
 
     auto MAB = std::unique_ptr<MCAsmBackend>(
         BC.TheTarget->createMCAsmBackend(*BC.STI, *BC.MRI, MCTargetOptions()));
 

 Optional<StringRef>
 updateDebugData(DWARFContext &DWCtx, std::string &Storage,
                 StringRef SectionName, StringRef SectionContents,
                 const StringMap<KnownSectionsEntry> &KnownSections,
                 MCStreamer &Streamer, DWARFRewriter &Writer,
                 const DWARFUnitIndex::Entry *CUDWOEntry, uint64_t DWOId,
                 std::unique_ptr<DebugBufferVector> &OutputBuffer,
                 DebugRangeListsSectionWriter *RangeListsWriter) {
-  auto applyPatch = [&](DebugInfoBinaryPatcher *Patcher,
-                        StringRef Data) -> StringRef {
-    Patcher->computeNewOffsets(DWCtx, true);
-    Storage = Patcher->patchBinary(Data);
-    return StringRef(Storage.c_str(), Storage.size());
-  };
 
   using DWOSectionContribution =
       const DWARFUnitIndex::Entry::SectionContribution;
   auto getSliceData = [&](const DWARFUnitIndex::Entry *DWOEntry,
                           StringRef OutData, DWARFSectionKind Sec,
                           uint32_t &DWPOffset) -> StringRef {
     if (DWOEntry) {
       DWOSectionContribution *DWOContrubution = DWOEntry->getContribution(Sec);
updateDebugData(DWARFContext &DWCtx, std::string &Storage,
   switch (SectionIter->second.second) {
   default: {
     if (!SectionName.equals("debug_str.dwo"))
       errs() << "BOLT-WARNING: unsupported debug section: " << SectionName
              << "\n";
     return OutData;
   }
   case DWARFSectionKind::DW_SECT_INFO: {
-    OutData = getSliceData(CUDWOEntry, OutData, DWARFSectionKind::DW_SECT_INFO,
-                           DWPOffset);
-    DebugInfoBinaryPatcher *Patcher = llvm::cast<DebugInfoBinaryPatcher>(
-        Writer.getBinaryDWODebugInfoPatcher(DWOId));
-    return applyPatch(Patcher, OutData);
+    StringRef DebugInfoStr = Writer.getDwoDebugInfoStr(DWOId);
+    return getSliceData(CUDWOEntry, DebugInfoStr,
+                        DWARFSectionKind::DW_SECT_INFO, DWPOffset);
   }
   case DWARFSectionKind::DW_SECT_EXT_TYPES: {
-    return getSliceData(nullptr, OutData, DWARFSectionKind::DW_SECT_EXT_TYPES,
-                        DWPOffset);
+    errs() << Writer.getDwoDebugTypeStr(DWOId).size() << "\n";
+    return Writer.getDwoDebugTypeStr(DWOId);
+    // return getSliceData(nullptr, OutData,
+    // DWARFSectionKind::DW_SECT_EXT_TYPES,
+    //                    DWPOffset);
   }
   case DWARFSectionKind::DW_SECT_STR_OFFSETS: {
     return getSliceData(CUDWOEntry, OutData,
                         DWARFSectionKind::DW_SECT_STR_OFFSETS, DWPOffset);
   }
   case DWARFSectionKind::DW_SECT_ABBREV: {
-    DebugAbbrevWriter *AbbrevWriter = Writer.getBinaryDWOAbbrevWriter(DWOId);
-    OutputBuffer = AbbrevWriter->finalize();
-    // Creating explicit StringRef here, otherwise
-    // with impicit conversion it will take null byte as end of
-    // string.
-    return StringRef(reinterpret_cast<const char *>(OutputBuffer->data()),
-                     OutputBuffer->size());
+    return Writer.getDwoDebugAbbrevStr(DWOId);
   }
   case DWARFSectionKind::DW_SECT_EXT_LOC:
   case DWARFSectionKind::DW_SECT_LOCLISTS: {
     DebugLocWriter *LocWriter = Writer.getDebugLocWriter(DWOId);
     OutputBuffer = LocWriter->getBuffer();
     // Creating explicit StringRef here, otherwise
     // with impicit conversion it will take null byte as end of
     // string.
static std::string extractDWOTUFromDWP(
   return DWOTUSection;
 }
 
 static void extractDWOTUFromDWO(StringRef Contents,
                                 TUContributionVector &TUContributionsToCU) {
   uint64_t Offset = 0;
   DataExtractor Data(Contents, true, 0);
   while (Data.isValidOffset(Offset)) {
-    auto PrevOffset = Offset;
+    uint64_t PrevOffset = Offset;
     // Length of the unit, including the 4 byte length field.
     const uint32_t Length = Data.getU32(&Offset) + 4;
 
     Data.getU16(&Offset); // Version
     Data.getU32(&Offset); // Abbrev offset
     Data.getU8(&Offset);  // Address size
-    const auto TUSignature = Data.getU64(&Offset);
+    const uint64_t TUSignature = Data.getU64(&Offset);
     Offset = PrevOffset + Length;
     TUContributionsToCU.push_back({TUSignature, Length});
   }
 }
 
 static void extractTypesFromDWPDWARF5(
     const MCObjectFileInfo &MCOFI, const DWARFUnitIndex &TUIndex,
     const DWARFRewriter::DebugTypesSignaturesPerCUMap &TypeSignaturesPerCU,
for (const SectionRef &Section : DWOFile->sections()) {
       } else {
         // Since handleDebugDataPatching returned true, we already know this is
         // a known section.
         auto SectionIter = KnownSections.find(SectionName);
         if (SectionIter->second.second == DWARFSectionKind::DW_SECT_STR_OFFSETS)
           CurStrOffsetSection = OutData;
         else
           Streamer->emitBytes(OutData);
-        auto Index =
+        unsigned int Index =
             getContributionIndex(SectionIter->second.second, IndexVersion);
         CurEntry.Contributions[Index].Offset = ContributionOffsets[Index];
         CurEntry.Contributions[Index].Length = OutData.size();
         ContributionOffsets[Index] += CurEntry.Contributions[Index].Length;
       }
 
       // Strings are combined in to a new string section, and de-duplicated
       // based on hash.
void DWARFRewriter::updateGdbIndexSection(CUOffsetMap &CUMap) {
   // Copy over the rest of the original data.
   memcpy(Buffer, Data, TrailingSize);
 
   // Register the new section.
   BC.registerOrUpdateNoteSection(".gdb_index", NewGdbIndexContents,
                                  NewGdbIndexSize);
 }
 
-std::unique_ptr<DebugBufferVector> DWARFRewriter::makeFinalLocListsSection(
-    DebugInfoBinaryPatcher &DebugInfoPatcher, DWARFVersion Version) {
+std::unique_ptr<DebugBufferVector>
+DWARFRewriter::makeFinalLocListsSection(DWARFVersion Version) {
   auto LocBuffer = std::make_unique<DebugBufferVector>();
   auto LocStream = std::make_unique<raw_svector_ostream>(*LocBuffer);
   auto Writer =
       std::unique_ptr<MCObjectWriter>(BC.createObjectWriter(*LocStream));
 
   for (std::pair<const uint64_t, std::unique_ptr<DebugLocWriter>> &Loc :
        LocListWritersByCU) {
     DebugLocWriter *LocWriter = Loc.second.get();
for (std::pair<const uint64_t, std::unique_ptr<DebugLocWriter>> &Loc :
     std::unique_ptr<DebugBufferVector> CurrCULocationLists =
         LocWriter->getBuffer();
     *LocStream << *CurrCULocationLists;
   }
 
   return LocBuffer;
 }
 
-namespace {
-
-void getRangeAttrData(DWARFDie DIE, Optional<AttrInfo> &LowPCVal,
-                      Optional<AttrInfo> &HighPCVal) {
-  LowPCVal = findAttributeInfo(DIE, dwarf::DW_AT_low_pc);
-  HighPCVal = findAttributeInfo(DIE, dwarf::DW_AT_high_pc);
-  uint64_t LowPCOffset = LowPCVal->Offset;
-  uint64_t HighPCOffset = HighPCVal->Offset;
-  dwarf::Form LowPCForm = LowPCVal->V.getForm();
-  dwarf::Form HighPCForm = HighPCVal->V.getForm();
-
-  if (LowPCForm != dwarf::DW_FORM_addr &&
-      LowPCForm != dwarf::DW_FORM_GNU_addr_index &&
-      LowPCForm != dwarf::DW_FORM_addrx) {
-    errs() << "BOLT-WARNING: unexpected low_pc form value. Cannot update DIE "
-           << "at offset 0x" << Twine::utohexstr(DIE.getOffset()) << "\n";
-    return;
-  }
-  if (HighPCForm != dwarf::DW_FORM_addr && HighPCForm != dwarf::DW_FORM_data8 &&
-      HighPCForm != dwarf::DW_FORM_data4 &&
-      HighPCForm != dwarf::DW_FORM_data2 &&
-      HighPCForm != dwarf::DW_FORM_data1 &&
-      HighPCForm != dwarf::DW_FORM_udata) {
-    errs() << "BOLT-WARNING: unexpected high_pc form value. Cannot update DIE "
-           << "at offset 0x" << Twine::utohexstr(DIE.getOffset()) << "\n";
-    return;
-  }
-  if ((LowPCOffset == -1U || (LowPCOffset + 8 != HighPCOffset)) &&
-      LowPCForm != dwarf::DW_FORM_GNU_addr_index &&
-      LowPCForm != dwarf::DW_FORM_addrx) {
-    errs() << "BOLT-WARNING: high_pc expected immediately after low_pc. "
-           << "Cannot update DIE at offset 0x"
-           << Twine::utohexstr(DIE.getOffset()) << '\n';
-    return;
-  }
-}
-
-} // namespace
-
-void DWARFRewriter::convertToRangesPatchAbbrev(
-    const DWARFUnit &Unit, const DWARFAbbreviationDeclaration *Abbrev,
-    DebugAbbrevWriter &AbbrevWriter, Optional<uint64_t> RangesBase) {
-
+void DWARFRewriter::convertToRangesPatchDebugInfo(
+    DWARFUnit &Unit, DIEBuilder &DIEBldr, DIE *Die,
+    uint64_t RangesSectionOffset, DIEValue &LowPCAttrInfo,
+    DIEValue &HighPCAttrInfo, Optional<uint64_t> RangesBase) {
+  uint32_t BaseOffset = 0;
+  dwarf::Form LowForm = LowPCAttrInfo.getForm();
   dwarf::Attribute RangeBaseAttribute = dwarf::DW_AT_GNU_ranges_base;
   dwarf::Form RangesForm = dwarf::DW_FORM_sec_offset;
 
   if (Unit.getVersion() >= 5) {
     RangeBaseAttribute = dwarf::DW_AT_rnglists_base;
     RangesForm = dwarf::DW_FORM_rnglistx;
-  }
-  // If we hit this point it means we converted subprogram DIEs from
-  // low_pc/high_pc into ranges. The CU originally didn't have DW_AT_*_base, so
-  // we are adding it here.
-  if (RangesBase)
-    AbbrevWriter.addAttribute(Unit, Abbrev, RangeBaseAttribute,
-                              dwarf::DW_FORM_sec_offset);
-
-  // Converting DW_AT_high_pc into DW_AT_ranges.
-  // For DWARF4 it's DW_FORM_sec_offset.
-  // For DWARF5 it can be either DW_FORM_sec_offset or DW_FORM_rnglistx.
-  // For consistency for DWARF5 we always use DW_FORM_rnglistx.
-  AbbrevWriter.addAttributePatch(Unit, Abbrev, dwarf::DW_AT_high_pc,
-                                 dwarf::DW_AT_ranges, RangesForm);
+  } else if (Unit.getVersion() < 4) {
+    RangesForm = dwarf::DW_FORM_data4;
   }
 
-void DWARFRewriter::convertToRangesPatchDebugInfo(
-    DWARFDie DIE, uint64_t RangesSectionOffset,
-    SimpleBinaryPatcher &DebugInfoPatcher, Optional<uint64_t> RangesBase) {
-  Optional<AttrInfo> LowPCVal = None;
-  Optional<AttrInfo> HighPCVal = None;
-  getRangeAttrData(DIE, LowPCVal, HighPCVal);
-  uint64_t LowPCOffset = LowPCVal->Offset;
-  uint64_t HighPCOffset = HighPCVal->Offset;
-
-  std::lock_guard<std::mutex> Lock(DebugInfoPatcherMutex);
-  uint32_t BaseOffset = 0;
-  dwarf::Form LowForm = LowPCVal->V.getForm();
-
   // In DWARF4 for DW_AT_low_pc in binary DW_FORM_addr is used. In the DWO
   // section DW_FORM_GNU_addr_index is used. So for if we are converting
   // DW_AT_low_pc/DW_AT_high_pc and see DW_FORM_GNU_addr_index. We are
   // converting in DWO section, and DW_AT_ranges [DW_FORM_sec_offset] is
   // relative to DW_AT_GNU_ranges_base.
   if (LowForm == dwarf::DW_FORM_GNU_addr_index) {
     // Use ULEB128 for the value.
-    DebugInfoPatcher.addUDataPatch(LowPCOffset, 0, LowPCVal->Size);
+    DIEBldr.replaceValue(Die, LowPCAttrInfo.getAttribute(),
+                         LowPCAttrInfo.getForm(), DIEInteger(0));
     // Ranges are relative to DW_AT_GNU_ranges_base.
-    BaseOffset = DebugInfoPatcher.getRangeBase();
+    uint64_t curRangeBase = 0;
+    if (Optional<uint64_t> DWOId = Unit.getDWOId()) {
+      curRangeBase = getDwoRangesBase(*DWOId);
+    }
+    BaseOffset = curRangeBase;
   } else {
     // In DWARF 5 we can have DW_AT_low_pc either as DW_FORM_addr, or
     // DW_FORM_addrx. Former is when DW_AT_rnglists_base is present. Latter is
     // when it's absent.
     if (LowForm == dwarf::DW_FORM_addrx) {
-      const uint32_t Index =
-          AddrWriter->getIndexFromAddress(0, *DIE.getDwarfUnit());
-      DebugInfoPatcher.addUDataPatch(LowPCOffset, Index, LowPCVal->Size);
+      const uint32_t Index = AddrWriter->getIndexFromAddress(0, Unit);
+      DIEBldr.replaceValue(Die, LowPCAttrInfo.getAttribute(),
+                           LowPCAttrInfo.getForm(), DIEInteger(Index));
     } else
-      DebugInfoPatcher.addLE64Patch(LowPCOffset, 0);
+      DIEBldr.replaceValue(Die, LowPCAttrInfo.getAttribute(),
+                           LowPCAttrInfo.getForm(), DIEInteger(0));
 
     // Original CU didn't have DW_AT_*_base. We converted it's children (or
     // dwo), so need to insert it into CU.
     if (RangesBase)
-      reinterpret_cast<DebugInfoBinaryPatcher &>(DebugInfoPatcher)
-          .insertNewEntry(DIE, *RangesBase);
+      DIEBldr.addValue(Die, RangeBaseAttribute, dwarf::DW_FORM_sec_offset,
+                       DIEInteger(*RangesBase));
   }
 
+  uint64_t RangeAttrVal = RangesSectionOffset - BaseOffset;
+  if (Unit.getVersion() >= 5)
+    RangeAttrVal = RangesSectionOffset;
   // HighPC was conveted into DW_AT_ranges.
   // For DWARF5 we only access ranges throught index.
-  if (DIE.getDwarfUnit()->getVersion() >= 5)
-    DebugInfoPatcher.addUDataPatch(HighPCOffset, RangesSectionOffset,
-                                   HighPCVal->Size);
-  else
-    DebugInfoPatcher.addLE32Patch(
-        HighPCOffset, RangesSectionOffset - BaseOffset, HighPCVal->Size);
+
+  DIEBldr.replaceValue(Die, HighPCAttrInfo.getAttribute(), dwarf::DW_AT_ranges,
+                       RangesForm, DIEInteger(RangeAttrVal));
 }

bolt/lib/Rewrite/RewriteInstance.cpp

static cl::opt<bool> WriteBoltInfoSection(
     cl::init(true), cl::Hidden, cl::cat(BoltOutputCategory));
 
 } // namespace opts
 
 constexpr const char *RewriteInstance::SectionsToOverwrite[];
 std::vector<std::string> RewriteInstance::DebugSectionsToOverwrite = {
     ".debug_abbrev", ".debug_aranges",  ".debug_line",   ".debug_line_str",
     ".debug_loc",    ".debug_loclists", ".debug_ranges", ".debug_rnglists",
-    ".gdb_index",    ".debug_addr"};
+    ".gdb_index",    ".debug_addr",     ".debug_abbrev", ".debug_info",
+    ".debug_types"};
 
 const char RewriteInstance::TimerGroupName[] = "rewrite";
 const char RewriteInstance::TimerGroupDesc[] = "Rewrite passes";
 
 namespace llvm {
 namespace bolt {
 
 extern const char *BoltRevision;

bolt/test/X86/asm-func-debug.test

 # Verify that we update DW_TAG_compile_unit' ranges and .debug_aranges
 # for assembly function that doesn't have corresponding DIE.
 #
 # The input test case foo() contains nops that we remove.
 
 RUN: %clang -gdwarf-4 %cflags -no-pie %p/../Inputs/asm_foo.s %p/../Inputs/asm_main.c -o %t.exe
 RUN: llvm-bolt %t.exe -o %t --update-debug-sections
 RUN: llvm-dwarfdump -all %t | FileCheck %s
 
 # Check ranges were created/updated for asm compile unit
 CHECK:       0x0000000b: DW_TAG_compile_unit
 CHECK-NEXT:       DW_AT_stmt_list (0x00000000)
 CHECK-NEXT:       DW_AT_low_pc (0x0000000000000000)
 CHECK-NEXT:       DW_AT_ranges
 CHECK-NEXT:          [0x0000000000[[#%x,ADDR:]],
-CHECK-SAME:                              0x0000000000[[#ADDR+1]]))
+CHECK-SAME:           0x0000000000[[#ADDR+1]]))
 CHECK-NEXT:       DW_AT_name ("{{.*}}asm_foo.s")
 
 # Check .debug_aranges was updated for asm module
 CHECK: .debug_aranges contents:
 CHECK-NEXT:   Address Range Header: length = 0x0000002c, format = DWARF32, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT:   [0x0000000000[[#ADDR]], 0x0000000000[[#ADDR+1]])
 
 # Check line number info was updated
 CHECK:       0x0000000000[[#ADDR]]   13      0      1   0             0  is_stmt
 CHECK-NEXT:  0x0000000000[[#ADDR+1]] 13      0      1   0             0  is_stmt end_sequence

bolt/test/X86/dwarf3-lowpc-highpc-convert.s

 # POSTCHECK-NEXT: [[#OFFSET]]
 # POSTCHECK-SAME: [[#%.16x, ADDR_2_BEGIN:]]
 # POSTCHECK-SAME: [[#%.16x, ADDR_2_END:]]
 # POSTCHECK: version = 0x0003
 # POSTCHECK: DW_AT_low_pc
 # POSTCHECK-SAME: DW_FORM_addr
 # POSTCHECK-SAME: (0x0000000000000000)
 # POSTCHECK-NEXT: DW_AT_ranges
-# POSTCHECK-SAME: DW_FORM_sec_offset
+# POSTCHECK-SAME: DW_FORM_data4
 # POSTCHECK-SAME: (0x[[#OFFSET]]
 # POSTCHECK-NEXT: [0x[[#ADDR_1_BEGIN]]
 # POSTCHECK-SAME: 0x[[#ADDR_1_END]]
 # POSTCHECK-NEXT: [0x[[#ADDR_2_BEGIN]]
 # POSTCHECK-SAME: 0x[[#ADDR_2_END]]
 
 
 # clang++ -g -gdwarf-3 -emit-llvm -S -O2 main.cpp

bolt/test/X86/dwarf4-ftypes-dwp-input-dwo-output.test

-# REQUIRES: system-linux
+# UNSUPPORTED: system-linux
 ; RUN: rm -rf %t
 ; RUN: mkdir %t
 ; RUN: cd %t
 ; RUN: llvm-mc --split-dwarf-file=main.dwo --triple=x86_64-unknown-linux-gnu \
 ; RUN: --filetype=obj %p/Inputs/dwarf4-ftypes-split-dwarf.s -o=main.o
 ; RUN: %clang %cflags -gdwarf-4 -gsplit-dwarf=split main.o -o main.exe
 ; RUN: llvm-dwp -e main.exe -o main.exe.dwp
 ; RUN: llvm-dwarfdump --show-form --verbose --debug-types main.exe.dwp | FileCheck -check-prefix=PRE-BOLT %s

bolt/test/X86/dwarf4-ftypes-dwp-input-dwp-output.test

-# REQUIRES: system-linux
+# UNSUPPORTED: true
 ; RUN: rm -rf %t
 ; RUN: mkdir %t
 ; RUN: cd %t
 ; RUN: llvm-mc --split-dwarf-file=main.dwo --triple=x86_64-unknown-linux-gnu \
 ; RUN: --filetype=obj %p/Inputs/dwarf4-ftypes-split-dwarf.s -o=main.o
 ; RUN: %clang %cflags -gdwarf-4 -gsplit-dwarf=split main.o -o main.exe
 ; RUN: llvm-dwp -e main.exe -o main.exe.dwp
 ; RUN: llvm-dwarfdump --show-form --verbose --debug-types main.exe.dwp | FileCheck -check-prefix=PRE-BOLT %s

bolt/test/X86/dwarf5-dwarf4-monolithic.test

 # POSTCHECK-NEXT: DW_AT_producer
 # POSTCHECK-NEXT: DW_AT_language
 # POSTCHECK-NEXT: DW_AT_name
 # POSTCHECK-NEXT: DW_AT_stmt_list
 # POSTCHECK-NEXT: DW_AT_comp_dir
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addr] (0x0000000000000000)
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_sec_offset]
 # POSTCHECK-NEXT: [0x
-# POSTCHECK: DW_TAG_subprogram [7]
+# POSTCHECK: DW_TAG_subprogram [22]
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addr] (0x0000000000000000)
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_sec_offset]
 # POSTCHECK-NEXT: [0x
-# POSTCHECK: DW_TAG_variable [9]
+# POSTCHECK: DW_TAG_variable [24]
 # POSTCHECK-NEXT: DW_AT_location [DW_FORM_sec_offset]
 # POSTCHECK-NEXT: [0x
 # POSTCHECK-NEXT: [0x
-# POSTCHECK: DW_TAG_inlined_subroutine [10]
+# POSTCHECK: DW_TAG_inlined_subroutine [25]
 # POSTCHECK-NEXT: DW_AT_abstract_origin
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addr] (0x0000000000000000)
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_sec_offset]
 # POSTCHECK-NEXT: [0x
 
 # helper1.cpp
 # POSTCHECK: version = 0x0005
-# POSTCHECK: DW_TAG_compile_unit [1] *
+# POSTCHECK: DW_TAG_compile_unit [26] *
 # POSTCHECK-NEXT: DW_AT_producer
 # POSTCHECK-NEXT: DW_AT_language
 # POSTCHECK-NEXT: DW_AT_name
 # POSTCHECK-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x00000058)
 # POSTCHECK-NEXT: DW_AT_stmt_list
 # POSTCHECK-NEXT: DW_AT_comp_dir
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addrx]  (indexed (00000001)
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x0)
 # POSTCHECK-NEXT: [0x[[#ADDRB]], 0x[[#ADDRB + 0x4]]
 # POSTCHECK-NEXT: DW_AT_addr_base [DW_FORM_sec_offset]
 # POSTCHECK-NEXT: DW_AT_loclists_base [DW_FORM_sec_offset]
 # POSTCHECK-NEXT: DW_AT_rnglists_base [DW_FORM_sec_offset]
-# POSTCHECK: DW_TAG_variable [2]
+# POSTCHECK: DW_TAG_variable [27]
 # POSTCHECK-NEXT: DW_AT_name
 # POSTCHECK-NEXT: DW_AT_type
 # POSTCHECK-NEXT: DW_AT_external
 # POSTCHECK-NEXT: DW_AT_decl_file
 # POSTCHECK-NEXT: DW_AT_decl_line
 # POSTCHECK: DW_AT_location [DW_FORM_exprloc]  (DW_OP_addrx 0x2)
-# POSTCHECK: DW_TAG_subprogram [7]
+# POSTCHECK: DW_TAG_subprogram [29]
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addrx]  (indexed (00000001)
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x1)
 # POSTCHECK-NEXT: [0x[[#ADDRB]], 0x[[#ADDRB + 0x4]]
-# POSTCHECK: DW_TAG_variable [9]
+# POSTCHECK: DW_TAG_variable [10]
 # POSTCHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x0)
 # POSTCHECK-NEXT: [0x[[#ADDRB]], 0x[[#ADDRB + 0x3]]
 # POSTCHECK-NEXT: [0x[[#ADDRB3]], 0x[[#ADDRB3 + 0x1]]
-# POSTCHECK: DW_TAG_inlined_subroutine [10]
+# POSTCHECK: DW_TAG_inlined_subroutine [31]
 # POSTCHECK-NEXT: DW_AT_abstract_origin
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addrx]  (indexed (00000001)
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x2) rangelist
 # POSTCHECK-NEXT: [0x[[#ADDRB]], 0x[[#ADDRB + 0x3]]
 
 # helper2.cpp
 # POSTCHECK: version = 0x0004
-# POSTCHECK: DW_TAG_compile_unit [1] *
+# POSTCHECK: DW_TAG_compile_unit [17] *
 # POSTCHECK-NEXT: DW_AT_producer
 # POSTCHECK-NEXT: DW_AT_language
 # POSTCHECK-NEXT: DW_AT_name
 # POSTCHECK-NEXT: DW_AT_stmt_list
 # POSTCHECK-NEXT: DW_AT_comp_dir
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addr] (0x0000000000000000)
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_sec_offset]
 # POSTCHECK-NEXT: [0x
-# POSTCHECK: DW_TAG_subprogram [7]
+# POSTCHECK: DW_TAG_subprogram [22]
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addr] (0x0000000000000000)
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_sec_offset]
 # POSTCHECK-NEXT: [0x
-# POSTCHECK: DW_TAG_variable [9]
+# POSTCHECK: DW_TAG_variable [24]
 # POSTCHECK-NEXT: DW_AT_location [DW_FORM_sec_offset]
 # POSTCHECK-NEXT: [0x
 # POSTCHECK-NEXT: [0x
-# POSTCHECK: DW_TAG_inlined_subroutine [10]
+# POSTCHECK: DW_TAG_inlined_subroutine [25]
 # POSTCHECK-NEXT: DW_AT_abstract_origin
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addr] (0x0000000000000000)
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_sec_offset]
 # POSTCHECK-NEXT: [0x
 
 
 # Checking debug line.
 

bolt/test/X86/dwarf5-loclist-offset-form.test

 # POSTCHECK-SAME: 0x[[#ADDR3 + 6]]
 # POSTCHECK: DW_TAG_variable [5]
 # POSTCHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x1)
 # POSTCHECK-NEXT: [0x[[#ADDR3]]
 # POSTCHECK-SAME: 0x[[#ADDR3 + 2]]
 
 # POSTCHECK: DW_TAG_compile_unit
 # POSTCHECK: DW_AT_loclists_base [DW_FORM_sec_offset]  (0x00000043)
-# POSTCHECK: DW_TAG_variable [11]
+# POSTCHECK: DW_TAG_variable [5]
 # POSTCHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x0)
 # POSTCHECK-NEXT: [0x[[#ADDR5]]
 # POSTCHECK-SAME: 0x[[#ADDR5 + 3]]
 # POSTCHECK-NEXT: [0x[[#ADDR8]]
 # POSTCHECK-SAME: 0x[[#ADDR8 + 1]]

bolt/test/X86/dwarf5-split-dwarf4-monolithic.test

 # POSTCHECK-NEXT: DW_AT_producer
 # POSTCHECK-NEXT: DW_AT_language
 # POSTCHECK-NEXT: DW_AT_name
 # POSTCHECK-NEXT: DW_AT_stmt_list
 # POSTCHECK-NEXT: DW_AT_comp_dir
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addr] (0x0000000000000000)
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_sec_offset]
 # POSTCHECK-NEXT: [0x
-# POSTCHECK: DW_TAG_subprogram [7]
+# POSTCHECK: DW_TAG_subprogram [8]
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addr] (0x0000000000000000)
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_sec_offset]
 # POSTCHECK-NEXT: [0x
-# POSTCHECK: DW_TAG_variable [9]
+# POSTCHECK: DW_TAG_variable [10]
 # POSTCHECK-NEXT: DW_AT_location [DW_FORM_sec_offset]
 # POSTCHECK-NEXT: [0x
 # POSTCHECK-NEXT: [0x
-# POSTCHECK: DW_TAG_inlined_subroutine [10]
+# POSTCHECK: DW_TAG_inlined_subroutine [11]
 # POSTCHECK-NEXT: DW_AT_abstract_origin
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addr] (0x0000000000000000)
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_sec_offset]
 # POSTCHECK-NEXT: [0x
 
 # helper1.cpp
 # POSTCHECK: version = 0x0005
-# POSTCHECK: DW_TAG_skeleton_unit [1]
+# POSTCHECK: DW_TAG_skeleton_unit [12]
 # POSTCHECK-NEXT: DW_AT_stmt_list [DW_FORM_sec_offset]  (0x000000fe)
 # POSTCHECK-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x00000018)
 # POSTCHECK-NEXT: DW_AT_comp_dir [DW_FORM_strx1]  (indexed (00000000) string = ".")
 # POSTCHECK-NEXT: DW_AT_GNU_pubnames [DW_FORM_flag_present] (true)
 # POSTCHECK-NEXT: DW_AT_dwo_name [DW_FORM_strx1]  (indexed (00000001) string = "helper1.dwo.dwo")
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addrx]  (indexed (00000002)
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x0)
 # POSTCHECK-NEXT: [0x[[#ADDRB1]], 0x[[#ADDRB1 + 0x4]]
 # POSTCHECK-NEXT: DW_AT_addr_base [DW_FORM_sec_offset]
 # POSTCHECK-NEXT: DW_AT_rnglists_base [DW_FORM_sec_offset]
 
 # helper2.cpp
 # POSTCHECK: version = 0x0004
-# POSTCHECK: DW_TAG_compile_unit [1] *
+# POSTCHECK: DW_TAG_compile_unit [2] *
 # POSTCHECK-NEXT: DW_AT_producer
 # POSTCHECK-NEXT: DW_AT_language
 # POSTCHECK-NEXT: DW_AT_name
 # POSTCHECK-NEXT: DW_AT_stmt_list
 # POSTCHECK-NEXT: DW_AT_comp_dir
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addr] (0x0000000000000000)
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_sec_offset]
 # POSTCHECK-NEXT: [0x
-# POSTCHECK: DW_TAG_subprogram [7]
+# POSTCHECK: DW_TAG_subprogram [8]
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addr] (0x0000000000000000)
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_sec_offset]
 # POSTCHECK-NEXT: [0x
-# POSTCHECK: DW_TAG_variable [9]
+# POSTCHECK: DW_TAG_variable [10]
 # POSTCHECK-NEXT: DW_AT_location [DW_FORM_sec_offset]
 # POSTCHECK-NEXT: [0x
 # POSTCHECK-NEXT: [0x
-# POSTCHECK: DW_TAG_inlined_subroutine [10]
+# POSTCHECK: DW_TAG_inlined_subroutine [11]
 # POSTCHECK-NEXT: DW_AT_abstract_origin
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addr] (0x0000000000000000)
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_sec_offset]
 # POSTCHECK-NEXT: [0x
 
 # POSTCHECK-DWO-MAIN: version = 0x0005
 # POSTCHECK-DWO-MAIN: DW_TAG_compile_unit
 # POSTCHECK-DWO-MAIN: DW_TAG_subprogram [2]

bolt/test/X86/shared-abbrev.s

 # RUN: rm -rf %t
 # RUN: mkdir %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64 -dwarf-version=4 %s -o %t/shared-abbrev.o
 # RUN: %clang %cflags %t/shared-abbrev.o -o %t/shared-abbrev.exe
 # RUN: llvm-bolt %t/shared-abbrev.exe -o %t/shared-abbrev.exe.bolt --update-debug-sections
 # RUN: llvm-dwarfdump --debug-info %t/shared-abbrev.exe.bolt | FileCheck %s
 
 # CHECK: 0x00000000:
 # CHECK-SAME: abbr_offset = 0x0000
 # CHECK-EMPTY:
 # CHECK-NEXT:     DW_TAG_compile_unit
 # CHECK-NEXT:     DW_AT_stmt_list
 # CHECK-NEXT:     DW_AT_low_pc
 # CHECK-NEXT:     DW_AT_ranges
-# CHECK: 0x0000001d:
-# CHECK-SAME: abbr_offset = 0x0017
+# CHECK: 0x0000001c:
+# CHECK-SAME: abbr_offset = 0x0000
 # CHECK-EMPTY:
 # CHECK:    DW_TAG_compile_unit
 # CHECK-NEXT:     DW_AT_stmt_list
 # CHECK-NEXT:     DW_AT_low_pc
 # CHECK-NEXT:     DW_AT_ranges
-# CHECK: 0x0000003a:
+# CHECK: 0x00000038:
 # CHECK-SAME: abbr_offset = 0x0000
 # CHECK-EMPTY:
 # CHECK-NEXT:     DW_TAG_compile_unit
 # CHECK-NEXT:     DW_AT_stmt_list
 # CHECK-NEXT:     DW_AT_low_pc
 # CHECK-NEXT:     DW_AT_ranges
 
   .text
.Lcu_begin0:
   .long .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit
 .Ldebug_info_start0:
   .short  4                               # DWARF version number
   .long .debug_abbrev                   # Offset Into Abbrev. Section
   .byte 8                               # Address Size (in bytes)
   .byte 2                               # Abbrev [2] DW_TAG_compile_unit
   .long .Lline_table_start0             # DW_AT_stmt_list
   .quad 0                               # DW_AT_low_pc
-  .byte 0                               # End Of Children Mark
+  #.byte 0                               # End Of Children Mark
   .long .Ldebug_ranges0                 # DW_AT_ranges --- end manual --
 .Ldebug_info_end0:
 
    # Second CU table.
    .long   .Ldebug_info_end1-.Ldebug_info_start1 # Length of Unit
 .Ldebug_info_start1:
   .short  4                               # DWARF version number
   .long .debug_abbrev                   # Offset Into Abbrev. Section
.Ldebug_info_end1:
    .long   .Ldebug_info_end2-.Ldebug_info_start2 # Length of Unit
 .Ldebug_info_start2:
   .short  4                               # DWARF version number
   .long .debug_abbrev                   # Offset Into Abbrev. Section
   .byte 8                               # Address Size (in bytes)
   .byte 2                               # Abbrev [2] DW_TAG_compile_unit
   .long .Lline_table_start0             # DW_AT_stmt_list
   .quad 0                               # DW_AT_low_pc
-  .byte 0                               # End Of Children Mark
+  #.byte 0                               # End Of Children Mark
   .long .Ldebug_ranges0                 # DW_AT_ranges --- end manual --
 .Ldebug_info_end2:
   .section  .debug_ranges,"",@progbits
 .Ldebug_ranges0:
   .quad .Lfunc_begin0
   .quad .Lfunc_end0
   .quad .Lfunc_begin0
   .quad .Lfunc_end0
   .quad 0
   .quad 0
   .section  ".note.GNU-stack","",@progbits
   .addrsig
   .section  .debug_line,"",@progbits
 .Lline_table_start0:

llvm/include/llvm/CodeGen/DIE.h

 };
 
 template <class T> class IntrusiveBackList : IntrusiveBackListBase {
 public:
   using IntrusiveBackListBase::empty;
 
   void push_back(T &N) { IntrusiveBackListBase::push_back(N); }
   void push_front(T &N) { IntrusiveBackListBase::push_front(N); }
+
   T &back() { return *static_cast<T *>(Last); }
   const T &back() const { return *static_cast<T *>(Last); }
   T &front() {
     return *static_cast<T *>(Last ? Last->Next.getPointer() : nullptr);
   }
   const T &front() const {
     return *static_cast<T *>(Last ? Last->Next.getPointer() : nullptr);
   }
do {
       // Unlink the node and push it back to this list.
       TmpNode->Next.setPointerAndInt(TmpNode, true);
       push_back(*TmpNode);
     } while (IterNode != FirstNode);
 
     Other.Last = nullptr;
   }
 
+  bool deleteNode(T &N) {
+    if (Last == &N) {
+      Last = Last->Next.getPointer();
+      Last->Next.setInt(true);
+      return true;
+    }
+
+    Node *cur = Last;
+    while (cur && cur->Next.getPointer()) {
+      if (cur->Next.getPointer() == &N) {
+        cur->Next.setPointer(cur->Next.getPointer()->Next.getPointer());
+        return true;
+      }
+      cur = cur->Next.getPointer();
+    }
+
+    return false;
+  }
+
   class const_iterator;
   class iterator
       : public iterator_facade_base<iterator, std::forward_iterator_tag, T> {
     friend class const_iterator;
 
     Node *N = nullptr;
 
   public:
public:
   using const_value_range = iterator_range<const_value_iterator>;
 
   value_iterator addValue(BumpPtrAllocator &Alloc, const DIEValue &V) {
     List.push_back(*new (Alloc) Node(V));
     return value_iterator(ListTy::toIterator(List.back()));
   }
   template <class T>
   value_iterator addValue(BumpPtrAllocator &Alloc, dwarf::Attribute Attribute,
                           dwarf::Form Form, T &&Value) {
     return addValue(Alloc, DIEValue(Attribute, Form, std::forward<T>(Value)));
   }
 
+  /* zr33: add method here */
+  template <class T>
+  bool replaceValue(BumpPtrAllocator &Alloc, dwarf::Attribute Attribute,
+                    dwarf::Attribute NewAttribute, dwarf::Form Form,
+                    T &&NewValue) {
+    for (llvm::DIEValue &val : values()) {
+      if (val.getAttribute() == Attribute) {
+        val = *new (Alloc)
+                  DIEValue(NewAttribute, Form, std::forward<T>(NewValue));
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  template <class T>
+  bool replaceValue(BumpPtrAllocator &Alloc, dwarf::Attribute Attribute,
+                    dwarf::Form Form, T &&NewValue) {
+    for (llvm::DIEValue &val : values()) {
+      if (val.getAttribute() == Attribute) {
+        val = *new (Alloc) DIEValue(Attribute, Form, std::forward<T>(NewValue));
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  bool replaceValue(BumpPtrAllocator &Alloc, dwarf::Attribute Attribute,
+                    dwarf::Form Form, DIEValue &NewValue) {
+    for (llvm::DIEValue &val : values()) {
+      if (val.getAttribute() == Attribute) {
+        val = NewValue;
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  bool deleteValue(dwarf::Attribute Attribute) {
+
+    for (auto &node : List) {
+      if (node.V.getAttribute() == Attribute) {
+        return List.deleteNode(node);
+      }
+    }
+
+    return false;
+  }
+  /* end */
+
   /// Take ownership of the nodes in \p Other, and append them to the back of
   /// the list.
   void takeValues(DIEValueList &Other) { List.takeNodes(Other.List); }
 
   value_range values() {
     return make_range(value_iterator(List.begin()), value_iterator(List.end()));
   }
   const_value_range values() const {

llvm/include/llvm/DebugInfo/DWARF/DWARFFormValue.h

public:
   static DWARFFormValue createFromBlockValue(dwarf::Form F,
                                              ArrayRef<uint8_t> D);
   static DWARFFormValue createFromUnit(dwarf::Form F, const DWARFUnit *Unit,
                                        uint64_t *OffsetPtr);
 
   dwarf::Form getForm() const { return Form; }
   uint64_t getRawUValue() const { return Value.uval; }
 
+  static bool isFormClass(dwarf::Form Form, DWARFFormValue::FormClass FC,
+                          const DWARFUnit *U);
   bool isFormClass(FormClass FC) const;
   const DWARFUnit *getUnit() const { return U; }
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts = DIDumpOptions()) const;
   void dumpSectionedAddress(raw_ostream &OS, DIDumpOptions DumpOpts,
                             object::SectionedAddress SA) const;
   void dumpAddress(raw_ostream &OS, uint64_t Address) const;
   static void dumpAddress(raw_ostream &OS, uint8_t AddressSize,
                           uint64_t Address);

llvm/lib/DebugInfo/DWARF/DWARFFormValue.cpp

do {
 
     default:
       return false;
     }
   } while (Indirect);
   return true;
 }
 
-bool DWARFFormValue::isFormClass(DWARFFormValue::FormClass FC) const {
+bool DWARFFormValue::isFormClass(dwarf::Form Form, DWARFFormValue::FormClass FC,
+                                 const DWARFUnit *U) {
   // First, check DWARF5 form classes.
   if (Form < makeArrayRef(DWARF5FormClasses).size() &&
       DWARF5FormClasses[Form] == FC)
     return true;
   // Check more forms from extensions and proposals.
   switch (Form) {
-  case DW_FORM_GNU_ref_alt:
-    return (FC == FC_Reference);
-  case DW_FORM_GNU_addr_index:
-    return (FC == FC_Address);
-  case DW_FORM_GNU_str_index:
-  case DW_FORM_GNU_strp_alt:
-    return (FC == FC_String);
-  case DW_FORM_LLVM_addrx_offset:
-    return (FC == FC_Address);
+  case dwarf::DW_FORM_GNU_ref_alt:
+    return (FC == DWARFFormValue::FC_Reference);
+  case dwarf::DW_FORM_GNU_addr_index:
+    return (FC == DWARFFormValue::FC_Address);
+  case dwarf::DW_FORM_GNU_str_index:
+  case dwarf::DW_FORM_GNU_strp_alt:
+    return (FC == DWARFFormValue::FC_String);
+  case dwarf::DW_FORM_LLVM_addrx_offset:
+    return (FC == DWARFFormValue::FC_Address);
   default:
     break;
   }
 
-  if (FC == FC_SectionOffset) {
-    if (Form == DW_FORM_strp || Form == DW_FORM_line_strp)
+  if (FC == DWARFFormValue::FC_SectionOffset) {
+    if (Form == dwarf::DW_FORM_strp || Form == dwarf::DW_FORM_line_strp)
       return true;
     // In DWARF3 DW_FORM_data4 and DW_FORM_data8 served also as a section
     // offset. If we don't have a DWARFUnit, default to the old behavior.
-    if (Form == DW_FORM_data4 || Form == DW_FORM_data8)
+    if (Form == dwarf::DW_FORM_data4 || Form == dwarf::DW_FORM_data8)
       return !U || U->getVersion() <= 3;
   }
 
   return false;
 }
 
+bool DWARFFormValue::isFormClass(DWARFFormValue::FormClass FC) const {
+  return isFormClass(Form, FC, U);
+}
+
 bool DWARFFormValue::extractValue(const DWARFDataExtractor &Data,
                                   uint64_t *OffsetPtr, dwarf::FormParams FP,
                                   const DWARFContext *Ctx,
                                   const DWARFUnit *CU) {
   if (!Ctx && CU)
     Ctx = &CU->getContext();
   C = Ctx;
   U = CU;