[dsymutil] Delete unneeded parameter Triple from DWARFLinker

[avl]

Hi Fangrui, you are absolutely correct. This llvm::Triple looks redundant. I have to do this and other similar cleanups. I was thinking about following change:

diff --git a/llvm/tools/dsymutil/DwarfStreamer.cpp b/llvm/tools/dsymutil/DwarfStreamer.cpp
index de20d9a3478..a219a7542d2 100644
--- a/llvm/tools/dsymutil/DwarfStreamer.cpp
+++ b/llvm/tools/dsymutil/DwarfStreamer.cpp
@@ -220,13 +220,13 @@ void DwarfStreamer::emitSectionContents(const object::ObjectFile &Obj,
 }
 
 /// Emit DIE containing warnings.
-void DwarfStreamer::emitPaperTrailWarningsDie(const Triple &Triple, DIE &Die) {
+void DwarfStreamer::emitPaperTrailWarningsDie(DIE &Die) {
   switchToDebugInfoSection(/* Version */ 2);
   auto &Asm = getAsmPrinter();
   Asm.emitInt32(11 + Die.getSize() - 4);
   Asm.emitInt16(2);
   Asm.emitInt32(0);
-  Asm.emitInt8(Triple.isArch64Bit() ? 8 : 4);
+  Asm.emitInt8(MOFI->getTargetTriple().isArch64Bit() ? 8 : 4);
   DebugInfoSectionSize += 11;
   emitDIE(Die);
 }

[MaskRay]

Adopt avl's suggestion

[JDevlieghere]

Great, thank you!

llvm/include/llvm/DWARFLinker/DWARFLinker.h

 };
 
 /// DwarfEmitter presents interface to generate all debug info tables.
 class DwarfEmitter {
 public:
   virtual ~DwarfEmitter();
 
   /// Emit DIE containing warnings.
-  virtual void emitPaperTrailWarningsDie(const Triple &Triple, DIE &Die) = 0;
+  virtual void emitPaperTrailWarningsDie(DIE &Die, bool IsArch64Bit) = 0;
 
   /// Emit section named SecName with content equals to
   /// corresponding section in Obj.
   virtual void emitSectionContents(const object::ObjectFile &Obj,
                                    StringRef SecName) = 0;
 
   /// Emit the abbreviation table \p Abbrevs to the debug_abbrev section.
   virtual void

 ///
 /// The root DIEs are identified because they contain relocations that
 /// points to code section(the low_pc for a function, the location for
 /// a variable). These relocations are called ValidRelocs in the
 /// AddressesInfo and are gathered as a very first step when we start
 /// processing a object file.
 class DWARFLinker {
 public:
-  DWARFLinker(const Triple &Triple, DwarfEmitter *Emitter,
+  DWARFLinker(bool IsArch64Bit, DwarfEmitter *Emitter,
               DwarfLinkerClient ClientID = DwarfLinkerClient::General)
-      : TheTriple(Triple), TheDwarfEmitter(Emitter),
+      : TheDwarfEmitter(Emitter), IsArch64Bit(IsArch64Bit),
         DwarfLinkerClientID(ClientID) {}
 
   /// Add object file to be linked.
   void addObjectFile(DwarfLinkerObjFile &ObjFile);
 
   /// Link debug info for added objFiles. Object
   /// files are linked all together.
   bool link();
private:
 
   /// DIEBlock objects that need to be destructed (but not freed!).
   std::vector<DIEBlock *> DIEBlocks;
 
   /// Allocator used for all the DIEValue objects.
   BumpPtrAllocator DIEAlloc;
   /// @}
 
-  Triple TheTriple;
-
   DwarfEmitter *TheDwarfEmitter;
   std::vector<LinkContext> ObjectContexts;
 
   unsigned MaxDwarfVersion = 0;
   unsigned MinDwarfVersion = std::numeric_limits<unsigned>::max();
 
   bool AtLeastOneAppleAccelTable = false;
   bool AtLeastOneDwarfAccelTable = false;
 
+  bool IsArch64Bit;
+
   /// The CIEs that have been emitted in the output section. The actual CIE
   /// data serves a the key to this StringMap, this takes care of comparing the
   /// semantics of CIEs defined in different object files.
   StringMap<uint32_t> EmittedCIEs;
 
   /// Offset of the last CIE that has been emitted in the output
   /// debug_frame section.
   uint32_t LastCIEOffset = 0;

llvm/lib/DWARFLinker/DWARFLinker.cpp

bool DWARFLinker::emitPaperTrailWarnings(const DwarfLinkerObjFile &OF,
   // Abbreviation ordering needed for classic compatibility.
   for (auto &Child : CUDie->children()) {
     Abbrev = Child.generateAbbrev();
     assignAbbrev(Abbrev);
     Child.setAbbrevNumber(Abbrev.getNumber());
     Size += getULEB128Size(Abbrev.getNumber());
   }
   CUDie->setSize(Size);
-  TheDwarfEmitter->emitPaperTrailWarningsDie(TheTriple, *CUDie);
+  TheDwarfEmitter->emitPaperTrailWarningsDie(*CUDie, IsArch64Bit);
 
   return true;
 }
 
 void DWARFLinker::copyInvariantDebugSection(const object::ObjectFile &Obj) {
   if (!needToTranslateStrings())
     TheDwarfEmitter->emitSectionContents(Obj, "debug_line");
   TheDwarfEmitter->emitSectionContents(Obj, "debug_loc");

llvm/tools/dsymutil/DwarfLinkerForBinary.cpp

 bool DwarfLinkerForBinary::link(const DebugMap &Map) {
   if (!createStreamer(Map.getTriple(), OutFile))
     return false;
 
   ObjectsForLinking.clear();
 
   DebugMap DebugMap(Map.getTriple(), Map.getBinaryPath());
 
-  DWARFLinker GeneralLinker(Map.getTriple(), Streamer.get(),
+  DWARFLinker GeneralLinker(Map.getTriple().isArch64Bit(), Streamer.get(),
                             DwarfLinkerClient::Dsymutil);
 
   remarks::RemarkLinker RL;
   if (!Options.RemarksPrependPath.empty())
     RL.setExternalFilePrependPath(Options.RemarksPrependPath);
 
   std::function<StringRef(StringRef)> TranslationLambda = [&](StringRef Input) {
     assert(Options.Translator);

llvm/tools/dsymutil/DwarfStreamer.h

public:
   /// Recursively emit the DIE tree rooted at \p Die.
   void emitDIE(DIE &Die) override;
 
   /// Emit the abbreviation table \p Abbrevs to the debug_abbrev section.
   void emitAbbrevs(const std::vector<std::unique_ptr<DIEAbbrev>> &Abbrevs,
                    unsigned DwarfVersion) override;
 
   /// Emit DIE containing warnings.
-  void emitPaperTrailWarningsDie(const Triple &Triple, DIE &Die) override;
+  void emitPaperTrailWarningsDie(DIE &Die, bool IsArch64Bit) override;
 
   /// Emit contents of section SecName From Obj.
   void emitSectionContents(const object::ObjectFile &Obj,
                            StringRef SecName) override;
 
   /// Emit the string table described by \p Pool.
   void emitStrings(const NonRelocatableStringpool &Pool) override;
 

llvm/tools/dsymutil/DwarfStreamer.cpp

if (auto Sec = getSectionByName(Obj, SecName)) {
         MS->EmitBytes(*E);
       else
         consumeError(E.takeError());
     }
   }
 }
 
 /// Emit DIE containing warnings.
-void DwarfStreamer::emitPaperTrailWarningsDie(const Triple &Triple, DIE &Die) {
+void DwarfStreamer::emitPaperTrailWarningsDie(DIE &Die, bool IsArch64Bit) {
   switchToDebugInfoSection(/* Version */ 2);
   auto &Asm = getAsmPrinter();
   Asm.emitInt32(11 + Die.getSize() - 4);
   Asm.emitInt16(2);
   Asm.emitInt32(0);
-  Asm.emitInt8(Triple.isArch64Bit() ? 8 : 4);
+  Asm.emitInt8(IsArch64Bit ? 8 : 4);
   DebugInfoSectionSize += 11;
   emitDIE(Die);
 }
 
 /// Emit the debug_str section stored in \p Pool.
 void DwarfStreamer::emitStrings(const NonRelocatableStringpool &Pool) {
   Asm->OutStreamer->SwitchSection(MOFI->getDwarfStrSection());
   std::vector<DwarfStringPoolEntryRef> Entries = Pool.getEntriesForEmission();