[lld/mac] Use C++17 nested namespace syntax in most places

[thakis]

Summary

Some header files used

namespace lld {
namespace macho {
// ...
} // namespace macho
std::string toString(const Type &t);
} // namespace lld

In those files, I didn't use a nested namespace since it's not a big win there.

No behavior change.

[int3]

Neat!

lld/MachO/Arch/ARM64Common.h

 
 #include "InputFiles.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 
 #include "llvm/BinaryFormat/MachO.h"
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 
 struct ARM64Common : TargetInfo {
   template <class LP> ARM64Common(LP lp) : TargetInfo(lp) {}
 
   int64_t getEmbeddedAddend(MemoryBufferRef, uint64_t offset,
                             const llvm::MachO::relocation_info) const override;
   void relocateOne(uint8_t *loc, const Reloc &, uint64_t va,
                    uint64_t pc) const override;
inline void writeStubHelperEntry(uint8_t *buf8,
   auto pcVA = [entryVA](int i) { return entryVA + i * sizeof(uint32_t); };
   uint64_t stubHelperHeaderVA = in.stubHelper->addr;
   buf32[0] = stubHelperEntryCode[0];
   encodeBranch26(&buf32[1], {&sym, "stub helper"}, stubHelperEntryCode[1],
                  stubHelperHeaderVA - pcVA(1));
   buf32[2] = sym.lazyBindOffset;
 }
 
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho
 
 #endif

lld/MachO/ConcatOutputSection.h

 #define LLD_MACHO_CONCAT_OUTPUT_SECTION_H
 
 #include "InputSection.h"
 #include "OutputSection.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/MapVector.h"
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 
 class Defined;
 
 // Linking multiple files will inevitably mean resolving sections in different
 // files that are labeled with the same segment and section name. This class
 // contains all such sections and writes the data from each section sequentially
 // in the final binary.
 class ConcatOutputSection : public OutputSection {

 NamePair maybeRenameSection(NamePair key);
 
 // Output sections are added to output segments in iteration order
 // of ConcatOutputSection, so must have deterministic iteration order.
 extern llvm::MapVector<NamePair, ConcatOutputSection *> concatOutputSections;
 
 extern llvm::DenseMap<Symbol *, ThunkInfo> thunkMap;
 
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho
 
 #endif

lld/MachO/Driver.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 #include <set>
 #include <type_traits>
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 
 class DylibFile;
 class InputFile;
 
 class MachOOptTable : public llvm::opt::OptTable {
 public:
   MachOOptTable();
   llvm::opt::InputArgList parse(ArrayRef<const char *> argv);
private:
   // The paths need to be alphabetically ordered.
   // We need to own the paths because some of them are temporarily
   // constructed.
   std::set<std::string> notFounds;
 };
 
 extern std::unique_ptr<DependencyTracker> depTracker;
 
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho
 
 #endif

lld/MachO/Dwarf.h

 //===- DWARF.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 LLD_MACHO_DWARF_H
 #define LLD_MACHO_DWARF_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/DWARF/DWARFObject.h"
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 
 class ObjFile;
 
 // Implements the interface between LLVM's DWARF-parsing utilities and LLD's
 // InputSection structures.
 class DwarfObject final : public llvm::DWARFObject {
 public:
   bool isLittleEndian() const override { return true; }

 private:
   llvm::DWARFSection infoSection;
   llvm::DWARFSection lineSection;
   llvm::DWARFSection strOffsSection;
   llvm::StringRef abbrevSection;
   llvm::StringRef strSection;
 };
 
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho
 
 #endif

lld/MachO/EhFrame.h

  * An FDE comprises of the following:
  * 1. Length of the entry (4 or 12 bytes)
  * 2. CIE offset (4 bytes pcrel offset that points backwards to this FDE's CIE)
  * 3. Function address (pointer-sized pcrel offset)
  * 4. (Optional) Augmentation data length
  * 5. (Optional) LSDA address (pointer-sized pcrel offset)
  * 6. DWARF instructions (ignored by LLD)
  */
-namespace lld {
-namespace macho {
+namespace lld::macho {
 
 class EhReader {
 public:
   EhReader(const ObjFile *file, ArrayRef<uint8_t> data, size_t dataOff)
       : file(file), data(data), dataOff(dataOff) {}
   size_t size() const { return data.size(); }
   // Read and validate the length field.
   uint64_t readLength(size_t *off) const;

 
 private:
   InputSection *isec;
   // Insert new relocs here so that we don't invalidate iterators into the
   // existing relocs vector.
   SmallVector<Reloc, 6> newRelocs;
 };
 
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho
 
 #endif

lld/MachO/ExportTrie.h

 //===- ExportTrie.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 LLD_MACHO_EXPORT_TRIE_H
 #define LLD_MACHO_EXPORT_TRIE_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
 
 #include <vector>
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 
 struct TrieNode;
 class Symbol;
 
 class TrieBuilder {
 public:
   ~TrieBuilder();
   void setImageBase(uint64_t addr) { imageBase = addr; }
private:
   std::vector<TrieNode *> nodes;
 };
 
 using TrieEntryCallback =
     llvm::function_ref<void(const llvm::Twine & /*name*/, uint64_t /*flags*/)>;
 
 void parseTrie(const uint8_t *buf, size_t size, const TrieEntryCallback &);
 
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho
 
 #endif

lld/MachO/ICF.h

 //===- ICF.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 LLD_MACHO_ICF_H
 #define LLD_MACHO_ICF_H
 
 #include "InputFiles.h"
 #include "lld/Common/LLVM.h"
 #include <vector>
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 class Symbol;
 
 void markAddrSigSymbols();
 void markSymAsAddrSig(Symbol *s);
 void foldIdenticalSections(bool onlyCfStrings);
 
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho
 
 #endif

lld/MachO/LTO.h

 //===- LTO.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 LLD_MACHO_LTO_H
 #define LLD_MACHO_LTO_H
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <memory>
 #include <vector>
 
-namespace llvm {
-namespace lto {
+namespace llvm::lto {
 class LTO;
-} // namespace lto
-} // namespace llvm
+} // namespace llvm::lto
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 
 class BitcodeFile;
 class ObjFile;
 
 class BitcodeCompiler {
 public:
   BitcodeCompiler();
 
   void add(BitcodeFile &f);
   std::vector<ObjFile *> compile();
 
 private:
   std::unique_ptr<llvm::lto::LTO> ltoObj;
   std::vector<llvm::SmallString<0>> buf;
   std::vector<std::unique_ptr<llvm::MemoryBuffer>> files;
 };
 
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho
 
 #endif

lld/MachO/MachOStructs.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_MACHO_MACHO_STRUCTS_H
 #define LLD_MACHO_MACHO_STRUCTS_H
 
 #include "llvm/Support/Endian.h"
 
-namespace lld {
-
-namespace structs {
+namespace lld::structs {
 
 struct nlist_64 {
   llvm::support::ulittle32_t n_strx;
   uint8_t n_type;
   uint8_t n_sect;
   llvm::support::ulittle16_t n_desc;
   llvm::support::ulittle64_t n_value;
 };
 
 struct nlist {
   llvm::support::ulittle32_t n_strx;
   uint8_t n_type;
   uint8_t n_sect;
   llvm::support::ulittle16_t n_desc;
   llvm::support::ulittle32_t n_value;
 };
 
 struct entry_point_command {
   llvm::support::ulittle32_t cmd;
   llvm::support::ulittle32_t cmdsize;
   llvm::support::ulittle64_t entryoff;
   llvm::support::ulittle64_t stacksize;
 };
 
-} // namespace structs
-
-} // namespace lld
+} // namespace lld::structs
 
 #endif

lld/MachO/MapFile.h

 //===- MapFile.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 LLD_MACHO_MAPFILE_H
 #define LLD_MACHO_MAPFILE_H
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 void writeMapFile();
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho
 
 #endif

lld/MachO/MarkLive.h

 //===- MarkLive.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 LLD_MACHO_MARKLIVE_H
 #define LLD_MACHO_MARKLIVE_H
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 
 void markLive();
 
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho
 
 #endif // LLD_MACHO_MARKLIVE_H

lld/MachO/MarkLive.cpp

 #include "Config.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "UnwindInfoSection.h"
 #include "mach-o/compact_unwind_encoding.h"
 #include "llvm/Support/TimeProfiler.h"
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 
 using namespace llvm;
 using namespace llvm::MachO;
 
 struct WhyLiveEntry {
   InputSection *isec;
   // Keep track of the entry that caused us to mark `isec` as live.
   const WhyLiveEntry *prev;
if (sectionType(isec->getFlags()) == S_MOD_INIT_FUNC_POINTERS ||
       marker->enqueue(isec, 0);
       continue;
     }
   }
 
   marker->markTransitively();
 }
 
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho

lld/MachO/ObjC.h

 //===- ObjC.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 LLD_MACHO_OBJC_H
 #define LLD_MACHO_OBJC_H
 
 #include "llvm/Support/MemoryBuffer.h"
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 
 namespace objc {
 
 constexpr const char klass[] = "_OBJC_CLASS_$_";
 constexpr const char metaclass[] = "_OBJC_METACLASS_$_";
 constexpr const char ehtype[] = "_OBJC_EHTYPE_$_";
 constexpr const char ivar[] = "_OBJC_IVAR_$_";
 
 } // namespace objc
 
 bool hasObjCSection(llvm::MemoryBufferRef);
 
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho
 
 #endif

lld/MachO/OutputSection.h

 
 #include "Symbols.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/TinyPtrVector.h"
 
 #include <limits>
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 
 class Defined;
 class InputSection;
 class OutputSegment;
 
 // The default order value for OutputSections that are not constructed from
 // InputSections (i.e. SyntheticSections). We make it less than INT_MAX in order
 // not to conflict with the ordering of zerofill sections, which must always be
public:
   uint32_t flags = 0;
   uint32_t reserved1 = 0;
   uint32_t reserved2 = 0;
 
 private:
   Kind sectionKind;
 };
 
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho
 
 #endif

lld/MachO/OutputSegment.h

 #include "OutputSection.h"
 #include "Symbols.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/TinyPtrVector.h"
 
 #include <limits>
 #include <vector>
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 
 namespace segment_names {
 
 constexpr const char dataConst[] = "__DATA_CONST";
 constexpr const char dataDirty[] = "__DATA_DIRTY";
 constexpr const char data[] = "__DATA";
 constexpr const char dwarf[] = "__DWARF";
 constexpr const char import[] = "__IMPORT";

 
 extern std::vector<OutputSegment *> outputSegments;
 
 void sortOutputSegments();
 void resetOutputSegments();
 
 OutputSegment *getOrCreateOutputSegment(StringRef name);
 
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho
 
 #endif

lld/MachO/Relocations.h

 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Support/Endian.h"
 
 #include <cstddef>
 #include <cstdint>
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 
 class Symbol;
 class InputSection;
 
 enum class RelocAttrBits {
   _0 = 0,              // invalid
   PCREL = 1 << 0,      // Value is PC-relative offset
case 3:
     break;
   default:
     llvm_unreachable("invalid r_length");
   }
 }
 
 extern const RelocAttrs invalidRelocAttrs;
 
-} // namespace macho
-} // namespace lld
+} // namespace lld::Macho
 
 #endif

lld/MachO/SectionPriorities.h

 //===- SectionPriorities.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 LLD_MACHO_SECTION_PRIORITIES_H
 #define LLD_MACHO_SECTION_PRIORITIES_H
 
 #include "InputSection.h"
 #include "llvm/ADT/DenseMap.h"
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 
 using SectionPair = std::pair<const InputSection *, const InputSection *>;
 
 class PriorityBuilder {
 public:
   // Reads every input section's call graph profile, and combines them into
   // callGraphProfile. If an order file is present, any edges where one or both
   // of the vertices are specified in the order file are discarded.
private:
   };
 
   llvm::Optional<size_t> getSymbolPriority(const Defined *sym);
   llvm::DenseMap<llvm::StringRef, SymbolPriorityEntry> priorities;
   llvm::MapVector<SectionPair, uint64_t> callGraphProfile;
 };
 
 extern PriorityBuilder priorityBuilder;
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho
 
 #endif

lld/MachO/SymbolTable.h

 
 #include "Symbols.h"
 
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Object/Archive.h"
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 
 class ArchiveFile;
 class DylibFile;
 class InputFile;
 class ObjFile;
 class InputSection;
 class MachHeaderSection;
 class Symbol;

 
 // Call reportPendingUndefinedSymbols() to emit diagnostics.
 void treatUndefinedSymbol(const Undefined &, StringRef source);
 void treatUndefinedSymbol(const Undefined &, const InputSection *,
                           uint64_t offset);
 
 extern std::unique_ptr<SymbolTable> symtab;
 
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho
 
 #endif

lld/MachO/SyntheticSections.h

 #include "llvm/Support/raw_ostream.h"
 
 #include <unordered_map>
 
 namespace llvm {
 class DWARFUnit;
 } // namespace llvm
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 
 class Defined;
 class DylibSymbol;
 class LoadCommand;
 class ObjFile;
 class UnwindInfoSection;
 
 class SyntheticSection : public OutputSection {
struct InStruct {
   ConcatInputSection *imageLoaderCache = nullptr;
 };
 
 extern InStruct in;
 extern std::vector<SyntheticSection *> syntheticSections;
 
 void createSyntheticSymbols();
 
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho
 
 #endif

lld/MachO/Target.h

 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 #include <cstddef>
 #include <cstdint>
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 
 class Symbol;
 class Defined;
 class DylibSymbol;
 class InputSection;
 class ConcatInputSection;
 
static constexpr uint32_t encryptionInfoLCType =
       llvm::MachO::LC_ENCRYPTION_INFO;
 
   static constexpr uint64_t pageZeroSize = 1ull << 12;
   static constexpr size_t wordSize = 4;
 };
 
 extern TargetInfo *target;
 
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho
 
 #endif

lld/MachO/UnwindInfoSection.h

 #define LLD_MACHO_UNWIND_INFO_H
 
 #include "ConcatOutputSection.h"
 #include "SyntheticSections.h"
 #include "llvm/ADT/MapVector.h"
 
 #include "mach-o/compact_unwind_encoding.h"
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 
 class UnwindInfoSection : public SyntheticSection {
 public:
   // If all functions are free of unwind info, we can omit the unwind info
   // section entirely.
   bool isNeeded() const override { return !allEntriesAreOmitted; }
   void addSymbol(const Defined *);
   virtual void prepareRelocations() = 0;
 
 protected:
   UnwindInfoSection();
 
   llvm::MapVector<std::pair<const InputSection *, uint64_t /*Defined::value*/>,
                   const Defined *>
       symbols;
   bool allEntriesAreOmitted = true;
 };
 
 UnwindInfoSection *makeUnwindInfoSection();
 
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho
 
 #endif

lld/MachO/Writer.h

 //===- Writer.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 LLD_MACHO_WRITER_H
 #define LLD_MACHO_WRITER_H
 
 #include <cstdint>
 
-namespace lld {
-namespace macho {
+namespace lld::macho {
 
 class OutputSection;
 class InputSection;
 class Symbol;
 
 class LoadCommand {
 public:
   virtual ~LoadCommand() = default;
   virtual uint32_t getSize() const = 0;
   virtual void writeTo(uint8_t *buf) const = 0;
 };
 
 template <class LP> void writeResult();
 void resetWriter();
 
 void createSyntheticSections();
 
 // Add bindings for symbols that need weak or non-lazy bindings.
 void addNonLazyBindingEntries(const Symbol *, const InputSection *,
                               uint64_t offset, int64_t addend = 0);
 
 extern OutputSection *firstTLVDataSection;
 
-} // namespace macho
-} // namespace lld
+} // namespace lld::macho
 
 #endif