[lldb] Move and clean-up the Declaration class (NFC)

[mib]

Summary

This patch moves the Declaration class from the Symbol library to the
Core library. This will allow to use it in a more generic fashion and
aims to lower the dependency cycles when it comes to the linking.

The patch also does some cleaning up by making column information
permanent and removing the LLDB_ENABLE_DECLARATION_COLUMNS directives.

Signed-off-by: Med Ismail Bennani <[e-mail]>

[teemperor]

IIRC they were #ifdef's out because of memory concerns. Did you have a chance to benchmark this quickly (e.g., trying to attach to a debug Clang and see how much it increases memory)

Otherwise this LGTM.

FWIW, we also need this for the SourceLocation in Clang Decls feature I was working on some time ago.

[JDevlieghere]

lldb/include/lldb/Core/Declaration.h

129

Let's also add an operator bool that just calls IsValid() under the hood.

130

197–198

Move this above the variables.

[mib]

In D101556#2726434, @teemperor wrote:

IIRC they were #ifdef's out because of memory concerns. Did you have a chance to benchmark this quickly (e.g., trying to attach to a debug Clang and see how much it increases memory)

Otherwise this LGTM.

FWIW, we also need this for the SourceLocation in Clang Decls feature I was working on some time ago.

I ran a benchmark as you suggested, attaching to a debug clang build, checking lldb's memory before starting the process (650MB), setting a breakpoint to main then launching the process (~1GB), and after the process stops, I tried evaluating the following expression : (lldb) expr std::string("This is a string.", 4) (4.83GB) and the memory usage matched in both scenarios.

[mib]

Addressed @JDevlieghere comments.

[JDevlieghere]

LGTM

lldb/include/lldb/Core/Declaration.h

161

Is this actually used? I don't think it's worth adding that if it's not.

198

This is useless.

[mib]

Addressed @JDevlieghere comments.

[teemperor]

In D101556#2727603, @mib wrote:

In D101556#2726434, @teemperor wrote:

IIRC they were #ifdef's out because of memory concerns. Did you have a chance to benchmark this quickly (e.g., trying to attach to a debug Clang and see how much it increases memory)

Otherwise this LGTM.

FWIW, we also need this for the SourceLocation in Clang Decls feature I was working on some time ago.

I ran a benchmark as you suggested, attaching to a debug clang build, checking lldb's memory before starting the process (650MB), setting a breakpoint to main then launching the process (~1GB), and after the process stops, I tried evaluating the following expression : (lldb) expr std::string("This is a string.", 4) (4.83GB) and the memory usage matched in both scenarios.

Thanks. I anyway realized we don't actually increase the memory consumption with that member as it just occupies what was previously tail padding (we actually still have padding left with this uint16_t member). I probably should have checked that before asking for benchmarks :)

LGTM, let's ship it.

lldb/include/lldb/Core/Declaration.h

198

I personally learned C++ by reading LLDB's comments such as "Destructor", "Constructor" and "member variables"

lldb/include/lldb/Core/Declaration.h

 //===-- Declaration.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_SYMBOL_DECLARATION_H
 #define LLDB_SYMBOL_DECLARATION_H
 
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
-/// \class Declaration Declaration.h "lldb/Symbol/Declaration.h"
+/// \class Declaration Declaration.h "lldb/Core/Declaration.h"
 /// A class that describes the declaration location of a
 ///        lldb object.
 ///
 /// The declarations include the file specification, line number, and the
 /// column info and can help track where functions, blocks, inlined functions,
 /// types, variables, any many other debug core objects were declared.
 class Declaration {
 public:
   /// Default constructor.
-  Declaration()
-      : m_file(), m_line(0)
-#ifdef LLDB_ENABLE_DECLARATION_COLUMNS
-        ,
-        m_column(0)
-#endif
-  {
-  }
+  Declaration() : m_file(), m_line(0), m_column(LLDB_INVALID_COLUMN_NUMBER) {}
 
   /// Construct with file specification, and optional line and column.
   ///
   /// \param[in] file_spec
   ///     The file specification that describes where this was
   ///     declared.
   ///
   /// \param[in] line
   ///     The line number that describes where this was declared. Set
   ///     to zero if there is no line number information.
   ///
   /// \param[in] column
   ///     The column number that describes where this was declared.
   ///     Set to zero if there is no column number information.
-  Declaration(const FileSpec &file_spec, uint32_t line = 0, uint32_t column = 0)
-      : m_file(file_spec), m_line(line)
-#ifdef LLDB_ENABLE_DECLARATION_COLUMNS
-        ,
-        m_column(column)
-#endif
-  {
-  }
+  Declaration(const FileSpec &file_spec, uint32_t line = 0,
+              uint16_t column = LLDB_INVALID_COLUMN_NUMBER)
+      : m_file(file_spec), m_line(line), m_column(column) {}
 
   /// Construct with a pointer to another Declaration object.
   Declaration(const Declaration *decl_ptr)
-      : m_file(), m_line(0)
-#ifdef LLDB_ENABLE_DECLARATION_COLUMNS
-        ,
-        m_column(0)
-#endif
-  {
+      : m_file(), m_line(0), m_column(LLDB_INVALID_COLUMN_NUMBER) {
     if (decl_ptr)
       *this = *decl_ptr;
   }
 
   /// Clear the object's state.
   ///
   /// Sets the file specification to be empty, and the line and column to
   /// zero.
   void Clear() {
     m_file.Clear();
     m_line = 0;
-#ifdef LLDB_ENABLE_DECLARATION_COLUMNS
     m_column = 0;
-#endif
   }
 
   /// Compare two declaration objects.
   ///
   /// Compares the two file specifications from \a lhs and \a rhs. If the file
   /// specifications are equal, then continue to compare the line number and
   /// column numbers respectively.
   ///
public:
   /// Dump a description of the contents of this object to the supplied stream
   /// \a s.
   ///
   /// \param[in] s
   ///     The stream to which to dump the object description.
   void Dump(Stream *s, bool show_fullpaths) const;
 
   bool DumpStopContext(Stream *s, bool show_fullpaths) const;
-  /// Get accessor for the declaration column number.
-  ///
-  /// \return
-  ///     Non-zero indicates a valid column number, zero indicates no
-  ///     column information is available.
-  uint32_t GetColumn() const {
-#ifdef LLDB_ENABLE_DECLARATION_COLUMNS
-    return m_column;
-#else
-    return 0;
-#endif
-  }
 
   /// Get accessor for file specification.
   ///
   /// \return
   ///     A reference to the file specification object.
   FileSpec &GetFile() { return m_file; }
 
   /// Get const accessor for file specification.
   ///
   /// \return
   ///     A const reference to the file specification object.
   const FileSpec &GetFile() const { return m_file; }
 
   /// Get accessor for the declaration line number.
   ///
   /// \return
   ///     Non-zero indicates a valid line number, zero indicates no
   ///     line information is available.
   uint32_t GetLine() const { return m_line; }
 
-  bool IsValid() const { return m_file && m_line != 0; }
+  /// Get accessor for the declaration column number.
+  ///
+  /// \return
+  ///     Non-zero indicates a valid column number, zero indicates no
+  ///     column information is available.
+  uint16_t GetColumn() const { return m_column; }
+  
+  /// Convert to boolean operator.
+  ///
+  /// This allows code to check a Declaration object to see if it
+  /// contains anything valid using code such as:
+  ///
+  /// \code
+  /// Declaration decl(...);
+  /// if (decl)
+  /// { ...
+  /// \endcode
+  ///
+  /// \return
+  ///     A \b true if both the file_spec and the line are valid,
+  ///     \b false otherwise.
+  explicit operator bool() const {
+    return IsValid();
+  }
+
+  /// Logical NOT operator.
+  ///
+  /// This allows code to check a Declaration object to see if it is
+  /// invalid using code such as:
+  ///
+  /// \code
+  /// Declaration decl(...);
+  /// if (!decl)
+  /// { ...
+  /// \endcode
+  ///
+  /// \return
+  ///     Returns \b true if the object has an invalid file_spec or line number,
+  ///     \b false otherwise.
+  bool operator!() const { return !operator bool(); }
+
+  bool IsValid() const {
+    return m_file && m_line != 0 && m_line != LLDB_INVALID_LINE_NUMBER;
+  }
 
   /// Get the memory cost of this object.
   ///
   /// \return
   ///     The number of bytes that this object occupies in memory.
   ///     The returned value does not include the bytes for any
   ///     shared string values.
   ///
   /// \see ConstString::StaticMemorySize ()
   size_t MemorySize() const;
 
-  /// Set accessor for the declaration column number.
-  ///
-  /// \param[in] column
-  ///     Non-zero indicates a valid column number, zero indicates no
-  ///     column information is available.
-  void SetColumn(uint32_t column) {
-#ifdef LLDB_ENABLE_DECLARATION_COLUMNS
-    m_column = col;
-#endif
-  }
-
   /// Set accessor for the declaration file specification.
   ///
   /// \param[in] file_spec
   ///     The new declaration file specification.
   void SetFile(const FileSpec &file_spec) { m_file = file_spec; }
 
   /// Set accessor for the declaration line number.
   ///
   /// \param[in] line
   ///     Non-zero indicates a valid line number, zero indicates no
   ///     line information is available.
   void SetLine(uint32_t line) { m_line = line; }
 
+  /// Set accessor for the declaration column number.
+  ///
+  /// \param[in] column
+  ///     Non-zero indicates a valid column number, zero indicates no
+  ///     column information is available.
+  void SetColumn(uint16_t column) { m_column = column; }
+
 protected:
-  /// Member variables.
-  FileSpec m_file; ///< The file specification that points to the
-                   ///< source file where the declaration occurred.
-  uint32_t m_line; ///< Non-zero values indicates a valid line number,
-                   ///< zero indicates no line number information is available.
-#ifdef LLDB_ENABLE_DECLARATION_COLUMNS
-  uint32_t m_column; ///< Non-zero values indicates a valid column number,
-                     ///< zero indicates no column information is available.
-#endif
+  // Member variables.
+  /// The file specification that points to the source file where the declaration occurred.
+  FileSpec m_file;
+  /// Non-zero values indicates a valid line number, zero indicates no line number information is available.
+  uint32_t m_line;
+  /// Non-zero values indicates a valid column number, zero indicates no column information is available.
+  uint16_t m_column;
 };
 
 bool operator==(const Declaration &lhs, const Declaration &rhs);
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_DECLARATION_H

lldb/include/lldb/Symbol/Function.h

 //===-- Function.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_SYMBOL_FUNCTION_H
 #define LLDB_SYMBOL_FUNCTION_H
 
 #include "lldb/Core/AddressRange.h"
+#include "lldb/Core/Declaration.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/Block.h"
-#include "lldb/Symbol/Declaration.h"
 #include "lldb/Utility/UserID.h"
 #include "llvm/ADT/ArrayRef.h"
 
 #include <mutex>
 
 namespace lldb_private {
 
 class ExecutionContext;

lldb/include/lldb/Symbol/Type.h

 //===-- Type.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_SYMBOL_TYPE_H
 #define LLDB_SYMBOL_TYPE_H
 
+#include "lldb/Core/Declaration.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerType.h"
-#include "lldb/Symbol/Declaration.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/APSInt.h"
 
 #include <set>
 

lldb/include/lldb/Symbol/Variable.h

 //===-- Variable.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_SYMBOL_VARIABLE_H
 #define LLDB_SYMBOL_VARIABLE_H
 
+#include "lldb/Core/Declaration.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Expression/DWARFExpression.h"
-#include "lldb/Symbol/Declaration.h"
 #include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/RangeMap.h"
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-private.h"
 #include <memory>
 #include <vector>
 

lldb/source/API/SBDeclaration.cpp

 //===-- SBDeclaration.cpp -------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBDeclaration.h"
 #include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBStream.h"
+#include "lldb/Core/Declaration.h"
 #include "lldb/Host/PosixApi.h"
-#include "lldb/Symbol/Declaration.h"
 #include "lldb/Utility/Stream.h"
 
 #include <limits.h>
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBDeclaration::SBDeclaration() : m_opaque_up() {

lldb/source/API/SBValue.cpp

 //===-- SBValue.cpp -------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBValue.h"
 #include "SBReproducerPrivate.h"
 
 #include "lldb/API/SBDeclaration.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTypeFilter.h"
 #include "lldb/API/SBTypeFormat.h"
 #include "lldb/API/SBTypeSummary.h"
 #include "lldb/API/SBTypeSynthetic.h"
 
 #include "lldb/Breakpoint/Watchpoint.h"
+#include "lldb/Core/Declaration.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/Symbol/Block.h"
-#include "lldb/Symbol/Declaration.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"

lldb/source/Core/Address.cpp

 //===-- Address.cpp -------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/Address.h"
+#include "lldb/Core/Declaration.h"
 #include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/Block.h"
-#include "lldb/Symbol/Declaration.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Symtab.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/Variable.h"

lldb/source/Core/CMakeLists.txt

 
 add_lldb_library(lldbCore
   Address.cpp
   AddressRange.cpp
   AddressResolver.cpp
   AddressResolverFileLine.cpp
   Communication.cpp
   Debugger.cpp
+  Declaration.cpp
   Disassembler.cpp
   DumpDataExtractor.cpp
   DumpRegisterValue.cpp
   DynamicLoader.cpp
   EmulateInstruction.cpp
   FileLineResolver.cpp
   FileSpecList.cpp
   FormatEntity.cpp

lldb/source/Core/Declaration.cpp

 //===-- Declaration.cpp ---------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "lldb/Symbol/Declaration.h"
+#include "lldb/Core/Declaration.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb_private;
 
 void Declaration::Dump(Stream *s, bool show_fullpaths) const {
   if (m_file) {
     *s << ", decl = ";
     if (show_fullpaths)
       *s << m_file;
     else
       *s << m_file.GetFilename();
     if (m_line > 0)
       s->Printf(":%u", m_line);
-#ifdef LLDB_ENABLE_DECLARATION_COLUMNS
-    if (m_column > 0)
+    if (m_column != LLDB_INVALID_COLUMN_NUMBER)
       s->Printf(":%u", m_column);
-#endif
   } else {
     if (m_line > 0) {
       s->Printf(", line = %u", m_line);
-#ifdef LLDB_ENABLE_DECLARATION_COLUMNS
-      if (m_column > 0)
+      if (m_column != LLDB_INVALID_COLUMN_NUMBER)
         s->Printf(":%u", m_column);
-#endif
-    }
-#ifdef LLDB_ENABLE_DECLARATION_COLUMNS
-    else if (m_column > 0)
+    } else if (m_column != LLDB_INVALID_COLUMN_NUMBER)
       s->Printf(", column = %u", m_column);
-#endif
   }
 }
 
 bool Declaration::DumpStopContext(Stream *s, bool show_fullpaths) const {
   if (m_file) {
     if (show_fullpaths)
       *s << m_file;
     else
       m_file.GetFilename().Dump(s);
 
     if (m_line > 0)
       s->Printf(":%u", m_line);
-#ifdef LLDB_ENABLE_DECLARATION_COLUMNS
-    if (m_column > 0)
+    if (m_column != LLDB_INVALID_COLUMN_NUMBER)
       s->Printf(":%u", m_column);
-#endif
     return true;
   } else if (m_line > 0) {
     s->Printf(" line %u", m_line);
-#ifdef LLDB_ENABLE_DECLARATION_COLUMNS
-    if (m_column > 0)
+    if (m_column != LLDB_INVALID_COLUMN_NUMBER)
       s->Printf(":%u", m_column);
-#endif
     return true;
   }
   return false;
 }
 
 size_t Declaration::MemorySize() const { return sizeof(Declaration); }
 
 int Declaration::Compare(const Declaration &a, const Declaration &b) {
   int result = FileSpec::Compare(a.m_file, b.m_file, true);
   if (result)
     return result;
   if (a.m_line < b.m_line)
     return -1;
   else if (a.m_line > b.m_line)
     return 1;
-#ifdef LLDB_ENABLE_DECLARATION_COLUMNS
   if (a.m_column < b.m_column)
     return -1;
   else if (a.m_column > b.m_column)
     return 1;
-#endif
   return 0;
 }
 
 bool Declaration::FileAndLineEqual(const Declaration &declaration) const {
   int file_compare = FileSpec::Compare(this->m_file, declaration.m_file, true);
   return file_compare == 0 && this->m_line == declaration.m_line;
 }
 
 bool lldb_private::operator==(const Declaration &lhs, const Declaration &rhs) {
-#ifdef LLDB_ENABLE_DECLARATION_COLUMNS
   if (lhs.GetColumn() != rhs.GetColumn())
     return false;
-#else
+
   return lhs.GetLine() == rhs.GetLine() && lhs.GetFile() == rhs.GetFile();
-#endif
 }

lldb/source/Core/ValueObject.cpp

 //===-- ValueObject.cpp ---------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObject.h"
 
 #include "lldb/Core/Address.h"
+#include "lldb/Core/Declaration.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ValueObjectCast.h"
 #include "lldb/Core/ValueObjectChild.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectDynamicValue.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Core/ValueObjectSyntheticFilter.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/DataFormatters/DumpValueObjectOptions.h"
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/DataFormatters/StringPrinter.h"
 #include "lldb/DataFormatters/TypeFormat.h"
 #include "lldb/DataFormatters/TypeSummary.h"
 #include "lldb/DataFormatters/ValueObjectPrinter.h"
 #include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/CompilerType.h"
-#include "lldb/Symbol/Declaration.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"

lldb/source/Core/ValueObjectVariable.cpp

 //===-- ValueObjectVariable.cpp -------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObjectVariable.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h"
+#include "lldb/Core/Declaration.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DWARFExpression.h"
-#include "lldb/Symbol/Declaration.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolContextScope.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"

lldb/source/Plugins/SymbolFile/DWARF/UniqueDWARFASTType.h

 //===-- UniqueDWARFASTType.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_SOURCE_PLUGINS_SYMBOLFILE_DWARF_UNIQUEDWARFASTTYPE_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_UNIQUEDWARFASTTYPE_H
 
 #include <vector>
 
 #include "llvm/ADT/DenseMap.h"
 
 #include "DWARFDIE.h"
-#include "lldb/Symbol/Declaration.h"
+#include "lldb/Core/Declaration.h"
 
 class UniqueDWARFASTType {
 public:
   // Constructors and Destructors
   UniqueDWARFASTType()
       : m_type_sp(), m_die(), m_declaration(),
         m_byte_size(
             -1) // Set to negative value to make sure we have a valid value

lldb/source/Plugins/SymbolFile/DWARF/UniqueDWARFASTType.cpp

 //===-- UniqueDWARFASTType.cpp --------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "UniqueDWARFASTType.h"
 
-#include "lldb/Symbol/Declaration.h"
+#include "lldb/Core/Declaration.h"
 
 bool UniqueDWARFASTTypeList::Find(const DWARFDIE &die,
                                   const lldb_private::Declaration &decl,
                                   const int32_t byte_size,
                                   UniqueDWARFASTType &entry) const {
   for (const UniqueDWARFASTType &udt : m_collection) {
     // Make sure the tags match
     if (udt.m_die.Tag() == die.Tag()) {

lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

 
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangASTMetadata.h"
 #include "Plugins/ExpressionParser/Clang/ClangUtil.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
+#include "lldb/Core/Declaration.h"
 #include "lldb/Core/Module.h"
-#include "lldb/Symbol/Declaration.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/TypeSystem.h"
 
 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
 #include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
 #include "llvm/DebugInfo/PDB/PDBSymbol.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"

lldb/source/Symbol/CMakeLists.txt

 set(LLVM_OPTIONAL_SOURCES LocateSymbolFileMacOSX.cpp)
 
 if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
   set(PLATFORM_SOURCES LocateSymbolFileMacOSX.cpp)
 endif()
 
 add_lldb_library(lldbSymbol
   ArmUnwindInfo.cpp
   Block.cpp
   CompactUnwindInfo.cpp
   CompileUnit.cpp
   CompilerDecl.cpp
   CompilerDeclContext.cpp
   CompilerType.cpp
   DWARFCallFrameInfo.cpp
   DebugMacros.cpp
-  Declaration.cpp
   DeclVendor.cpp
   FuncUnwinders.cpp
   Function.cpp
   LineEntry.cpp
   LineTable.cpp
   LocateSymbolFile.cpp
   ObjectFile.cpp
   PostfixExpression.cpp

lldb/unittests/Symbol/TestClangASTImporter.cpp

 //===-- TestClangASTImporter.cpp ------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangASTImporter.h"
 #include "Plugins/ExpressionParser/Clang/ClangASTMetadata.h"
 #include "Plugins/ExpressionParser/Clang/ClangUtil.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/Symbol/ClangTestUtils.h"
+#include "lldb/Core/Declaration.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Symbol/Declaration.h"
 #include "clang/AST/DeclCXX.h"
 
 using namespace clang;
 using namespace lldb;
 using namespace lldb_private;
 
 class TestClangASTImporter : public testing::Test {
 public:

lldb/unittests/Symbol/TestTypeSystemClang.cpp

 //===-- TestTypeSystemClang.cpp -------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/ExpressionParser/Clang/ClangUtil.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/Symbol/ClangTestUtils.h"
+#include "lldb/Core/Declaration.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Symbol/Declaration.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/ExprCXX.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 using namespace lldb;
 using namespace lldb_private;