Manually merged main:d37ced88809cb4d2df57ec80887b3f8801ca719b into amd-gfx:bbaefb59377a

Local branch amd-gfx bbaefb5 Manually merged main:3c423722cfd75bf293e42001145fe9ebad53c522 into amd-gfx:52eb0adfd010
Remote branch main d37ced8 AMDGPU: refactor phi lowering from SILowerI1Copies (NFCI) (llvm#75349)

Author: mbrkusanin

bolt/include/bolt/Core/DIEBuilder.h

@@ -33,6 +33,7 @@ namespace llvm {
 
 namespace bolt {
 class DIEStreamer;
+class DebugStrOffsetsWriter;
 
 class DIEBuilder {
   friend DIEStreamer;
@@ -266,7 +267,8 @@ class DIEBuilder {
   ProcessingType getCurrentProcessingState() { return getState().Type; }
 
   /// Constructs IR for Type Units.
-  void buildTypeUnits(const bool Init = true);
+  void buildTypeUnits(DebugStrOffsetsWriter *StrOffsetWriter = nullptr,
+                      const bool Init = true);
   /// Constructs IR for all the CUs.
   void buildCompileUnits(const bool Init = true);
   /// Constructs IR for CUs in a vector.

bolt/include/bolt/Core/DebugData.h

@@ -436,10 +436,6 @@ class DebugStrOffsetsWriter {
     StrOffsetsStream = std::make_unique<raw_svector_ostream>(*StrOffsetsBuffer);
   }
 
-  /// Initializes Buffer and Stream.
-  void initialize(const DWARFSection &StrOffsetsSection,
-                  const std::optional<StrOffsetsContributionDescriptor> Contr);
-
   /// Update Str offset in .debug_str in .debug_str_offsets.
   void updateAddressMap(uint32_t Index, uint32_t Address);
 
@@ -455,9 +451,13 @@ class DebugStrOffsetsWriter {
   }
 
 private:
+  /// Initializes Buffer and Stream.
+  void initialize(DWARFUnit &Unit);
+
   std::unique_ptr<DebugStrOffsetsBufferVector> StrOffsetsBuffer;
   std::unique_ptr<raw_svector_ostream> StrOffsetsStream;
   std::map<uint32_t, uint32_t> IndexToAddressMap;
+  std::vector<uint32_t> StrOffsets;
   std::unordered_map<uint64_t, uint64_t> ProcessedBaseOffsets;
   bool StrOffsetSectionWasModified = false;
 };

bolt/lib/Core/DIEBuilder.cpp

@@ -189,7 +189,8 @@ static unsigned int getCUNum(DWARFContext *DwarfContext, bool IsDWO) {
   return CUNum;
 }
 
-void DIEBuilder::buildTypeUnits(const bool Init) {
+void DIEBuilder::buildTypeUnits(DebugStrOffsetsWriter *StrOffsetWriter,
+                                const bool Init) {
   if (Init)
     BuilderState.reset(new State());
 
@@ -229,8 +230,11 @@ void DIEBuilder::buildTypeUnits(const bool Init) {
     registerUnit(*DU.get(), false);
   }
 
-  for (DWARFUnit *DU : getState().DWARF5TUVector)
+  for (DWARFUnit *DU : getState().DWARF5TUVector) {
     constructFromUnit(*DU);
+    if (StrOffsetWriter)
+      StrOffsetWriter->finalizeSection(*DU, *this);
+  }
 }
 
 void DIEBuilder::buildCompileUnits(const bool Init) {
@@ -280,7 +284,7 @@ void DIEBuilder::buildCompileUnits(const std::vector<DWARFUnit *> &CUs) {
 void DIEBuilder::buildDWOUnit(DWARFUnit &U) {
   BuilderState.release();
   BuilderState = std::make_unique<State>();
-  buildTypeUnits(false);
+  buildTypeUnits(nullptr, false);
   getState().Type = ProcessingType::CUs;
   registerUnit(U, false);
   constructFromUnit(U);

bolt/lib/Core/DebugData.cpp

@@ -851,35 +851,34 @@ std::string SimpleBinaryPatcher::patchBinary(StringRef BinaryContents) {
   return BinaryContentsStr;
 }
 
-void DebugStrOffsetsWriter::initialize(
-    const DWARFSection &StrOffsetsSection,
-    const std::optional<StrOffsetsContributionDescriptor> Contr) {
+void DebugStrOffsetsWriter::initialize(DWARFUnit &Unit) {
+  if (Unit.getVersion() < 5)
+    return;
+  const DWARFSection &StrOffsetsSection = Unit.getStringOffsetSection();
+  const std::optional<StrOffsetsContributionDescriptor> &Contr =
+      Unit.getStringOffsetsTableContribution();
   if (!Contr)
     return;
-
   const uint8_t DwarfOffsetByteSize = Contr->getDwarfOffsetByteSize();
   assert(DwarfOffsetByteSize == 4 &&
          "Dwarf String Offsets Byte Size is not supported.");
-  uint32_t Index = 0;
+  StrOffsets.reserve(Contr->Size);
   for (uint64_t Offset = 0; Offset < Contr->Size; Offset += DwarfOffsetByteSize)
-    IndexToAddressMap[Index++] = support::endian::read32le(
-        StrOffsetsSection.Data.data() + Contr->Base + Offset);
+    StrOffsets.push_back(support::endian::read32le(
+        StrOffsetsSection.Data.data() + Contr->Base + Offset));
 }
 
 void DebugStrOffsetsWriter::updateAddressMap(uint32_t Index, uint32_t Address) {
-  assert(IndexToAddressMap.count(Index) > 0 && "Index is not found.");
   IndexToAddressMap[Index] = Address;
   StrOffsetSectionWasModified = true;
 }
 
 void DebugStrOffsetsWriter::finalizeSection(DWARFUnit &Unit,
                                             DIEBuilder &DIEBldr) {
-  if (IndexToAddressMap.empty())
-    return;
-
   std::optional<AttrInfo> AttrVal =
       findAttributeInfo(Unit.getUnitDIE(), dwarf::DW_AT_str_offsets_base);
-  assert(AttrVal && "DW_AT_str_offsets_base not present.");
+  if (!AttrVal)
+    return;
   std::optional<uint64_t> Val = AttrVal->V.getAsSectionOffset();
   assert(Val && "DW_AT_str_offsets_base Value not present.");
   DIE &Die = *DIEBldr.getUnitDIEbyUnit(Unit);
@@ -888,11 +887,14 @@ void DebugStrOffsetsWriter::finalizeSection(DWARFUnit &Unit,
   auto RetVal = ProcessedBaseOffsets.find(*Val);
   // Handling re-use of str-offsets section.
   if (RetVal == ProcessedBaseOffsets.end() || StrOffsetSectionWasModified) {
+    initialize(Unit);
+    // Update String Offsets that were modified.
+    for (const auto &Entry : IndexToAddressMap)
+      StrOffsets[Entry.first] = Entry.second;
     // Writing out the header for each section.
-    support::endian::write(
-        *StrOffsetsStream,
-        static_cast<uint32_t>(IndexToAddressMap.size() * 4 + 4),
-        llvm::endianness::little);
+    support::endian::write(*StrOffsetsStream,
+                           static_cast<uint32_t>(StrOffsets.size() * 4 + 4),
+                           llvm::endianness::little);
     support::endian::write(*StrOffsetsStream, static_cast<uint16_t>(5),
                            llvm::endianness::little);
     support::endian::write(*StrOffsetsStream, static_cast<uint16_t>(0),
@@ -904,8 +906,8 @@ void DebugStrOffsetsWriter::finalizeSection(DWARFUnit &Unit,
       DIEBldr.replaceValue(&Die, dwarf::DW_AT_str_offsets_base,
                            StrListBaseAttrInfo.getForm(),
                            DIEInteger(BaseOffset));
-    for (const auto &Entry : IndexToAddressMap)
-      support::endian::write(*StrOffsetsStream, Entry.second,
+    for (const uint32_t Offset : StrOffsets)
+      support::endian::write(*StrOffsetsStream, Offset,
                              llvm::endianness::little);
   } else {
     DIEBldr.replaceValue(&Die, dwarf::DW_AT_str_offsets_base,
@@ -915,6 +917,7 @@ void DebugStrOffsetsWriter::finalizeSection(DWARFUnit &Unit,
 
   StrOffsetSectionWasModified = false;
   IndexToAddressMap.clear();
+  StrOffsets.clear();
 }
 
 void DebugStrWriter::create() {

bolt/lib/Rewrite/DWARFRewriter.cpp

@@ -554,7 +554,7 @@ void DWARFRewriter::addStringHelper(DIEBuilder &DIEBldr, DIE &Die,
                                     const DWARFUnit &Unit,
                                     DIEValue &DIEAttrInfo, StringRef Str) {
   uint32_t NewOffset = StrWriter->addString(Str);
-  if (Unit.getVersion() == 5) {
+  if (Unit.getVersion() >= 5) {
     StrOffstsWriter->updateAddressMap(DIEAttrInfo.getDIEInteger().getValue(),
                                       NewOffset);
     return;
@@ -696,9 +696,6 @@ void DWARFRewriter::updateDebugInfo() {
     std::optional<DWARFUnit *> SplitCU;
     std::optional<uint64_t> RangesBase;
     std::optional<uint64_t> DWOId = Unit->getDWOId();
-    if (Unit->getVersion() >= 5)
-      StrOffstsWriter->initialize(Unit->getStringOffsetSection(),
-                                  Unit->getStringOffsetsTableContribution());
     if (DWOId)
       SplitCU = BC.getDWOCU(*DWOId);
     DebugLocWriter *DebugLocWriter = createRangeLocList(*Unit);
@@ -753,7 +750,7 @@ void DWARFRewriter::updateDebugInfo() {
   };
 
   DIEBuilder DIEBlder(BC.DwCtx.get());
-  DIEBlder.buildTypeUnits();
+  DIEBlder.buildTypeUnits(StrOffstsWriter.get());
   SmallVector<char, 20> OutBuffer;
   std::unique_ptr<raw_svector_ostream> ObjOS =
       std::make_unique<raw_svector_ostream>(OutBuffer);

bolt/test/RISCV/call-annotations.s

@@ -16,13 +16,13 @@ f:
 
 // CHECK-LABEL: Binary Function "_start" after building cfg {
 // CHECK:      auipc ra, f
-// CHECK-NEXT: jalr ra, -4(ra) # Offset: 4
+// CHECK-NEXT: jalr ra, -0x4(ra) # Offset: 4
 // CHECK-NEXT: jal ra, f # Offset: 8
 // CHECK-NEXT: jal zero, f # TAILCALL  # Offset: 12
 
 // CHECK-LABEL: Binary Function "long_tail" after building cfg {
 // CHECK:      auipc t1, f
-// CHECK-NEXT: jalr zero, -24(t1) # TAILCALL  # Offset: 8
+// CHECK-NEXT: jalr zero, -0x18(t1) # TAILCALL  # Offset: 8
 
 // CHECK-LABEL: Binary Function "compressed_tail" after building cfg {
 // CHECK:      jr a0 # TAILCALL  # Offset: 0

bolt/test/RISCV/relax.s

@@ -7,7 +7,7 @@
 // CHECK:      Binary Function "_start" after building cfg {
 // CHECK:      jal ra, near_f
 // CHECK-NEXT: auipc ra, far_f@plt
-// CHECK-NEXT: jalr ra, 12(ra)
+// CHECK-NEXT: jalr ra, 0xc(ra)
 // CHECK-NEXT: j near_f
 
 // CHECK:      Binary Function "_start" after fix-riscv-calls {
@@ -17,8 +17,8 @@
 
 // OBJDUMP:      0000000000600000 <_start>:
 // OBJDUMP-NEXT:     jal 0x600040 <near_f>
-// OBJDUMP-NEXT:     auipc ra, 512
-// OBJDUMP-NEXT:     jalr 124(ra)
+// OBJDUMP-NEXT:     auipc ra, 0x200
+// OBJDUMP-NEXT:     jalr 0x7c(ra)
 // OBJDUMP-NEXT:     j 0x600040 <near_f>
 // OBJDUMP:      0000000000600040 <near_f>:
 // OBJDUMP:      0000000000800080 <far_f>:

bolt/test/RISCV/reloc-tls.s

@@ -4,10 +4,10 @@
 // RUN:    | FileCheck %s
 
 // CHECK-LABEL: Binary Function "tls_le{{.*}}" after building cfg {
-// CHECK:      lui a5, 0
+// CHECK:      lui a5, 0x0
 // CHECK-NEXT: add a5, a5, tp
-// CHECK-NEXT: lw t0, 0(a5)
-// CHECK-NEXT: sw t0, 0(a5)
+// CHECK-NEXT: lw t0, 0x0(a5)
+// CHECK-NEXT: sw t0, 0x0(a5)
 
 // CHECK-LABEL: Binary Function "tls_ie" after building cfg {
 // CHECK-LABEL: .LBB01

bolt/test/RISCV/reorder-blocks-reverse.s

@@ -23,9 +23,9 @@ _start:
 // CHECK-NEXT:   {{.*}}00:       beq t0, t1, {{.*}} <_start+0x10>
 // CHECK-NEXT:   {{.*}}04:       j {{.*}} <_start+0x16>
 // CHECK-NEXT:   {{.*}}08:       ret
-// CHECK-NEXT:   {{.*}}0a:       li a0, 6
+// CHECK-NEXT:   {{.*}}0a:       li a0, 0x6
 // CHECK-NEXT:   {{.*}}0c:       j {{.*}} <_start+0x8>
-// CHECK-NEXT:   {{.*}}10:       li a0, 5
+// CHECK-NEXT:   {{.*}}10:       li a0, 0x5
 // CHECK-NEXT:   {{.*}}12:       j {{.*}} <_start+0x8>
 // CHECK-NEXT:   {{.*}}16:       beq t0, t2, {{.*}} <_start+0xa>
 // CHECK-NEXT:   {{.*}}1a:       j {{.*}} <_start+0x10>

bolt/test/RISCV/tls-le-gnu-ld.test

@@ -7,5 +7,5 @@
 // RUN:   | FileCheck %s
 
 // CHECK: Binary Function "_start" after building cfg {
-// CHECK:      lw t0, 0(tp)
-// CHECK-NEXT: sw t0, 0(tp)
+// CHECK:      lw t0, 0x0(tp)
+// CHECK-NEXT: sw t0, 0x0(tp)