LLDB mainline
Go to the documentation of this file.
1//===-- SymbolContextScope.h ------------------------------------*- C++ -*-===//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
12#include "lldb/lldb-private.h"
14namespace lldb_private {
16/// \class SymbolContextScope SymbolContextScope.h
17/// "lldb/Symbol/SymbolContextScope.h" Inherit from this if your object is
18/// part of a symbol context
19/// and can reconstruct its symbol context.
21/// Many objects that are part of a symbol context that have pointers back to
22/// parent objects that own them. Any members of a symbol context that, once
23/// they are built, will not go away, can inherit from this pure virtual class
24/// and can then reconstruct their symbol context without having to keep a
25/// complete SymbolContext object in the object.
27/// Examples of these objects include:
28/// \li Module
29/// \li CompileUnit
30/// \li Function
31/// \li Block
32/// \li Symbol
34/// Other objects can store a "SymbolContextScope *" using any pointers to one
35/// of the above objects. This allows clients to hold onto a pointer that
36/// uniquely will identify a symbol context. Those clients can then always
37/// reconstruct the symbol context using the pointer, or use it to uniquely
38/// identify a symbol context for an object.
40/// Example objects include that currently use "SymbolContextScope *" objects
41/// include:
42/// \li Variable objects that can reconstruct where they are scoped
43/// by making sure the SymbolContextScope * comes from the scope
44/// in which the variable was declared. If a variable is a global,
45/// the appropriate CompileUnit * will be used when creating the
46/// variable. A static function variables, can the Block scope
47/// in which the variable is defined. Function arguments can use
48/// the Function object as their scope. The SymbolFile parsers
49/// will set these correctly as the variables are parsed.
50/// \li Type objects that know exactly in which scope they
51/// originated much like the variables above.
52/// \li StackID objects that are able to know that if the CFA
53/// (stack pointer at the beginning of a function) and the
54/// start PC for the function/symbol and the SymbolContextScope
55/// pointer (a unique pointer that identifies a symbol context
56/// location) match within the same thread, that the stack
57/// frame is the same as the previous stack frame.
59/// Objects that adhere to this protocol can reconstruct enough of a symbol
60/// context to allow functions that take a symbol context to be called. Lists
61/// can also be created using a SymbolContextScope* and and object pairs that
62/// allow large collections of objects to be passed around with minimal
63/// overhead.
66 virtual ~SymbolContextScope() = default;
68 /// Reconstruct the object's symbol context into \a sc.
69 ///
70 /// The object should fill in as much of the SymbolContext as it can so
71 /// function calls that require a symbol context can be made for the given
72 /// object.
73 ///
74 /// \param[out] sc
75 /// A symbol context object pointer that gets filled in.
78 virtual lldb::ModuleSP CalculateSymbolContextModule() {
79 return lldb::ModuleSP();
80 }
82 virtual CompileUnit *CalculateSymbolContextCompileUnit() { return nullptr; }
84 virtual Function *CalculateSymbolContextFunction() { return nullptr; }
86 virtual Block *CalculateSymbolContextBlock() { return nullptr; }
88 virtual Symbol *CalculateSymbolContextSymbol() { return nullptr; }
90 /// Dump the object's symbol context to the stream \a s.
91 ///
92 /// The object should dump its symbol context to the stream \a s. This
93 /// function is widely used in the DumpDebug and verbose output for lldb
94 /// objects.
95 ///
96 /// \param[in] s
97 /// The stream to which to dump the object's symbol context.
98 virtual void DumpSymbolContext(Stream *s) = 0;
101} // namespace lldb_private
A class that describes a single lexical block.
Definition: Block.h:41
A class that describes a compilation unit.
Definition: CompileUnit.h:41
A class that describes a function.
Definition: Function.h:409
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
"lldb/Symbol/SymbolContextScope.h" Inherit from this if your object is part of a symbol context and c...
virtual void DumpSymbolContext(Stream *s)=0
Dump the object's symbol context to the stream s.
virtual Symbol * CalculateSymbolContextSymbol()
virtual ~SymbolContextScope()=default
virtual Function * CalculateSymbolContextFunction()
virtual CompileUnit * CalculateSymbolContextCompileUnit()
virtual void CalculateSymbolContext(SymbolContext *sc)=0
Reconstruct the object's symbol context into sc.
virtual Block * CalculateSymbolContextBlock()
virtual lldb::ModuleSP CalculateSymbolContextModule()
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:33
A class that represents a running process on the host machine.