Remove namespace lld { namespace coff { from COFF LLD cpp files

[rnk]

Summary

Instead, use using namespace lld(::coff), and fully qualify the names
of free functions where they are defined in cpp files.

This effectively reverts d79c3be618 to follow the new style guide added
in 236fcbc21a7a8872.

[MaskRay]

lld/COFF/DebugTypes.cpp

23–24

Other files using namespace lld before llvm.

[rnk]

• adjust namespace using

lld/COFF/DebugTypes.cpp

23–24

That's true. Actually, I'm not sure I like it. I started just feeding these blocks to vim :sort, but now it makes them like this:

using namespace lld::coff;
using namespace lld;
using namespace llvm::codeview;
using namespace llvm;

This seems kind of wrong, it's better to go most general to most specific. At the very least, we should use lld before lld::coff. By the same reasoning, we could put llvm before lld, since it has general things like ADT, StringRef, etc.

[MaskRay]

lld/COFF/DebugTypes.cpp

23–24

For #includes, we follow this order:

• Main Module Header
• Local/Private Headers
• LLVM project/subproject headers (clang/..., lldb/..., llvm/..., etc)
• System #includes

lld headers are included before LLVM headers. Now it becomes unclear to me why for using directives we follow a different convention......

[rnk]

lld/COFF/DebugTypes.cpp

23–24

I don't think we have rules because it really hasn't come up. LLVM just doesn't have that many namespaces, just llvm::, clang::, and some small per-library namespaces in that area. So we only ever have two or so using namespace decls in most source code. I don't feel like the header guidelines define an ordering between the project headers. For example, llvm includes and clang includes are part of the same block, sorted alphabetically.

In any case, as written now, it is closer to a straight revert. Should we do that and decide on namespace ordering rules another time?

lld/COFF/DebugTypes.cpp

 #include "llvm/DebugInfo/PDB/GenericError.h"
 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Native/NativeSession.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
 #include "llvm/Support/Path.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
-
-namespace lld {
-namespace coff {
+using namespace lld;
+using namespace lld::coff;
 
 namespace {
 // The TypeServerSource class represents a PDB type server, a file referenced by
 // OBJ files compiled with MSVC /Zi. A single PDB can be shared by several OBJ
 // files, therefore there must be only once instance per OBJ lot. The file path
 // is discovered from the dependent OBJ's debug type stream. The
 // TypeServerSource object is then queued and loaded by the COFF Driver. The
 // debug type stream for such PDB files will be merged first in the final PDB,
public:
   // Information about the Precomp OBJ dependency, that needs to be loaded in
   // before merging this OBJ.
   PrecompRecord precompDependency;
 };
 } // namespace
 
 TpiSource::TpiSource(TpiKind k, const ObjFile *f) : kind(k), file(f) {}
 
-TpiSource *makeTpiSource(const ObjFile *f) {
+TpiSource *lld::coff::makeTpiSource(const ObjFile *f) {
   return make<TpiSource>(TpiSource::Regular, f);
 }
 
-TpiSource *makeUseTypeServerSource(const ObjFile *f,
+TpiSource *lld::coff::makeUseTypeServerSource(const ObjFile *f,
                                               const TypeServer2Record *ts) {
   TypeServerSource::enqueue(f, *ts);
   return make<UseTypeServerSource>(f, ts);
 }
 
-TpiSource *makePrecompSource(const ObjFile *f) {
+TpiSource *lld::coff::makePrecompSource(const ObjFile *f) {
   return make<PrecompSource>(f);
 }
 
-TpiSource *makeUsePrecompSource(const ObjFile *f,
+TpiSource *lld::coff::makeUsePrecompSource(const ObjFile *f,
                                            const PrecompRecord *precomp) {
   return make<UsePrecompSource>(f, precomp);
 }
 
+namespace lld {
+namespace coff {
 template <>
 const PrecompRecord &retrieveDependencyInfo(const TpiSource *source) {
   assert(source->kind == TpiSource::UsingPCH);
   return ((const UsePrecompSource *)source)->precompDependency;
 }
 
 template <>
 const TypeServer2Record &retrieveDependencyInfo(const TpiSource *source) {
   assert(source->kind == TpiSource::UsingPDB);
   return ((const UseTypeServerSource *)source)->typeServerDependency;
 }
+} // namespace coff
+} // namespace lld
 
 std::map<std::string, std::pair<std::string, TypeServerSource *>>
     TypeServerSource::instances;
 
 // Make a PDB path assuming the PDB is in the same folder as the OBJ
 static std::string getPdbBaseName(const ObjFile *file, StringRef tSPath) {
   StringRef localPath =
       !file->parentName.empty() ? file->parentName : file->getName();
return createFileError(
         ts.Name,
         make_error<pdb::PDBError>(pdb::pdb_error_code::signature_out_of_date));
 
   return pdb.second;
 }
 
 // FIXME: Temporary interface until PDBLinker::maybeMergeTypeServerPDB() is
 // moved here.
-Expected<llvm::pdb::NativeSession *> findTypeServerSource(const ObjFile *f) {
+Expected<llvm::pdb::NativeSession *>
+lld::coff::findTypeServerSource(const ObjFile *f) {
   Expected<TypeServerSource *> ts = TypeServerSource::findFromFile(f);
   if (!ts)
     return ts.takeError();
   return ts.get()->session.get();
 }
 
 // Queue a PDB type server for loading in the COFF Driver
 void TypeServerSource::enqueue(const ObjFile *dependentFile,
void TypeServerSource::enqueue(const ObjFile *dependentFile,
   driver->enqueuePath(*p, false, false);
 }
 
 // Create an instance of TypeServerSource or an error string if the PDB couldn't
 // be loaded. The error message will be displayed later, when the referring OBJ
 // will be merged in. NOTE - a PDB load failure is not a link error: some
 // debug info will simply be missing from the final PDB - that is the default
 // accepted behavior.
-void loadTypeServerSource(llvm::MemoryBufferRef m) {
+void lld::coff::loadTypeServerSource(llvm::MemoryBufferRef m) {
   std::string path = normalizePdbPath(m.getBufferIdentifier());
 
   Expected<TypeServerSource *> ts = TypeServerSource::getInstance(m);
   if (!ts)
     TypeServerSource::instances[path] = {toString(ts.takeError()), nullptr};
   else
     TypeServerSource::instances[path] = {{}, *ts};
 }
Expected<TypeServerSource *> TypeServerSource::getInstance(MemoryBufferRef m) {
 
   pdb::PDBFile &pdbFile = session->getPDBFile();
   Expected<pdb::InfoStream &> info = pdbFile.getPDBInfoStream();
   // All PDB Files should have an Info stream.
   if (!info)
     return info.takeError();
   return make<TypeServerSource>(m, session.release());
 }
-
-} // namespace coff
-} // namespace lld

lld/COFF/InputFiles.cpp

 #include <system_error>
 #include <utility>
 
 using namespace llvm;
 using namespace llvm::COFF;
 using namespace llvm::codeview;
 using namespace llvm::object;
 using namespace llvm::support::endian;
+using namespace lld;
+using namespace lld::coff;
 
 using llvm::Triple;
 using llvm::support::ulittle32_t;
 
-namespace lld {
-
 // Returns the last element of a path, which is supposed to be a filename.
 static StringRef getBasename(StringRef path) {
   return sys::path::filename(path, sys::path::Style::windows);
 }
 
 // Returns a string in the format of "foo.obj" or "foo.obj(bar.lib)".
-std::string toString(const coff::InputFile *file) {
+std::string lld::toString(const coff::InputFile *file) {
   if (!file)
     return "<internal>";
   if (file->parentName.empty() || file->kind() == coff::InputFile::ImportKind)
     return std::string(file->getName());
 
   return (getBasename(file->parentName) + "(" + getBasename(file->getName()) +
           ")")
       .str();
 }
 
-namespace coff {
-
 std::vector<ObjFile *> ObjFile::instances;
 std::vector<ImportFile *> ImportFile::instances;
 std::vector<BitcodeFile *> BitcodeFile::instances;
 
 /// Checks that Source is compatible with being a weak alias to Target.
 /// If Source is Undefined and has no weak alias set, makes it a weak
 /// alias to Target.
 static void checkAndSetWeakAlias(SymbolTable *symtab, InputFile *f,
void ArchiveFile::addMember(const Archive::Symbol &sym) {
 
   // Return an empty buffer if we have already returned the same buffer.
   if (!seen.insert(c.getChildOffset()).second)
     return;
 
   driver->enqueueArchiveMember(c, sym, getName());
 }
 
-std::vector<MemoryBufferRef> getArchiveMembers(Archive *file) {
+std::vector<MemoryBufferRef> lld::coff::getArchiveMembers(Archive *file) {
   std::vector<MemoryBufferRef> v;
   Error err = Error::success();
   for (const Archive::Child &c : file->children(err)) {
     MemoryBufferRef mbref =
         CHECK(c.getMemoryBufferRef(),
               file->getFileName() +
                   ": could not get the buffer for a child of the archive");
     v.push_back(mbref);
case Triple::arm:
     return ARMNT;
   case Triple::aarch64:
     return ARM64;
   default:
     return IMAGE_FILE_MACHINE_UNKNOWN;
   }
 }
 
-std::string replaceThinLTOSuffix(StringRef path) {
+std::string lld::coff::replaceThinLTOSuffix(StringRef path) {
   StringRef suffix = config->thinLTOObjectSuffixReplace.first;
   StringRef repl = config->thinLTOObjectSuffixReplace.second;
 
   if (path.consume_back(suffix))
     return (path + repl).str();
   return std::string(path);
 }
-
-} // namespace coff
-} // namespace lld

lld/COFF/LTO.cpp

 #include <cstddef>
 #include <memory>
 #include <string>
 #include <system_error>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::object;
-
-namespace lld {
-namespace coff {
+using namespace lld;
+using namespace lld::coff;
 
 // Creates an empty file to and returns a raw_fd_ostream to write to it.
 static std::unique_ptr<raw_fd_ostream> openFile(StringRef file) {
   std::error_code ec;
   auto ret =
       std::make_unique<raw_fd_ostream>(file, ec, sys::fs::OpenFlags::OF_None);
   if (ec) {
     error("cannot open " + file + ": " + ec.message());
std::vector<StringRef> BitcodeCompiler::compile() {
   }
 
   for (std::unique_ptr<MemoryBuffer> &file : files)
     if (file)
       ret.push_back(file->getBuffer());
 
   return ret;
 }
-
-} // namespace coff
-} // namespace lld

lld/COFF/MapFile.cpp

 #include "Symbols.h"
 #include "Writer.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Threads.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::object;
-
-namespace lld {
-namespace coff {
+using namespace lld;
+using namespace lld::coff;
 
 using SymbolMapTy =
     DenseMap<const SectionChunk *, SmallVector<DefinedRegular *, 4>>;
 
 static constexpr char indent8[] = "        ";          // 8 spaces
 static constexpr char indent16[] = "                "; // 16 spaces
 
 // Print out the first three columns of a line.
getSymbolStrings(ArrayRef<DefinedRegular *> syms) {
   });
 
   DenseMap<DefinedRegular *, std::string> ret;
   for (size_t i = 0, e = syms.size(); i < e; ++i)
     ret[syms[i]] = std::move(str[i]);
   return ret;
 }
 
-void writeMapFile(ArrayRef<OutputSection *> outputSections) {
+void lld::coff::writeMapFile(ArrayRef<OutputSection *> outputSections) {
   if (config->mapFile.empty())
     return;
 
   std::error_code ec;
   raw_fd_ostream os(config->mapFile, ec, sys::fs::OF_None);
   if (ec)
     fatal("cannot open " + config->mapFile + ": " + ec.message());
 
for (Chunk *c : sec->chunks) {
       writeHeader(os, sc->getRVA(), sc->getSize(), sc->getAlignment());
       os << indent8 << sc->file->getName() << ":(" << sc->getSectionName()
          << ")\n";
       for (DefinedRegular *sym : sectionSyms[sc])
         os << symStr[sym] << '\n';
     }
   }
 }
-
-} // namespace coff
-} // namespace lld

lld/COFF/MinGW.cpp

 #include "SymbolTable.h"
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::COFF;
-
-namespace lld {
-namespace coff {
+using namespace lld;
+using namespace lld::coff;
 
 AutoExporter::AutoExporter() {
   excludeLibs = {
       "libgcc",
       "libgcc_s",
       "libstdc++",
       "libmingw32",
       "libmingwex",
bool AutoExporter::shouldExport(Defined *sym) const {
   libName = libName.substr(0, libName.rfind('.'));
   if (!libName.empty())
     return !excludeLibs.count(libName);
 
   StringRef fileName = sys::path::filename(sym->getFile()->getName());
   return !excludeObjects.count(fileName);
 }
 
-void writeDefFile(StringRef name) {
+void lld::coff::writeDefFile(StringRef name) {
   std::error_code ec;
   raw_fd_ostream os(name, ec, sys::fs::OF_None);
   if (ec)
     fatal("cannot open " + name + ": " + ec.message());
 
   os << "EXPORTS\n";
   for (Export &e : config->exports) {
     os << "    " << e.exportName << " "
        << "@" << e.ordinal;
     if (auto *def = dyn_cast_or_null<Defined>(e.sym)) {
       if (def && def->getChunk() &&
           !(def->getChunk()->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE))
         os << " DATA";
     }
     os << "\n";
   }
 }
-
-} // namespace coff
-} // namespace lld

lld/COFF/PDB.cpp

 #include "llvm/Support/FormatAdapters.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include <memory>
 
 using namespace llvm;
 using namespace llvm::codeview;
+using namespace lld;
+using namespace lld::coff;
 
 using llvm::object::coff_section;
 
-namespace lld {
-namespace coff {
-
 static ExitOnError exitOnErr;
 
 static Timer totalPdbLinkTimer("PDB Emission (Cumulative)", Timer::root());
 
 static Timer addObjectsTimer("Add Objects", totalPdbLinkTimer);
 static Timer typeMergingTimer("Type Merging", addObjectsTimer);
 static Timer symbolMergingTimer("Symbol Merging", addObjectsTimer);
 static Timer globalsLayoutTimer("Globals Stream Layout", totalPdbLinkTimer);
for (ImportFile *file : ImportFile::instances) {
 
     pdb::SectionContrib sc =
         createSectionContrib(thunk->getChunk(), mod->getModuleIndex());
     mod->setFirstSectionContrib(sc);
   }
 }
 
 // Creates a PDB file.
-void createPDB(SymbolTable *symtab,
+void lld::coff::createPDB(SymbolTable *symtab,
                           ArrayRef<OutputSection *> outputSections,
                           ArrayRef<uint8_t> sectionTable,
                           llvm::codeview::DebugInfo *buildId) {
   ScopedTimer t1(totalPdbLinkTimer);
   PDBLinker pdb(symtab);
 
   pdb.initialize(buildId);
   pdb.addObjectsToPDB();
   pdb.addImportFilesToPDB(outputSections);
   pdb.addSections(outputSections, sectionTable);
   pdb.addNatvisFiles();
static bool findLineTable(const SectionChunk *c, uint32_t addr,
 
   return false;
 }
 
 // Use CodeView line tables to resolve a file and line number for the given
 // offset into the given chunk and return them, or None if a line table was
 // not found.
 Optional<std::pair<StringRef, uint32_t>>
-getFileLineCodeView(const SectionChunk *c, uint32_t addr) {
+lld::coff::getFileLineCodeView(const SectionChunk *c, uint32_t addr) {
   ExitOnError exitOnErr;
 
   DebugStringTableSubsectionRef cVStrTab;
   DebugChecksumsSubsectionRef checksums;
   DebugLinesSubsectionRef lines;
   uint32_t offsetInLinetable;
 
   if (!findLineTable(c, addr, cVStrTab, checksums, lines, offsetInLinetable))
for (const LineNumberEntry &ln : entry.LineNumbers) {
       lineNumber = li.getStartLine();
     }
   }
   if (!nameIndex)
     return None;
   StringRef filename = exitOnErr(getFileName(cVStrTab, checksums, *nameIndex));
   return std::make_pair(filename, *lineNumber);
 }
-
-} // namespace coff
-} // namespace lld

lld/COFF/Writer.cpp

 #include <memory>
 #include <utility>
 
 using namespace llvm;
 using namespace llvm::COFF;
 using namespace llvm::object;
 using namespace llvm::support;
 using namespace llvm::support::endian;
-
-namespace lld {
-namespace coff {
+using namespace lld;
+using namespace lld::coff;
 
 /* To re-generate DOSProgram:
 $ cat > /tmp/DOSProgram.asm
 org 0
         ; Copy cs to ds.
         push cs
         pop ds
         ; Point ds:dx at the $-terminated string.
private:
   Chunk *firstPdata = nullptr;
   Chunk *lastPdata;
 };
 } // anonymous namespace
 
 static Timer codeLayoutTimer("Code Layout", Timer::root());
 static Timer diskCommitTimer("Commit Output File", Timer::root());
 
-void writeResult() { Writer().run(); }
+void lld::coff::writeResult() { Writer().run(); }
 
 void OutputSection::addChunk(Chunk *c) {
   chunks.push_back(c);
 }
 
 void OutputSection::insertChunkAtStart(Chunk *c) {
   chunks.insert(chunks.begin(), c);
 }

 }
 
 PartialSection *Writer::findPartialSection(StringRef name, uint32_t outChars) {
   auto it = partialSections.find({name, outChars});
   if (it != partialSections.end())
     return it->second;
   return nullptr;
 }
-
-} // namespace coff
-} // namespace lld