[DWARFLinkerParallel][PowerPC] Cure tests failing on powerpc machine.

[avl]

Summary

location-expression.test and tls-variable.test failed because wrong
endianness was used on powerpc machine. To fix the issue this patch
uses endianness from debug map as endianness for the whole target file.
Previosly, architecture endianness won over what is specified
in debug map.

[aprantl]

llvm/lib/DWARFLinkerParallel/DWARFLinkerImpl.cpp

98–101

If (!...)

llvm/lib/DWARFLinkerParallel/OutputSections.h

294

same type on rhs

[avl]

Thank you for the review!

llvm/lib/DWARFLinkerParallel/DWARFLinkerCompileUnit.h

enum class Stage : uint8_t {
     PatchesUpdated,
 
     /// Resources(Input DWARF, Output DWARF tree) are released.
     Cleaned,
   };
 
   CompileUnit(LinkingGlobalData &GlobalData, unsigned ID,
               StringRef ClangModuleName, DWARFFile &File,
-              OffsetToUnitTy UnitFromOffset)
+              OffsetToUnitTy UnitFromOffset, dwarf::FormParams Format,
+              support::endianness Endianess)
       : DwarfUnit(GlobalData, ID, ClangModuleName), File(File),
         getUnitFromOffset(UnitFromOffset), Stage(Stage::CreatedNotLoaded) {
     UnitName = File.FileName;
+    setOutputFormat(Format, Endianess);
   }
 
   CompileUnit(LinkingGlobalData &GlobalData, DWARFUnit &OrigUnit, unsigned ID,
               StringRef ClangModuleName, DWARFFile &File,
-              OffsetToUnitTy UnitFromOffset)
+              OffsetToUnitTy UnitFromOffset, dwarf::FormParams Format,
+              support::endianness Endianess)
       : DwarfUnit(GlobalData, ID, ClangModuleName), File(File),
         OrigUnit(&OrigUnit), getUnitFromOffset(UnitFromOffset),
         Stage(Stage::CreatedNotLoaded) {
     DWARFDie CUDie = OrigUnit.getUnitDIE();
     if (!CUDie)
       return;
 
-    setOutputFormat(OrigUnit);
+    setOutputFormat(Format, Endianess);
 
     Language = dwarf::toUnsigned(CUDie.find(dwarf::DW_AT_language), 0);
     if (const char *CUName = CUDie.getName(DINameKind::ShortName))
       UnitName = CUName;
     else
       UnitName = File.FileName;
     SysRoot = dwarf::toStringRef(CUDie.find(dwarf::DW_AT_LLVM_sysroot)).str();
   }

llvm/lib/DWARFLinkerParallel/DWARFLinkerImpl.h

LinkContext(LinkingGlobalData &GlobalData, DWARFFile &File,
                 std::optional<Triple> TargetTriple)
         : OutputSections(GlobalData), InputDWARFFile(File),
           ClangModules(ClangModules), TargetTriple(TargetTriple),
           UniqueUnitID(UniqueUnitID) {
 
       if (File.Dwarf) {
         if (!File.Dwarf->compile_units().empty())
           CompileUnits.reserve(File.Dwarf->getNumCompileUnits());
+
+        // Set context format&endianness based on the input file.
+        Format.Version = File.Dwarf->getMaxVersion();
+        Format.AddrSize = File.Dwarf->getCUAddrSize();
+        Endianness = File.Dwarf->isLittleEndian() ? support::endianness::little
+                                                  : support::endianness::big;
       }
     }
 
     /// Check whether specified \p CUDie is a Clang module reference.
     /// if \p Quiet is false then display error messages.
     /// \return first == true if CUDie is a Clang module reference.
     ///         second == true if module is already loaded.
     std::pair<bool, bool> isClangModuleRef(const DWARFDie &CUDie,

llvm/lib/DWARFLinkerParallel/DWARFLinkerImpl.cpp

 
 Error DWARFLinkerImpl::link() {
   // reset compile unit unique ID counter.
   UniqueUnitID = 0;
 
   if (Error Err = validateAndUpdateOptions())
     return Err;
 
-  std::optional<dwarf::FormParams> Format;
-  std::optional<support::endianness> Endianess;
+  dwarf::FormParams GlobalFormat = {GlobalData.getOptions().TargetDWARFVersion,
+                                    0, dwarf::DwarfFormat::DWARF32};
+  support::endianness GlobalEndianness = support::endian::system_endianness();
+
+  if (TheDwarfEmitter) {
+    GlobalEndianness = TheDwarfEmitter->getTargetTriple().isLittleEndian()
+                           ? support::endianness::little
+                           : support::endianness::big;
+  }
 
   for (std::unique_ptr<LinkContext> &Context : ObjectContexts) {
-    if (Context->InputDWARFFile.Dwarf.get() == nullptr)
+    if (Context->InputDWARFFile.Dwarf.get() == nullptr) {
+      Context->setOutputFormat(Context->getFormParams(), GlobalEndianness);
       continue;
+    }
 
     if (GlobalData.getOptions().Verbose) {
       outs() << "OBJECT: " << Context->InputDWARFFile.FileName << "\n";
 
       for (const std::unique_ptr<DWARFUnit> &OrigCU :
            Context->InputDWARFFile.Dwarf->compile_units()) {
         outs() << "Input compilation unit:";
         DIDumpOptions DumpOpts;
         DumpOpts.ChildRecurseDepth = 0;
         DumpOpts.Verbose = GlobalData.getOptions().Verbose;
         OrigCU->getUnitDIE().dump(outs(), 0, DumpOpts);
       }
     }
 
     // Verify input DWARF if requested.
     if (GlobalData.getOptions().VerifyInputDWARF)
       verifyInput(Context->InputDWARFFile);
 
-    for (const std::unique_ptr<DWARFUnit> &OrigCU :
-         Context->InputDWARFFile.Dwarf->compile_units()) {
-      if (!Format)
-        Format = OrigCU.get()->getFormParams();
-    }
+    if (!TheDwarfEmitter)
+      GlobalEndianness = Context->getEndianness();
+    GlobalFormat.AddrSize =
+        std::max(GlobalFormat.AddrSize, Context->getFormParams().AddrSize);
+
+    Context->setOutputFormat(Context->getFormParams(), GlobalEndianness);
 
-    if (!Endianess)
-      Endianess = Context->InputDWARFFile.Dwarf->isLittleEndian()
-                      ? support::endianness::little
-                      : support::endianness::big;
+  if (GlobalFormat.AddrSize == 0) {
+    if (TheDwarfEmitter)
+      GlobalFormat.AddrSize =
+          TheDwarfEmitter->getTargetTriple().isArch32Bit() ? 4 : 8;
+    else
+      GlobalFormat.AddrSize = 8;
   }
 
-  if (!Format)
-    Format = {GlobalData.getOptions().TargetDWARFVersion, 8,
-              dwarf::DwarfFormat::DWARF32};
-  Format->Version = GlobalData.getOptions().TargetDWARFVersion;
-  if (!Endianess)
-    Endianess = support::endianness::little;
-
-  CommonSections.setOutputFormat(*Format, *Endianess);
+  CommonSections.setOutputFormat(GlobalFormat, GlobalEndianness);
 
   // Set parallel options.
   if (GlobalData.getOptions().Threads == 0)
     parallel::strategy = optimal_concurrency(OverallNumberOfCU);
   else
     parallel::strategy = hardware_concurrency(GlobalData.getOptions().Threads);
 
   // Link object files.
if (!registerModuleReference(ChildCUDie, Loader, OnCUDieLoaded, Indent)) {
 
       // Empty modules units should not be cloned.
       if (!ChildCUDie.hasChildren())
         continue;
 
       // Add this module.
       Unit = std::make_unique<CompileUnit>(
           GlobalData, *CU, UniqueUnitID.fetch_add(1), ModuleName, *ErrOrObj,
-          getUnitForOffset);
+          getUnitForOffset, CU->getFormParams(), getEndianness());
     }
   }
 
   if (Unit) {
     ModulesCompileUnits.emplace_back(RefModuleUnit{*ErrOrObj, std::move(Unit)});
     // Preload line table, as it can't be loaded asynchronously.
     ModulesCompileUnits.back().Unit->loadLineTable();
   }
for (const auto &OrigCU : InputDWARFFile.Dwarf->compile_units()) {
           getPCMFile(CUDie, GlobalData.getOptions().ObjectPrefixMap);
 
       // The !isClangModuleRef condition effectively skips over fully resolved
       // skeleton units.
       if (!CUDie || GlobalData.getOptions().UpdateIndexTablesOnly ||
           !isClangModuleRef(CUDie, PCMFile, 0, true).first) {
         CompileUnits.emplace_back(std::make_unique<CompileUnit>(
             GlobalData, *OrigCU, UniqueUnitID.fetch_add(1), "", InputDWARFFile,
-            getUnitForOffset));
+            getUnitForOffset, OrigCU->getFormParams(), getEndianness()));
 
         // Preload line table, as it can't be loaded asynchronously.
         CompileUnits.back()->loadLineTable();
       }
     };
 
     HasNewInterconnectedCUs = false;
 
void DWARFLinkerImpl::LinkContext::emitFDE(uint32_t CIEOffset,
                                            SectionDescriptor &Section) {
   Section.emitIntVal(FDEBytes.size() + 4 + AddrSize, 4);
   Section.emitIntVal(CIEOffset, 4);
   Section.emitIntVal(Address, AddrSize);
   Section.OS.write(FDEBytes.data(), FDEBytes.size());
 }
 
 Error DWARFLinkerImpl::LinkContext::cloneAndEmitPaperTrails() {
-
-  CompileUnits.emplace_back(
-      std::make_unique<CompileUnit>(GlobalData, UniqueUnitID.fetch_add(1), "",
-                                    InputDWARFFile, getUnitForOffset));
+  CompileUnits.emplace_back(std::make_unique<CompileUnit>(
+      GlobalData, UniqueUnitID.fetch_add(1), "", InputDWARFFile,
+      getUnitForOffset, Format, Endianness));
 
   CompileUnit &CU = *CompileUnits.back();
 
   BumpPtrAllocator Allocator;
 
   DIEGenerator ParentGenerator(Allocator, CU);
 
   SectionDescriptor &DebugInfoSection =

llvm/lib/DWARFLinkerParallel/OutputSections.h

 /// This class keeps contents and offsets to the debug sections. Any objects
 /// which is supposed to be emitted into the debug sections should use this
 /// class to track debug sections offsets and keep sections data.
 class OutputSections {
 public:
   OutputSections(LinkingGlobalData &GlobalData) : GlobalData(GlobalData) {}
 
   /// Sets output format for all keeping sections.
-  void setOutputFormat(DWARFUnit &OriginalUnit) {
-    setOutputFormat(OriginalUnit.getFormParams(),
-                    OriginalUnit.isLittleEndian() ? support::endianness::little
-                                                  : support::endianness::big);
-  }
-
-  /// Sets output format for all keeping sections.
   void setOutputFormat(dwarf::FormParams Format,
-                       support::endianness Endianess) {
+                       support::endianness Endianness) {
     this->Format = Format;
-    this->Endianess = Endianess;
+    this->Endianness = Endianness;
   }
 
   /// Returns descriptor for the specified section of \p SectionKind.
   std::optional<const SectionDescriptor *>
   getSectionDescriptor(DebugSectionKind SectionKind) const {
     SectionsSetTy::const_iterator It = SectionDescriptors.find(SectionKind);
 
     if (It == SectionDescriptors.end())
getSectionDescriptor(DebugSectionKind SectionKind) {
     return &It->second;
   }
 
   /// Returns descriptor for the specified section of \p SectionKind.
   /// If descriptor does not exist then create it.
   SectionDescriptor &
   getOrCreateSectionDescriptor(DebugSectionKind SectionKind) {
     return SectionDescriptors
-        .try_emplace(SectionKind, SectionKind, GlobalData, Format, Endianess)
+        .try_emplace(SectionKind, SectionKind, GlobalData, Format, Endianness)
         .first->second;
   }
 
   /// Erases data of all sections.
   void eraseSections() {
     for (auto &Section : SectionDescriptors)
       Section.second.erase();
   }
public:
   }
 
   /// Enumerate all sections, for each section apply all section patches.
   void applyPatches(SectionDescriptor &Section,
                     StringEntryToDwarfStringPoolEntryMap &DebugStrStrings,
                     StringEntryToDwarfStringPoolEntryMap &DebugLineStrStrings);
 
   /// Endiannes for the sections.
-  support::endianness getEndianness() const { return Endianess; }
+  support::endianness getEndianness() const { return Endianness; }
 
   /// Return DWARF version.
   uint16_t getVersion() const { return Format.Version; }
 
   /// Return size of header of debug_info table.
   uint16_t getDebugInfoHeaderSize() const {
     return Format.Version >= 5 ? 12 : 11;
   }

 
 protected:
   LinkingGlobalData &GlobalData;
 
   /// Format for sections.
   dwarf::FormParams Format = {4, 4, dwarf::DWARF32};
 
   /// Endiannes for sections.
-  support::endianness Endianess = support::endianness::little;
+  support::endianness Endianness = support::endian::system_endianness();
 
   /// All keeping sections.
   using SectionsSetTy = std::map<DebugSectionKind, SectionDescriptor>;
   SectionsSetTy SectionDescriptors;
 };
 
 } // end of namespace dwarflinker_parallel
 } // end namespace llvm
 
 #endif // LLVM_LIB_DWARFLINKERPARALLEL_OUTPUTSECTIONS_H

llvm/test/tools/dsymutil/X86/location-expression.test

 ## This test checks that size of DW_AT_location attribute
 ## of the DW_FORM_block1 form is correctly written to the
 ## output.
 
 # RUN: yaml2obj %s -o %t.o
 # RUN: echo '---' > %t2.map
 # RUN: echo "triple:          'x86_64-apple-darwin'" >> %t2.map
 # RUN: echo 'objects:'  >> %t2.map
 # RUN: echo " -  filename: '%t.o'" >> %t2.map
 # RUN: echo '    symbols:' >> %t2.map
 # RUN: echo '      - { sym: __Z3foov, objAddr: 0x0, binAddr: 0x10000, size: 0x10 }' >> %t2.map
 # RUN: echo '...' >> %t2.map
 # RUN: dsymutil -y %t2.map -f -o - | llvm-dwarfdump -a --verbose - | FileCheck %s
-# COM: dsymutil --linker llvm -y %t2.map -f -o - | llvm-dwarfdump -a --verbose - | FileCheck %s
+# RUN: dsymutil --linker llvm -y %t2.map -f -o - | llvm-dwarfdump -a --verbose - | FileCheck %s
 
 # CHECK: file format Mach-O 64-bit x86-64
 # CHECK: .debug_info contents:
 # CHECK: Compile Unit:
 # CHECK: DW_TAG_compile_unit
 # CHECK: DW_AT_name{{.*}}"CU1"
 # CHECK: 0x0000001b:   DW_TAG_variable
 # CHECK: DW_AT_name {{.*}}"var1"

llvm/test/tools/dsymutil/X86/tls-variable.test

 ## This test checks that thread local storage variables
 ## are preserved.
 
 # RUN: yaml2obj %s -o %t.o
 # RUN: echo '---' > %t2.map
 # RUN: echo "triple:          'x86_64-apple-darwin'" >> %t2.map
 # RUN: echo 'objects:'  >> %t2.map
 # RUN: echo " -  filename: '%t.o'" >> %t2.map
 # RUN: echo '    symbols:' >> %t2.map
 # RUN: echo '      - { sym: __Z3foov, objAddr: 0x0, binAddr: 0x10000, size: 0x10 }' >> %t2.map
 # RUN: echo '...' >> %t2.map
 # RUN: dsymutil -y %t2.map --keep-function-for-static -f -o - | llvm-dwarfdump -a - | FileCheck %s
-# COM: dsymutil --linker llvm -y %t2.map --keep-function-for-static -f -o - | llvm-dwarfdump -a - | FileCheck %s
+# RUN: dsymutil --linker llvm -y %t2.map --keep-function-for-static -f -o - | llvm-dwarfdump -a - | FileCheck %s
 
 # CHECK: file format Mach-O 64-bit x86-64
 # CHECK: .debug_info contents:
 # CHECK: Compile Unit:
 # CHECK: DW_TAG_compile_unit
 # CHECK: DW_AT_name{{.*}}"CU1"
 # CHECK: DW_TAG_subprogram
 # CHECK: DW_AT_name{{.*}}"foo"