17 files changed, 0 insertions, 100 deletions
diff --git a/lldb/source/Core/Address.cpp b/lldb/source/Core/Address.cpp
index 0efe071af09..9520e43697e 100644
--- a/lldb/source/Core/Address.cpp
+++ b/lldb/source/Core/Address.cpp
@@ -927,7 +927,6 @@ size_t Address::MemorySize() const {
   return sizeof(Address);
 }
 
-//----------------------------------------------------------------------
 // NOTE: Be careful using this operator. It can correctly compare two
 // addresses from the same Module correctly. It can't compare two addresses
 // from different modules in any meaningful way, but it will compare the module
@@ -939,7 +938,6 @@ size_t Address::MemorySize() const {
 //   address results to make much sense
 //
 // This basically lets Address objects be used in ordered collection classes.
-//----------------------------------------------------------------------
 
 bool lldb_private::operator<(const Address &lhs, const Address &rhs) {
   ModuleSP lhs_module_sp(lhs.GetModule());
diff --git a/lldb/source/Core/AddressResolver.cpp b/lldb/source/Core/AddressResolver.cpp
index c2580c2d4d8..974d99b6206 100644
--- a/lldb/source/Core/AddressResolver.cpp
+++ b/lldb/source/Core/AddressResolver.cpp
@@ -16,9 +16,7 @@ class ModuleList;
 
 using namespace lldb_private;
 
-//----------------------------------------------------------------------
 // AddressResolver:
-//----------------------------------------------------------------------
 AddressResolver::AddressResolver() {}
 
 AddressResolver::~AddressResolver() {}
diff --git a/lldb/source/Core/AddressResolverFileLine.cpp b/lldb/source/Core/AddressResolverFileLine.cpp
index 5fd1da6dd53..24c0222d6ec 100644
--- a/lldb/source/Core/AddressResolverFileLine.cpp
+++ b/lldb/source/Core/AddressResolverFileLine.cpp
@@ -27,9 +27,7 @@
 using namespace lldb;
 using namespace lldb_private;
 
-//----------------------------------------------------------------------
 // AddressResolverFileLine:
-//----------------------------------------------------------------------
 AddressResolverFileLine::AddressResolverFileLine(const FileSpec &file_spec,
                                                  uint32_t line_no,
                                                  bool check_inlines)
diff --git a/lldb/source/Core/Debugger.cpp b/lldb/source/Core/Debugger.cpp
index c170274da5e..3ff9232dec3 100644
--- a/lldb/source/Core/Debugger.cpp
+++ b/lldb/source/Core/Debugger.cpp
@@ -824,7 +824,6 @@ Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton)
 Debugger::~Debugger() { Clear(); }
 
 void Debugger::Clear() {
-  //----------------------------------------------------------------------
   // Make sure we call this function only once. With the C++ global destructor
   // chain having a list of debuggers and with code that can be running on
   // other threads, we need to ensure this doesn't happen multiple times.
@@ -833,7 +832,6 @@ void Debugger::Clear() {
   //     Debugger::~Debugger();
   //     static void Debugger::Destroy(lldb::DebuggerSP &debugger_sp);
   //     static void Debugger::Terminate();
-  //----------------------------------------------------------------------
   llvm::call_once(m_clear_once, [this]() {
     ClearIOHandlers();
     StopIOHandlerThread();
diff --git a/lldb/source/Core/Disassembler.cpp b/lldb/source/Core/Disassembler.cpp
index f5cfcf2ade1..74f66b5d479 100644
--- a/lldb/source/Core/Disassembler.cpp
+++ b/lldb/source/Core/Disassembler.cpp
@@ -1237,9 +1237,7 @@ size_t Disassembler::ParseInstructions(const ExecutionContext *exe_ctx,
   return m_instruction_list.GetSize();
 }
 
-//----------------------------------------------------------------------
 // Disassembler copy constructor
-//----------------------------------------------------------------------
 Disassembler::Disassembler(const ArchSpec &arch, const char *flavor)
     : m_arch(arch), m_instruction_list(), m_base_addr(LLDB_INVALID_ADDRESS),
       m_flavor() {
@@ -1271,9 +1269,7 @@ const InstructionList &Disassembler::GetInstructionList() const {
   return m_instruction_list;
 }
 
-//----------------------------------------------------------------------
 // Class PseudoInstruction
-//----------------------------------------------------------------------
 
 PseudoInstruction::PseudoInstruction()
     : Instruction(Address(), AddressClass::eUnknown), m_description() {}
diff --git a/lldb/source/Core/DynamicLoader.cpp b/lldb/source/Core/DynamicLoader.cpp
index c773caa1f21..57130d6fa57 100644
--- a/lldb/source/Core/DynamicLoader.cpp
+++ b/lldb/source/Core/DynamicLoader.cpp
@@ -62,10 +62,8 @@ DynamicLoader::DynamicLoader(Process *process) : m_process(process) {}
 
 DynamicLoader::~DynamicLoader() = default;
 
-//----------------------------------------------------------------------
 // Accessosors to the global setting as to whether to stop at image (shared
 // library) loading/unloading.
-//----------------------------------------------------------------------
 
 bool DynamicLoader::GetStopWhenImagesChange() const {
   return m_process->GetStopOnSharedLibraryEvents();
diff --git a/lldb/source/Core/FileLineResolver.cpp b/lldb/source/Core/FileLineResolver.cpp
index 949a4c92a61..3cba1c7e814 100644
--- a/lldb/source/Core/FileLineResolver.cpp
+++ b/lldb/source/Core/FileLineResolver.cpp
@@ -23,9 +23,7 @@ class Address;
 using namespace lldb;
 using namespace lldb_private;
 
-//----------------------------------------------------------------------
 // FileLineResolver:
-//----------------------------------------------------------------------
 FileLineResolver::FileLineResolver(const FileSpec &file_spec, uint32_t line_no,
                                    bool check_inlines)
     : Searcher(), m_file_spec(file_spec), m_line_number(line_no),
diff --git a/lldb/source/Core/FileSpecList.cpp b/lldb/source/Core/FileSpecList.cpp
index fc8c6d78954..95133faf750 100644
--- a/lldb/source/Core/FileSpecList.cpp
+++ b/lldb/source/Core/FileSpecList.cpp
@@ -22,19 +22,15 @@ FileSpecList::FileSpecList() : m_files() {}
 
 FileSpecList::~FileSpecList() = default;
 
-//------------------------------------------------------------------
 // Append the "file_spec" to the end of the file spec list.
-//------------------------------------------------------------------
 void FileSpecList::Append(const FileSpec &file_spec) {
   m_files.push_back(file_spec);
 }
 
-//------------------------------------------------------------------
 // Only append the "file_spec" if this list doesn't already contain it.
 //
 // Returns true if "file_spec" was added, false if this list already contained
 // a copy of "file_spec".
-//------------------------------------------------------------------
 bool FileSpecList::AppendIfUnique(const FileSpec &file_spec) {
   collection::iterator end = m_files.end();
   if (find(m_files.begin(), end, file_spec) == end) {
@@ -44,14 +40,10 @@ bool FileSpecList::AppendIfUnique(const FileSpec &file_spec) {
   return false;
 }
 
-//------------------------------------------------------------------
 // Clears the file list.
-//------------------------------------------------------------------
 void FileSpecList::Clear() { m_files.clear(); }
 
-//------------------------------------------------------------------
 // Dumps the file list to the supplied stream pointer "s".
-//------------------------------------------------------------------
 void FileSpecList::Dump(Stream *s, const char *separator_cstr) const {
   collection::const_iterator pos, end = m_files.end();
   for (pos = m_files.begin(); pos != end; ++pos) {
@@ -61,13 +53,11 @@ void FileSpecList::Dump(Stream *s, const char *separator_cstr) const {
   }
 }
 
-//------------------------------------------------------------------
 // Find the index of the file in the file spec list that matches "file_spec"
 // starting "start_idx" entries into the file spec list.
 //
 // Returns the valid index of the file that matches "file_spec" if it is found,
 // else std::numeric_limits<uint32_t>::max() is returned.
-//------------------------------------------------------------------
 size_t FileSpecList::FindFileIndex(size_t start_idx, const FileSpec &file_spec,
                                    bool full) const {
   const size_t num_files = m_files.size();
@@ -92,10 +82,8 @@ size_t FileSpecList::FindFileIndex(size_t start_idx, const FileSpec &file_spec,
   return UINT32_MAX;
 }
 
-//------------------------------------------------------------------
 // Returns the FileSpec object at index "idx". If "idx" is out of range, then
 // an empty FileSpec object will be returned.
-//------------------------------------------------------------------
 const FileSpec &FileSpecList::GetFileSpecAtIndex(size_t idx) const {
   if (idx < m_files.size())
     return m_files[idx];
@@ -109,12 +97,10 @@ const FileSpec *FileSpecList::GetFileSpecPointerAtIndex(size_t idx) const {
   return nullptr;
 }
 
-//------------------------------------------------------------------
 // Return the size in bytes that this object takes in memory. This returns the
 // size in bytes of this object's member variables and any FileSpec objects its
 // member variables contain, the result doesn't not include the string values
 // for the directories any filenames as those are in shared string pools.
-//------------------------------------------------------------------
 size_t FileSpecList::MemorySize() const {
   size_t mem_size = sizeof(FileSpecList);
   collection::const_iterator pos, end = m_files.end();
@@ -125,9 +111,7 @@ size_t FileSpecList::MemorySize() const {
   return mem_size;
 }
 
-//------------------------------------------------------------------
 // Return the number of files in the file spec list.
-//------------------------------------------------------------------
 size_t FileSpecList::GetSize() const { return m_files.size(); }
 
 size_t FileSpecList::GetFilesMatchingPartialPath(const char *path,
diff --git a/lldb/source/Core/IOHandler.cpp b/lldb/source/Core/IOHandler.cpp
index 257db46e942..3a7a75e8ae5 100644
--- a/lldb/source/Core/IOHandler.cpp
+++ b/lldb/source/Core/IOHandler.cpp
@@ -1078,9 +1078,7 @@ public:
 
   operator WINDOW *() { return m_window; }
 
-  //----------------------------------------------------------------------
   // Window drawing utilities
-  //----------------------------------------------------------------------
   void DrawTitleBox(const char *title, const char *bottom_message = nullptr) {
     attr_t attr = 0;
     if (IsActive())
diff --git a/lldb/source/Core/Mangled.cpp b/lldb/source/Core/Mangled.cpp
index e3b3721e4ea..608ea8964e7 100644
--- a/lldb/source/Core/Mangled.cpp
+++ b/lldb/source/Core/Mangled.cpp
@@ -124,15 +124,11 @@ get_demangled_name_without_arguments(ConstString mangled,
 }
 
 #pragma mark Mangled
-//----------------------------------------------------------------------
 // Default constructor
-//----------------------------------------------------------------------
 Mangled::Mangled() : m_mangled(), m_demangled() {}
 
-//----------------------------------------------------------------------
 // Constructor with an optional string and a boolean indicating if it is the
 // mangled version.
-//----------------------------------------------------------------------
 Mangled::Mangled(ConstString s, bool mangled)
     : m_mangled(), m_demangled() {
   if (s)
@@ -154,54 +150,42 @@ Mangled::Mangled(llvm::StringRef name) {
     SetValue(ConstString(name));
 }
 
-//----------------------------------------------------------------------
 // Destructor
-//----------------------------------------------------------------------
 Mangled::~Mangled() {}
 
-//----------------------------------------------------------------------
 // Convert to pointer operator. This allows code to check any Mangled objects
 // to see if they contain anything valid using code such as:
 //
 //  Mangled mangled(...);
 //  if (mangled)
 //  { ...
-//----------------------------------------------------------------------
 Mangled::operator void *() const {
   return (m_mangled) ? const_cast<Mangled *>(this) : NULL;
 }
 
-//----------------------------------------------------------------------
 // Logical NOT operator. This allows code to check any Mangled objects to see
 // if they are invalid using code such as:
 //
 //  Mangled mangled(...);
 //  if (!file_spec)
 //  { ...
-//----------------------------------------------------------------------
 bool Mangled::operator!() const { return !m_mangled; }
 
-//----------------------------------------------------------------------
 // Clear the mangled and demangled values.
-//----------------------------------------------------------------------
 void Mangled::Clear() {
   m_mangled.Clear();
   m_demangled.Clear();
 }
 
-//----------------------------------------------------------------------
 // Compare the string values.
-//----------------------------------------------------------------------
 int Mangled::Compare(const Mangled &a, const Mangled &b) {
   return ConstString::Compare(
       a.GetName(lldb::eLanguageTypeUnknown, ePreferMangled),
       b.GetName(lldb::eLanguageTypeUnknown, ePreferMangled));
 }
 
-//----------------------------------------------------------------------
 // Set the string value in this objects. If "mangled" is true, then the mangled
 // named is set with the new value in "s", else the demangled name is set.
-//----------------------------------------------------------------------
 void Mangled::SetValue(ConstString s, bool mangled) {
   if (s) {
     if (mangled) {
@@ -232,9 +216,7 @@ void Mangled::SetValue(ConstString name) {
   }
 }
 
-//----------------------------------------------------------------------
 // Local helpers for different demangling implementations.
-//----------------------------------------------------------------------
 static char *GetMSVCDemangledStr(const char *M) {
 #if defined(_MSC_VER)
   const size_t demangled_length = 2048;
@@ -287,10 +269,8 @@ static char *GetItaniumDemangledStr(const char *M) {
   return demangled_cstr;
 }
 
-//----------------------------------------------------------------------
 // Explicit demangling for scheduled requests during batch processing. This
 // makes use of ItaniumPartialDemangler's rich demangle info
-//----------------------------------------------------------------------
 bool Mangled::DemangleWithRichManglingInfo(
     RichManglingContext &context, SkipMangledNameFn *skip_mangled_name) {
   // We need to generate and cache the demangled name.
@@ -356,12 +336,10 @@ bool Mangled::DemangleWithRichManglingInfo(
   llvm_unreachable("Fully covered switch above!");
 }
 
-//----------------------------------------------------------------------
 // Generate the demangled name on demand using this accessor. Code in this
 // class will need to use this accessor if it wishes to decode the demangled
 // name. The result is cached and will be kept until a new string value is
 // supplied to this object, or until the end of the object's lifetime.
-//----------------------------------------------------------------------
 ConstString 
 Mangled::GetDemangledName(lldb::LanguageType language) const {
   // Check to make sure we have a valid mangled name and that we haven't
@@ -421,9 +399,7 @@ bool Mangled::NameMatches(const RegularExpression &regex,
   return demangled && regex.Execute(demangled.AsCString());
 }
 
-//----------------------------------------------------------------------
 // Get the demangled name if there is one, else return the mangled name.
-//----------------------------------------------------------------------
 ConstString Mangled::GetName(lldb::LanguageType language,
                              Mangled::NamePreference preference) const {
   if (preference == ePreferMangled && m_mangled)
@@ -444,10 +420,8 @@ ConstString Mangled::GetName(lldb::LanguageType language,
   return demangled;
 }
 
-//----------------------------------------------------------------------
 // Dump a Mangled object to stream "s". We don't force our demangled name to be
 // computed currently (we don't use the accessor).
-//----------------------------------------------------------------------
 void Mangled::Dump(Stream *s) const {
   if (m_mangled) {
     *s << ", mangled = " << m_mangled;
@@ -458,10 +432,8 @@ void Mangled::Dump(Stream *s) const {
   }
 }
 
-//----------------------------------------------------------------------
 // Dumps a debug version of this string with extra object and state information
 // to stream "s".
-//----------------------------------------------------------------------
 void Mangled::DumpDebug(Stream *s) const {
   s->Printf("%*p: Mangled mangled = ", static_cast<int>(sizeof(void *) * 2),
             static_cast<const void *>(this));
@@ -470,23 +442,19 @@ void Mangled::DumpDebug(Stream *s) const {
   m_demangled.DumpDebug(s);
 }
 
-//----------------------------------------------------------------------
 // Return the size in byte that this object takes in memory. The size includes
 // the size of the objects it owns, and not the strings that it references
 // because they are shared strings.
-//----------------------------------------------------------------------
 size_t Mangled::MemorySize() const {
   return m_mangled.MemorySize() + m_demangled.MemorySize();
 }
 
-//----------------------------------------------------------------------
 // We "guess" the language because we can't determine a symbol's language from
 // it's name.  For example, a Pascal symbol can be mangled using the C++
 // Itanium scheme, and defined in a compilation unit within the same module as
 // other C++ units.  In addition, different targets could have different ways
 // of mangling names from a given language, likewise the compilation units
 // within those targets.
-//----------------------------------------------------------------------
 lldb::LanguageType Mangled::GuessLanguage() const {
   ConstString mangled = GetMangledName();
   if (mangled) {
@@ -507,9 +475,7 @@ lldb::LanguageType Mangled::GuessLanguage() const {
   return lldb::eLanguageTypeUnknown;
 }
 
-//----------------------------------------------------------------------
 // Dump OBJ to the supplied stream S.
-//----------------------------------------------------------------------
 Stream &operator<<(Stream &s, const Mangled &obj) {
   if (obj.GetMangledName())
     s << "mangled = '" << obj.GetMangledName() << "'";
diff --git a/lldb/source/Core/PluginManager.cpp b/lldb/source/Core/PluginManager.cpp
index 07121dacfd2..f69610cf246 100644
--- a/lldb/source/Core/PluginManager.cpp
+++ b/lldb/source/Core/PluginManager.cpp
@@ -1539,9 +1539,7 @@ lldb::ScriptInterpreterSP PluginManager::GetScriptInterpreterForLanguage(
 #pragma mark -
 #pragma mark StructuredDataPlugin
 
-// -----------------------------------------------------------------------------
 // StructuredDataPlugin
-// -----------------------------------------------------------------------------
 
 struct StructuredDataPluginInstance {
   StructuredDataPluginInstance()
diff --git a/lldb/source/Core/RichManglingContext.cpp b/lldb/source/Core/RichManglingContext.cpp
index 5957a2b8dc8..3d1941ebdd2 100644
--- a/lldb/source/Core/RichManglingContext.cpp
+++ b/lldb/source/Core/RichManglingContext.cpp
@@ -18,9 +18,7 @@
 using namespace lldb;
 using namespace lldb_private;
 
-//----------------------------------------------------------------------
 // RichManglingContext
-//----------------------------------------------------------------------
 void RichManglingContext::ResetProvider(InfoProvider new_provider) {
   // If we want to support parsers for other languages some day, we need a
   // switch here to delete the correct parser type.
diff --git a/lldb/source/Core/SearchFilter.cpp b/lldb/source/Core/SearchFilter.cpp
index 55589b848ac..2f6b16f8112 100644
--- a/lldb/source/Core/SearchFilter.cpp
+++ b/lldb/source/Core/SearchFilter.cpp
@@ -171,9 +171,7 @@ lldb::SearchFilterSP SearchFilter::CopyForBreakpoint(Breakpoint &breakpoint) {
   return ret_sp;
 }
 
-//----------------------------------------------------------------------
 // Helper functions for serialization.
-//----------------------------------------------------------------------
 
 StructuredData::DictionarySP
 SearchFilter::WrapOptionsDict(StructuredData::DictionarySP options_dict_sp) {
@@ -204,10 +202,8 @@ void SearchFilter::SerializeFileSpecList(
   options_dict_sp->AddItem(GetKey(name), module_array_sp);
 }
 
-//----------------------------------------------------------------------
 // UTILITY Functions to help iterate down through the elements of the
 // SymbolContext.
-//----------------------------------------------------------------------
 
 void SearchFilter::Search(Searcher &searcher) {
   SymbolContext empty_sc;
@@ -363,11 +359,9 @@ Searcher::CallbackReturn SearchFilter::DoFunctionIteration(
   return Searcher::eCallbackReturnContinue;
 }
 
-//----------------------------------------------------------------------
 //  SearchFilterForUnconstrainedSearches:
 //  Selects a shared library matching a given file spec, consulting the targets
 //  "black list".
-//----------------------------------------------------------------------
 SearchFilterSP SearchFilterForUnconstrainedSearches::CreateFromStructuredData(
     Target &target, const StructuredData::Dictionary &data_dict,
     Status &error) {
@@ -403,10 +397,8 @@ lldb::SearchFilterSP SearchFilterForUnconstrainedSearches::DoCopyForBreakpoint(
   return std::make_shared<SearchFilterForUnconstrainedSearches>(*this);
 }
 
-//----------------------------------------------------------------------
 //  SearchFilterByModule:
 //  Selects a shared library matching a given file spec
-//----------------------------------------------------------------------
 
 SearchFilterByModule::SearchFilterByModule(const lldb::TargetSP &target_sp,
                                            const FileSpec &module)
@@ -533,10 +525,8 @@ StructuredData::ObjectSP SearchFilterByModule::SerializeToStructuredData() {
   return WrapOptionsDict(options_dict_sp);
 }
 
-//----------------------------------------------------------------------
 //  SearchFilterByModuleList:
 //  Selects a shared library matching a given file spec
-//----------------------------------------------------------------------
 
 SearchFilterByModuleList::SearchFilterByModuleList(
     const lldb::TargetSP &target_sp, const FileSpecList &module_list)
@@ -687,10 +677,8 @@ StructuredData::ObjectSP SearchFilterByModuleList::SerializeToStructuredData() {
   return WrapOptionsDict(options_dict_sp);
 }
 
-//----------------------------------------------------------------------
 //  SearchFilterByModuleListAndCU:
 //  Selects a shared library matching a given file spec
-//----------------------------------------------------------------------
 
 SearchFilterByModuleListAndCU::SearchFilterByModuleListAndCU(
     const lldb::TargetSP &target_sp, const FileSpecList &module_list,
diff --git a/lldb/source/Core/Section.cpp b/lldb/source/Core/Section.cpp
index 1fa5a8cc0c2..05d1468314c 100644
--- a/lldb/source/Core/Section.cpp
+++ b/lldb/source/Core/Section.cpp
@@ -381,9 +381,7 @@ bool Section::Slide(addr_t slide_amount, bool slide_children) {
   return false;
 }
 
-//------------------------------------------------------------------
 /// Get the permissions as OR'ed bits from lldb::Permissions
-//------------------------------------------------------------------
 uint32_t Section::GetPermissions() const {
   uint32_t permissions = 0;
   if (m_readable)
@@ -395,9 +393,7 @@ uint32_t Section::GetPermissions() const {
   return permissions;
 }
 
-//------------------------------------------------------------------
 /// Set the permissions using bits OR'ed from lldb::Permissions
-//------------------------------------------------------------------
 void Section::SetPermissions(uint32_t permissions) {
   m_readable = (permissions & ePermissionsReadable) != 0;
   m_writable = (permissions & ePermissionsWritable) != 0;
diff --git a/lldb/source/Core/SourceManager.cpp b/lldb/source/Core/SourceManager.cpp
index 8b5cb262e2d..9cd9ac163fb 100644
--- a/lldb/source/Core/SourceManager.cpp
+++ b/lldb/source/Core/SourceManager.cpp
@@ -49,9 +49,7 @@ using namespace lldb_private;
 
 static inline bool is_newline_char(char ch) { return ch == '\n' || ch == '\r'; }
 
-//----------------------------------------------------------------------
 // SourceManager constructor
-//----------------------------------------------------------------------
 SourceManager::SourceManager(const TargetSP &target_sp)
     : m_last_file_sp(), m_last_line(0), m_last_count(0), m_default_set(false),
       m_target_wp(target_sp),
@@ -61,9 +59,7 @@ SourceManager::SourceManager(const DebuggerSP &debugger_sp)
     : m_last_file_sp(), m_last_line(0), m_last_count(0), m_default_set(false),
       m_target_wp(), m_debugger_wp(debugger_sp) {}
 
-//----------------------------------------------------------------------
 // Destructor
-//----------------------------------------------------------------------
 SourceManager::~SourceManager() {}
 
 SourceManager::FileSP SourceManager::GetFile(const FileSpec &file_spec) {
diff --git a/lldb/source/Core/StreamFile.cpp b/lldb/source/Core/StreamFile.cpp
index db184df5856..ce6e1ea2c18 100644
--- a/lldb/source/Core/StreamFile.cpp
+++ b/lldb/source/Core/StreamFile.cpp
@@ -14,9 +14,7 @@
 using namespace lldb;
 using namespace lldb_private;
 
-//----------------------------------------------------------------------
 // StreamFile constructor
-//----------------------------------------------------------------------
 StreamFile::StreamFile() : Stream(), m_file() {}
 
 StreamFile::StreamFile(uint32_t flags, uint32_t addr_size, ByteOrder byte_order)
diff --git a/lldb/source/Core/ValueObject.cpp b/lldb/source/Core/ValueObject.cpp
index e749315dcde..1d9d7d49543 100644
--- a/lldb/source/Core/ValueObject.cpp
+++ b/lldb/source/Core/ValueObject.cpp
@@ -77,9 +77,7 @@ using namespace lldb_utility;
 
 static user_id_t g_value_obj_uid = 0;
 
-//----------------------------------------------------------------------
 // ValueObject constructor
-//----------------------------------------------------------------------
 ValueObject::ValueObject(ValueObject &parent)
     : UserID(++g_value_obj_uid), // Unique identifier for every value object
       m_parent(&parent), m_root(NULL), m_update_point(parent.GetUpdatePoint()),
@@ -105,9 +103,7 @@ ValueObject::ValueObject(ValueObject &parent)
   m_manager->ManageObject(this);
 }
 
-//----------------------------------------------------------------------
 // ValueObject constructor
-//----------------------------------------------------------------------
 ValueObject::ValueObject(ExecutionContextScope *exe_scope,
                          AddressType child_ptr_or_ref_addr_type)
     : UserID(++g_value_obj_uid), // Unique identifier for every value object
@@ -134,9 +130,7 @@ ValueObject::ValueObject(ExecutionContextScope *exe_scope,
   m_manager->ManageObject(this);
 }
 
-//----------------------------------------------------------------------
 // Destructor
-//----------------------------------------------------------------------
 ValueObject::~ValueObject() {}
 
 bool ValueObject::UpdateValueIfNeeded(bool update_format) {