Vendor import of lldb trunk r290819:vendor/lldb/lldb-trunk-r290819

https://llvm.org/svn/llvm-project/lldb/trunk@290819

1 files changed, 41 insertions, 62 deletions

diff --git a/include/lldb/Symbol/SymbolContextScope.h b/include/lldb/Symbol/SymbolContextScope.h
index 212d8e6df233..926e34bc03a2 100644
--- a/include/lldb/Symbol/SymbolContextScope.h
+++ b/include/lldb/Symbol/SymbolContextScope.h
@@ -19,16 +19,17 @@
 namespace lldb_private {
 
 //----------------------------------------------------------------------
-/// @class SymbolContextScope SymbolContextScope.h "lldb/Symbol/SymbolContextScope.h"
+/// @class SymbolContextScope SymbolContextScope.h
+/// "lldb/Symbol/SymbolContextScope.h"
 /// @brief Inherit from this if your object is part of a symbol context
 ///        and can reconstruct its symbol context.
 ///
 /// Many objects that are part of a symbol context that have pointers
-/// back to parent objects that own them. Any members of a symbol 
+/// back to parent objects that own them. Any members of a symbol
 /// context that, once they are built, will not go away, can inherit
 /// from this pure virtual class and can then reconstruct their symbol
-/// context without having to keep a complete SymbolContext object in 
-/// the object. 
+/// context without having to keep a complete SymbolContext object in
+/// the object.
 ///
 /// Examples of these objects include:
 ///     @li Module
@@ -38,7 +39,7 @@ namespace lldb_private {
 ///     @li Symbol
 ///
 /// Other objects can store a "SymbolContextScope *" using any pointers
-/// to one of the above objects. This allows clients to hold onto a 
+/// to one of the above objects. This allows clients to hold onto a
 /// pointer that uniquely will identify a symbol context. Those clients
 /// can then always reconstruct the symbol context using the pointer, or
 /// use it to uniquely identify a symbol context for an object.
@@ -53,12 +54,12 @@ namespace lldb_private {
 ///         in which the variable is defined. Function arguments can use
 ///         the Function object as their scope. The SymbolFile parsers
 ///         will set these correctly as the variables are parsed.
-///     @li Type objects that know exactly in which scope they 
+///     @li Type objects that know exactly in which scope they
 ///         originated much like the variables above.
-///     @li StackID objects that are able to know that if the CFA 
-///         (stack pointer at the beginning of a function) and the 
+///     @li StackID objects that are able to know that if the CFA
+///         (stack pointer at the beginning of a function) and the
 ///         start PC for the function/symbol and the SymbolContextScope
-///         pointer (a unique pointer that identifies a symbol context 
+///         pointer (a unique pointer that identifies a symbol context
 ///         location) match within the same thread, that the stack
 ///         frame is the same as the previous stack frame.
 ///
@@ -68,67 +69,45 @@ namespace lldb_private {
 /// and object pairs that allow large collections of objects to be
 /// passed around with minimal overhead.
 //----------------------------------------------------------------------
-class SymbolContextScope
-{
+class SymbolContextScope {
 public:
-    virtual
-    ~SymbolContextScope() = default;
+  virtual ~SymbolContextScope() = default;
 
-    //------------------------------------------------------------------
-    /// Reconstruct the object's symbol context into \a sc.
-    ///
-    /// The object should fill in as much of the SymbolContext as it
-    /// can so function calls that require a symbol context can be made
-    /// for the given object.
-    ///
-    /// @param[out] sc
-    ///     A symbol context object pointer that gets filled in.
-    //------------------------------------------------------------------
-    virtual void
-    CalculateSymbolContext (SymbolContext *sc) = 0;
+  //------------------------------------------------------------------
+  /// Reconstruct the object's symbol context into \a sc.
+  ///
+  /// The object should fill in as much of the SymbolContext as it
+  /// can so function calls that require a symbol context can be made
+  /// for the given object.
+  ///
+  /// @param[out] sc
+  ///     A symbol context object pointer that gets filled in.
+  //------------------------------------------------------------------
+  virtual void CalculateSymbolContext(SymbolContext *sc) = 0;
 
-    virtual lldb::ModuleSP
-    CalculateSymbolContextModule ()
-    {
-        return lldb::ModuleSP();
-    }
+  virtual lldb::ModuleSP CalculateSymbolContextModule() {
+    return lldb::ModuleSP();
+  }
 
-    virtual CompileUnit *
-    CalculateSymbolContextCompileUnit ()
-    {
-        return nullptr;
-    }
+  virtual CompileUnit *CalculateSymbolContextCompileUnit() { return nullptr; }
 
-    virtual Function *
-    CalculateSymbolContextFunction ()
-    {
-        return nullptr;
-    }
+  virtual Function *CalculateSymbolContextFunction() { return nullptr; }
 
-    virtual Block *
-    CalculateSymbolContextBlock ()
-    {
-        return nullptr;
-    }
+  virtual Block *CalculateSymbolContextBlock() { return nullptr; }
 
-    virtual Symbol *
-    CalculateSymbolContextSymbol ()
-    {
-        return nullptr;
-    }
+  virtual Symbol *CalculateSymbolContextSymbol() { return nullptr; }
 
-    //------------------------------------------------------------------
-    /// Dump the object's symbol context to the stream \a s.
-    ///
-    /// The object should dump its symbol context to the stream \a s.
-    /// This function is widely used in the DumpDebug and verbose output
-    /// for lldb objects.
-    ///
-    /// @param[in] s
-    ///     The stream to which to dump the object's symbol context.
-    //------------------------------------------------------------------
-    virtual void
-    DumpSymbolContext (Stream *s) = 0;
+  //------------------------------------------------------------------
+  /// Dump the object's symbol context to the stream \a s.
+  ///
+  /// The object should dump its symbol context to the stream \a s.
+  /// This function is widely used in the DumpDebug and verbose output
+  /// for lldb objects.
+  ///
+  /// @param[in] s
+  ///     The stream to which to dump the object's symbol context.
+  //------------------------------------------------------------------
+  virtual void DumpSymbolContext(Stream *s) = 0;
 };
 
 } // namespace lldb_private