Reduce header footprint of Module.h

[zturner]

Summary

This is part of a larger effort to reduce header file footprints. Locally, I have a working copy of LLDB that builds between 30-40% faster than ToT. This is done almost entirely by removing header file includes from other headers where they are not needed. I have focused on the biggest offender, which is the clang headers. In particular, this and other subsequent patches will attempt to stop #including clang headers from other headers except where absolutely necessary. The way this happens in practice is that a class needs to store a ClangASTType. This patch (and the ones that follow) address this by changing by-value inclusion of ClangASTType to an std::unique_ptr<ClangASTType>, and then forward declaring the ClangASTType.

I don't expect this to be too controversial, but I want to throw up this small patch for review first before I take it as a sign that I'm going about this the right way. You probably won't notice much of a difference in build speed by applying this patch, but taken in conjunction with the rest of the patches, the build speed on my local machine is between 30-40% faster depending on the run, and I wasn't even done yet :)

[clayborg]

Looks fine.

[zturner]

Thanks, I'll take this as a sign that it's ok to commit further patches of this nature. Let me know if you have concerns about any of the patches I submit. Removing header file includes from other headers breaks some cpp files, so I'll make sure to test on all 3 platforms before comitting anything.

[clayborg]

This is fine as long as you don't take a simple class that contains very few things (like ClangASTType) and try to hide everything behind a unique_ptr just to avoid clang includes. I don't want to trade of compile time for run time performance (heap fragmentation).

Your fix in this patch was fine as it moved a ClangASTContext into a shared pointer which is fine as it is a large class.

[zturner]

Yea I don't plan to impl entire classes. If I end up with any patches that
I'm unsure about, I'll upload them for you to look at first.

[zturner]

What about the ClangASTType member in Value.h? Can I change that to a
unique_ptr<ClangASTType>?

lldb/trunk/include/lldb/Core/ArchSpec.h

 //===-- ArchSpec.h ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ArchSpec_h_
 #define liblldb_ArchSpec_h_
 
 #if defined(__cplusplus)
 
-#include "lldb/lldb-private.h"
+#include "lldb/lldb-forward.h"
 #include "lldb/Core/ConstString.h"
-#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 
 namespace lldb_private {
 
 struct CoreDefinition;    
 
 //----------------------------------------------------------------------
 /// @class ArchSpec ArchSpec.h "lldb/Core/ArchSpec.h"
public:
     /// For example, if this ArchSpec's triple is something like
     /// i386-unknown-unknown-unknown, and we have a triple which is
     /// x64-pc-windows-msvc, then merging that triple into this one
     /// will result in the triple i386-pc-windows-msvc.
     ///
     //------------------------------------------------------------------
     void
     MergeFrom(const ArchSpec &other);
     
     //------------------------------------------------------------------
-    /// Sets this ArchSpec according to the given architecture name.
-    ///
-    /// The architecture name can be one of the generic system default
-    /// values:
-    ///
-    /// @li \c LLDB_ARCH_DEFAULT - The arch the current system defaults
-    ///        to when a program is launched without any extra
-    ///        attributes or settings.
-    /// @li \c LLDB_ARCH_DEFAULT_32BIT - The default host architecture
-    ///        for 32 bit (if any).
-    /// @li \c LLDB_ARCH_DEFAULT_64BIT - The default host architecture
-    ///        for 64 bit (if any).
-    ///
-    /// Alternatively, if the object type of this ArchSpec has been
-    /// configured,  a concrete architecture can be specified to set
-    /// the CPU type ("x86_64" for example).
-    ///
-    /// Finally, an encoded object and archetecture format is accepted.
-    /// The format contains an object type (like "macho" or "elf"),
-    /// followed by a platform dependent encoding of CPU type and
-    /// subtype.  For example:
-    ///
-    ///     "macho"        : Specifies an object type of MachO.
-    ///     "macho-16-6"   : MachO specific encoding for ARMv6.
-    ///     "elf-43        : ELF specific encoding for Sparc V9.
-    ///
-    /// @param[in] arch_name The name of an architecture.
-    ///
-    /// @return True if @p arch_name was successfully translated, false
-    ///         otherwise.
-    //------------------------------------------------------------------
-//    bool
-//    SetArchitecture (const llvm::StringRef& arch_name);
-//
-//    bool
-//    SetArchitecture (const char *arch_name);
-    
-    //------------------------------------------------------------------
     /// Change the architecture object type and CPU type.
     ///
     /// @param[in] arch_type The object type of this ArchSpec.
     ///
     /// @param[in] cpu The required CPU type.
     ///
     /// @return True if the object and CPU type were successfully set.
     //------------------------------------------------------------------

lldb/trunk/include/lldb/Core/Module.h

 //===-- Module.h ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_Module_h_
 #define liblldb_Module_h_
 
+#include "lldb/lldb-forward.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/UUID.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Host/TimeValue.h"
-#include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/SymbolContextScope.h"
 #include "lldb/Target/PathMappingList.h"
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 /// @class Module Module.h "lldb/Core/Module.h"
 /// @brief A class that describes an executable image and its associated

 
 protected:
     //------------------------------------------------------------------
     // Member Variables
     //------------------------------------------------------------------
     mutable Mutex               m_mutex;        ///< A mutex to keep this object happy in multi-threaded environments.
     TimeValue                   m_mod_time;     ///< The modification time for this module when it was created.
     ArchSpec                    m_arch;         ///< The architecture for this module.
-    lldb_private::UUID          m_uuid;         ///< Each module is assumed to have a unique identifier to help match it up to debug symbols.
+    UUID                        m_uuid;         ///< Each module is assumed to have a unique identifier to help match it up to debug symbols.
     FileSpec                    m_file;         ///< The file representation on disk for this module (if there is one).
     FileSpec                    m_platform_file;///< The path to the module on the platform on which it is being debugged
     FileSpec                    m_remote_install_file;  ///< If set when debugging on remote platforms, this module will be installed at this location
     FileSpec                    m_symfile_spec; ///< If this path is valid, then this is the file that _will_ be used as the symbol file for this module
     ConstString                 m_object_name;  ///< The name an object within this module that is selected, or empty of the module is represented by \a m_file.
     uint64_t                    m_object_offset;
     TimeValue                   m_object_mod_time;
     lldb::ObjectFileSP          m_objfile_sp;   ///< A shared pointer to the object file parser for this module as it may or may not be shared with the SymbolFile
-    std::unique_ptr<SymbolVendor> m_symfile_ap;   ///< A pointer to the symbol vendor for this module.
-    ClangASTContext             m_ast;          ///< The AST context for this module.
+    lldb::SymbolVendorUP        m_symfile_ap;   ///< A pointer to the symbol vendor for this module.
+    lldb::ClangASTContextUP     m_ast;          ///< The AST context for this module.
     PathMappingList             m_source_mappings; ///< Module specific source remappings for when you have debug info for a module that doesn't match where the sources currently are
-    std::unique_ptr<lldb_private::SectionList> m_sections_ap; ///< Unified section list for module that is used by the ObjectFile and and ObjectFile instances for the debug info
+    lldb::SectionListUP         m_sections_ap; ///< Unified section list for module that is used by the ObjectFile and and ObjectFile instances for the debug info
 
     bool                        m_did_load_objfile:1,
                                 m_did_load_symbol_vendor:1,
                                 m_did_parse_uuid:1,
                                 m_did_init_ast:1;
     mutable bool                m_file_has_changed:1,
                                 m_first_file_changed_log:1;   /// See if the module was modified after it was initially opened.
     

lldb/trunk/include/lldb/lldb-forward.h

namespace lldb {
     typedef std::shared_ptr<lldb_private::Breakpoint> BreakpointSP;
     typedef std::weak_ptr<lldb_private::Breakpoint> BreakpointWP;
     typedef std::shared_ptr<lldb_private::BreakpointSite> BreakpointSiteSP;
     typedef std::weak_ptr<lldb_private::BreakpointSite> BreakpointSiteWP;
     typedef std::shared_ptr<lldb_private::BreakpointLocation> BreakpointLocationSP;
     typedef std::weak_ptr<lldb_private::BreakpointLocation> BreakpointLocationWP;
     typedef std::shared_ptr<lldb_private::BreakpointResolver> BreakpointResolverSP;
     typedef std::shared_ptr<lldb_private::Broadcaster> BroadcasterSP;
+    typedef std::unique_ptr<lldb_private::ClangASTContext> ClangASTContextUP;
     typedef std::shared_ptr<lldb_private::ClangExpressionVariable> ClangExpressionVariableSP;
     typedef std::shared_ptr<lldb_private::CommandObject> CommandObjectSP;
     typedef std::shared_ptr<lldb_private::Communication> CommunicationSP;
     typedef std::shared_ptr<lldb_private::Connection> ConnectionSP;
     typedef std::shared_ptr<lldb_private::CompileUnit> CompUnitSP;
     typedef std::shared_ptr<lldb_private::DataBuffer> DataBufferSP;
     typedef std::shared_ptr<lldb_private::DataExtractor> DataExtractorSP;
     typedef std::shared_ptr<lldb_private::Debugger> DebuggerSP;
namespace lldb {
     typedef std::shared_ptr<lldb_private::Queue> QueueSP;
     typedef std::weak_ptr<lldb_private::Queue> QueueWP;
     typedef std::shared_ptr<lldb_private::QueueItem> QueueItemSP;
     typedef std::shared_ptr<lldb_private::ScriptInterpreterObject> ScriptInterpreterObjectSP;
 #ifndef LLDB_DISABLE_PYTHON
     typedef std::shared_ptr<lldb_private::ScriptSummaryFormat> ScriptSummaryFormatSP;
 #endif // #ifndef LLDB_DISABLE_PYTHON
     typedef std::shared_ptr<lldb_private::Section> SectionSP;
+    typedef std::unique_ptr<lldb_private::SectionList> SectionListUP;
     typedef std::weak_ptr<lldb_private::Section> SectionWP;
     typedef std::shared_ptr<lldb_private::SectionLoadList> SectionLoadListSP;
     typedef std::shared_ptr<lldb_private::SearchFilter> SearchFilterSP;
     typedef std::shared_ptr<lldb_private::Settings> SettingsSP;
     typedef std::shared_ptr<lldb_private::StackFrame> StackFrameSP;
     typedef std::unique_ptr<lldb_private::StackFrame> StackFrameUP;
     typedef std::weak_ptr<lldb_private::StackFrame> StackFrameWP;
     typedef std::shared_ptr<lldb_private::StackFrameList> StackFrameListSP;
     typedef std::shared_ptr<lldb_private::StopInfo> StopInfoSP;
     typedef std::shared_ptr<lldb_private::StoppointLocation> StoppointLocationSP;
     typedef std::shared_ptr<lldb_private::Stream> StreamSP;
     typedef std::weak_ptr<lldb_private::Stream> StreamWP;
     typedef std::shared_ptr<lldb_private::StreamFile> StreamFileSP;
     typedef std::shared_ptr<lldb_private::StringSummaryFormat> StringTypeSummaryImplSP;
     typedef std::shared_ptr<lldb_private::SymbolFile> SymbolFileSP;
     typedef std::shared_ptr<lldb_private::SymbolFileType> SymbolFileTypeSP;
     typedef std::weak_ptr<lldb_private::SymbolFileType> SymbolFileTypeWP;
     typedef std::shared_ptr<lldb_private::SymbolContextSpecifier> SymbolContextSpecifierSP;
+    typedef std::unique_ptr<lldb_private::SymbolVendor> SymbolVendorUP;
     typedef std::shared_ptr<lldb_private::SyntheticChildren> SyntheticChildrenSP;
     typedef std::shared_ptr<lldb_private::SyntheticChildrenFrontEnd> SyntheticChildrenFrontEndSP;
     typedef std::shared_ptr<lldb_private::Target> TargetSP;
     typedef std::weak_ptr<lldb_private::Target> TargetWP;
     typedef std::shared_ptr<lldb_private::Thread> ThreadSP;
     typedef std::weak_ptr<lldb_private::Thread> ThreadWP;
     typedef std::shared_ptr<lldb_private::ThreadCollection> ThreadCollectionSP;
     typedef std::shared_ptr<lldb_private::ThreadPlan> ThreadPlanSP;

lldb/trunk/source/API/SBModule.cpp

 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBSymbolContextList.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/ValueObjectList.h"
 #include "lldb/Core/ValueObjectVariable.h"
+#include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Symtab.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;

lldb/trunk/source/Core/Module.cpp

 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/Timer.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/Symbols.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/lldb-private-log.h"
+#include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/CPPLanguageRuntime.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
Module::Module (const ModuleSpec &module_spec) :
     m_platform_file(),
     m_remote_install_file(),
     m_symfile_spec (),
     m_object_name (),
     m_object_offset (),
     m_object_mod_time (),
     m_objfile_sp (),
     m_symfile_ap (),
-    m_ast (),
+    m_ast (new ClangASTContext),
     m_source_mappings (),
     m_sections_ap(),
     m_did_load_objfile (false),
     m_did_load_symbol_vendor (false),
     m_did_parse_uuid (false),
     m_did_init_ast (false),
     m_file_has_changed (false),
     m_first_file_changed_log (false)
Module::Module(const FileSpec& file_spec,
     m_platform_file(),
     m_remote_install_file (),
     m_symfile_spec (),
     m_object_name (),
     m_object_offset (object_offset),
     m_object_mod_time (),
     m_objfile_sp (),
     m_symfile_ap (),
-    m_ast (),
+    m_ast (new ClangASTContext),
     m_source_mappings (),
     m_sections_ap(),
     m_did_load_objfile (false),
     m_did_load_symbol_vendor (false),
     m_did_parse_uuid (false),
     m_did_init_ast (false),
     m_file_has_changed (false),
     m_first_file_changed_log (false)
Module::Module () :
     m_platform_file(),
     m_remote_install_file (),
     m_symfile_spec (),
     m_object_name (),
     m_object_offset (0),
     m_object_mod_time (),
     m_objfile_sp (),
     m_symfile_ap (),
-    m_ast (),
+    m_ast (new ClangASTContext),
     m_source_mappings (),
     m_sections_ap(),
     m_did_load_objfile (false),
     m_did_load_symbol_vendor (false),
     m_did_parse_uuid (false),
     m_did_init_ast (false),
     m_file_has_changed (false),
     m_first_file_changed_log (false)
if (m_did_init_ast == false)
                 {
                     object_arch.GetTriple().setOS(llvm::Triple::IOS);
                 }
                 else
                 {
                     object_arch.GetTriple().setOS(llvm::Triple::MacOSX);
                 }
             }
-            m_ast.SetArchitecture (object_arch);
+            m_ast->SetArchitecture (object_arch);
         }
     }
-    return m_ast;
+    return *m_ast;
 }
 
 void
 Module::ParseAllDebugSymbols()
 {
     Mutex::Locker locker (m_mutex);
     size_t num_comp_units = GetNumCompileUnits();
     if (num_comp_units == 0)

lldb/trunk/source/Expression/ClangASTSource.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecordLayout.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Expression/ASTDumper.h"
 #include "lldb/Expression/ClangASTSource.h"
 #include "lldb/Expression/ClangExpression.h"
+#include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangNamespaceDecl.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Target.h"
 
 using namespace clang;
 using namespace lldb_private;

lldb/trunk/source/Host/common/Symbols.cpp

 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/Timer.h"
 #include "lldb/Core/UUID.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Target.h"
 
+#include "llvm/Support/FileSystem.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 #if defined (__linux__) || defined (__FreeBSD__)
 
 FileSpec
 Symbols::LocateExecutableObjectFile (const ModuleSpec &module_spec)
 {

lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

 #include "lldb/Core/DataBuffer.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/State.h"
+#include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Target/StackFrame.h"

lldb/trunk/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp

 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Expression/ClangFunction.h"
 #include "lldb/Expression/ClangUtilityFunction.h"
 #include "lldb/Host/FileSpec.h"
+#include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "Plugins/Process/Utility/HistoryThread.h"
 #include "lldb/Target/Queue.h"
 #include "lldb/Target/QueueList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/Process.h"