[lld][WebAssembly] Use C++17 nested namespace syntax in most places. NFC

[sbc100]

Summary

Like D131405, but for wasm-ld.

lld/wasm/Config.h

 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/Support/CachePruning.h"
 #include <optional>
 
 namespace llvm::CodeGenOpt {
 enum Level : int;
 } // namespace llvm::CodeGenOpt
 
-namespace lld {
-namespace wasm {
+namespace lld::wasm {
 
 // For --unresolved-symbols.
 enum class UnresolvedPolicy { ReportError, Warn, Ignore, ImportDynamic };
 
 // For --build-id.
 enum class BuildIdKind { None, Fast, Sha1, Hexstring, Uuid };
 
 // This struct contains the global configuration for the linker.
struct Configuration {
   // Will be set to true if bss data segments should be emitted. In most cases
   // this is not necessary.
   bool emitBssSegments = false;
 };
 
 // The only instance of Configuration struct.
 extern Configuration *config;
 
-} // namespace wasm
-} // namespace lld
+} // namespace lld::wasm
 
 #endif

lld/wasm/Driver.cpp

 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::sys;
 using namespace llvm::wasm;
 
-namespace lld {
-namespace wasm {
+namespace lld::wasm {
 Configuration *config;
 
 namespace {
 
 // Create enum with OPT_xxx values for each option in Options.td
 enum {
   OPT_INVALID = 0,
 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
 
   if (errorCount())
     return;
 
   // Write the result to the file.
   writeResult();
 }
 
-} // namespace wasm
-} // namespace lld
+} // namespace wasm::lld

lld/wasm/LTO.h

 #include <vector>
 
 namespace llvm {
 namespace lto {
 class LTO;
 }
 } // namespace llvm
 
-namespace lld {
-namespace wasm {
+namespace lld::wasm {
 
 class BitcodeFile;
 class InputFile;
 
 class BitcodeCompiler {
 public:
   BitcodeCompiler();
   ~BitcodeCompiler();
 
   void add(BitcodeFile &f);
   std::vector<StringRef> compile();
 
 private:
   std::unique_ptr<llvm::lto::LTO> ltoObj;
   std::vector<SmallString<0>> buf;
   std::vector<std::unique_ptr<MemoryBuffer>> files;
 };
-} // namespace wasm
-} // namespace lld
+} // namespace lld::wasm
 
 #endif

lld/wasm/LTO.cpp

 #include <cstddef>
 #include <memory>
 #include <string>
 #include <system_error>
 #include <vector>
 
 using namespace llvm;
 
-namespace lld {
-namespace wasm {
+namespace lld::wasm {
 static std::unique_ptr<lto::LTO> createLTO() {
   lto::Config c;
   c.Options = initTargetOptionsFromCodeGenFlags();
 
   // Always emit a section per function/data with LTO.
   c.Options.FunctionSections = true;
   c.Options.DataSections = true;
 
std::vector<StringRef> BitcodeCompiler::compile() {
 
   for (std::unique_ptr<MemoryBuffer> &file : files)
     if (file)
       ret.push_back(file->getBuffer());
 
   return ret;
 }
 
-} // namespace wasm
-} // namespace lld
+} // namespace lld::wasm

lld/wasm/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_WASM_MAPFILE_H
 #define LLD_WASM_MAPFILE_H
 
 #include "llvm/ADT/ArrayRef.h"
 
-namespace lld {
-namespace wasm {
+namespace lld::wasm {
 class OutputSection;
 void writeMapFile(llvm::ArrayRef<OutputSection *> outputSections);
-} // namespace wasm
-} // namespace lld
+} // namespace lld::wasm
 
 #endif

lld/wasm/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_WASM_MARKLIVE_H
 #define LLD_WASM_MARKLIVE_H
 
-namespace lld {
-namespace wasm {
+namespace lld::wasm {
 
 void markLive();
 
-} // namespace wasm
-} // namespace lld
+} // namespace lld::wasm
 
 #endif // LLD_WASM_MARKLIVE_H

lld/wasm/MarkLive.cpp

 #include "SymbolTable.h"
 #include "Symbols.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 
-namespace lld {
-namespace wasm {
+namespace lld::wasm {
 
 namespace {
 
 class MarkLive {
 public:
   void run();
 
 private:
for (const WasmInitFunc &f : l.InitFunctions) {
       if (!sym->isDiscarded() && sym->isLive())
         return true;
     }
   }
 
   return false;
 }
 
-} // namespace wasm
-} // namespace lld
+} // namespace lld::wasm

lld/wasm/OutputSegment.h

 //===- OutputSegment.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_WASM_OUTPUT_SEGMENT_H
 #define LLD_WASM_OUTPUT_SEGMENT_H
 
 #include "InputChunks.h"
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/Object/Wasm.h"
 
-namespace lld {
-namespace wasm {
+namespace lld::wasm {
 
 class InputSegment;
 
 class OutputSegment {
 public:
   OutputSegment(StringRef n) : name(n) {}
 
   void addInputSegment(InputChunk *inSeg);
public:
 
   // Sum of the size of the all the input segments
   uint32_t size = 0;
 
   // Segment header
   std::string header;
 };
 
-} // namespace wasm
-} // namespace lld
+} // namespace lld::wasm
 
 #endif // LLD_WASM_OUTPUT_SEGMENT_H

lld/wasm/OutputSegment.cpp

 #include "InputChunks.h"
 #include "lld/Common/Memory.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 
-namespace lld {
-
-namespace wasm {
+namespace lld::wasm {
 
 void OutputSegment::addInputSegment(InputChunk *inSeg) {
   alignment = std::max(alignment, inSeg->alignment);
   inputSegments.push_back(inSeg);
   size = llvm::alignTo(size, 1ULL << inSeg->alignment);
   LLVM_DEBUG(dbgs() << "addInputSegment: " << inSeg->name << " oname=" << name
                     << " size=" << inSeg->getSize()
                     << " align=" << inSeg->alignment << " at:" << size << "\n");
for (InputChunk *seg : inputSegments) {
     size = llvm::alignTo(size, 1ULL << seg->alignment);
     LLVM_DEBUG(llvm::dbgs() << "outputSegmentOffset set: " << seg->name
                             << " -> " << size << "\n");
     seg->outputSegmentOffset = size;
     size += seg->getSize();
   }
 }
 
-} // namespace wasm
-} // namespace lld
+} // namespace lld::wasm

lld/wasm/Relocations.h

 //===- Relocations.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_WASM_RELOCATIONS_H
 #define LLD_WASM_RELOCATIONS_H
 
-namespace lld {
-namespace wasm {
+namespace lld::wasm {
 
 class InputChunk;
 
 void scanRelocations(InputChunk *chunk);
 
-} // namespace wasm
-} // namespace lld
+} // namespace lld::wasm
 
 #endif

lld/wasm/Relocations.cpp

 #include "InputChunks.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "SyntheticSections.h"
 
 using namespace llvm;
 using namespace llvm::wasm;
 
-namespace lld {
-namespace wasm {
+namespace lld::wasm {
 
 static bool requiresGOTAccess(const Symbol *sym) {
   if (!config->isPic &&
       config->unresolvedSymbols != UnresolvedPolicy::ImportDynamic)
     return false;
   if (sym->isHidden() || sym->isLocal())
     return false;
   // With `-Bsymbolic` (or when building an executable) as don't need to use
if (config->isPic ||
       }
     } else if (sym->isUndefined() && !config->relocatable && !sym->isWeak()) {
       // Report undefined symbols
       reportUndefined(sym);
     }
   }
 }
 
-} // namespace wasm
-} // namespace lld
+} // namespace lld::wasm

lld/wasm/SymbolTable.h

 #include "LTO.h"
 #include "Symbols.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/BinaryFormat/WasmTraits.h"
 #include <optional>
 
-namespace lld {
-namespace wasm {
+namespace lld::wasm {
 
 class InputSegment;
 
 // SymbolTable is a bucket of all known symbols, including defined,
 // undefined, or lazy symbols (the last one is symbols in archive
 // files whose archive members are not yet loaded).
 //
 // We put all symbols of all files to a SymbolTable, and the
private:
   llvm::DenseSet<llvm::CachedHashStringRef> comdatGroups;
 
   // For LTO.
   std::unique_ptr<BitcodeCompiler> lto;
 };
 
 extern SymbolTable *symtab;
 
-} // namespace wasm
-} // namespace lld
+} // namespace lld::wasm
 
 #endif

lld/wasm/SymbolTable.cpp

 #include <optional>
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 using namespace llvm::object;
 
-namespace lld {
-namespace wasm {
+namespace lld::wasm {
 SymbolTable *symtab;
 
 void SymbolTable::addFile(InputFile *file) {
   log("Processing: " + toString(file));
 
   // .a file
   if (auto *f = dyn_cast<ArchiveFile>(file)) {
     f->parse();
for (auto *symbol : variants) {
         StringRef debugName =
             saver().save("signature_mismatch:" + toString(*f));
         replaceWithUnreachable(f, *f->signature, debugName);
       }
     }
   }
 }
 
-} // namespace wasm
-} // namespace lld
+} // namespace wasm::lld

lld/wasm/SyntheticSections.h

 
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/BinaryFormat/WasmTraits.h"
 #include <optional>
 
 #define DEBUG_TYPE "lld"
 
-namespace lld {
-namespace wasm {
+namespace lld::wasm {
 
 // An init entry to be written to either the synthetic init func or the
 // linking metadata.
 struct WasmInitEntry {
   const FunctionSymbol *sym;
   uint32_t priority;
 };
 

 };
 
 template <typename T>
 inline bool operator==(const ImportKey<T> &lhs, const ImportKey<T> &rhs) {
   return lhs.state == rhs.state && lhs.importModule == rhs.importModule &&
          lhs.importName == rhs.importName && lhs.type == rhs.type;
 }
 
-} // namespace wasm
-} // namespace lld
+} // namespace wasm::lld
 
 // `ImportKey<T>` can be used as a key in a `DenseMap` if `T` can be used as a
 // key in a `DenseMap`.
 namespace llvm {
 template <typename T> struct DenseMapInfo<lld::wasm::ImportKey<T>> {
   static lld::wasm::ImportKey<T> getEmptyKey() {
     typename lld::wasm::ImportKey<T> key(llvm::DenseMapInfo<T>::getEmptyKey());
     key.state = lld::wasm::ImportKey<T>::State::Empty;

lld/wasm/SyntheticSections.cpp

 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "llvm/Support/Path.h"
 #include <optional>
 
 using namespace llvm;
 using namespace llvm::wasm;
 
-namespace lld {
-namespace wasm {
+namespace lld::wasm {
 
 OutStruct out;
 
 namespace {
 
 // Some synthetic sections (e.g. "name" and "linking") have subsections.
 // Just like the synthetic sections themselves these need to be created before
 // they can be written out (since they are preceded by their length). This

 
 void BuildIdSection::writeBuildId(llvm::ArrayRef<uint8_t> buf) {
   assert(buf.size() == hashSize);
   LLVM_DEBUG(dbgs() << "buildid write " << buf.size() << " "
                     << hashPlaceholderPtr << '\n');
   memcpy(hashPlaceholderPtr, buf.data(), hashSize);
 }
 
-} // namespace wasm
-} // namespace lld
+} // namespace wasm::lld

lld/wasm/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_WASM_WRITER_H
 #define LLD_WASM_WRITER_H
 
-namespace lld {
-namespace wasm {
+namespace lld::wasm {
 
 void writeResult();
 
-} // namespace wasm
-} // namespace lld
+} // namespace lld::wasm
 
 #endif

lld/wasm/Writer.cpp

 #include <map>
 #include <optional>
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 
-namespace lld {
-namespace wasm {
+namespace lld::wasm {
 static constexpr int stackAlignment = 16;
 static constexpr int heapAlignment = 16;
 
 namespace {
 
 // The writer writes a SymbolTable result to a file.
 class Writer {
 public:
void Writer::createHeader() {
   writeBytes(os, WasmMagic, sizeof(WasmMagic), "wasm magic");
   writeU32(os, WasmVersion, "wasm version");
   os.flush();
   fileSize += header.size();
 }
 
 void writeResult() { Writer().run(); }
 
-} // namespace wasm
-} // namespace lld
+} // namespace wasm::lld