[lldb/Plugins] Move entry points out of plugin namespace

[JDevlieghere]

Summary

This moves the plugin entry points (the class that has the ::Initialize and ::Terminate methods) out of the plugin namespace. This is part of a greater refactoring to auto generate the initializers. (D73067)

[labath]

Some of these plugins are very simple (a single class) and so having the namespace there is not that useful. However, for the not-so-simple plugins, it seems strange to have one part of it be in the namespace, and one part outside. E.g., it's unfortunate that that ProcessGDBRemote now has to qualify all references to ThreadGDBRemote, as they are both coupled closely together.

Technically, the ProcessGDBRemote class is not really the "entry point" into "gdb" plugin -- only its "initialize" function is. Nothing else should access the ProcessGDBRemote class directly (except through its base class).

In this sense, it was a mistake to have the "initalize" function be a (static) method. It makes it impossible to forward-declare it, and that means that anything which includes this file gets exposed to whatever ProcessGDBRemote.h includes. IIUC, this was the main reason we created the ScriptInterpreterPythonImpl class (which means that now ScriptInterpreterPython::Initialize references ScriptInterpreterPythonImpl::CreateInstance). Apart from python there are other plugins that could potentially cause problems due to 3rd party dependencies and their prolific uses of macros, and which might benefit from additional compartmentalization.

It seems to me like this would be a good opportunity to solve both of these issues and move the Initialize functions out of their classes (or just create a function that forwards to these). Those functions can be in the lldb_private namespace and have fully predictable names. They are also easily forward-declarable, so we don't need to generate the #include directives. And that in turn means we don't have to rename everything to make things super-consistent. And the added benefits are that the plugins are fully self-contained and don't have to do second-level pimpling just to avoid namespace polution.

[labath]

A weaker for of that would be to do something like using ProcessGDBRemote = process_gdb_remote::ProcessGDBRemote, which would require less changes to existing plugins, but it would still require us to include all the headers...

[JDevlieghere]

This is no longer relevant

lldb/source/API/SystemInitializerFull.cpp

 #define LLDB_PROCESS_Sparc(op)
 #define LLDB_PROCESS_WebAssembly(op)
 #define LLDB_PROCESS_XCore(op)
 
 llvm::Error SystemInitializerFull::Initialize() {
   if (auto e = SystemInitializerCommon::Initialize())
     return e;
 
-  breakpad::ObjectFileBreakpad::Initialize();
+  ObjectFileBreakpad::Initialize();
   ObjectFileELF::Initialize();
   ObjectFileMachO::Initialize();
   ObjectFilePECOFF::Initialize();
-  wasm::ObjectFileWasm::Initialize();
+  ObjectFileWasm::Initialize();
 
   ObjectContainerBSDArchive::Initialize();
   ObjectContainerUniversalMachO::Initialize();
 
   ScriptInterpreterNone::Initialize();
 
 #if LLDB_ENABLE_PYTHON
   OperatingSystemPython::Initialize();
 #endif
 
 #if LLDB_ENABLE_PYTHON
   ScriptInterpreterPython::Initialize();
 #endif
 
 #if LLDB_ENABLE_LUA
   ScriptInterpreterLua::Initialize();
 #endif
 
-  platform_freebsd::PlatformFreeBSD::Initialize();
-  platform_linux::PlatformLinux::Initialize();
-  platform_netbsd::PlatformNetBSD::Initialize();
-  platform_openbsd::PlatformOpenBSD::Initialize();
+  PlatformFreeBSD::Initialize();
+  PlatformLinux::Initialize();
+  PlatformNetBSD::Initialize();
+  PlatformOpenBSD::Initialize();
   PlatformWindows::Initialize();
-  platform_android::PlatformAndroid::Initialize();
+  PlatformAndroid::Initialize();
   PlatformRemoteiOS::Initialize();
   PlatformMacOSX::Initialize();
 
   // Initialize LLVM and Clang
   llvm::InitializeAllTargets();
   llvm::InitializeAllAsmPrinters();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllDisassemblers();
 
   ClangASTContext::Initialize();
 
 #define LLVM_TARGET(t) LLDB_PROCESS_ ## t(Initialize)
 #include "llvm/Config/Targets.def"
 
   ArchitectureArm::Initialize();
   ArchitectureMips::Initialize();
   ArchitecturePPC64::Initialize();
 
   DisassemblerLLVMC::Initialize();
 
   JITLoaderGDB::Initialize();
   ProcessElfCore::Initialize();
   ProcessMachCore::Initialize();
-  minidump::ProcessMinidump::Initialize();
+  ProcessMinidump::Initialize();
   MemoryHistoryASan::Initialize();
   AddressSanitizerRuntime::Initialize();
   ThreadSanitizerRuntime::Initialize();
   UndefinedBehaviorSanitizerRuntime::Initialize();
   MainThreadCheckerRuntime::Initialize();
 
   SymbolVendorELF::Initialize();
-  breakpad::SymbolFileBreakpad::Initialize();
+  SymbolFileBreakpad::Initialize();
   SymbolFileDWARF::Initialize();
   SymbolFilePDB::Initialize();
   SymbolFileSymtab::Initialize();
-  wasm::SymbolVendorWasm::Initialize();
+  SymbolVendorWasm::Initialize();
   UnwindAssemblyInstEmulation::Initialize();
   UnwindAssembly_x86::Initialize();
 
   EmulateInstructionARM::Initialize();
   EmulateInstructionARM64::Initialize();
   EmulateInstructionMIPS::Initialize();
   EmulateInstructionMIPS64::Initialize();
   EmulateInstructionPPC64::Initialize();
#if defined(__APPLE__)
   DynamicLoaderDarwinKernel::Initialize();
 #endif
 
   // This plugin is valid on any host that talks to a Darwin remote. It
   // shouldn't be limited to __APPLE__.
   StructuredDataDarwinLog::Initialize();
 
   // Platform agnostic plugins
-  platform_gdb_server::PlatformRemoteGDBServer::Initialize();
+  PlatformRemoteGDBServer::Initialize();
 
-  process_gdb_remote::ProcessGDBRemote::Initialize();
+  ProcessGDBRemote::Initialize();
   DynamicLoaderMacOSXDYLD::Initialize();
   DynamicLoaderMacOS::Initialize();
   DynamicLoaderPOSIXDYLD::Initialize();
   DynamicLoaderStatic::Initialize();
   DynamicLoaderWindowsDYLD::Initialize();
 
   // Scan for any system or user LLDB plug-ins
   PluginManager::Initialize();

 #define LLVM_TARGET(t) LLDB_PROCESS_ ## t(Terminate)
 #include "llvm/Config/Targets.def"
 
   DisassemblerLLVMC::Terminate();
 
   JITLoaderGDB::Terminate();
   ProcessElfCore::Terminate();
   ProcessMachCore::Terminate();
-  minidump::ProcessMinidump::Terminate();
+  ProcessMinidump::Terminate();
   MemoryHistoryASan::Terminate();
   AddressSanitizerRuntime::Terminate();
   ThreadSanitizerRuntime::Terminate();
   UndefinedBehaviorSanitizerRuntime::Terminate();
   MainThreadCheckerRuntime::Terminate();
-  wasm::SymbolVendorWasm::Terminate();
+  SymbolVendorWasm::Terminate();
   SymbolVendorELF::Terminate();
-  breakpad::SymbolFileBreakpad::Terminate();
+  SymbolFileBreakpad::Terminate();
   SymbolFileDWARF::Terminate();
   SymbolFilePDB::Terminate();
   SymbolFileSymtab::Terminate();
   UnwindAssembly_x86::Terminate();
   UnwindAssemblyInstEmulation::Terminate();
 
   EmulateInstructionARM::Terminate();
   EmulateInstructionARM64::Terminate();
#if defined(__APPLE__)
   SymbolVendorMacOSX::Terminate();
 #endif
 
 #if defined(__FreeBSD__)
   ProcessFreeBSD::Terminate();
 #endif
   Debugger::SettingsTerminate();
 
-  platform_gdb_server::PlatformRemoteGDBServer::Terminate();
-  process_gdb_remote::ProcessGDBRemote::Terminate();
+  PlatformRemoteGDBServer::Terminate();
+  ProcessGDBRemote::Terminate();
   StructuredDataDarwinLog::Terminate();
 
   DynamicLoaderMacOSXDYLD::Terminate();
   DynamicLoaderMacOS::Terminate();
   DynamicLoaderPOSIXDYLD::Terminate();
   DynamicLoaderStatic::Terminate();
   DynamicLoaderWindowsDYLD::Terminate();
 
-  platform_freebsd::PlatformFreeBSD::Terminate();
-  platform_linux::PlatformLinux::Terminate();
-  platform_netbsd::PlatformNetBSD::Terminate();
-  platform_openbsd::PlatformOpenBSD::Terminate();
+  PlatformFreeBSD::Terminate();
+  PlatformLinux::Terminate();
+  PlatformNetBSD::Terminate();
+  PlatformOpenBSD::Terminate();
   PlatformWindows::Terminate();
-  platform_android::PlatformAndroid::Terminate();
+  PlatformAndroid::Terminate();
   PlatformMacOSX::Terminate();
   PlatformRemoteiOS::Terminate();
 
-  breakpad::ObjectFileBreakpad::Terminate();
+  ObjectFileBreakpad::Terminate();
   ObjectFileELF::Terminate();
   ObjectFileMachO::Terminate();
   ObjectFilePECOFF::Terminate();
-  wasm::ObjectFileWasm::Terminate();
+  ObjectFileWasm::Terminate();
 
   ObjectContainerBSDArchive::Terminate();
   ObjectContainerUniversalMachO::Terminate();
 
 #if LLDB_ENABLE_PYTHON
   OperatingSystemPython::Terminate();
 #endif
 

lldb/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.h

 //===-- ObjectFileBreakpad.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 LLDB_PLUGINS_OBJECTFILE_BREAKPAD_OBJECTFILEBREAKPAD_H
 #define LLDB_PLUGINS_OBJECTFILE_BREAKPAD_OBJECTFILEBREAKPAD_H
 
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/ArchSpec.h"
 
 namespace lldb_private {
-namespace breakpad {
 
 class ObjectFileBreakpad : public ObjectFile {
 public:
   // Static Functions
   static void Initialize();
   static void Terminate();
 
   static ConstString GetPluginNameStatic();
private:
   UUID m_uuid;
 
   ObjectFileBreakpad(const lldb::ModuleSP &module_sp,
                      lldb::DataBufferSP &data_sp, lldb::offset_t data_offset,
                      const FileSpec *file, lldb::offset_t offset,
                      lldb::offset_t length, ArchSpec arch, UUID uuid);
 };
 
-} // namespace breakpad
 } // namespace lldb_private
 #endif // LLDB_PLUGINS_OBJECTFILE_BREAKPAD_OBJECTFILEBREAKPAD_H

lldb/source/Plugins/ObjectFile/wasm/ObjectFileWasm.h

 //===-- ObjectFileWasm.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 LLDB_PLUGINS_OBJECTFILE_WASM_OBJECTFILEWASM_H
 #define LLDB_PLUGINS_OBJECTFILE_WASM_OBJECTFILEWASM_H
 
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/ArchSpec.h"
 
 namespace lldb_private {
-namespace wasm {
 
 /// Generic Wasm object file reader.
 ///
 /// This class provides a generic wasm32 reader plugin implementing the
 /// ObjectFile protocol.
 class ObjectFileWasm : public ObjectFile {
 public:
   static void Initialize();
private:
   /// \}
 
   std::vector<section_info_t> m_sect_infos;
   ArchSpec m_arch;
   UUID m_uuid;
   uint32_t m_code_section_offset;
 };
 
-} // namespace wasm
 } // namespace lldb_private
 #endif // LLDB_PLUGINS_OBJECTFILE_WASM_OBJECTFILEWASM_H

lldb/source/Plugins/ObjectFile/wasm/ObjectFileWasm.cpp

 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Format.h"
 
 using namespace lldb;
 using namespace lldb_private;
-using namespace lldb_private::wasm;
 
 static const uint32_t kWasmHeaderSize =
     sizeof(llvm::wasm::WasmMagic) + sizeof(llvm::wasm::WasmVersion);
 
 /// Checks whether the data buffer starts with a valid Wasm module header.
 static bool ValidateModuleHeader(const DataBufferSP &data_sp) {
   if (!data_sp || data_sp->GetByteSize() < kWasmHeaderSize)
     return false;

lldb/source/Plugins/Platform/Android/PlatformAndroid.h

 #include <memory>
 #include <string>
 
 #include "Plugins/Platform/Linux/PlatformLinux.h"
 
 #include "AdbClient.h"
 
 namespace lldb_private {
-namespace platform_android {
 
-class PlatformAndroid : public platform_linux::PlatformLinux {
+class PlatformAndroid : public PlatformLinux {
 public:
   PlatformAndroid(bool is_host);
 
   ~PlatformAndroid() override;
 
   static void Initialize();
 
   static void Terminate();
protected:
 
   Status DownloadSymbolFile(const lldb::ModuleSP &module_sp,
                             const FileSpec &dst_file_spec) override;
 
   llvm::StringRef
   GetLibdlFunctionDeclarations(lldb_private::Process *process) override;
 
 private:
-  AdbClient::SyncService *GetSyncService(Status &error);
+  platform_android::AdbClient::SyncService *GetSyncService(Status &error);
 
-  std::unique_ptr<AdbClient::SyncService> m_adb_sync_svc;
+  std::unique_ptr<platform_android::AdbClient::SyncService> m_adb_sync_svc;
   std::string m_device_id;
   uint32_t m_sdk_version;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformAndroid);
 };
 
-} // namespace platofor_android
 } // namespace lldb_private
 
 #endif // liblldb_PlatformAndroid_h_

lldb/source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.h

 
 #include "llvm/ADT/Optional.h"
 
 #include "AdbClient.h"
 
 namespace lldb_private {
 namespace platform_android {
 
-class PlatformAndroidRemoteGDBServer
-    : public platform_gdb_server::PlatformRemoteGDBServer {
+class PlatformAndroidRemoteGDBServer : public PlatformRemoteGDBServer {
 public:
   PlatformAndroidRemoteGDBServer();
 
   ~PlatformAndroidRemoteGDBServer() override;
 
   Status ConnectRemote(Args &args) override;
 
   Status DisconnectRemote() override;

lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.h

 //===-- PlatformFreeBSD.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 liblldb_PlatformFreeBSD_h_
 #define liblldb_PlatformFreeBSD_h_
 
 #include "Plugins/Platform/POSIX/PlatformPOSIX.h"
 
 namespace lldb_private {
-namespace platform_freebsd {
 
 class PlatformFreeBSD : public PlatformPOSIX {
 public:
   PlatformFreeBSD(bool is_host);
 
   ~PlatformFreeBSD() override;
 
   static void Initialize();
MmapArgList GetMmapArgumentList(const ArchSpec &arch, lldb::addr_t addr,
                                   lldb::addr_t length, unsigned prot,
                                   unsigned flags, lldb::addr_t fd,
                                   lldb::addr_t offset) override;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(PlatformFreeBSD);
 };
 
-} // namespace platform_freebsd
 } // namespace lldb_private
 
 #endif // liblldb_PlatformFreeBSD_h_

lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

 
 // Define these constants from FreeBSD mman.h for use when targeting remote
 // FreeBSD systems even when host has different values.
 #define MAP_PRIVATE 0x0002
 #define MAP_ANON 0x1000
 
 using namespace lldb;
 using namespace lldb_private;
-using namespace lldb_private::platform_freebsd;
 
 static uint32_t g_initialize_count = 0;
 
 
 PlatformSP PlatformFreeBSD::CreateInstance(bool force, const ArchSpec *arch) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
   LLDB_LOG(log, "force = {0}, arch=({1}, {2})", force,
            arch ? arch->GetArchitectureName() : "<null>",

lldb/source/Plugins/Platform/Linux/PlatformLinux.h

 //===-- PlatformLinux.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 liblldb_PlatformLinux_h_
 #define liblldb_PlatformLinux_h_
 
 #include "Plugins/Platform/POSIX/PlatformPOSIX.h"
 
 namespace lldb_private {
-namespace platform_linux {
 
 class PlatformLinux : public PlatformPOSIX {
 public:
   PlatformLinux(bool is_host);
 
   ~PlatformLinux() override;
 
   static void Initialize();
MmapArgList GetMmapArgumentList(const ArchSpec &arch, lldb::addr_t addr,
                                   lldb::addr_t length, unsigned prot,
                                   unsigned flags, lldb::addr_t fd,
                                   lldb::addr_t offset) override;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(PlatformLinux);
 };
 
-} // namespace platform_linux
 } // namespace lldb_private
 
 #endif // liblldb_PlatformLinux_h_

lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp

 
 // Define these constants from Linux mman.h for use when targeting remote linux
 // systems even when host has different values.
 #define MAP_PRIVATE 2
 #define MAP_ANON 0x20
 
 using namespace lldb;
 using namespace lldb_private;
-using namespace lldb_private::platform_linux;
 
 static uint32_t g_initialize_count = 0;
 
 
 PlatformSP PlatformLinux::CreateInstance(bool force, const ArchSpec *arch) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
   LLDB_LOG(log, "force = {0}, arch=({1}, {2})", force,
            arch ? arch->GetArchitectureName() : "<null>",

lldb/source/Plugins/Platform/NetBSD/PlatformNetBSD.h

 //===-- PlatformNetBSD.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 liblldb_PlatformNetBSD_h_
 #define liblldb_PlatformNetBSD_h_
 
 #include "Plugins/Platform/POSIX/PlatformPOSIX.h"
 
 namespace lldb_private {
-namespace platform_netbsd {
 
 class PlatformNetBSD : public PlatformPOSIX {
 public:
   PlatformNetBSD(bool is_host);
 
   ~PlatformNetBSD() override;
 
   static void Initialize();
MmapArgList GetMmapArgumentList(const ArchSpec &arch, lldb::addr_t addr,
                                   lldb::addr_t length, unsigned prot,
                                   unsigned flags, lldb::addr_t fd,
                                   lldb::addr_t offset) override;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(PlatformNetBSD);
 };
 
-} // namespace platform_netbsd
 } // namespace lldb_private
 
 #endif // liblldb_PlatformNetBSD_h_

lldb/source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp

 
 // Define these constants from NetBSD mman.h for use when targeting remote
 // netbsd systems even when host has different values.
 #define MAP_PRIVATE 0x0002
 #define MAP_ANON 0x1000
 
 using namespace lldb;
 using namespace lldb_private;
-using namespace lldb_private::platform_netbsd;
 
 static uint32_t g_initialize_count = 0;
 
 
 PlatformSP PlatformNetBSD::CreateInstance(bool force, const ArchSpec *arch) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
   LLDB_LOG(log, "force = {0}, arch=({1}, {2})", force,
            arch ? arch->GetArchitectureName() : "<null>",

lldb/source/Plugins/Platform/OpenBSD/PlatformOpenBSD.h

 //===-- PlatformOpenBSD.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 liblldb_PlatformOpenBSD_h_
 #define liblldb_PlatformOpenBSD_h_
 
 #include "Plugins/Platform/POSIX/PlatformPOSIX.h"
 
 namespace lldb_private {
-namespace platform_openbsd {
 
 class PlatformOpenBSD : public PlatformPOSIX {
 public:
   PlatformOpenBSD(bool is_host);
 
   ~PlatformOpenBSD() override;
 
   static void Initialize();
MmapArgList GetMmapArgumentList(const ArchSpec &arch, lldb::addr_t addr,
                                   lldb::addr_t length, unsigned prot,
                                   unsigned flags, lldb::addr_t fd,
                                   lldb::addr_t offset) override;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(PlatformOpenBSD);
 };
 
-} // namespace platform_openbsd
 } // namespace lldb_private
 
 #endif // liblldb_PlatformOpenBSD_h_

lldb/source/Plugins/Platform/OpenBSD/PlatformOpenBSD.cpp

 
 // Define these constants from OpenBSD mman.h for use when targeting remote
 // openbsd systems even when host has different values.
 #define MAP_PRIVATE 0x0002
 #define MAP_ANON 0x1000
 
 using namespace lldb;
 using namespace lldb_private;
-using namespace lldb_private::platform_openbsd;
 
 static uint32_t g_initialize_count = 0;
 
 
 PlatformSP PlatformOpenBSD::CreateInstance(bool force, const ArchSpec *arch) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
   LLDB_LOG(log, "force = {0}, arch=({1}, {2})", force,
            arch ? arch->GetArchitectureName() : "<null>",

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h

 
 #include <string>
 
 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h"
 #include "Plugins/Process/Utility/GDBRemoteSignals.h"
 #include "lldb/Target/Platform.h"
 
 namespace lldb_private {
-namespace platform_gdb_server {
 
 class PlatformRemoteGDBServer : public Platform, private UserIDResolver {
 public:
   static void Initialize();
 
   static void Terminate();
 
   static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
std::string MakeGdbServerUrl(const std::string &platform_scheme,
                                uint16_t port, const char *socket_name);
 
   llvm::Optional<std::string> DoGetUserName(UserIDResolver::id_t uid) override;
   llvm::Optional<std::string> DoGetGroupName(UserIDResolver::id_t uid) override;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformRemoteGDBServer);
 };
 
-} // namespace platform_gdb_server
 } // namespace lldb_private
 
 #endif // liblldb_PlatformRemoteGDBServer_h_

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/UriParser.h"
 
 #include "Plugins/Process/Utility/GDBRemoteSignals.h"
 
 using namespace lldb;
 using namespace lldb_private;
-using namespace lldb_private::platform_gdb_server;
 
 static bool g_initialized = false;
 
 void PlatformRemoteGDBServer::Initialize() {
   Platform::Initialize();
 
   if (!g_initialized) {
     g_initialized = true;

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h

 #include "lldb/Utility/Predicate.h"
 #include "lldb/Utility/StringExtractorGDBRemote.h"
 #include "lldb/lldb-public.h"
 
 namespace lldb_private {
 namespace repro {
 class PacketRecorder;
 }
+class ProcessGDBRemote;
 namespace process_gdb_remote {
 
 enum GDBStoppointType {
   eStoppointInvalid = -1,
   eBreakpointSoftware = 0,
   eBreakpointHardware,
   eWatchpointWrite,
   eWatchpointRead,
   eWatchpointReadWrite
 };
 
 enum class CompressionType {
   None = 0,    // no compression
   ZlibDeflate, // zlib's deflate compression scheme, requires zlib or Apple's
                // libcompression
   LZFSE,       // an Apple compression scheme, requires Apple's libcompression
   LZ4, // lz compression - called "lz4 raw" in libcompression terms, compat with
        // https://code.google.com/p/lz4/
   LZMA, // Lempel–Ziv–Markov chain algorithm
 };
 
-class ProcessGDBRemote;
 
 class GDBRemoteCommunication : public Communication {
 public:
   enum {
     eBroadcastBitRunPacketSent = kLoUserBroadcastBit,
     eBroadcastBitGdbReadThreadGotNotify =
         kLoUserBroadcastBit << 1 // Sent when we received a notify packet.
   };

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationReplayServer.h

 // C++ Includes
 #include <functional>
 #include <map>
 #include <thread>
 
 class StringExtractorGDBRemote;
 
 namespace lldb_private {
-namespace process_gdb_remote {
-
 class ProcessGDBRemote;
+namespace process_gdb_remote {
 
 /// Dummy GDB server that replays packets from the GDB Remote Communication
 /// history. This is used to replay GDB packets.
 class GDBRemoteCommunicationReplayServer : public GDBRemoteCommunication {
 public:
   GDBRemoteCommunicationReplayServer();
 
   ~GDBRemoteCommunicationReplayServer() override;

lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.h

 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-private.h"
 
 #include "GDBRemoteCommunicationClient.h"
 
 class StringExtractor;
 
 namespace lldb_private {
+class ProcessGDBRemote;
 namespace process_gdb_remote {
 
 class ThreadGDBRemote;
-class ProcessGDBRemote;
 
 class GDBRemoteDynamicRegisterInfo : public DynamicRegisterInfo {
 public:
   GDBRemoteDynamicRegisterInfo() : DynamicRegisterInfo() {}
 
   ~GDBRemoteDynamicRegisterInfo() override = default;
 
   void HardcodeARMRegisters(bool from_scratch);

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

 #include "GDBRemoteRegisterContext.h"
 
 #include "llvm/ADT/DenseMap.h"
 
 namespace lldb_private {
 namespace repro {
 class Loader;
 }
-namespace process_gdb_remote {
 
+namespace process_gdb_remote {
 class ThreadGDBRemote;
+}
 
-class ProcessGDBRemote : public Process,
-                         private GDBRemoteClientBase::ContinueDelegate {
+class ProcessGDBRemote
+    : public Process,
+      private process_gdb_remote::GDBRemoteClientBase::ContinueDelegate {
 public:
   ProcessGDBRemote(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp);
 
   ~ProcessGDBRemote() override;
 
   static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp,
                                         lldb::ListenerSP listener_sp,
                                         const FileSpec *crash_file_path);
public:
   Status GetTraceConfig(lldb::user_id_t uid, TraceOptions &options) override;
 
   Status GetWatchpointSupportInfo(uint32_t &num, bool &after) override;
 
   bool StartNoticingNewThreads() override;
 
   bool StopNoticingNewThreads() override;
 
-  GDBRemoteCommunicationClient &GetGDBRemote() { return m_gdb_comm; }
+  process_gdb_remote::GDBRemoteCommunicationClient &GetGDBRemote() {
+    return m_gdb_comm;
+  }
 
   Status SendEventData(const char *data) override;
 
   // Override DidExit so we can disconnect from the remote GDB server
   void DidExit() override;
 
   void SetUserSpecifiedMaxMemoryTransferSize(uint64_t user_specified_max);
 
public:
   GetLoadedDynamicLibrariesInfos_sender(StructuredData::ObjectSP args);
 
   StructuredData::ObjectSP GetSharedCacheInfo() override;
 
   std::string HarmonizeThreadIdsForProfileData(
       StringExtractorGDBRemote &inputStringExtractor);
 
 protected:
-  friend class ThreadGDBRemote;
-  friend class GDBRemoteCommunicationClient;
-  friend class GDBRemoteRegisterContext;
+  friend class process_gdb_remote::ThreadGDBRemote;
+  friend class process_gdb_remote::GDBRemoteCommunicationClient;
+  friend class process_gdb_remote::GDBRemoteRegisterContext;
 
   /// Broadcaster event bits definitions.
   enum {
     eBroadcastBitAsyncContinue = (1 << 0),
     eBroadcastBitAsyncThreadShouldExit = (1 << 1),
     eBroadcastBitAsyncThreadDidExit = (1 << 2)
   };
 
-  GDBRemoteCommunicationClient m_gdb_comm;
-  GDBRemoteCommunicationReplayServer m_gdb_replay_server;
+  process_gdb_remote::GDBRemoteCommunicationClient m_gdb_comm;
+  process_gdb_remote::GDBRemoteCommunicationReplayServer m_gdb_replay_server;
   std::atomic<lldb::pid_t> m_debugserver_pid;
   std::vector<StringExtractorGDBRemote> m_stop_packet_stack; // The stop packet
                                                              // stack replaces
                                                              // the last stop
                                                              // packet variable
   std::recursive_mutex m_last_stop_packet_mutex;
-  GDBRemoteDynamicRegisterInfo m_register_info;
+  process_gdb_remote::GDBRemoteDynamicRegisterInfo m_register_info;
   Broadcaster m_async_broadcaster;
   lldb::ListenerSP m_async_listener_sp;
   HostThread m_async_thread;
   std::recursive_mutex m_async_thread_state_mutex;
   typedef std::vector<lldb::tid_t> tid_collection;
   typedef std::vector<std::pair<lldb::tid_t, int>> tid_sig_collection;
   typedef std::map<lldb::addr_t, lldb::addr_t> MMapMap;
   typedef std::map<uint32_t, std::string> ExpeditedRegisterMap;
protected:
   bool ParsePythonTargetDefinition(const FileSpec &target_definition_fspec);
 
   DataExtractor GetAuxvData() override;
 
   StructuredData::ObjectSP GetExtendedInfoForThread(lldb::tid_t tid);
 
   void GetMaxMemorySize();
 
-  bool CalculateThreadStopInfo(ThreadGDBRemote *thread);
+  bool CalculateThreadStopInfo(process_gdb_remote::ThreadGDBRemote *thread);
 
   size_t UpdateThreadPCsFromStopReplyThreadsValue(std::string &value);
 
   size_t UpdateThreadIDsFromStopReplyThreadsValue(std::string &value);
 
   bool HandleNotifyPacket(StringExtractorGDBRemote &packet);
 
   bool StartAsyncThread();
 
   void StopAsyncThread();
 
   static lldb::thread_result_t AsyncThread(void *arg);
 
   static bool
   MonitorDebugserverProcess(std::weak_ptr<ProcessGDBRemote> process_wp,
                             lldb::pid_t pid, bool exited, int signo,
                             int exit_status);
 
   lldb::StateType SetThreadStopInfo(StringExtractor &stop_packet);
 
   bool
-  GetThreadStopInfoFromJSON(ThreadGDBRemote *thread,
+  GetThreadStopInfoFromJSON(process_gdb_remote::ThreadGDBRemote *thread,
                             const StructuredData::ObjectSP &thread_infos_sp);
 
   lldb::ThreadSP SetThreadStopInfo(StructuredData::Dictionary *thread_dict);
 
   lldb::ThreadSP
   SetThreadStopInfo(lldb::tid_t tid,
                     ExpeditedRegisterMap &expedited_register_map, uint8_t signo,
                     const std::string &thread_name, const std::string &reason,
protected:
   Status ConnectToDebugserver(llvm::StringRef host_port);
 
   const char *GetDispatchQueueNameForThread(lldb::addr_t thread_dispatch_qaddr,
                                             std::string &dispatch_queue_name);
 
   DynamicLoader *GetDynamicLoader() override;
 
   bool GetGDBServerRegisterInfoXMLAndProcess(ArchSpec &arch_to_use,
-                                             std::string xml_filename, 
+                                             std::string xml_filename,
                                              uint32_t &cur_reg_num,
                                              uint32_t &reg_offset);
 
   // Query remote GDBServer for register information
   bool GetGDBServerRegisterInfo(ArchSpec &arch);
 
   lldb::ModuleSP LoadModuleAtAddress(const FileSpec &file,
                                      lldb::addr_t link_map,
private:
   };
 
   llvm::DenseMap<ModuleCacheKey, ModuleSpec, ModuleCacheInfo>
       m_cached_module_specs;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessGDBRemote);
 };
 
-} // namespace process_gdb_remote
 } // namespace lldb_private
 
 #endif // liblldb_ProcessGDBRemote_h_

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

lldb::ModuleSP ProcessGDBRemote::LoadModuleAtAddress(const FileSpec &file,
   if (!loader)
     return nullptr;
 
   return loader->LoadModuleAtAddress(file, link_map, base_addr,
                                      value_is_offset);
 }
 
 llvm::Error ProcessGDBRemote::LoadModules() {
-  using lldb_private::process_gdb_remote::ProcessGDBRemote;
+  using lldb_private::ProcessGDBRemote;
 
   // request a list of loaded libraries from GDBServer
   llvm::Expected<LoadedModuleInfoList> module_list = GetLoadedModuleList();
   if (!module_list)
     return module_list.takeError();
 
   // get a list of all the modules
   ModuleList new_modules;

lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h

 
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/StructuredData.h"
 
 class StringExtractor;
 
 namespace lldb_private {
 class Process;
-
-namespace process_gdb_remote {
-
 class ProcessGDBRemote;
+namespace process_gdb_remote {
 
 class ThreadGDBRemote : public Thread {
 public:
   ThreadGDBRemote(Process &process, lldb::tid_t tid);
 
   ~ThreadGDBRemote() override;
 
   void WillResume(lldb::StateType resume_state) override;
public:
   lldb_private::LazyBool GetAssociatedWithLibdispatchQueue() override;
 
   void SetAssociatedWithLibdispatchQueue(
       lldb_private::LazyBool associated_with_libdispatch_queue) override;
 
   StructuredData::ObjectSP FetchThreadExtendedInfo() override;
 
 protected:
-  friend class ProcessGDBRemote;
+  friend class lldb_private::ProcessGDBRemote;
 
   std::string m_thread_name;
   std::string m_dispatch_queue_name;
   lldb::addr_t m_thread_dispatch_qaddr;
   lldb::addr_t m_dispatch_queue_t;
   lldb::QueueKind
       m_queue_kind; // Queue info from stop reply/stop info for thread
   uint64_t

lldb/source/Plugins/Process/minidump/ProcessMinidump.h

 #include "lldb/Utility/Status.h"
 
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 
 
 namespace lldb_private {
 
-namespace minidump {
-
 class ProcessMinidump : public Process {
 public:
   static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp,
                                         lldb::ListenerSP listener_sp,
                                         const FileSpec *crash_file_path);
 
   static void Initialize();
 
public:
   Status WillResume() override {
     Status error;
     error.SetErrorStringWithFormat(
         "error: %s does not support resuming processes",
         GetPluginName().GetCString());
     return error;
   }
 
-  llvm::Optional<MinidumpParser> m_minidump_parser;
+  llvm::Optional<minidump::MinidumpParser> m_minidump_parser;
 
 protected:
   void Clear();
 
   bool UpdateThreadList(ThreadList &old_thread_list,
                         ThreadList &new_thread_list) override;
 
   void ReadModuleList();
 
   JITLoaderList &GetJITLoaders() override;
 
 private:
   FileSpec m_core_file;
   lldb::DataBufferSP m_core_data;
   llvm::ArrayRef<minidump::Thread> m_thread_list;
   const minidump::ExceptionStream *m_active_exception;
   lldb::CommandObjectSP m_command_sp;
   bool m_is_wow64;
   llvm::Optional<MemoryRegionInfos> m_memory_regions;
 
   void BuildMemoryRegions();
 };
 
-} // namespace minidump
 } // namespace lldb_private
 
 #endif // liblldb_ProcessMinidump_h_

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h

 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/PostfixExpression.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/UnwindPlan.h"
 
 namespace lldb_private {
 
-namespace breakpad {
-
 class SymbolFileBreakpad : public SymbolFile {
   /// LLVM RTTI support.
   static char ID;
 
 public:
   /// LLVM RTTI support.
   /// \{
   bool isA(const void *ClassID) const override {
private:
   // At iterator class for simplifying algorithms reading data from the breakpad
   // file. It iterates over all records (lines) in the sections of a given type.
   // It also supports saving a specific position (via the GetBookmark() method)
   // and then resuming from it afterwards.
   class LineIterator;
 
   // Return an iterator range for all records in the given object file of the
   // given type.
-  llvm::iterator_range<LineIterator> lines(Record::Kind section_type);
+  llvm::iterator_range<LineIterator> lines(breakpad::Record::Kind section_type);
 
   // Breakpad files do not contain sufficient information to correctly
   // reconstruct compile units. The approach chosen here is to treat each
   // function as a compile unit. The compile unit name is the name if the first
   // line entry belonging to this function.
   // This class is our internal representation of a compile unit. It stores the
   // CompileUnit object and a bookmark pointing to the FUNC record of the
   // compile unit function. It also lazily construct the list of support files
private:
   struct UnwindData {
     UnwindMap cfi;
     UnwindMap win;
   };
   llvm::Optional<UnwindData> m_unwind_data;
   llvm::BumpPtrAllocator m_allocator;
 };
 
-} // namespace breakpad
 } // namespace lldb_private
 
 #endif

lldb/source/Plugins/SymbolVendor/wasm/SymbolVendorWasm.h

 //===-- SymbolVendorWasm.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 liblldb_SymbolVendorWasm_h_
 #define liblldb_SymbolVendorWasm_h_
 
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
-namespace wasm {
 
 class SymbolVendorWasm : public lldb_private::SymbolVendor {
 public:
   SymbolVendorWasm(const lldb::ModuleSP &module_sp);
 
   static void Initialize();
   static void Terminate();
   static lldb_private::ConstString GetPluginNameStatic();
   static const char *GetPluginDescriptionStatic();
 
   static lldb_private::SymbolVendor *
   CreateInstance(const lldb::ModuleSP &module_sp,
                  lldb_private::Stream *feedback_strm);
 
   /// PluginInterface protocol.
   /// \{
   lldb_private::ConstString GetPluginName() override;
   uint32_t GetPluginVersion() override;
   /// \}
 
 private:
   DISALLOW_COPY_AND_ASSIGN(SymbolVendorWasm);
 };
 
-} // namespace wasm
 } // namespace lldb_private
 
 #endif // liblldb_SymbolVendorWasm_h_

lldb/source/Plugins/SymbolVendor/wasm/SymbolVendorWasm.cpp

 #include "lldb/Symbol/LocateSymbolFile.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 
 using namespace lldb;
 using namespace lldb_private;
-using namespace lldb_private::wasm;
 
 // SymbolVendorWasm constructor
 SymbolVendorWasm::SymbolVendorWasm(const lldb::ModuleSP &module_sp)
     : SymbolVendor(module_sp) {}
 
 void SymbolVendorWasm::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                 GetPluginDescriptionStatic(), CreateInstance);

lldb/tools/lldb-test/SystemInitializerTest.cpp

 #define LLDB_PROCESS_Sparc(op)
 #define LLDB_PROCESS_WebAssembly(op)
 #define LLDB_PROCESS_XCore(op)
 
 llvm::Error SystemInitializerTest::Initialize() {
   if (auto e = SystemInitializerCommon::Initialize())
     return e;
 
-  breakpad::ObjectFileBreakpad::Initialize();
+  ObjectFileBreakpad::Initialize();
   ObjectFileELF::Initialize();
   ObjectFileMachO::Initialize();
   ObjectFilePECOFF::Initialize();
-  wasm::ObjectFileWasm::Initialize();
+  ObjectFileWasm::Initialize();
 
   ObjectContainerBSDArchive::Initialize();
   ObjectContainerUniversalMachO::Initialize();
 
   ScriptInterpreterNone::Initialize();
 
-  platform_freebsd::PlatformFreeBSD::Initialize();
-  platform_linux::PlatformLinux::Initialize();
-  platform_netbsd::PlatformNetBSD::Initialize();
-  platform_openbsd::PlatformOpenBSD::Initialize();
+  PlatformFreeBSD::Initialize();
+  PlatformLinux::Initialize();
+  PlatformNetBSD::Initialize();
+  PlatformOpenBSD::Initialize();
   PlatformWindows::Initialize();
-  platform_android::PlatformAndroid::Initialize();
+  PlatformAndroid::Initialize();
   PlatformRemoteiOS::Initialize();
   PlatformMacOSX::Initialize();
 
   // Initialize LLVM and Clang
   llvm::InitializeAllTargets();
   llvm::InitializeAllAsmPrinters();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllDisassemblers();
 
   ClangASTContext::Initialize();
 
 #define LLVM_TARGET(t) LLDB_PROCESS_ ## t(Initialize)
 #include "llvm/Config/Targets.def"
 
   ArchitectureArm::Initialize();
   ArchitectureMips::Initialize();
   ArchitecturePPC64::Initialize();
 
   DisassemblerLLVMC::Initialize();
 
   JITLoaderGDB::Initialize();
   ProcessElfCore::Initialize();
   ProcessMachCore::Initialize();
-  minidump::ProcessMinidump::Initialize();
+  ProcessMinidump::Initialize();
   MemoryHistoryASan::Initialize();
   AddressSanitizerRuntime::Initialize();
   ThreadSanitizerRuntime::Initialize();
   UndefinedBehaviorSanitizerRuntime::Initialize();
   MainThreadCheckerRuntime::Initialize();
 
   SymbolVendorELF::Initialize();
-  breakpad::SymbolFileBreakpad::Initialize();
+  SymbolFileBreakpad::Initialize();
   SymbolFileDWARF::Initialize();
   SymbolFilePDB::Initialize();
   SymbolFileSymtab::Initialize();
-  wasm::SymbolVendorWasm::Initialize();
+  SymbolVendorWasm::Initialize();
   UnwindAssemblyInstEmulation::Initialize();
   UnwindAssembly_x86::Initialize();
 
   EmulateInstructionARM::Initialize();
   EmulateInstructionARM64::Initialize();
   EmulateInstructionMIPS::Initialize();
   EmulateInstructionMIPS64::Initialize();
   EmulateInstructionPPC64::Initialize();
#if defined(__APPLE__)
   ProcessKDP::Initialize();
 #endif
 
   // This plugin is valid on any host that talks to a Darwin remote. It
   // shouldn't be limited to __APPLE__.
   StructuredDataDarwinLog::Initialize();
 
   // Platform agnostic plugins
-  platform_gdb_server::PlatformRemoteGDBServer::Initialize();
+  PlatformRemoteGDBServer::Initialize();
 
-  process_gdb_remote::ProcessGDBRemote::Initialize();
+  ProcessGDBRemote::Initialize();
   DynamicLoaderMacOSXDYLD::Initialize();
   DynamicLoaderMacOS::Initialize();
   DynamicLoaderPOSIXDYLD::Initialize();
   DynamicLoaderStatic::Initialize();
   DynamicLoaderWindowsDYLD::Initialize();
 
   // Scan for any system or user LLDB plug-ins
   PluginManager::Initialize();

 #define LLVM_TARGET(t) LLDB_PROCESS_ ## t(Terminate)
 #include "llvm/Config/Targets.def"
 
   DisassemblerLLVMC::Terminate();
 
   JITLoaderGDB::Terminate();
   ProcessElfCore::Terminate();
   ProcessMachCore::Terminate();
-  minidump::ProcessMinidump::Terminate();
+  ProcessMinidump::Terminate();
   MemoryHistoryASan::Terminate();
   AddressSanitizerRuntime::Terminate();
   ThreadSanitizerRuntime::Terminate();
   UndefinedBehaviorSanitizerRuntime::Terminate();
   MainThreadCheckerRuntime::Terminate();
-  wasm::SymbolVendorWasm::Terminate();
+  SymbolVendorWasm::Terminate();
   SymbolVendorELF::Terminate();
-  breakpad::SymbolFileBreakpad::Terminate();
+  SymbolFileBreakpad::Terminate();
   SymbolFileDWARF::Terminate();
   SymbolFilePDB::Terminate();
   SymbolFileSymtab::Terminate();
   UnwindAssembly_x86::Terminate();
   UnwindAssemblyInstEmulation::Terminate();
 
   EmulateInstructionARM::Terminate();
   EmulateInstructionARM64::Terminate();
#if defined(__APPLE__)
   SymbolVendorMacOSX::Terminate();
 #endif
 
 #if defined(__FreeBSD__)
   ProcessFreeBSD::Terminate();
 #endif
   Debugger::SettingsTerminate();
 
-  platform_gdb_server::PlatformRemoteGDBServer::Terminate();
-  process_gdb_remote::ProcessGDBRemote::Terminate();
+  PlatformRemoteGDBServer::Terminate();
+  ProcessGDBRemote::Terminate();
   StructuredDataDarwinLog::Terminate();
 
   DynamicLoaderMacOSXDYLD::Terminate();
   DynamicLoaderMacOS::Terminate();
   DynamicLoaderPOSIXDYLD::Terminate();
   DynamicLoaderStatic::Terminate();
   DynamicLoaderWindowsDYLD::Terminate();
 
-  platform_freebsd::PlatformFreeBSD::Terminate();
-  platform_linux::PlatformLinux::Terminate();
-  platform_netbsd::PlatformNetBSD::Terminate();
-  platform_openbsd::PlatformOpenBSD::Terminate();
+  PlatformFreeBSD::Terminate();
+  PlatformLinux::Terminate();
+  PlatformNetBSD::Terminate();
+  PlatformOpenBSD::Terminate();
   PlatformWindows::Terminate();
-  platform_android::PlatformAndroid::Terminate();
+  PlatformAndroid::Terminate();
   PlatformMacOSX::Terminate();
   PlatformRemoteiOS::Terminate();
 
-  breakpad::ObjectFileBreakpad::Terminate();
+  ObjectFileBreakpad::Terminate();
   ObjectFileELF::Terminate();
   ObjectFileMachO::Terminate();
   ObjectFilePECOFF::Terminate();
-  wasm::ObjectFileWasm::Terminate();
+  ObjectFileWasm::Terminate();
 
   ObjectContainerBSDArchive::Terminate();
   ObjectContainerUniversalMachO::Terminate();
 
   // Now shutdown the common parts, in reverse order.
   SystemInitializerCommon::Terminate();
 }