1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
//===-- StackID.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_StackID_h_
#define liblldb_StackID_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-private.h"
#include "lldb/Core/AddressRange.h"
namespace lldb_private {
class StackID
{
public:
//------------------------------------------------------------------
// Constructors and Destructors
//------------------------------------------------------------------
StackID () :
m_pc (LLDB_INVALID_ADDRESS),
m_cfa (LLDB_INVALID_ADDRESS),
m_symbol_scope (NULL)
{
}
explicit
StackID (lldb::addr_t pc, lldb::addr_t cfa, SymbolContextScope *symbol_scope) :
m_pc (pc),
m_cfa (cfa),
m_symbol_scope (symbol_scope)
{
}
StackID (const StackID& rhs) :
m_pc (rhs.m_pc),
m_cfa (rhs.m_cfa),
m_symbol_scope (rhs.m_symbol_scope)
{
}
~StackID()
{
}
lldb::addr_t
GetPC() const
{
return m_pc;
}
lldb::addr_t
GetCallFrameAddress() const
{
return m_cfa;
}
SymbolContextScope *
GetSymbolContextScope () const
{
return m_symbol_scope;
}
void
SetSymbolContextScope (SymbolContextScope *symbol_scope)
{
m_symbol_scope = symbol_scope;
}
void
Clear ()
{
m_pc = LLDB_INVALID_ADDRESS;
m_cfa = LLDB_INVALID_ADDRESS;
m_symbol_scope = NULL;
}
bool
IsValid () const
{
return m_pc != LLDB_INVALID_ADDRESS || m_cfa != LLDB_INVALID_ADDRESS;
}
void
Dump (Stream *s);
//------------------------------------------------------------------
// Operators
//------------------------------------------------------------------
const StackID&
operator=(const StackID& rhs)
{
if (this != &rhs)
{
m_pc = rhs.m_pc;
m_cfa = rhs.m_cfa;
m_symbol_scope = rhs.m_symbol_scope;
}
return *this;
}
protected:
friend class StackFrame;
void
SetPC (lldb::addr_t pc)
{
m_pc = pc;
}
void
SetCFA (lldb::addr_t cfa)
{
m_cfa = cfa;
}
//------------------------------------------------------------------
// Classes that inherit from StackID can see and modify these
//------------------------------------------------------------------
lldb::addr_t m_pc; // The pc value for the function/symbol for this frame. This will
// only get used if the symbol scope is NULL (the code where we are
// stopped is not represented by any function or symbol in any
// shared library).
lldb::addr_t m_cfa; // The call frame address (stack pointer) value
// at the beginning of the function that uniquely
// identifies this frame (along with m_symbol_scope below)
SymbolContextScope *m_symbol_scope; // If NULL, there is no block or symbol for this frame.
// If not NULL, this will either be the scope for the
// lexical block for the frame, or the scope
// for the symbol. Symbol context scopes are
// always be unique pointers since the are part
// of the Block and Symbol objects and can easily
// be used to tell if a stack ID is the same as
// another.
};
bool operator== (const StackID& lhs, const StackID& rhs);
bool operator!= (const StackID& lhs, const StackID& rhs);
// frame_id_1 < frame_id_2 means "frame_id_1 is YOUNGER than frame_id_2"
bool operator< (const StackID& lhs, const StackID& rhs);
} // namespace lldb_private
#endif // liblldb_StackID_h_
|
